VPS पर Self-hosted Speech to Text और TTS कैसे सेटअप करें

Self-hosted speech to text और TTS का संक्षिप्त विवरण

Self-hosted speech to text और TTS (text to speech) आपके द्वारा संचालित सर्वर पर चलने वाला सबसे किफायती AI है। Transcription के लिए Whisper को faster-whisper runtime के माध्यम से चलाया जाता है। Synthesis के लिए Piper का उपयोग होता है। ये दोनों बिना GPU वाले सामान्य CPU VPS पर काम करते हैं। छोटा Whisper model लगभग 484 MB डिस्क स्पेस लेता है और एक Piper voice फाइल 150 MB से काफी कम होती है।

यही कारण है कि ऑडियो से शुरुआत करना सबसे बेहतर है। Self-hosted image generator और self-hosted video generation दोनों को उपयोग करने योग्य होने के लिए GPU की आवश्यकता होती है। ऑडियो के लिए इसकी आवश्यकता नहीं है।

यह गाइड दोनों दिशाओं और उन्हें जोड़ने वाली परत को कवर करती है। Whisper ऑडियो को टेक्स्ट में बदलता है। Piper टेक्स्ट को ऑडियो में बदलता है। इन दोनों के सामने एक OpenAI-compatible HTTP server लगाने से कोई भी मौजूदा client बिना किसी बदलाव के केवल base URL बदलकर आपके सर्वर से जुड़ सकता है।

यहाँ उल्लिखित प्रत्येक version अगस्त 2026 तक अद्यतित था।

faster-whisper क्यों, न कि reference Whisper package

OpenAI का whisper package मॉडल को PyTorch में चलाता है। faster-whisper उन्हीं मॉडल weights को CTranslate2 पर चलाता है, जो विशेष रूप से transformer मॉडल्स के लिए बनाया गया एक inference engine है। Weights समान हैं, इसलिए transcript भी वही मिलता है। अंतर पूरी तरह से runtime का है।

CTranslate2 लोड होते समय weights को quantize करता है, इसीलिए compute_type="int8" एक argument है, न कि कोई अलग conversion step। इसमें PyTorch की कोई dependency भी नहीं है। pip install faster-whisper, CTranslate2, एक tokenizer और audio decoding के लिए PyAV को pull करता है, जिससे virtual environment का आकार कई gigabytes के बजाय कुछ सौ megabytes ही रहता है। 40 GB disk वाले VPS पर यह अंतर 'आरामदायक' और 'तंग' स्थिति के बीच का होता है।

यहाँ CPU पर small मॉडल के लिए प्रोजेक्ट द्वारा प्रकाशित आंकड़े दिए गए हैं। यह benchmark Intel Core i7-12700K पर 8 threads का उपयोग करके 13 मिनट के audio को transcribe करता है। x_realtime column वह 13 मिनट है जिसे मापे गए समय से विभाजित किया गया है: 7.6 का अर्थ है कि 13 मिनट की recording 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 बनाम 5.0x, और यह आधी से भी कम memory में काम करता है। यह वही ggml family है जो local LLM stack के llama.cpp side के पीछे काम करती है। faster-whisper तब आगे निकल जाता है जब int8 और batching चालू होते हैं, जो 15.3x तक पहुँच जाता है, और इसके लिए यह 3,608 MB RAM का उपयोग करता है। इसलिए: Python API और batching के लिए faster-whisper चुनें, और जब RAM की कमी हो जिसे आप दूर नहीं कर सकते, तब whisper.cpp चुनें।

पहली पंक्ति इस section का मुख्य बिंदु है। reference package उसी machine पर 1.9x real time है, जिसका अर्थ है कि एक घंटे के audio को process करने में आधा घंटा CPU समय लगता है।

Whisper model 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"
  }
]

ये CTranslate2 द्वारा रूपांतरित (converted) float16 प्रारूप में प्रकाशित weights हैं। ध्यान दें कि compute_type="int8" क्या नहीं करता है: यह डाउनलोड के आकार को कम नहीं करता है। Weights float16 में ही डाउनलोड होते हैं और CTranslate2 उन्हें लोड होते समय मेमोरी में quantize करता है, इसलिए large-v3 चाहे आप float16 में चलाएं या int8 में, डिस्क पर 3,090 MB जगह ही लेगा। int8 का उपयोग करने से RAM और गति में लाभ मिलता है, डिस्क स्पेस में नहीं।

