SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor

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

अपने VPS पर Whisper और Piper चलाकर किफायती AI ऑडियो समाधान पाएं। यह गाइड CPU उपयोग, डिस्क स्पेस की खपत और OpenAI compatible API एंडपॉइंट बनाने की पूरी प्रक्रिया बताती है।

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

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

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

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

यहाँ कमांड में पिन किया गया हर version 11 अक्टूबर, 2026 को संबंधित प्रोजेक्ट के release page के अनुसार जाँचा गया था। Failure modes के अंतर्गत बताए गए CTranslate2 versions compatibility markers हैं, न कि वर्तमान releases।

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

OpenAI का whisper package मॉडल को PyTorch में चलाता है। faster-whisper उन्हीं मॉडल weights को CTranslate2 पर चलाता है, जो विशेष रूप से transformer मॉडल्स के लिए बनाया गया एक inference engine है। मॉडल वही है, लेकिन quantization और decoding सेटिंग्स 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 कॉलम वह 13 मिनट है जिसे मापे गए समय से विभाजित किया गया है: 7.6 का मतलब है कि 13 मिनट की recording 1 मिनट 40 सेकंड से कुछ अधिक समय में पूरी हुई।

चार्टWhisper small on CPU, 13 minutes of audio (published project figures)
इस चार्ट के पीछे का डेटा
[
  {
    "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 परिवार है जो local LLM stack के llama.cpp पक्ष के पीछे काम करता है। faster-whisper तब आगे निकल जाता है जब int8 और batching चालू होते हैं, जो 15.3x तक पहुँच जाता है, और इसके लिए यह 3,608 MB RAM का उपयोग करता है। इसलिए: Python API और batching के लिए faster-whisper चुनें, और जब RAM की कमी हो जिसे आप बदल नहीं सकते, तब whisper.cpp चुनें।

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

Whisper model weights को कितनी डिस्क स्पेस की आवश्यकता होती है?

चार्टfaster-whisper model weights on disk (Systran CTranslate2 conversions, float16)
इस चार्ट के पीछे का डेटा
[
  {
    "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 डाउनलोड करने से पहले installation की जाँच करें:

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

ok पढ़ने वाली एक पंक्ति का अर्थ है कि wheels सफलतापूर्वक इंस्टॉल हो गए हैं। ctranslate2 का नाम लेने वाली एक ImportError त्रुटि का अर्थ है कि runtime गायब है या इसकी compiled library लोड नहीं हो सकी, और संदेश का शेष भाग यह बताता है कि समस्या क्या है। 32-bit ARM images पर CTranslate2 का कोई wheel उपलब्ध नहीं है, इसलिए pip install के समय ही विफल हो जाता है।

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

इसे 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 होने पर लाइब्रेरी को दोबारा बनाने की आवश्यकता के बिना यह एक इंग्लिश ट्रैक के रूप में दिखाई देता है। कोई विशिष्ट क्लाइंट इसे सीधे चलाएगा, या सर्वर इसे remux करेगा या वीडियो में बर्न (burn) करेगा, यह इस बात पर निर्भर करता है कि वह क्लाइंट क्या सपोर्ट करता है।

सबसे पहले ऑडियो को एक्सट्रैक्ट करें। 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 के कीबोर्ड इंटरैक्शन को डिसेबल करता है। यह ffmpeg को तब फाइलनाम लेने से भी रोकता है जब यह ऐसे लूप के अंदर चलता है जो उन्हें स्टैंडर्ड इनपुट से पढ़ता है। ऊपर दिया गया glob-आधारित लूप अपनी फाइल लिस्ट को स्टैंडर्ड इनपुट से नहीं पढ़ता है।

शुरू करने से पहले समय का अनुमान लगा लें। ऊपर दिए गए 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.8.0 है, जिसे September 2026 में publish किया गया था।

python3 -m venv ~/tts
~/tts/bin/pip install piper-tts==1.8.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 में दो files लिखता है: .onnx weights और एक .onnx.json config जिसमें sample rate और speaker list होती है। इन्हें एक साथ रहना चाहिए। यदि आप voices को किसी निश्चित स्थान पर रखते हैं, तो दोनों commands को --data-dir pass करें, क्योंकि अन्यथा player working directory में देखता है और उसे वह voice नहीं मिलती जो वहाँ नहीं है।

Text से पहले -- भी मायने रखता है। यह text को command-line options से अलग करता है, जिसमें वे options भी शामिल हैं जिन्हें hyphen से शुरू होने वाला वाक्य trigger कर सकता है।

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

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

~/tts/bin/pip install 'piper-tts[http]==1.8.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 का नहीं, इसलिए जो client /v1/audio/speech की अपेक्षा करता है, वह इससे बात नहीं करेगा। अगला section इसे ठीक करता है।

इसे terminal के बजाय unit file के साथ चलाएँ जिसे आप बंद कर देंगे। Unit Piper को एक piper user के रूप में चलाती है जिसका कोई login नहीं है, उस user के home से, ताकि service आपके account पर निर्भर न रहे। User बनाएँ और वहाँ Piper तथा voice install करें:

sudo useradd --system --create-home --home-dir /home/piper --shell /usr/sbin/nologin piper
sudo -u piper python3 -m venv /home/piper/tts
sudo -u piper /home/piper/tts/bin/pip install 'piper-tts[http]==1.8.0'
sudo -u piper /home/piper/tts/bin/python -m piper.download_voices --data-dir /home/piper/voices en_US-lessac-medium

अपने terminal में शुरू किए गए server को stop करें, फिर unit लिखें:

[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 इसे शुरू करता है और 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 दिसंबर 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 container के अंदर रहता है, इसलिए container को हटाने और फिर से बनाने पर डाउनलोड किए गए weights नष्ट हो जाते हैं। उसी container को restart करने पर वे सुरक्षित रहते हैं।

Speech को /v1/audio/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())

Placeholder api_key आवश्यक है क्योंकि OpenAI क्लाइंट लाइब्रेरी इसके बिना अनुरोध भेजने से मना कर देती है। जब तक आप एक वास्तविक key कॉन्फ़िगर नहीं करते, सर्वर इसके मान को अनदेखा कर देता है।

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 या CAP_NET_BIND_SERVICE capability की आवश्यकता होती है। यदि सर्वर पर अन्य कार्य भी हो रहे हैं, तो reverse proxy के पीछे एक high port का उपयोग करना बेहतर स्वरूप है। vox-box start एक बार में एक ही model लेता है, इसलिए दोनों दिशाओं को कवर करने के लिए एक speech repo id के साथ दूसरे port पर एक दूसरा instance चलाना होगा।

सर्वर से पूछें कि उसने क्या लोड किया है, फिर उस 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 सही ढंग से काम कर रहा है। 404 error के लिए, response body को पढ़ें और /v1/models के विरुद्ध model id की जाँच करें। Speaches एक ऐसे valid model के लिए भी 404 लौटाता है जो स्थानीय रूप से स्थापित नहीं है। यदि error में यह कहा गया है, तो uvx speaches-cli model download MODEL_ID के साथ अनुरोधित model को डाउनलोड करें और फिर पुनः प्रयास करें। इसका download route POST /v1/models/{model_id} है।

इनमें से कोई भी सर्वर डिफ़ॉल्ट रूप से authentication चालू नहीं करता है। उन्हें 127.0.0.1 पर bind करें और उन तक VPN या ऐसे reverse proxy के माध्यम से पहुँचें जो credentials मांगता है। सार्वजनिक 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 वास्तव में कब उपयोगी होता है?

चार्टWhisper large-v2 on an RTX 3070 Ti, 13 minutes of audio (published project figures)
इस चार्ट के पीछे का डेटा
[
  {
    "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 के भीतर चलता है, और batching इसे 48.8x तक ले जाती है। ध्यान दें कि ये दो चार्ट क्या नहीं बताते हैं। वे अलग-अलग मॉडल चलाते हैं: GPU पंक्तियाँ large-v2 हैं, CPU पंक्तियाँ small हैं। GPU छोटे मॉडल को छह गुना तेज़ नहीं बनाता है। यह सटीक मॉडल को उपयोग करने योग्य बनाता है।

ये आंकड़े कहाँ से आए हैं

दोनों चार्ट faster-whisper README में प्रकाशित बेंचमार्क को दर्शाते हैं। ऑडियो 13 मिनट की एक फाइल है। CPU पंक्तियों ने Intel Core i7-12700K पर 8 threads का उपयोग किया, और GPU पंक्तियों ने 8 GB VRAM वाले NVIDIA RTX 3070 Ti पर CUDA 12.4 का उपयोग किया। सेकंड और मेमोरी कॉलम प्रकाशित आंकड़े हैं। x_realtime कॉलम उन पर की गई गणना है: 780 सेकंड का ऑडियो जिसे मापे गए समय से विभाजित किया गया है, एक दशमलव तक राउंड किया गया है। मेमोरी कॉलम CPU चार्ट के लिए सिस्टम RAM है और GPU चार्ट के लिए VRAM है।

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

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

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

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

विफलता के प्रकार और वे संदेश जो आपको दिखाई देंगे

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

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

This CTranslate2 package was not compiled with CUDA support एक अलग दोष है जो समान महसूस होता है। इंस्टॉल किए गए CTranslate2 बिल्ड में CUDA सपोर्ट की कमी है। आधिकारिक Linux और Windows व्हील्स GPU निष्पादन का समर्थन करते हैं; प्लेटफॉर्म और पैकेज स्रोत की जाँच करें, फिर CUDA-सक्षम बिल्ड इंस्टॉल करें। उसी CPU-ओनली बिल्ड के साथ एनवायरनमेंट को फिर से बनाने से यह ठीक नहीं होता।

ट्रांसक्रिप्ट में दोहराए गए वाक्यांश। दस बार लूप होने वाला वाक्य लगभग हमेशा मौन या संगीत होता है जिसे स्पीच के रूप में डिकोड किया जा रहा है। पहले vad_filter=True को चालू करें। यदि समस्या बनी रहती है, तो उस सेगमेंट को सुनें: लगभग-मौन ऑडियो Whisper को एंकर करने के लिए कुछ नहीं देता है और यह अपने अंतिम आत्मविश्वास वाले अनुमान को दोहराता है।

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

प्रोसेस Killed प्रिंट करती है और रुक जाती है। यह पुष्टि करने के लिए कि मेमोरी खत्म होने के कारण कर्नेल ने इसे मार दिया है, dmesg में oom-kill लाइन की जाँच करें। large-v3 3 GB से अधिक float16 वेट डाउनलोड करता है, लेकिन int8 लोड होने के समय उनके मेमोरी फुटप्रिंट को कम कर देता है। प्रकाशित small-model int8 बेंचमार्क 1,477 MB RAM का उपयोग करता है, इसलिए 2 GB VPS में ऑपरेटिंग सिस्टम और अन्य सेवाओं के लिए बहुत कम जगह बचती है।

Piper आवाज़ नहीं ढूँढ पा रहा है। प्लेयर वर्किंग डायरेक्टरी में देखता है जब तक कि आप --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 का है और स्पष्ट रिकॉर्ड की गई स्पीच को अच्छी तरह से हैंडल करता है। जब लहजे (accents) या बैकग्राउंड शोर के कारण ऐसी त्रुटियाँ हों जिन्हें आप स्वीकार नहीं कर सकते, तब medium मॉडल पर जाएँ। large-v3 का उपयोग केवल तभी करें जब सटीकता (accuracy) बाकी सब चीजों से अधिक महत्वपूर्ण हो, क्योंकि इसके लिए 3,090 MB डिस्क स्पेस चाहिए। इसका RAM उपयोग compute प्रकार और वर्कलोड पर निर्भर करता है, इसलिए VPS का आकार चुनने से पहले इसे मापें। इसके विपरीत, 75.5 MB वाला tiny मॉडल भाषा का पता लगाने और पाइपलाइन का परीक्षण करने के लिए उपयोगी है, न कि उन ट्रांसक्रिप्ट के लिए जिन्हें कोई व्यक्ति पढ़ेगा।

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

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

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

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

क्या यह लेख उपयोगी था?

#whisper#tts#piper#speech-to-text#self-hosted-ai