VPSలో సొంతంగా Whisper మరియు Piper ఎలా రన్ చేయాలి?

Self-hosted speech to text మరియు TTS, క్లుప్తంగా

Self-hosted speech to text మరియు TTS (text to speech) అనేది మీరు సొంత సర్వర్‌లో రన్ చేయగల అత్యంత చౌకైన AI రకం. Transcription ప్రక్రియ faster-whisper రన్‌టైమ్ ద్వారా Whisper ను ఉపయోగిస్తుంది. Synthesis ప్రక్రియ Piper ను ఉపయోగిస్తుంది. ఇవి రెండూ ఎటువంటి GPU లేని సాధారణ CPU VPS లో కూడా పనిచేస్తాయి. చిన్న Whisper మోడల్‌కు సుమారు 484 MB డిస్క్ స్థలం అవసరం, మరియు ఒక Piper వాయిస్ ఫైల్ 150 MB కంటే తక్కువ పరిమాణంలో ఉంటుంది.

అందుకే ఆడియోతో ప్రారంభించడం ఉత్తమం. Self-hosted image generator మరియు self-hosted video generation రెండింటికీ అవి ఉపయోగపడాలంటే ముందుగా GPU అవసరం. ఆడియోకు ఆ అవసరం లేదు.

ఈ గైడ్ ఈ రెండు దిశలను మరియు వాటిని కలిపే లేయర్‌ను వివరిస్తుంది. Whisper ఆడియోను టెక్స్ట్‌గా మారుస్తుంది. Piper టెక్స్ట్‌ను ఆడియోగా మారుస్తుంది. వీటి ముందు ఉండే OpenAI-compatible HTTP సర్వర్, ఇప్పటికే ఉన్న క్లయింట్‌లను కేవలం base URL మార్చడం ద్వారా మీ సర్వర్‌కు కనెక్ట్ అయ్యేలా చేస్తుంది.

ఇక్కడ పేర్కొన్న ప్రతి వెర్షన్ ఆగస్టు 2026 నాటికి ప్రస్తుత వెర్షన్లు.

ఎందుకు faster-whisper, రిఫరెన్స్ Whisper ప్యాకేజీ కాదు

OpenAI యొక్క whisper ప్యాకేజీ మోడల్‌ను PyTorchలో రన్ చేస్తుంది. faster-whisper అదే మోడల్ వెయిట్స్‌ను CTranslate2పై రన్ చేస్తుంది, ఇది ప్రత్యేకంగా ట్రాన్స్‌ఫార్మర్ మోడల్స్ కోసం రూపొందించబడిన ఇన్ఫరెన్స్ ఇంజిన్. వెయిట్స్ ఒకటే కాబట్టి, ట్రాన్స్‌క్రిప్ట్ కూడా ఒకేలా ఉంటుంది. తేడా అంతా రన్‌టైమ్‌లోనే ఉంది.

CTranslate2 వెయిట్స్‌ను లోడ్ చేసేటప్పుడే క్వాంటైజ్ చేస్తుంది, అందుకే compute_type="int8" అనేది ఒక ఆర్గ్యుమెంట్ మాత్రమే, విడిగా కన్వర్షన్ స్టెప్ అవసరం లేదు. దీనికి PyTorch డిపెండెన్సీ కూడా లేదు. pip install faster-whisper అనేది CTranslate2, ఒక టోకెనైజర్ మరియు ఆడియో డీకోడింగ్ కోసం PyAVని తీసుకుంటుంది, కాబట్టి వర్చువల్ ఎన్విరాన్‌మెంట్ పరిమాణం కొన్ని గిగాబైట్ల బదులు వందల మెగాబైట్లలోనే ఉంటుంది. 40 GB డిస్క్ ఉన్న VPSలో, ఈ తేడా సౌకర్యవంతంగా ఉండటానికి లేదా స్థలం సరిపోక ఇబ్బంది పడటానికి మధ్య ఉన్న వ్యత్యాసం.

CPUపై small మోడల్ కోసం ప్రాజెక్ట్ స్వయంగా ప్రచురించిన గణాంకాలు ఇక్కడ ఉన్నాయి. ఈ బెంచ్‌మార్క్ Intel Core i7-12700Kపై 8 త్రెడ్లను ఉపయోగించి 13 నిమిషాల ఆడియోను ట్రాన్స్‌క్రైబ్ చేస్తుంది. x_realtime కాలమ్ అనేది ఆ 13 నిమిషాలను కొలిచిన సమయంతో భాగించగా వచ్చిన విలువ: 7.6 అంటే 13 నిమిషాల రికార్డింగ్ 1 నిమిషం 40 సెకన్ల కంటే కొంచెం ఎక్కువ సమయంలో పూర్తయిందని అర్థం.

[
  {
    "label": "openai/whisper, fp32",
    "x_realtime": 1.9,
    "seconds": 418,
    "memory_mb": "2,335"
  },
  {
    "label": "whisper.cpp, fp32",
    "x_realtime": 6.2,
    "seconds": 125,
    "memory_mb": "1,049"
  },
  {
    "label": "faster-whisper, fp32",
    "x_realtime": 5.0,
    "seconds": 157,
    "memory_mb": "2,257"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 7.6,
    "seconds": 102,
    "memory_mb": "1,477"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 15.3,
    "seconds": 51,
    "memory_mb": "3,608"
  }
]