Models पहली बार उपयोग किए जाने पर ~/.cache/huggingface/hub में डाउनलोड होते हैं। यदि आप छोटे root volume वाले VPS का उपयोग कर रहे हैं, तो download_root argument या HF_HOME environment variable का उपयोग करके इसे किसी ऐसी जगह निर्देशित करें जहाँ पर्याप्त जगह हो। अन्यथा, पहली बार चलाने पर डिस्क भर जाएगी और डाउनलोड के बीच में ही प्रक्रिया समाप्त (die) हो जाएगी।

system Python को प्रभावित किए बिना faster-whisper इंस्टॉल करना

Ubuntu 24.04 और Debian 13 में system Python को externally managed के रूप में चिह्नित किया गया है। virtual environment के बाहर pip install faster-whisper चलाने पर प्रक्रिया तुरंत रुक जाती है और यह त्रुटि मिलती है:

error: externally-managed-environment

यह packaging system उन फाइलों की सुरक्षा कर रहा है जिनका स्वामित्व apt के पास है। इसके लिए virtual environment का उपयोग करें।

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

Version 1.2.1 वर्तमान release है, जिसे October 2025 में प्रकाशित किया गया था। faster-whisper PyAV के माध्यम से audio decode करता है, जो अपनी स्वयं की ffmpeg libraries को बंडल करता है। इसलिए यह किसी अलग ffmpeg binary के बिना ही mp3 या m4a फाइलें पढ़ लेता है। ऊपर दिया गया ffmpeg package इस गाइड में बाद में वीडियो संबंधी कार्यों के लिए है।

तीन gigabytes के weights डाउनलोड करने से पहले इंस्टॉलेशन की जाँच करें:

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

ok पढ़ने वाली एक लाइन का अर्थ है कि wheels सफलतापूर्वक इंस्टॉल हो गए हैं। ctranslate2 का नाम लेने वाली एक ImportError का अर्थ है कि आपके architecture के लिए wheel इंस्टॉल नहीं हुआ है, जो कि 32-bit ARM images पर होता है।

मीटिंग रिकॉर्डिंग या वॉइस नोट को ट्रांसक्राइब करें

इसे 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() कॉल का समय मापते हैं, देखते हैं कि यह तुरंत return हो जाता है, और सोचते हैं कि कुछ खराब हो गया है। कुछ भी खराब नहीं है। सारा काम लूप के अंदर होता है।

vad_filter=True पहले Silero VAD (voice activity detection) चलाता है और Whisper द्वारा देखे जाने से पहले silent हिस्सों को हटा देता है। लंबी चुप्पी वाली मीटिंग रिकॉर्डिंग पर यह गति बढ़ाने का सबसे बड़ा तरीका है, क्योंकि Whisper को उन ऑडियो हिस्सों पर समय बर्बाद नहीं करना पड़ता जिनमें कोई बातचीत नहीं है। यह उन दोहराए जाने वाले वाक्यों के लूप को भी रोकता है जो Whisper तब बनाता है जब उसे silence दी जाती है और वह उसमें शब्द खोजने की कोशिश करता है।

cpu_threads को उन cores की संख्या पर सेट करें जो आपके पास वास्तव में उपलब्ध हैं। इसे अपने vCPU काउंट से ऊपर सेट करने पर ट्रांसक्रिप्शन धीमा हो जाता है, क्योंकि अतिरिक्त threads एक ही core के लिए प्रतिस्पर्धा करते हैं और 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 एक neural text to speech engine है जो CPU पर ONNX voice model चलाता है। यह text को phonemes में बदलने के लिए espeak-ng को embed करता है, इसलिए अलग से कोई phonemizer install करने की आवश्यकता नहीं है। वर्तमान release 1.6.0 है, जिसे July 2026 में publish किया गया था।

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 working directory में दो फाइलें लिखता है: .onnx weights और एक .onnx.json config जिसमें sample rate और speaker list होती है। इन्हें एक साथ रहना चाहिए। यदि आप voices को किसी निश्चित स्थान पर रखते हैं, तो दोनों commands में --data-dir pass करें, क्योंकि अन्यथा player working directory में देखता है और वहां मौजूद न होने पर voice को ढूंढ नहीं पाता है।

