원본 영상을 바탕으로 AI의 도움을 받아 작성했습니다. 원본 영상이 기준입니다.
Log in to leave a comment
아직 작성된 글이 없습니다
Quando você gerencia um SaaS solo com um orçamento inferior a 500.000 wons por mês, as faturas de uma API de TTS paga se tornam um peso incômodo todos os meses. A latência de rede também é um problema. Se demorar 1 a 2 segundos desde o momento em que você clica no botão na tela até o áudio sair, o usuário fecha a aba imediatamente.
O Supertonic 3 (Supertonic 3), um modelo de código aberto com 99 milhões de parâmetros, é uma alternativa atraente. Ao executá-lo diretamente em um servidor local, você pode zerar os custos de API.
No entanto, rodar algumas linhas de código de exemplo em Python e fazer um deploy real em produção são coisas completamente diferentes. Aqui está um resumo de como resolvi diretamente os gargalos de memória e os problemas de processamento assíncrono que surgem no instante em que você inicia esse modelo em um servidor de baixo desempenho.
O tamanho do arquivo de pesos ONNX do Supertonic 3 é de aproximadamente 305 MB. Quando o modelo é carregado na memória pela primeira vez, a memória residente (RSS) fica em torno de 350 MB.
O problema ocorre quando um usuário envia uma solicitação e o sistema começa a computar o tensor de áudio de 44,1 kHz. O pico momentâneo de memória ultrapassa 900 MB. Se você usar a instância mais barata com especificação de 1 vCPU / 1 GB de RAM, o OOM Killer do Linux entra em ação e encerra o processo Python imediatamente.
A linha de base para uma operação estável é uma instância de 2 vCPU / 2 GB de RAM.
| Especificação da Instância do Servidor | RAM em Ociosidade | Pico de RAM na Computação | Uso Médio de CPU | Fator de Tempo Real (RTF) | Redução de Custo Mensal Estimada |
|---|---|---|---|---|---|
| 1 vCPU / 1 GB RAM | 280 MB | 890 MB (Risco de encerramento forçado) | 98% | 0,85 (Leva 0,85s para gerar 1s de áudio) | $130 (Comparado à API comercial) |
| 2 vCPU / 2 GB RAM | 320 MB | 920 MB (Zona segura) | 48% (Com limite de threads) | 0,28 (Leva 0,28s para gerar 1s de áudio) | $120 (Comparado à instância de GPU) |
| 4 vCPU / 4 GB RAM | 350 MB | 950 MB | 25% | 0,15 | $90 (Ajuste de instância superdimensionada) |
Para evitar que o uso da CPU disparasse para 100% quando várias solicitações chegassem em um servidor CPU de baixo desempenho, era necessário controlar manualmente o pool de threads do tempo de execução ONNX.
intra_op_num_threads para corresponder ao número de núcleos físicos do servidor (2).execution_mode como ORT_SEQUENTIAL e defina inter_op_num_threads como 1 para evitar alternâncias de contexto desnecessárias.enable_cpu_mem_arena para evitar re alocações frequentes de memória de heap e defina allow_spinning como 0 para impedir que a CPU fique ociosa em loops vazios.`python
import onnxruntime as ort
def get_optimized_session_options(cpu_cores: int = 2) -> ort.SessionOptions:
options = ort.SessionOptions()
options.intra_op_num_threads = cpu_cores
options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
options.inter_op_num_threads = 1
options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
options.enable_cpu_mem_arena = True
options.add_session_config_entry("session.dynamic_block_base", "4")
options.add_session_config_entry("session.intra_op.allow_spinning", "0")
return options
`
Ao aplicar essas opções e iniciar os workers, você consegue controlar o uso médio de CPU abaixo de 50% em um ambiente de 2 vCPU. Mesmo sem usar um servidor de GPU caro, você economiza cerca de 120 dólares por mês em custos de infraestrutura.
Ao carregar o SDK em um ambiente local ou em um contêiner de deploy, ocorrem frequentemente conflitos de bibliotecas dinâmicas em C++.
ImportError: DLL load failed, instale o pacote redistribuível do Microsoft Visual C++ 2015-2022 e verifique se o Python está em um ambiente virtual de 64 bits.libomp.dylib porque o compilador Clang não possui o OpenMP. Execute brew install libomp no terminal e adicione o caminho da biblioteca (export DYLD_LIBRARY_PATH="$(brew --prefix libomp)/lib:$DYLD_LIBRARY_PATH") às variáveis de ambiente.python:3.10-slim, instale previamente os pacotes build-essential e libgomp1 via apt.Depois de ajustar o ambiente, você precisa anexar um purificador de texto de entrada. Isso ocorre porque, se siglas em inglês, números e símbolos se misturarem, o modelo distorcerá a pronúncia ou emitirá ruídos mecânicos estranhos.
`python
import re
from typing import Dict
class SupertonicTextNormalizer:
def init(self):
self.lexicon_map: Dict[str, str] = {
"FastAPI": "fast api",
"SaaS": "saas",
"TTS": "t t s",
"ONNX": "onnx",
"Python": "python",
"SDK": "s d k",
"API": "a p i",
}
self.currency_pattern = re.compile(r'(\d+)\s원')
self.date_pattern = re.compile(r'(\d{4})년\s(\d{1,2})월\s*(\d{1,2})일')
self.time_pattern = re.compile(r'(\d{1,2}):(\d{2})')
self.special_char_pattern = re.compile(r'[^\w\s.,!?~<>]')
def normalize(self, text: str) -> str:
if not text or not text.strip():
raise ValueError("O texto de entrada está vazio.")
for word, pronunciation in self.lexicon_map.items():
text = re.sub(rf'\b{re.escape(word)}\b', pronunciation, text, flags=re.IGNORECASE)
text = self.date_pattern.sub(r'\1년 \2월 \3일', text)
text = self.time_pattern.sub(r'\1시 \2분', text)
tags = re.findall(r'<[^>]+>', text)
text_placeholder = re.sub(r'<[^>]+>', ' ___TAG___ ', text)
text_cleaned = self.special_char_pattern.sub('', text_placeholder)
for tag in tags:
text_cleaned = text_cleaned.replace('___TAG___', tag, 1)
return re.sub(r'\s+', ' ', text_cleaned).strip()
`
Para evitar situações em que o módulo de inferência C++ caia em espera infinita em determinados padrões de texto, configure um timeout com asyncio.wait_for e coloque um código de defesa para retornar um áudio de orientação de erro preparado em caso de falha.
`python
import asyncio
import logging
logger = logging.getLogger("TTSPipeline")
async def synthesize_with_fallback(tts_engine, text: str, voice_style, timeout_sec: float = 3.0) -> bytes:
try:
normalizer = SupertonicTextNormalizer()
cleaned_text = normalizer.normalize(text)
loop = asyncio.get_running_loop()
wav_data = await asyncio.wait_for(
loop.run_in_executor(
None,
lambda: tts_engine.synthesize(text=cleaned_text, lang="ko", voice_style=voice_style)
),
timeout=timeout_sec
)
return wav_data
except Exception as err:
logger.error(f"Falha na inferência TTS ou timeout: {err}")
with open("static/audio/fallback_system_error.wav", "rb") as f:
return f.read()
`
Passar por este pipeline de pré-processamento reduz significativamente os erros de reprodução de áudio causados por pronúncias incorretas. Na fase de QA, você pode economizar de cinco a seis horas por semana verificando e corrigindo problemas de pronúncia um por um.
Se você executar o inferenciador do Supertonic 3 (que é uma função síncrona) diretamente dentro de um roteador assíncrono do FastAPI, surgirão problemas. Todo o loop de eventos único trava até que a computação em C++ termine, fazendo com que até mesmo solicitações de API leves de outros usuários fiquem em estado de espera.
Tarefas de inferência intensivas em computação devem ser direcionadas para um ProcessPoolExecutor separado.
`python
from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from concurrent.futures import ProcessPoolExecutor
import asyncio
import io
import os
app = FastAPI()
process_pool = ProcessPoolExecutor(max_workers=min(4, os.cpu_count() or 1))
def sync_tts_inference(text: str, voice_style_name: str):
from supertonic import TTS
tts = TTS(auto_download=False)
style = tts.get_voice_style(voice_style_name)
wav, _ = tts.synthesize(text=text, lang="ko", voice_style=style)
return wav.tobytes()
@app.post("/api/v1/tts/realtime")
async def generate_speech_realtime(text: str, voice: str = "M1"):
loop = asyncio.get_running_loop()
try:
audio_bytes = await loop.run_in_executor(process_pool, sync_tts_inference, text, voice)
return StreamingResponse(io.BytesIO(audio_bytes), media_type="audio/wav")
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
`
A estrutura de gravar o áudio gerado em um arquivo no disco e lê-lo novamente para retorná-lo consome o I/O de disco de um servidor de baixo desempenho. É muito mais rápido fazer o streaming diretamente na memória com io.BytesIO sem passar pelo armazenamento de arquivos.
Se o tráfego se acumular alongando a fila ou se você precisar processar frases longas, separe as solicitações com uma fila Redis e um worker Celery.
task_id e encerra a resposta com HTTP 202.Se a arquitetura obrigatoriamente deixar caches de arquivos temporários no disco, execute uma tarefa de limpeza em segundo plano para evitar falhas por disco cheio (Disk Full).
`python
import os
import time
import glob
AUDIO_CACHE_DIR = "/tmp/supertonic_audio_cache"
MAX_FILE_AGE_SECONDS = 600
def cleanup_ephemeral_audio_files():
now = time.time()
if not os.path.exists(AUDIO_CACHE_DIR):
return
for filepath in glob.glob(os.path.join(AUDIO_CACHE_DIR, "*.wav")):
try:
if now - os.path.getmtime(filepath) > MAX_FILE_AGE_SECONDS:
os.remove(filepath)
except Exception:
pass
`
Com o isolamento de processos e o streaming em memória configurados, você consegue manter a latência p95 em torno de 200 milissegundos mesmo ao processar solicitações simultâneas em uma instância de 2 vCPU. Você pode integrar um serviço de voz on-device independente ao seu serviço de forma estável, sem se preocupar com contas exorbitantes de API externa.