రెండవ వరుసను నిశితంగా గమనించండి. fp32 వద్ద, ఈ CPUపై whisper.cpp అనేది faster-whisper కంటే వేగంగా పనిచేస్తుంది, ఇది 6.2x వద్ద ఉంది, అదే faster-whisper 5.0x వద్ద ఉంది. అంతేకాకుండా, ఇది సగం కంటే తక్కువ మెమరీని మాత్రమే తీసుకుంటుంది. ఇది local LLM స్టాక్‌లోని llama.cpp వెనుక ఉన్న అదే ggml ఫ్యామిలీకి చెందినది. int8 మరియు బ్యాచింగ్ ఆన్ చేసినప్పుడు faster-whisper ముందుంటుంది, ఇది 15.3x వేగాన్ని అందుకుంటుంది, దీని కోసం 3,608 MB RAM అవసరమవుతుంది. కాబట్టి: Python API మరియు బ్యాచింగ్ కోసం faster-whisperను ఎంచుకోండి, RAM పరిమితి ఎక్కువగా ఉన్నప్పుడు whisper.cppని ఎంచుకోండి.

మొదటి వరుస ఈ విభాగం యొక్క ముఖ్య ఉద్దేశ్యం. రిఫరెన్స్ ప్యాకేజీ అదే మెషీన్‌పై 1.9x రియల్ టైమ్ వేగంతో పనిచేస్తుంది, అంటే ఒక గంట ఆడియోను ప్రాసెస్ చేయడానికి అరగంట CPU సమయం పడుతుంది.

Whisper మోడల్ వెయిట్స్ (weights) కోసం ఎంత డిస్క్ స్థలం అవసరం?

[
  {
    "label": "tiny",
    "weights_mb": 75.5
  },
  {
    "label": "base",
    "weights_mb": 145
  },
  {
    "label": "small",
    "weights_mb": 484
  },
  {
    "label": "medium",
    "weights_mb": "1,530"
  },
  {
    "label": "large-v3",
    "weights_mb": "3,090"
  }
]

ఇవి float16 ఫార్మాట్‌లో ప్రచురించబడిన CTranslate2 కన్వర్షన్లు. compute_type="int8" ఏమి చేయదో గమనించండి: ఇది డౌన్‌లోడ్ పరిమాణాన్ని తగ్గించదు. వెయిట్స్ float16 ఫార్మాట్‌లో వస్తాయి మరియు CTranslate2 వాటిని లోడ్ చేసే సమయంలో మెమరీలో క్వాంటైజ్ (quantize) చేస్తుంది. కాబట్టి, మీరు float16 లేదా int8 దేనిలో రన్ చేసినా, large-v3 డిస్క్‌పై 3,090 MB స్థలాన్ని ఆక్రమిస్తుంది. int8 మీకు RAM మరియు వేగాన్ని ఇస్తుంది, డిస్క్ స్థలాన్ని కాదు.

మోడల్స్ మొదటిసారి ఉపయోగించినప్పుడు ~/.cache/huggingface/hub లోకి డౌన్‌లోడ్ అవుతాయి. చిన్న రూట్ వాల్యూమ్ ఉన్న VPSలో, download_root ఆర్గ్యుమెంట్ లేదా HF_HOME ఎన్విరాన్‌మెంట్ వేరియబుల్ ఉపయోగించి తగినంత స్థలం ఉన్న చోటికి దీనిని మళ్లించండి. లేకపోతే, మొదటి రన్‌లోనే డిస్క్ నిండిపోయి, డౌన్‌లోడ్ మధ్యలోనే ప్రాసెస్ ఆగిపోతుంది.

సిస్టమ్ Python ను పాడుచేయకుండా faster-whisper ను ఇన్‌స్టాల్ చేయడం

Ubuntu 24.04 మరియు Debian 13 ఆపరేటింగ్ సిస్టమ్స్ సిస్టమ్ Python ను externally managed గా పరిగణిస్తాయి. వర్చువల్ ఎన్విరాన్‌మెంట్ వెలుపల pip install faster-whisper రన్ చేస్తే, వెంటనే ఈ క్రింది విధంగా ఆగిపోతుంది:

error: externally-managed-environment

ఇది apt యాజమాన్యంలోని ఫైళ్లను ప్యాకేజింగ్ సిస్టమ్ రక్షించడం వల్ల జరుగుతుంది. కాబట్టి వర్చువల్ ఎన్విరాన్‌మెంట్‌ను ఉపయోగించండి.

sudo apt update
sudo apt install -y python3-venv ffmpeg
python3 -m venv ~/stt
~/stt/bin/pip install --upgrade pip
~/stt/bin/pip install faster-whisper==1.2.1

అక్టోబర్ 2025లో విడుదలైన 1.2.1 వెర్షన్ ప్రస్తుతం అందుబాటులో ఉంది. faster-whisper తన సొంత ffmpeg లైబ్రరీలను కలిగి ఉన్న PyAV ద్వారా ఆడియోను డీకోడ్ చేస్తుంది, కాబట్టి ఇది విడిగా ffmpeg బైనరీ అవసరం లేకుండానే mp3 లేదా m4a ఫైళ్లను చదవగలదు. పైన పేర్కొన్న ffmpeg ప్యాకేజీ ఈ గైడ్‌లో తర్వాత వచ్చే వీడియో పనుల కోసం ఉపయోగపడుతుంది.

మూడు గిగాబైట్ల వెయిట్స్ (weights) డౌన్‌లోడ్ చేసే ముందు ఇన్‌స్టాలేషన్‌ను సరిచూసుకోండి:

~/stt/bin/python -c "from faster_whisper import WhisperModel; print('ok')"