Text से पहले -- का उपयोग करना भी महत्वपूर्ण है। इसके बिना, hyphen से शुरू होने वाला कोई भी वाक्य command-line option के रूप में parse हो जाता है।

Voices कई quality levels में आती हैं। एक medium English voice लगभग 60 MB की होती है और high quality वाली इससे लगभग दोगुनी होती है। उच्च quality का अर्थ है एक बड़ा model और प्रति सेकंड speech के लिए अधिक CPU usage, न कि कोई अलग speaker।

CLI को loop में call न करें। यह हर invocation पर model load करता है, और छोटे वाक्यों के लिए model loading में ही सबसे अधिक समय लगता है। इसके बजाय HTTP server चलाएं:

~/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 जिसे आप play कर सकते हैं, उसका मतलब है कि यह काम कर रहा है। वह endpoint Piper का अपना format है, OpenAI का नहीं, इसलिए /v1/audio/speech की अपेक्षा करने वाला client इससे connect नहीं हो पाएगा। अगला section इसे ठीक करता है।

इसे terminal के बजाय 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 इसे start करता है और reboot के बाद वापस लाता है। यदि ऊपर दिया गया curl कुछ भी return नहीं करता है, तो journalctl -u piper -n 50 में कारण मौजूद होता है, और आमतौर पर इसका कारण missing voice file होती है।

OpenAI-compatible सर्वर का स्वरूप

ऑडियो संभालने वाला अधिकांश सॉफ्टवेयर पहले से ही OpenAI ऑडियो API का उपयोग करता है: फाइल के लिए /v1/audio/transcriptions पर एक multipart POST, और वाक्य के लिए /v1/audio/speech पर एक JSON POST। इन दोनों paths को स्वयं serve करें, और क्लाइंट को केवल अपना base URL बदलने की आवश्यकता होगी।

Speaches एक ऐसा सर्वर है जो दोनों दिशाओं में काम करता है। यह OpenAI paths के पीछे transcription के लिए faster-whisper और speech के लिए Piper या Kokoro चलाता है। वर्तमान release v0.9.0-rc.3 है, जो दिसंबर 2025 का है। यह अभी 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 container के अंदर रहता है, इसलिए हर restart पर पहली request का उत्तर देने से पहले ही gigabytes weights को फिर से download करना पड़ता है।

Speech को /v1/audio/speech के उत्तर देने से पहले एक voice download करने की आवश्यकता होती है:

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

उसके बाद, कोई भी OpenAI क्लाइंट base URL बदलने पर काम करने लगता है:

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())

Placeholder api_key आवश्यक है क्योंकि OpenAI क्लाइंट लाइब्रेरी इसके बिना request भेजने से मना कर देती है। जब तक आप एक वास्तविक key configure नहीं करते, सर्वर इसके मान (value) को अनदेखा कर देता है।

vox-box यहाँ उल्लेख करने योग्य दूसरा प्रोजेक्ट है। यह container के बजाय एक Python package है, और यह Whisper, FunASR, Bark, Dia या CosyVoice के साथ उन्हीं paths को serve करता है। संस्करण 0.0.21 वर्तमान है, जो दिसंबर 2025 का है, और इसके लिए 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 एक model लेता है, इसलिए दोनों दिशाओं को कवर करने का अर्थ है एक दूसरे port पर दूसरी instance, जिसमें speech repo id हो।

सर्वर से पूछें कि उसने क्या load किया है, फिर उस id का उपयोग model field में करें:

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 body का अर्थ है कि पूरा path काम कर रहा है। Model name पर 404 आने का मतलब है कि आपने /v1/models output को पढ़ने के बजाय अनुमान लगाया है।

इनमें से कोई भी सर्वर डिफ़ॉल्ट रूप से authentication चालू नहीं करता है। उन्हें 127.0.0.1 पर bind करें और उन तक VPN या ऐसे reverse proxy के माध्यम से पहुँचें जो credentials मांगता हो। Public IP पर खुला /v1/audio/transcriptions किसी के भी उपयोग के लिए मुफ्त CPU है, और वे इसे ढूंढ ही लेंगे।

Self-hosted assistant के लिए एक voice front end

जब OpenAI paths पर दोनों दिशाओं में response मिलने लगे, तो एक chat front end उन्हें संचालित कर सकता है। Open WebUI और इसके विकल्प अपनी settings में audio के लिए OpenAI-compatible base URL स्वीकार करते हैं, इसलिए एक ही box Ollama के साथ local LLM चला सकता है और दोनों सिरों पर voice loop को पूरा कर सकता है।

