원본 영상을 바탕으로 AI의 도움을 받아 작성했습니다. 원본 영상이 기준입니다.
Log in to leave a comment
아직 작성된 글이 없습니다
Wenn man eine Solo-SaaS mit einem Budget von weniger als 500.000 KRW pro Monat betreibt, ist die Rechnung für kommerzielle TTS-APIs jeden Monat eine schwere Last. Auch die Netzwerk-Latenz ist ein Problem. Wenn es nach dem Klick auf eine Schaltfläche im UI 1 bis 2 Sekunden dauert, bis ein Ton ausgegeben wird, schließt der Nutzer den Tab sofort.
Das Open-Source-Modell Supertonic 3 mit 99 Millionen Parametern ist eine attraktive Alternative. Wenn man es auf einem lokalen Server betreibt, können die API-Kosten auf 0 gesenkt werden.
Ein paar Zeilen Python-Beispielcode auszuführen ist jedoch etwas völlig anderes als ein echtes Production-Deployment. Hier ist eine Zusammenfassung darüber, wie ich die Speicherengpässe und Probleme bei der asynchronen Verarbeitung gelöst habe, denen man unweigerlich begegnet, wenn man dieses Modell auf einem Server mit geringer Leistung betreibt.
Die Größe der ONNX-Gewichtsdatei von Supertonic 3 beträgt etwa 305 MB. Wenn das Modell zum ersten Mal in den Arbeitsspeicher geladen wird, bleibt der Resident Set Size (RSS) bei etwa 350 MB.
Das Problem tritt auf, wenn ein Nutzer eine Anfrage sendet und die Berechnung von 44,1-kHz-Audiotensoren beginnt. Der temporäre Speicher-Peak übersteigt 900 MB. Wenn man eine günstige Instanz mit 1 vCPU und 1 GB RAM verwendet, greift der Linux OOM Killer ein und beendet den Python-Prozess sofort zwangsweise.
Die absolute Untergrenze für einen stabilen Betrieb ist eine Instanz mit 2 vCPU und 2 GB RAM.
| Server-Instanz-Spezifikation | RAM im Leerlauf | RAM-Peak bei Berechnungen | Ø CPU-Auslastung | Real-Time Factor (RTF) | Voraussichtliche monatliche Kostenersparnis |
|---|---|---|---|---|---|
| 1 vCPU / 1 GB RAM | 280 MB | 890 MB (Gefahr eines erzwungenen Abbruchs) | 98% | 0,85 (0,85 s für 1 s Audio) | 130 $ (gegenüber kommerzieller API) |
| 2 vCPU / 2 GB RAM | 320 MB | 920 MB (Sicherheitsbereich) | 48% (bei Thread-Begrenzung) | 0,28 (0,28 s für 1 s Audio) | 120 $ (gegenüber GPU-Instanz) vert{} |
| vert{} 4 vCPU / 4 GB RAM vert{} 350 MB vert{} 950 MB vert{} 25% vert{} 0,15 vert{} 90 $ (Anpassung überdimensionierter Instanzen) |
Um zu verhindern, dass die CPU-Auslastung bei mehreren eingehenden Anfragen auf einem leistungsschwachen CPU-Server auf 100 % hoch schnellt, muss der Thread-Pool der ONNX-Runtime manuell gesteuert werden.
intra_op_num_threads wird an die Anzahl der physischen Kerne des Servers (2) angepasst.execution_mode wird auf ORT_SEQUENTIAL gesetzt und inter_op_num_threads auf 1 festgelegt, um unnötige Kontextwechsel zu verhindern.enable_cpu_mem_arena wird aktiviert, um häufige Heap-Speicher-Reallokationen zu vermeiden, und allow_spinning wird auf 0 gesetzt, um zu verhindern, dass die CPU in einer leeren Schleife wartet.`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
`
Wenn man diese Optionen anwendet und die Worker startet, lässt sich die durchschnittliche CPU-Auslastung in einer 2-vCPU-Umgebung unter 50 % halten. Selbst ohne teure GPU-Server lassen sich so Infrastrukturkosten von rund 120 Dollar pro Monat einsparen.
Beim Laden des SDKs in einer lokalen Umgebung oder einem Deployment-Container kommt es häufig zu Konflikten mit C++-Dynamischen Bibliotheken.
ImportError: DLL load failed angezeigt wird, installieren Sie das Microsoft Visual C++ 2015-2022 Redistributable Package und stellen Sie sicher, dass Python in einer 64-Bit-Virtuellen Umgebung läuft.libomp.dylib-Fehler auf. Führen Sie im Terminal brew install libomp aus und fügen Sie den Pfad zu den Umgebungsvariablen hinzu (export DYLD_LIBRARY_PATH="$(brew --prefix libomp)/lib:$DYLD_LIBRARY_PATH").python:3.10-slim müssen die Pakete build-essential und libgomp1 vorab via apt installiert werden.Nachdem die Umgebung eingerichtet ist, muss ein Textbereiniger vorgeschaltet werden. Wenn englische Abkürzungen, Zahlen und Symbole gemischt vorkommen, verunstaltet das Modell sonst die Aussprache oder gibt seltsame maschinelle Geräusche von sich.
`python
import re
from typing import Dict
class SupertonicTextNormalizer:
def init(self):
self.lexicon_map: Dict[str, str] = {
"FastAPI": "FastAPI",
"SaaS": "SaaS",
"TTS": "TTS",
"ONNX": "ONNX",
"Python": "Python",
"SDK": "SDK",
"API": "API",
}
self.currency_pattern = re.compile(r'(\d+)\sWon')
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("Der Eingabetext ist leer.")
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()
`
Um zu verhindern, dass das C++-Inferenzmodul bei bestimmten Textmustern in eine Endlosschleife gerät, wird ein Timeout mit asyncio.wait_for gesetzt und im Fehlerfall ein vorbereiteter Audiohinweis zurückgegeben.
`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"TTS-Inferenz fehlgeschlagen oder Timeout: {err}")
with open("static/audio/fallback_system_error.wav", "rb") as f:
return f.read()
`
Durch diese Vorverarbeitungspipeline werden Audio-Wiedergabefehler aufgrund falscher Aussprache drastisch reduziert. Bei der QA lässt sich so jede Woche wertvolle Zeit einsparen, die sonst für das manuelle Prüfen und Beheben von Ausspracheproblemen draufgehen würde.
Wenn die synchrone Inferenzfunktion von Supertonic 3 direkt innerhalb eines asynchronen FastAPI-Routers ausgeführt wird, treten Probleme auf. Die gesamte Event-Loop wird blockiert, bis die C++-Berechnung abgeschlossen ist, wodurch selbst einfache API-Anfragen anderer Nutzer in den Wartezustand versetzt werden.
Rechenintensive Inferenzaufgaben sollten in einen separaten ProcessPoolExecutor ausgelagert werden.
`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))
`
Eine Architektur, bei der generiertes Audio als Datei auf die Festplatte geschrieben und zum Lesen wieder eingelesen wird, strapaziert die Festplatten-I/O eines Servers mit geringer Leistung. Es ist weitaus schneller, direkt im Arbeitsspeicher über io.BytesIO zu streamen, ohne den Umweg über eine Dateispeicherung.
Wenn sich Traffic staut und die Warteschlange lang wird oder lange Sätze verarbeitet werden müssen, sollten Anfragen über eine Redis-Queue und Celery-Worker entkoppelt werden.
task_id aus und beendet die Antwort mit HTTP 202.Falls die Architektur zwingend temporäre Dateisets auf der Festplatte hinterlassen muss, verhindert ein Hintergrund-Bereinigungs-Task Ausfälle durch vollgelaufene Festplatten (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
`
Mit Prozessisolierung und In-Memory-Streaming lässt sich selbst auf einer 2-vCPU-Instanz die p95-Latenz bei gleichzeitigen Anfragen bei rund 200 Millisekunden halten. So lässt sich ein unabhängiger On-Device-Sprachdienst stabil in die App integrieren, ohne Angst vor astronomischen Rechnungen für externe APIs haben zu müssen.