ok అని ఉన్న లైన్ కనిపిస్తే, ప్యాకేజీలు విజయవంతంగా ఇన్‌స్టాల్ అయినట్లు అర్థం. ctranslate2 పేరుతో ImportError కనిపిస్తే, మీ ఆర్కిటెక్చర్‌కు సరిపోయే ప్యాకేజీ ఇన్‌స్టాల్ కాలేదని అర్థం; ఇది సాధారణంగా 32-bit ARM ఇమేజ్‌లలో జరుగుతుంది.

మీటింగ్ రికార్డింగ్ లేదా వాయిస్ నోట్‌ను ట్రాన్స్‌క్రిప్ట్ చేయడం

దీనిని transcribe.pyగా సేవ్ చేయండి:

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8", cpu_threads=4)
segments, info = model.transcribe("meeting.m4a", beam_size=5, vad_filter=True)

print("language: %s (%.2f)" % (info.language, info.language_probability))
for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))

దీనిని ~/stt/bin/python transcribe.pyతో రన్ చేయండి. మొదటిసారి రన్ చేసినప్పుడు weights డౌన్‌లోడ్ అవుతాయి, కాబట్టి కొంత సమయం వరకు ఏమీ ప్రింట్ అవ్వదు. ఆ తర్వాత, మోడల్ cache నుండి కొన్ని సెకన్లలోనే లోడ్ అవుతుంది.

segments అనేది ఒక generator, కాబట్టి మీరు దానిని iterate చేసే వరకు ట్రాన్స్‌క్రిప్షన్ ప్రారంభం కాదు. చాలామంది transcribe() కాల్‌ను టైమ్ చేస్తారు, అది వెంటనే రిటర్న్ అవ్వడం చూసి ఏదో పాడైందని అనుకుంటారు. ఏమీ పాడవలేదు. అసలు పని loop లోనే జరుగుతుంది.

vad_filter=True ముందుగా Silero VAD (voice activity detection) ను రన్ చేస్తుంది మరియు Whisper కు పంపే ముందు నిశ్శబ్దంగా ఉన్న భాగాలను తొలగిస్తుంది. ఎక్కువ విరామాలు ఉన్న మీటింగ్ రికార్డింగ్‌లలో ఇది వేగాన్ని పెంచే అతిపెద్ద మార్గం, ఎందుకంటే మాటలు లేని ఆడియోపై Whisper సమయాన్ని వృథా చేయదు. ఇది Whisper కు నిశ్శబ్దాన్ని పంపినప్పుడు అది పదాల కోసం వెతికి ఒకే వాక్యాన్ని పదేపదే చెప్పే సమస్యను కూడా నివారిస్తుంది.

cpu_threads ను మీకు ఉన్న అసలైన కోర్ల సంఖ్యకు సెట్ చేయండి. మీ vCPU కౌంట్ కంటే ఎక్కువగా సెట్ చేస్తే ట్రాన్స్‌క్రిప్షన్ నెమ్మదిస్తుంది, ఎందుకంటే అదనపు threads ఒకే కోర్ కోసం పోటీ పడతాయి మరియు scheduler ప్రతి switch కు సమయాన్ని వెచ్చించాల్సి వస్తుంది.

Jellyfin లైబ్రరీ కోసం సబ్‌టైటిల్స్

Jellyfin వీడియో పక్కన ఉండి, అదే పేరును కలిగి ఉన్న ఎక్స్‌టర్నల్ సబ్‌టైటిల్ ఫైళ్లను చదువుతుంది. కాబట్టి Movie (2019).en.srt పక్కన ఉన్న Movie (2019).mkv ఎటువంటి ట్రాన్స్‌కోడింగ్ లేదా లైబ్రరీ రీబిల్డ్ అవసరం లేకుండానే ఇంగ్లీష్ ట్రాక్‌గా కనిపిస్తుంది.

ముందుగా ఆడియోను ఎక్స్‌ట్రాక్ట్ చేయండి. Whisper అంతర్గతంగా అన్నింటినీ 16 kHz మోనోకు రీశాంపిల్ చేస్తుంది, కాబట్టి 16 kHz మోనో ఫైల్‌ను అందించడం వల్ల రెండు వైపులా పని తగ్గుతుంది:

ffmpeg -i "Movie (2019).mkv" -vn -ac 1 -ar 16000 -c:a pcm_s16le "Movie (2019).wav"

faster-whisper లో SRT రైటర్ లేదు, కాబట్టి సెగ్మెంట్లను మీరే ఫార్మాట్ చేయాలి. దీనిని srt.py గా సేవ్ చేయండి:

import sys
from faster_whisper import WhisperModel

def ts(seconds):
    ms = int(round(seconds * 1000))
    hours, ms = divmod(ms, 3600000)
    minutes, ms = divmod(ms, 60000)
    secs, ms = divmod(ms, 1000)
    return "%02d:%02d:%02d,%03d" % (hours, minutes, secs, ms)

model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe(sys.argv[1], vad_filter=True)

with open(sys.argv[2], "w", encoding="utf-8") as out:
    for index, segment in enumerate(segments, start=1):
        out.write("%d\n" % index)
        out.write("%s --> %s\n" % (ts(segment.start), ts(segment.end)))
        out.write("%s\n\n" % segment.text.strip())

ఆ తర్వాత లైబ్రరీని ఇలా ప్రాసెస్ చేయండి:

for f in /srv/media/films/*.mkv; do
  ffmpeg -nostdin -y -i "$f" -vn -ac 1 -ar 16000 -c:a pcm_s16le "${f%.mkv}.wav"
  nice -n 15 ~/stt/bin/python srt.py "${f%.mkv}.wav" "${f%.mkv}.en.srt"
  rm -f "${f%.mkv}.wav"
done

-nostdin అనేది అలంకరణ కోసం కాదు. అది లేకపోతే, ffmpeg లూప్ యొక్క స్టాండర్డ్ ఇన్‌పుట్ నుండి చదువుతుంది, మిగిలిన ఫైల్ జాబితాను తీసేసుకుంటుంది, మరియు ఎటువంటి ఎర్రర్ మెసేజ్ లేకుండానే ఒక సినిమా తర్వాత లూప్ ఆగిపోతుంది.

ప్రారంభించే ముందు సమయాన్ని అంచనా వేయండి. పైన పేర్కొన్న 7.6x వేగం ప్రకారం, 100 నిమిషాల సినిమాకు సుమారు 13 నిమిషాల CPU సమయం పడుతుంది, కాబట్టి యాభై సినిమాల లైబ్రరీకి రాత్రంతా సమయం పడుతుంది. షేర్డ్ vCPU ప్లాన్‌పై ఇది ఇంకా నెమ్మదిగా ఉంటుంది, అందుకే nice ఉపయోగపడుతుంది: ఇది సబ్‌టైటిల్ రన్ సమయంలో సర్వర్‌లోని ఇతర పనులకు ప్రాధాన్యతనిస్తుంది.

Piper తో Text to speech

Piper అనేది CPU పై ONNX వాయిస్ మోడల్‌ను రన్ చేసే ఒక neural text to speech ఇంజిన్. ఇది టెక్స్ట్‌ను ఫోనెమ్స్‌గా మార్చడానికి espeak-ng ను తనలో కలిగి ఉంటుంది, కాబట్టి విడిగా ఎటువంటి phonemizer ఇన్‌స్టాల్ చేయాల్సిన అవసరం లేదు. ప్రస్తుత release 1.6.0, ఇది జూలై 2026లో ప్రచురించబడింది.

python3 -m venv ~/tts
~/tts/bin/pip install piper-tts==1.6.0
~/tts/bin/python -m piper.download_voices en_US-lessac-medium
~/tts/bin/python -m piper -m en_US-lessac-medium -f test.wav -- 'This is a test.'

download_voices వర్కింగ్ డైరెక్టరీలో రెండు ఫైళ్లను రాస్తుంది: .onnx వెయిట్స్ మరియు శాంపిల్ రేట్, స్పీకర్ జాబితాను కలిగి ఉండే .onnx.json కాన్ఫిగరేషన్. ఇవి రెండూ కలిసే ఉండాలి. మీరు వాయిస్‌లను ఒక నిర్దిష్ట ప్రదేశంలో ఉంచినట్లయితే, రెండింటికీ --data-dir ను పాస్ చేయండి, లేకపోతే ప్లేయర్ వర్కింగ్ డైరెక్టరీలో వెతుకుతుంది మరియు అక్కడ లేని వాయిస్‌ను కనుగొనలేదు.

టెక్స్ట్‌కు ముందు ఉండే -- కూడా ముఖ్యమైనది. అది లేకపోతే, హైఫన్‌తో ప్రారంభమయ్యే ఏదైనా వాక్యం కమాండ్-లైన్ ఆప్షన్‌గా పరిగణించబడుతుంది.

వాయిస్‌లు వివిధ క్వాలిటీ స్థాయిలలో లభిస్తాయి. ఒక మీడియం ఇంగ్లీష్ వాయిస్ సుమారు 60 MB ఉంటుంది మరియు హై క్వాలిటీ వాయిస్ దానికంటే రెట్టింపు ఉంటుంది. అధిక క్వాలిటీ అంటే పెద్ద మోడల్ మరియు సెకనుకు ఎక్కువ CPU వినియోగం, వేరే స్పీకర్ అని కాదు.

CLI ని లూప్‌లో కాల్ చేయవద్దు. ఇది ప్రతిసారీ మోడల్‌ను లోడ్ చేస్తుంది, చిన్న వాక్యాలకు మోడల్ లోడింగ్ సమయమే ఎక్కువ తీసుకుంటుంది. దానికి బదులుగా HTTP సర్వర్‌ను రన్ చేయండి:

~/tts/bin/pip install 'piper-tts[http]==1.6.0'
~/tts/bin/python -m piper.http_server -m en_US-lessac-medium --host 127.0.0.1 --port 5000

curl -X POST -H 'Content-Type: application/json' \
  -d '{ "text": "This is a test." }' \
  -o test.wav localhost:5000/synthesize

మీరు ప్లే చేయగల test.wav ఉందంటే అది పనిచేస్తున్నట్లే. ఆ ఎండ్‌పాయింట్ Piper సొంత ఫార్మాట్, OpenAI ది కాదు, కాబట్టి /v1/audio/speech ని ఆశించే క్లయింట్ దీనితో కనెక్ట్ అవ్వదు. తదుపరి విభాగం దీనిని సరిచేస్తుంది.

దీనిని మీరు క్లోజ్ చేసే టెర్మినల్‌లో కాకుండా, unit file తో రన్ చేయండి:

[Unit]
Description=Piper text to speech HTTP server
After=network-online.target

[Service]
User=piper
ExecStart=/home/piper/tts/bin/python -m piper.http_server -m en_US-lessac-medium --data-dir /home/piper/voices --host 127.0.0.1 --port 5000
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now piper దీనిని స్టార్ట్ చేస్తుంది మరియు రీబూట్ తర్వాత కూడా తిరిగి రన్ అయ్యేలా చేస్తుంది. పైన ఉన్న curl ఏమీ చూపించకపోతే, journalctl -u piper -n 50 లో కారణం ఉంటుంది, సాధారణంగా వాయిస్ ఫైల్ లేకపోవడం వల్ల ఇలా జరుగుతుంది.

OpenAI-అనుకూల సర్వర్ ఆకృతి

ఆడియోను ప్రాసెస్ చేసే చాలా సాఫ్ట్‌వేర్‌లు ఇప్పటికే OpenAI ఆడియో APIని ఉపయోగిస్తాయి: ఫైల్ కోసం /v1/audio/transcriptions కి multipart POST, వాక్యం కోసం /v1/audio/speech కి JSON POST పంపాలి. ఈ రెండు paths ను మీరే సర్వ్ చేస్తే, క్లయింట్ దాని base URL ను ఒక్కసారి మార్చుకుంటే సరిపోతుంది.

Speaches అనేది రెండు దిశలలోనూ పనిచేసే ఒక సర్వర్. ఇది OpenAI paths వెనుక transcription కోసం faster-whisper ను, స్పీచ్ కోసం Piper లేదా Kokoro ను ఉపయోగిస్తుంది. ప్రస్తుత release డిసెంబర్ 2025 నాటి v0.9.0-rc.3, ఇది ఇంకా 1.0 వెర్షన్ కాలేదు, కాబట్టి మీ image tag ను pin చేసుకోండి మరియు upgrade చేసే ముందు release notes చదవండి.

curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.yaml
curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.cpu.yaml
export COMPOSE_FILE=compose.cpu.yaml
docker compose up --detach

మీరు compose files నిర్వహించకూడదనుకుంటే, single-container ఆకృతి ఇక్కడ ఉంది:

docker run --rm --detach --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cpu

Named volume ను చాలామంది మర్చిపోతుంటారు. అది లేకపోతే, model cache కంటైనర్ లోపలే ఉంటుంది, కాబట్టి ప్రతి restart తర్వాత మొదటి అభ్యర్థనను స్వీకరించేలోపు గిగాబైట్ల కొద్దీ weights మళ్ళీ డౌన్‌లోడ్ అవుతాయి.

/v1/audio/speech స్పందించాలంటే, ముందుగా Speech కు ఒక voice డౌన్‌లోడ్ అవసరం:

uvx speaches-cli model download speaches-ai/Kokoro-82M-v1.0-ONNX

ఆ తర్వాత, base URL మార్చడం ద్వారా ఏదైనా OpenAI క్లయింట్ పనిచేస్తుంది:

from pathlib import Path
from openai import OpenAI

openai = OpenAI(base_url="http://localhost:8000/v1", api_key="cant-be-empty")
res = openai.audio.speech.create(
    model="speaches-ai/Kokoro-82M-v1.0-ONNX",
    voice="af_heart",
    input="Hello, world!",
    response_format="mp3",
    speed=1,
)
with Path("output.mp3").open("wb") as f:
    f.write(res.response.read())

api_key అనే placeholder తప్పనిసరి, ఎందుకంటే OpenAI క్లయింట్ లైబ్రరీ అది లేకుండా అభ్యర్థనను పంపదు. మీరు నిజమైన కీని కాన్ఫిగర్ చేసే వరకు సర్వర్ దాని విలువను పట్టించుకోదు.

vox-box అనేది ఇక్కడ పేర్కొనదగ్గ మరొక ప్రాజెక్ట్. ఇది కంటైనర్ కంటే Python ప్యాకేజీగా ఉంటుంది, మరియు ఇది Whisper, FunASR, Bark, Dia లేదా CosyVoice లతో అదే paths ను సర్వ్ చేస్తుంది. డిసెంబర్ 2025 నాటి 0.0.21 వెర్షన్ ప్రస్తుతానికి అందుబాటులో ఉంది, దీనికి Python 3.10 లేదా అంతకంటే ఎక్కువ వెర్షన్ అవసరం.

python3 -m venv ~/voice
~/voice/bin/pip install vox-box==0.0.21
~/voice/bin/vox-box start --huggingface-repo-id Systran/faster-whisper-small \
  --data-dir ~/voice/data --host 127.0.0.1 --port 8010

ఈ ప్రాజెక్ట్ ఉదాహరణలో port 80 ని bind చేస్తారు, దీనికి root అనుమతులు అవసరం. ఇతర పనులు చేసే సర్వర్‌లో reverse proxy వెనుక high port ను ఉపయోగించడం మంచి పద్ధతి. vox-box start ఒక మోడల్‌ను మాత్రమే తీసుకుంటుంది, కాబట్టి రెండు దిశలను కవర్ చేయడానికి, speech repo id తో రెండో port పై మరొక instance ను నడపాలి.

సర్వర్ ఏది లోడ్ చేసిందో అడిగి తెలుసుకోండి, ఆపై ఆ id ని model ఫీల్డ్‌లో ఉపయోగించండి:

curl http://127.0.0.1:8010/v1/models

curl http://127.0.0.1:8010/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F file="@voice-note.m4a" \
  -F model="faster-whisper-small"

{"text": "..."} రూపంలో ఉన్న JSON బాడీ అంటే మొత్తం path పనిచేస్తుందని అర్థం. మోడల్ పేరుపై 404 వస్తే, మీరు /v1/models అవుట్‌పుట్‌ను చదవకుండా ఊహించారని అర్థం.

ఈ సర్వర్లలో ఏవీ డిఫాల్ట్‌గా authentication ను ఆన్ చేయవు. వీటిని 127.0.0.1 కి bind చేయండి మరియు VPN లేదా credentials అడిగే reverse proxy ద్వారా వీటిని యాక్సెస్ చేయండి. పబ్లిక్ IP పై తెరిచి ఉన్న /v1/audio/transcriptions ఎవరైనా కనుగొంటే, వారికి ఉచిత CPU వనరుగా మారుతుంది, మరియు వారు ఖచ్చితంగా దాన్ని కనుగొంటారు.

Self-hosted అసిస్టెంట్ కోసం వాయిస్ ఫ్రంట్ ఎండ్

OpenAI పాత్‌లపై రెండు దిశలలో సమాధానాలు వచ్చిన తర్వాత, ఒక చాట్ ఫ్రంట్ ఎండ్ వాటిని నడపగలదు. Open WebUI మరియు దాని ప్రత్యామ్నాయాలు తమ సెట్టింగ్‌లలో ఆడియో కోసం OpenAI-అనుకూల బేస్ URLను అంగీకరిస్తాయి, కాబట్టి ఒకే బాక్సులో Ollamaతో లోకల్ LLMను రన్ చేయడం మరియు రెండు చివరలా వాయిస్ లూప్‌ను పూర్తి చేయడం సాధ్యమవుతుంది.

Latencyని వాస్తవికంగా అంచనా వేయండి, ఎందుకంటే ఈ మూడు దశలు ఒకే కోర్లపై వరుసగా నడుస్తాయి. పైన పేర్కొన్న 7.6x వేగంతో 10 సెకన్ల ప్రశ్నను ట్రాన్స్‌క్రిప్ట్ చేయడానికి సుమారు 1.3 సెకన్లు పడుతుంది, ఇది మోడల్ ఒక్క టోకెన్‌ను కూడా చదవకముందే జరుగుతుంది. దీనికి CPU టోకెన్ జనరేషన్‌ను జోడిస్తే, రౌండ్ ట్రిప్ సమయం చాలా నెమ్మదిగా ఉంటుంది, దీనివల్ల అప్లికేషన్ క్రాష్ అయిందని వినియోగదారులు భావించే అవకాశం ఉంది. బ్యాచ్ ట్రాన్స్‌క్రిప్షన్ CPUపై సౌకర్యవంతంగా ఉంటుంది. సంభాషణ (Conversation) అలా ఉండదు, మరియు ఆ దశలోనే GPU ఉన్న VPS తన ఖర్చుకు తగిన విలువను అందించడం ప్రారంభిస్తుంది.

GPU ఎప్పుడు ఉపయోగకరంగా ఉంటుంది?

[
  {
    "label": "openai/whisper, fp16",
    "x_realtime": 5.5,
    "seconds": 143,
    "memory_mb": "4,708"
  },
  {
    "label": "faster-whisper, fp16",
    "x_realtime": 12.4,
    "seconds": 63,
    "memory_mb": "4,525"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 13.2,
    "seconds": 59,
    "memory_mb": "2,926"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 48.8,
    "seconds": 16,
    "memory_mb": "4,500"
  }
]

GPU పై, int8 లో ఉన్న పెద్ద మోడల్ 13.2x రియల్ టైమ్ వేగంతో, 2,926 MB VRAM లో నడుస్తుంది. బ్యాచింగ్ ద్వారా ఇది 48.8x కు చేరుకుంటుంది. ఈ రెండు చార్టులు ఏమి చెప్పడం లేదో గమనించండి. అవి వేర్వేరు మోడళ్లను ఉపయోగిస్తున్నాయి: GPU వరుసలు large-v2 మోడల్‌ను, CPU వరుసలు small మోడల్‌ను ఉపయోగిస్తున్నాయి. GPU చిన్న మోడల్‌ను ఆరు రెట్లు వేగవంతం చేయదు. ఇది ఖచ్చితమైన మోడల్‌ను ఉపయోగపడేలా చేస్తుంది.

ఒక షేర్డ్ vCPU ప్లాన్ ఈ CPU గణాంకాలను అందుకోలేదు. ఆ బెంచ్‌మార్క్ ఒక వేగవంతమైన డెస్క్‌టాప్ ప్రాసెసర్‌కు చెందిన 8 threads ను పూర్తిగా ఉపయోగించుకుంది. 7.6x ను గరిష్ట పరిమితిగా పరిగణించండి. ఏదైనా ప్లాన్ చేసే ముందు, నిజమైన రికార్డింగ్‌పై time ఉపయోగించి మీ స్వంత సర్వర్‌లో పరీక్షించండి.

ఆచరణలో ఉపయోగపడే నాలుగు సాధారణ నియమాలు:

• మీ స్వంత రికార్డింగ్‌లను అప్పుడప్పుడు ట్రాన్స్‌క్రిప్షన్ చేయడానికి: CPU, small, int8. రెండు డెడికేటెడ్ vCPU లు సరిపోతాయి.
• రాత్రిపూట బ్యాచ్ వర్క్ (ఉదాహరణకు సబ్‌టైటిల్స్ తయారీ): CPU, small లేదా medium, int8, nice లో అమర్చాలి.
• ఇంటరాక్టివ్ పనులు లేదా ఒకే రాత్రిలో మొత్తం లైబ్రరీని ప్రాసెస్ చేయడానికి: GPU.
• Piper: ఎల్లప్పుడూ CPU. ఈ పరిమాణంలో ఉన్న వాయిస్ మోడల్‌కు GPU వల్ల పెద్దగా ప్రయోజనం ఉండదు.

అదే హార్డ్‌వేర్‌పై ఇంకా ఏమి నడపవచ్చో మీరు ఆలోచిస్తుంటే, ఏ AI మోడళ్లను మీరు self-host చేయగలరు అనే విస్తృత ప్రశ్న ఏ పరిమాణాలు సరిపోతాయో, ఏవి సరిపోవో వివరిస్తుంది.

వైఫల్య రీతులు మరియు మీరు చూసే సందేశాలు

error: externally-managed-environment ఇన్‌స్టాలేషన్ సమయంలో వస్తుంది. సిస్టమ్ Python పంపిణీదారు (distribution) ద్వారా రక్షించబడుతుంది. పైన చూపిన విధంగా ఒక virtual environment ను సృష్టించండి.

GPU బాక్స్‌పై cuDNN సరిపోలకపోవడం. ఈ వైఫల్యం ఇలా కనిపిస్తుంది:

Unable to load any of {libcudnn_ops.so.9.1.0, libcudnn_ops.so.9.1, libcudnn_ops.so.9, libcudnn_ops.so}
Invalid handle. Cannot load symbol cudnnCreateTensorDescriptor

CTranslate2 4.5.0 మరియు ఆ తర్వాతి వెర్షన్లకు CUDA 12 కోసం cuDNN 9 అవసరం, కానీ హోస్ట్‌లో cuDNN 8 ఉంది. cuDNN 9 ను ఇన్‌స్టాల్ చేయండి లేదా pip install --force-reinstall ctranslate2==4.4.0 తో పాత రన్‌టైమ్‌ను పిన్ (pin) చేయండి. ఈ రెండింటిలో ఏదో ఒకటి మాత్రమే చేయండి. రెండూ చేస్తే మీరు మళ్ళీ మొదటికే వస్తారు.

This CTranslate2 package was not compiled with CUDA support అనేది ఇలాంటిదే కానీ భిన్నమైన లోపం. ఇన్‌స్టాల్ అయిన wheel కేవలం CPU-మాత్రమే ఉన్న బిల్డ్. GPU హోస్ట్‌లో virtual environment ను మళ్ళీ నిర్మించండి (rebuild) మరియు pip ని మళ్ళీ సరైన wheel ను ఎంచుకోనివ్వండి.

ట్రాన్స్‌క్రిప్ట్‌లో పునరావృతమయ్యే పదబంధాలు. ఒక వాక్యం పదిసార్లు లూప్ అవుతుందంటే, అది దాదాపు ఎప్పుడూ నిశ్శబ్దం లేదా సంగీతం ప్రసంగంగా డీకోడ్ అవ్వడం వల్ల జరుగుతుంది. ముందుగా vad_filter=True ను ఆన్ చేయండి. ఒకవేళ అప్పటికీ అలాగే ఉంటే, ఆ భాగాన్ని వినండి: దాదాపు నిశ్శబ్దంగా ఉన్న ఆడియోలో Whisper కు ఆధారపడటానికి ఏమీ దొరకదు, దాంతో అది చివరిగా నమ్మకంగా ఊహించిన పదాన్నే మళ్ళీ మళ్ళీ చెబుతుంది.

తప్పు భాష గుర్తించబడింది. Whisper మొదటి 30 సెకన్ల నుండి మాత్రమే భాషను ఊహిస్తుంది. info.language_probability విలువ 1.0 కంటే చాలా తక్కువగా ఉంటే, అది అనిశ్చితిలో ఉందని అర్థం; రికార్డింగ్ సంగీతంతో లేదా ఇతరుల సంభాషణలతో ప్రారంభమైనప్పుడు ఇలా జరుగుతుంది. మీకు భాష ముందే తెలిస్తే language="en" ను ఉపయోగించండి.

ప్రాసెస్ Killed అని ప్రింట్ చేసి ఆగిపోతుంది. ఇది కర్నల్ యొక్క out-of-memory killer, మరియు dmesg ఆ oom-kill లైన్‌ను చూపిస్తుంది. large-v3 మోడల్‌కు వర్కింగ్ మెమరీకి ముందే కేవలం వెయిట్స్ (weights) కోసమే 3 GB కంటే ఎక్కువ మెమరీ అవసరం. 2 GB VPS లో, int8 లో ఉన్న small మోడల్ మాత్రమే సరిపోతుంది.

Piper వాయిస్‌ను కనుగొనలేకపోతోంది. మీరు --data-dir ను పాస్ చేయకపోతే, ప్లేయర్ వర్కింగ్ డైరెక్టరీలో వెతుకుతుంది. మీరు ఆశించిన డైరెక్టరీలో ls ను రన్ చేయండి మరియు .onnx మరియు .onnx.json రెండూ అక్కడ ఉన్నాయని నిర్ధారించుకోండి, ఎందుకంటే ఒకటి లేకపోయినా అది పనిచేయదు.

FAQ

నేను కేవలం CPU మాత్రమే ఉన్న VPSలో speech-to-text రన్ చేయగలనా?

అవును, బ్యాచ్ పనుల కోసం ఇది సరైన ఎంపిక. int8 క్వాంటైజేషన్‌తో small మోడల్‌ను ఉపయోగిస్తున్న faster-whisper, డెస్క్‌టాప్ i7 లోని 8 త్రెడ్స్‌పై 13 నిమిషాల ఆడియోను 102 సెకన్లలో ట్రాన్స్‌క్రిప్ట్ చేస్తుందని ప్రాజెక్ట్ బెంచ్‌మార్క్‌లు చెబుతున్నాయి. ఇది 7.6x రియల్ టైమ్ వేగం మరియు 1,477 MB RAMను వినియోగిస్తుంది. షేర్డ్ vCPU ప్లాన్‌లు దీనికంటే నెమ్మదిగా ఉంటాయి, కాబట్టి మీ సర్వర్‌లో పనితీరును స్వయంగా పరీక్షించుకోండి. Piper తో text-to-speech మరింత సులభం మరియు దీనికి ఎటువంటి పరిస్థితుల్లోనూ GPU అవసరం లేదు.

నేను ఏ Whisper మోడల్ సైజును ఉపయోగించాలి?

int8 క్వాంటైజేషన్‌తో small మోడల్‌తో ప్రారంభించండి. ఇది డిస్క్‌పై 484 MB స్థలాన్ని ఆక్రమిస్తుంది మరియు స్పష్టంగా రికార్డ్ చేసిన మాటలను బాగా అర్థం చేసుకుంటుంది. యాస లేదా నేపథ్య శబ్దం (background noise) వల్ల లోపాలు వస్తున్నప్పుడు medium మోడల్‌కు మారండి. ఖచ్చితత్వమే అన్నింటికంటే ముఖ్యమైనప్పుడు మాత్రమే large-v3 మోడల్‌ను వాడండి, ఎందుకంటే దీనికి 3,090 MB డిస్క్ స్థలం మరియు 3 GB కంటే ఎక్కువ మెమరీ అవసరం. దీనికి విరుద్ధంగా, 75.5 MB సైజు ఉన్న tiny మోడల్ భాషను గుర్తించడానికి లేదా పైప్‌లైన్‌ను పరీక్షించడానికి ఉపయోగపడుతుంది, కానీ మనుషులు చదివే ట్రాన్స్‌క్రిప్ట్‌ల కోసం ఇది సరిపోదు.

అసలు Whisper ప్యాకేజీ కంటే faster-whisper ఎందుకు వేగంగా ఉంటుంది?

మోడల్ ఒక్కటే, కానీ రన్‌టైమ్ వేరు. అసలు ప్యాకేజీ PyTorch లో Whisper ను రన్ చేస్తుంది, కానీ faster-whisper అదే వెయిట్స్‌ను CTranslate2 పై రన్ చేస్తుంది. ఇది ట్రాన్స్‌ఫార్మర్ ఇన్‌ఫరెన్స్ కోసం రూపొందించబడిన ఇంజిన్, ఇది లోడ్ అయ్యేటప్పుడే వెయిట్స్‌ను క్వాంటైజ్ చేస్తుంది మరియు దీనికి PyTorch ఇన్‌స్టాలేషన్ అవసరం లేదు. ప్రచురించబడిన CPU బెంచ్‌మార్క్ ప్రకారం, అసలు ప్యాకేజీ 1.9x రియల్ టైమ్ వేగంతో పనిచేస్తుంటే, faster-whisper (int8) 7.6x వేగంతో, తక్కువ మెమరీని వాడుకుంటూ పనిచేస్తుంది.

నా ట్రాన్స్‌క్రిప్ట్ ఒకే వాక్యాన్ని పదే పదే ఎందుకు రిపీట్ చేస్తోంది?

Whisper నిశ్శబ్దాన్ని లేదా సంగీతాన్ని మాటలుగా పొరబడి, తన చివరి అంచనాను పదే పదే చెబుతోంది. transcribe() కాల్‌లో vad_filter=True ను సెట్ చేయండి. ఇది ముందుగా Silero voice activity detection ను రన్ చేసి, మోడల్‌కు ఆడియో అందకముందే నిశ్శబ్ద భాగాలను తొలగిస్తుంది. ఒకవేళ అప్పటికీ రిపీట్ అవుతుంటే, ఆడియో స్థాయిని తనిఖీ చేయండి; ఎందుకంటే పూర్తిగా నిశ్శబ్దంగా ఉన్న రికార్డింగ్‌లో మోడల్‌కు ప్రాసెస్ చేయడానికి ఏమీ ఉండదు.

నా సొంత సర్వర్‌లో OpenAI-compatible ఆడియో ఎండ్‌పాయింట్‌ను ఎలా పొందాలి?

POST /v1/audio/transcriptions మరియు POST /v1/audio/speech లను అమలు చేసే సర్వర్‌ను రన్ చేసి, క్లయింట్‌ను కొత్త base URL కి పాయింట్ చేయండి. Speaches ఒక ఎంపిక, ఇది CPU బిల్డ్‌తో కంటైనర్ ఇమేజ్‌గా లభిస్తుంది; ఇది ట్రాన్స్‌క్రిప్షన్ కోసం faster-whisper ను, స్పీచ్ కోసం Piper లేదా Kokoro ను ఉపయోగిస్తుంది. vox-box మరొక ఎంపిక, దీనిని pip install vox-box తో ఇన్‌స్టాల్ చేసి vox-box start --huggingface-repo-id తో స్టార్ట్ చేయవచ్చు, ఇది ప్రతి ప్రాసెస్‌కు ఒక మోడల్‌ను అందిస్తుంది. వీటిలో దేనికీ డిఫాల్ట్‌గా అథెంటికేషన్ ఉండదు, కాబట్టి localhost కి బైండ్ చేసి, ముందు ఒక proxy లేదా VPN ను ఉంచండి.