Latency का आकलन ईमानदारी से करें, क्योंकि ये तीनों चरण एक ही cores पर एक के बाद एक चलते हैं। 10 second के प्रश्न को transcribe करने में ऊपर दिए गए 7.6x आंकड़े के अनुसार लगभग 1.3 seconds लगते हैं, और यह तब है जब model ने एक भी token नहीं पढ़ा है। इसमें CPU token generation को जोड़ें, तो round trip इतना धीमा हो जाता है कि testers को लगता है कि system crash हो गया है। Batch transcription 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 पर, large model int8 में 13.2x real time की गति से 2,926 MB VRAM के भीतर चलता है, और batching इसे 48.8x तक ले जाती है। ध्यान दें कि ये दो चार्ट क्या नहीं बताते हैं। वे अलग-अलग models चलाते हैं: GPU पंक्तियाँ large-v2 के लिए हैं, और CPU पंक्तियाँ small model के लिए। GPU small model को छह गुना तेज नहीं बनाता है। यह सटीक (accurate) model को उपयोग करने योग्य बनाता है।

एक shared vCPU प्लान CPU के इन आंकड़ों तक नहीं पहुँचेगा। उस benchmark में एक तेज़ desktop processor के 8 threads का पूरा उपयोग किया गया था। 7.6x को एक अधिकतम सीमा (ceiling) मानें, और किसी भी योजना को बनाने से पहले time का उपयोग करके अपनी मशीन पर एक वास्तविक रिकॉर्डिंग के साथ मापें।

व्यावहारिक रूप से लागू होने वाले चार सामान्य नियम:

• अपनी रिकॉर्डिंग का कभी-कभार transcription: CPU, small, int8। दो dedicated vCPU पर्याप्त हैं।
• रात भर चलने वाला batch work जैसे subtitle run: CPU, small या medium, int8, जिसे nice में लपेटा गया हो।
• कुछ भी interactive, या एक शाम में पूरी लाइब्रेरी: GPU।
• Piper: हमेशा CPU। इस आकार का voice model GPU से लगभग कुछ भी हासिल नहीं करता है।

यदि आप यह पता लगा रहे हैं कि वही hardware और क्या संभाल सकता है, तो किन AI models को आप self-host कर सकते हैं, इस व्यापक प्रश्न में उन आकारों को शामिल किया गया है जो फिट होते हैं और जो नहीं होते हैं।

विफलता के प्रकार और दिखाई देने वाले संदेश

error: externally-managed-environment इंस्टॉलेशन के समय। सिस्टम Python वितरण (distribution) द्वारा सुरक्षित होता है। ऊपर दिखाए अनुसार एक virtual environment बनाएँ।

GPU बॉक्स पर cuDNN बेमेल (mismatch)। विफलता इस प्रकार दिखती है:

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 के साथ पुराने runtime को पिन करें। इन दोनों में से कोई एक कार्य करें। दोनों करने से आप वापस वहीं पहुँच जाएंगे जहाँ से शुरू किया था।

This CTranslate2 package was not compiled with CUDA support एक अलग त्रुटि है जो समान महसूस होती है। जो wheel इंस्टॉल हुआ है, वह केवल CPU-only बिल्ड है। GPU होस्ट पर virtual environment को फिर से बनाएँ और pip को wheel दोबारा चुनने दें।

ट्रांसक्रिप्ट में वाक्यांशों का दोहराव। एक वाक्य का दस बार लूप होना लगभग हमेशा चुप्पी या संगीत का भाषण के रूप में डिकोड होना होता है। पहले vad_filter=True को चालू करें। यदि इसके बाद भी समस्या बनी रहती है, तो उस सेगमेंट को सुनें: लगभग शांत ऑडियो Whisper को आधार (anchor) नहीं देता है और वह अपने अंतिम अनुमान को दोहराता है।

गलत भाषा का पता चलना। Whisper केवल पहले 30 सेकंड से अनुमान लगाता है। 1.0 से काफी कम info.language_probability का मतलब है कि यह अनिश्चित था, जो तब होता है जब रिकॉर्डिंग संगीत या क्रॉस-टॉक के साथ शुरू होती है। यदि आप उत्तर पहले से जानते हैं, तो language="en" पास करें।

प्रक्रिया Killed प्रिंट करती है और रुक जाती है। यह kernel का out-of-memory killer है, और dmesg संबंधित oom-kill लाइन दिखाएगा। large-v3 को किसी भी working memory से पहले केवल weights के लिए 3 GB से अधिक की आवश्यकता होती है। 2 GB VPS पर, int8 पर small सबसे बड़ा मॉडल है जो फिट हो सकता है।

Piper आवाज़ नहीं ढूँढ पा रहा है। प्लेयर working directory में देखता है जब तक कि आप --data-dir पास न करें। जिस डायरेक्टरी की आप अपेक्षा कर रहे हैं, उस पर ls चलाएँ और पुष्टि करें कि .onnx और .onnx.json दोनों मौजूद हैं, क्योंकि एक के बिना दूसरा होना भी उतना ही विफल होता है जितना कि दोनों का न होना।

FAQ

क्या मैं केवल CPU वाले VPS पर speech-to-text चला सकता हूँ?

हाँ, और batch कार्य के लिए यह एक समझदारी भरा विकल्प है। int8 पर small मॉडल के साथ faster-whisper का उपयोग करते हुए, प्रोजेक्ट के प्रकाशित बेंचमार्क के अनुसार यह डेस्कटॉप i7 के 8 थ्रेड्स पर 13 मिनट की ऑडियो को 102 सेकंड में ट्रांसक्राइब करता है, जो कि वास्तविक समय से लगभग 7.6 गुना तेज है और इसके लिए 1,477 MB RAM की आवश्यकता होती है। एक shared vCPU प्लान इससे धीमा चलेगा, इसलिए अपने सर्वर पर स्वयं मापें। Piper के साथ text-to-speech और भी आसान है और इसके लिए किसी भी परिस्थिति में GPU की आवश्यकता नहीं होती है।

मुझे किस Whisper मॉडल आकार का उपयोग करना चाहिए?

small मॉडल और int8 से शुरुआत करें। यह डिस्क पर 484 MB का है और स्पष्ट रिकॉर्ड की गई स्पीच को अच्छी तरह से हैंडल करता है। जब लहजे या बैकग्राउंड शोर के कारण ऐसी त्रुटियाँ आएँ जिन्हें आप स्वीकार नहीं कर सकते, तब medium पर जाएँ। large-v3 का उपयोग केवल तब करें जब सटीकता सबसे महत्वपूर्ण हो, क्योंकि इसके लिए 3,090 MB डिस्क और 3 GB से अधिक मेमोरी की आवश्यकता होती है। इसके विपरीत, 75.5 MB वाला tiny मॉडल भाषा का पता लगाने और पाइपलाइन का परीक्षण करने के लिए उपयोगी है, न कि उन ट्रांसक्रिप्ट के लिए जिन्हें कोई व्यक्ति पढ़ेगा।

faster-whisper मूल Whisper पैकेज से तेज क्यों है?

मॉडल वही है, लेकिन रनटाइम अलग है। संदर्भ पैकेज PyTorch में Whisper चलाता है, जबकि faster-whisper उन्हीं weights को CTranslate2 पर चलाता है। यह एक ऐसा इंजन है जिसे ट्रांसफॉर्मर इन्फरेंस के लिए बनाया गया है, जो लोड होने के समय weights को क्वांटाइज़ करता है और इसके लिए PyTorch इंस्टॉलेशन की आवश्यकता नहीं होती है। प्रकाशित CPU बेंचमार्क पर, संदर्भ पैकेज वास्तविक समय से 1.9 गुना तेज है, जबकि int8 पर faster-whisper 7.6 गुना तेज है और कम मेमोरी का उपयोग करता है।

मेरा ट्रांसक्रिप्ट एक ही वाक्य को बार-बार क्यों दोहराता है?

Whisper चुप्पी या संगीत को स्पीच के रूप में डिकोड कर रहा है और अपने पिछले अनुमान पर वापस जा रहा है। vad_filter=True को transcribe() कॉल में सेट करें, जो पहले 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 के साथ शुरू किया जाता है, जो प्रति प्रोसेस एक मॉडल सर्व करता है। इनमें से कोई भी डिफ़ॉल्ट रूप से प्रमाणीकरण (authentication) सक्षम नहीं करता है, इसलिए इसे localhost पर बाइंड करें और सामने एक प्रॉक्सी या VPN लगाएँ।