VPS वर Whisper आणि Piper: speech-to-text व TTS

स्वतः-होस्ट केलेले speech-to-text आणि TTS थोडक्यात

स्वतःच्या सर्व्हरवर चालवता येणारे speech-to-text आणि TTS (text-to-speech) हे तुम्ही स्वतःच्या सर्व्हरवर चालवू शकणाऱ्या AI पैकी सर्वात स्वस्त प्रकार आहेत. Transcription साठी faster-whisper runtime द्वारे Whisper चालते. Synthesis साठी Piper चालते. दोन्ही GPU शिवाय सामान्य CPU VPS वर कार्य करतात. लहान Whisper model ला सुमारे 484 MB disk लागते, आणि Piper voice ही 150 MB पेक्षा खूप कमी आकाराची एकच file असते.

म्हणून audio पासून सुरुवात करणे योग्य ठरते. स्वतः-होस्ट केलेला image generator आणि स्वतः-होस्ट केलेले video generation वापरण्यायोग्य होण्यासाठी आधी GPU आवश्यक असतो. Audio साठी तो आवश्यक नाही.

या मार्गदर्शकात दोन्ही दिशांचा आणि त्यांना जोडणाऱ्या स्तराचा समावेश आहे. Whisper audio चे text मध्ये रूपांतर करते. Piper text चे audio मध्ये रूपांतर करते. दोन्हींच्या समोर OpenAI-compatible HTTP server ठेवल्यास, base URL वगळता कोणताही बदल न करता विद्यमान client तुमच्या box कडे निर्देशित करता येतो.

येथे नमूद केलेली प्रत्येक version August 2026 पर्यंत अद्ययावत होती.

faster-whisper का, reference Whisper package का नाही

OpenAI चे whisper package हे model PyTorch मध्ये चालवते. faster-whisper हेच model weights CTranslate2 वर चालवते. CTranslate2 हे transformer models साठी विशेषतः तयार केलेले inference engine आहे. Weights एकसारखे असल्यामुळे transcript देखील तोच असतो. फरक पूर्णपणे runtime मध्ये आहे.

CTranslate2 weights load करताना त्यांचे quantization करते. त्यामुळे compute_type="int8" हा एक argument आहे; स्वतंत्र conversion step आवश्यक नाही. यासाठी PyTorch dependency देखील नाही. pip install faster-whisper मुळे CTranslate2, tokenizer आणि audio decoding साठी PyAV install होतात. त्यामुळे virtual environment चा आकार अनेक gigabytes ऐवजी काहीशे megabytes राहतो. 40 GB disk असलेल्या VPS वर हा फरक मोकळी जागा पुरेशी राहणे आणि disk भरून जाणे यातील फरक ठरतो.

CPU वरील small model साठी project ने प्रकाशित केलेली आकडेवारी खाली दिली आहे. या benchmark मध्ये Intel Core i7-12700K वर 8 threads वापरून 13 minutes audio चे transcription केले आहे. x_realtime column म्हणजे 13 minutes ला मोजलेल्या वेळेने भागल्यावर मिळणारे मूल्य. 7.6 म्हणजे 13 minutes चे recording 1 minute 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"
  }
]

दुसरी row नीट पाहा. fp32 मध्ये या CPU वर whisper.cpp हे faster-whisper पेक्षा जलद आहे: 6.2x विरुद्ध 5.0x. तसेच ते निम्म्यापेक्षा कमी memory वापरते. हेच ggml family आहे, ज्यावर स्थानिक LLM stack ची llama.cpp बाजू आधारित आहे. int8 आणि batching सुरू केल्यावर faster-whisper पुढे जाते आणि 15.3x पर्यंत पोहोचते. त्यासाठी 3,608 MB RAM लागते. म्हणून Python API आणि batching आवश्यक असल्यास faster-whisper निवडा. RAM ही बदलता न येणारी मर्यादा असल्यास whisper.cpp निवडा.

या section चा मुख्य मुद्दा पहिल्या row मध्ये आहे. त्याच machine वर reference package real time च्या 1.9x वेगाने चालते. याचा अर्थ 1 hour audio चे transcription करण्यासाठी CPU ला half an hour लागतो.

Whisper model weights साठी किती disk space आवश्यक आहे?

[
  {
    "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 रूपांतरे आहेत आणि ती float16 मध्ये आहेत. compute_type="int8" काय करत नाही हे लक्षात ठेवा: त्यामुळे download चा आकार कमी होत नाही. Weights float16 मध्ये download होतात आणि load करताना CTranslate2 त्यांचे memory मध्ये quantization करते. त्यामुळे तुम्ही ते float16 मध्ये चालवले किंवा int8 मध्ये, large-v3 साठी disk वर 3,090 MB जागा लागते. int8 मुळे RAM आणि speed मध्ये फायदा होतो; disk space मध्ये नाही.

पहिल्यांदा वापरताना models ~/.cache/huggingface/hub मध्ये download होतात. कमी root volume असलेल्या VPS वर download_root argument किंवा HF_HOME environment variable वापरून तो मार्ग पुरेशी जागा असलेल्या ठिकाणी बदला. अन्यथा पहिल्याच run मध्ये disk भरू शकते आणि download पूर्ण होण्यापूर्वी process बंद होऊ शकते.

सिस्टम 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 करते. PyAV मध्ये स्वतःच्या ffmpeg libraries समाविष्ट असतात. त्यामुळे स्वतंत्र ffmpeg binary शिवाय mp3 किंवा m4a वाचता येते. या मार्गदर्शकाच्या पुढील भागातील video कामासाठी वरील ffmpeg package आवश्यक आहे.

तीन gigabytes चे weights download करण्यापूर्वी installation तपासा:

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

ok दर्शविणारी ओळ म्हणजे wheels यशस्वीरीत्या स्थापित झाली आहेत. ImportError मध्ये ctranslate2 असे नाव दिसल्यास तुमच्या architecture साठीचे wheel स्थापित झालेले नाही. हे 32-bit ARM images मध्ये घडते.

बैठकीचे रेकॉर्डिंग किंवा voice note चे लिप्यंतरण करा

हे 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 डाउनलोड होतात, त्यामुळे काही काळ कोणतेही output दिसत नाही. त्यानंतर model काही सेकंदांत cache मधून load होते.

segments हा generator आहे. त्यामुळे त्यावर iterate करेपर्यंत transcription सुरू होत नाही. काही जण transcribe() call ला लागणारा वेळ मोजतात, तो त्वरित परत आल्याचे पाहतात आणि काहीतरी बिघडले आहे असे मानतात. काहीही बिघडलेले नाही. प्रत्यक्ष काम loop मध्ये होते.

vad_filter=True प्रथम Silero VAD (voice activity detection) चालवतो आणि Whisper कडे पाठवण्यापूर्वी शांत भाग काढून टाकतो. दीर्घ शांत अंतर असलेल्या बैठकीच्या रेकॉर्डिंगमध्ये हा उपलब्ध असलेला सर्वात मोठा स्वतंत्र speed gain आहे, कारण speech नसलेल्या audio वर Whisper अजिबात वेळ खर्च करत नाही. तसेच Whisper ला silence दिल्यावर आणि त्यात शब्द शोधण्याचा प्रयत्न केल्यावर तयार होणारे repeated-sentence loops देखील तो कमी करतो.

cpu_threads तुम्हाकडे प्रत्यक्षात उपलब्ध असलेल्या cores च्या संख्येवर सेट करा. vCPU count पेक्षा ते जास्त सेट केल्यास transcription अधिक धीमे होते, कारण अतिरिक्त threads त्याच core साठी स्पर्धा करतात आणि scheduler ला प्रत्येक context switch ची किंमत मोजावी लागते.

Jellyfin लायब्ररीसाठी उपशीर्षके

Jellyfin व्हिडिओच्या शेजारी असलेल्या आणि त्याच नावाच्या बाह्य उपशीर्षक फाइल्स वाचते. त्यामुळे Movie (2019).en.srt ही फाइल Movie (2019).mkv च्या शेजारी ठेवल्यास ती transcoding किंवा लायब्ररी पुन्हा तयार न करता इंग्रजी track म्हणून दिसते.

प्रथम audio वेगळा काढा. Whisper अंतर्गत सर्व audio 16 kHz mono मध्ये resample करते. त्यामुळे त्याला 16 kHz mono audio दिल्यास दोन्ही टोकांवरील प्रक्रिया कमी होते:

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

faster-whisper मध्ये SRT writer नाही. त्यामुळे segments स्वतः format करा. हे 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 loop च्या standard input मधून वाचते. त्यामुळे उरलेली file list वाचली जाते आणि loop कोणताही error message न देता पहिल्या film नंतर थांबते.

सुरू करण्यापूर्वी लागणारा वेळ ठरवा. वर दिलेल्या 7.6x वेगानुसार, 100 मिनिटांच्या film साठी साधारण 13 मिनिटांचा CPU time लागतो. त्यामुळे fifty-film लायब्ररीसाठी संपूर्ण रात्र लागू शकते. Shared vCPU plan वर प्रक्रिया यापेक्षाही धीमी असते. अशा वेळी nice उपयुक्त ठरते. त्यामुळे subtitle run ला server वरील इतर प्रत्यक्ष कामांना प्राधान्य देता येते.

Piper वापरून मजकूराचे ध्वनिमध्ये रूपांतर

Piper हे CPU वर ONNX voice model चालवणारे neural text-to-speech engine आहे. मजकुराचे phonemes मध्ये रूपांतर करण्यासाठी ते espeak-ng समाविष्ट करते. त्यामुळे स्वतंत्र phonemizer install करण्याची गरज नाही. सध्याचे release 1.6.0 आहे आणि ते July 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 working directory मध्ये दोन files लिहिते: .onnx weights आणि sample rate तसेच speaker list असलेली .onnx.json config. या दोन्ही files एकत्र ठेवणे आवश्यक आहे. Voices एखाद्या निश्चित ठिकाणी ठेवत असल्यास, दोन्ही commands मध्ये --data-dir द्या. अन्यथा player working directory मध्ये शोध घेतो आणि तेथे नसलेली voice शोधू शकत नाही.

मजकुरापूर्वीचे -- देखील महत्त्वाचे आहे. ते नसल्यास hyphen ने सुरू होणारे कोणतेही वाक्य command-line option म्हणून parse केले जाते.

Voices अनेक quality levels मध्ये उपलब्ध असतात. Medium English voice साधारण 60 MB असते आणि high voice त्याच्या जवळपास दुप्पट असते. Higher quality म्हणजे मोठे model आणि प्रत्येक speech second साठी अधिक CPU वापर. याचा अर्थ वेगळा speaker असा नाही.

CLI ला loop मध्ये call करू नका. प्रत्येक invocation वेळी ते model load करते आणि short sentence साठी 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

तुम्ही play करू शकणारा test.wav कार्यरत असल्याचे दर्शवतो. त्या endpoint ची रचना Piper ची स्वतःची आहे, OpenAI ची नाही. त्यामुळे /v1/audio/speech अपेक्षित असलेला client त्याच्याशी संवाद साधू शकत नाही. पुढील 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 ते सुरू करते आणि reboot नंतर पुन्हा सुरू करते. वरील curl काहीही परत करत नसल्यास, journalctl -u piper -n 50 कारण दाखवते. सहसा कारण म्हणजे voice file नसणे.

OpenAI-सुसंगत सर्व्हरची रचना

ऑडिओ हाताळणारे बहुतेक सॉफ्टवेअर आधीपासूनच OpenAI audio API वापरतात: फाइलसाठी /v1/audio/transcriptions वर multipart POST आणि वाक्यासाठी /v1/audio/speech वर JSON POST. हे दोन path स्वतः उपलब्ध करून द्या. त्यानंतर client मध्ये फक्त एक बदल आवश्यक असतो: त्याचा base URL.

Speaches हा दोन्ही दिशांसाठी काम करणारा एकच सर्व्हर आहे. तो transcription साठी faster-whisper आणि speech साठी Piper किंवा Kokoro चालवतो आणि ही दोन्ही कामे OpenAI path मागे उपलब्ध करून देतो. डिसेंबर 2025 मधील सध्याचे release v0.9.0-rc.3 आहे. हे अद्याप 1.0 पूर्वीचे आहे. त्यामुळे image tag निश्चित करा आणि 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

त्यानंतर base URL बदलून कोणताही OpenAI client वापरता येतो:

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 client library त्याशिवाय request पाठवत नाही. तुम्ही खरा key configure करेपर्यंत सर्व्हर त्याची value दुर्लक्षित करतो.

इथे नाव घेण्यासारखा दुसरा project म्हणजे vox-box. हा container ऐवजी Python package आहे. तो त्याच path मागे Whisper, FunASR, Bark, Dia किंवा CosyVoice उपलब्ध करून देतो. डिसेंबर 2025 मधील सध्याची version 0.0.21 आहे. त्यासाठी Python 3.10 किंवा त्याहून पुढील version आवश्यक आहे.

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

Project च्या स्वतःच्या उदाहरणात port 80 bind केला आहे. त्यासाठी root आवश्यक आहे. इतर कामे करणाऱ्या server वर reverse proxy मागे high port वापरणे अधिक योग्य रचना आहे. vox-box start एकच model स्वीकारतो. त्यामुळे दोन्ही दिशांना काम करण्यासाठी speech repo id सह दुसऱ्या port वर दुसरे instance चालवावे लागते.

सर्व्हरने कोणते model 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 वाचण्याऐवजी अंदाज लावला आहे.

यापैकी कोणताही सर्व्हर default ने authentication सुरू करत नाही. त्यांना 127.0.0.1 वर bind करा आणि VPN किंवा credentials विचारणाऱ्या reverse proxy द्वारे त्यांच्यापर्यंत पोहोचा. सार्वजनिक IP वर खुले /v1/audio/transcriptions म्हणजे ते शोधणाऱ्या कोणालाही विनामूल्य CPU उपलब्ध करून देणे होय. आणि ते ते शोधतीलच.

self-hosted assistant साठी voice front end

दोन्ही दिशांनी OpenAI paths वर प्रतिसाद देणे सुरू झाल्यावर chat front end त्यांना चालवू शकतो. Open WebUI आणि त्याचे पर्याय त्यांच्या settings मध्ये audio साठी OpenAI-compatible base URL स्वीकारतात. त्यामुळे एकाच box वर Ollama सह local LLM चालवता येतो आणि voice loop ची दोन्ही टोके जोडता येतात.

Latency चे वास्तववादी नियोजन करा, कारण या तीन पायऱ्या त्याच cores वर एकामागोमाग चालतात. वरील 7.6x आकड्यानुसार, 10 सेकंदांच्या प्रश्नाचे transcription करण्यास सुमारे 1.3 सेकंद लागतात. त्याआधी model ने एकही token वाचलेला नसतो. CPU token generation जोडल्यावर round trip इतका धीमा होतो की testers ना सेवा crash झाली असे वाटते. CPU वर batch transcription सहज चालते. 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 मध्ये large model 13.2x real time वेगाने चालतो आणि 2,926 MB VRAM वापरतो. Batching केल्यावर हा वेग 48.8x पर्यंत पोहोचतो. मात्र, दोन्ही charts मध्ये काय दाखवलेले नाही ते लक्षात घ्या. त्यात वेगवेगळी models वापरली आहेत: GPU rows मध्ये large-v2 आहे, तर CPU rows मध्ये small आहे. GPU मुळे small model सहा पट वेगवान होत नाही. GPU मुळे अचूक model वापरण्यायोग्य ठरतो.

Shared vCPU plan वर CPU चे हे आकडे मिळणार नाहीत. त्या benchmark मध्ये वेगवान desktop processor चे 8 threads पूर्णपणे त्याच कामासाठी उपलब्ध होते. 7.6x ही कमाल मर्यादा समजा. त्यानंतर कोणतेही नियोजन करण्यापूर्वी प्रत्यक्ष recording वर time वापरून तुमच्या स्वतःच्या box ची चाचणी घ्या.

प्रत्यक्ष वापरात उपयुक्त ठरणारे चार साधारण नियम:

• स्वतःच्या recordings चे अधूनमधून transcription: CPU, small, int8. दोन dedicated vCPU पुरेसे आहेत.
• Subtitle run सारखे overnight batch काम: CPU, small किंवा medium, int8, nice मध्ये चालवा.
• कोणतेही interactive काम किंवा एका संध्याकाळीत संपूर्ण library process करणे: GPU.
• Piper: नेहमी CPU. या आकाराच्या voice model ला GPU मुळे जवळजवळ काहीही फायदा होत नाही.

त्याच hardware वर आणखी कोणती कामे चालवता येतील हे ठरवत असल्यास, तुम्ही self-host करू शकणाऱ्या AI models चा व्यापक प्रश्न कोणते sizes योग्य बसतात आणि कोणते बसत नाहीत हे स्पष्ट करतो.

अपयशाच्या प्रकारांमध्ये दिसणारे संदेश

error: externally-managed-environment install करताना. System Python ला distribution ने संरक्षित केलेले असते. वर दाखवल्याप्रमाणे virtual environment तयार करा.

GPU host वर 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 आवश्यक आहे, पण host वर cuDNN 8 आहे. cuDNN 9 install करा किंवा pip install --force-reinstall ctranslate2==4.4.0 वापरून जुना runtime निश्चित करा. यापैकी एकच पर्याय वापरा. दोन्ही केल्यास समस्या पुन्हा पूर्वीच्या स्थितीत येते.

This CTranslate2 package was not compiled with CUDA support ही त्याच्यासारखी दिसणारी वेगळी त्रुटी आहे. install झालेले wheel हे CPU-only build आहे. GPU host वर virtual environment पुन्हा तयार करा आणि pip ला wheel पुन्हा निवडू द्या.

Transcript मध्ये वाक्यांची पुनरावृत्ती. एखादे वाक्य दहा वेळा पुन्हा येत असेल, तर जवळजवळ नेहमी silence किंवा music चे speech म्हणून decoding झालेले असते. प्रथम vad_filter=True चालू करा. त्यानंतरही समस्या राहिल्यास तो segment ऐका: जवळजवळ शांत audio मुळे Whisper ला आधार घेण्यासाठी काही मिळत नाही आणि तो शेवटचा विश्वासार्ह अंदाज पुन्हा देतो.

चुकीची भाषा ओळखली जाते. Whisper फक्त पहिल्या 30 सेकंदांवरून अंदाज लावतो. info.language_probability चे मूल्य 1.0 पेक्षा बरेच कमी असल्यास तो अनिश्चित होता. Recording ची सुरुवात music किंवा cross-talk ने झाल्यास असे घडते. उत्तर आधीच माहीत असल्यास language="en" द्या.

Process Killed छापतो आणि थांबतो. हा kernel चा out-of-memory killer आहे. संबंधित oom-kill line dmesg दाखवेल. कोणतीही working memory वापरण्यापूर्वीच large-v3 ला weights साठी 3 GB पेक्षा जास्त memory लागते. 2 GB VPS वर int8 मधील small हे बसू शकणारे सर्वात मोठे model आहे.

Piper ला voice सापडत नाही. --data-dir न दिल्यास player working directory मध्ये शोधतो. अपेक्षित directory वर ls चालवा आणि .onnx तसेच .onnx.json दोन्ही उपलब्ध आहेत याची खात्री करा. यांपैकी एकच उपलब्ध असले तरी, दोन्ही अनुपलब्ध असल्याप्रमाणेच प्रक्रिया अपयशी ठरते.

FAQ

केवळ CPU असलेल्या VPS वर speech to text चालवता येते का?

होय. Batch कामासाठी हा योग्य पर्याय आहे. int8 मधील small model सह faster-whisper वापरल्यास, प्रकल्पाच्या प्रकाशित benchmark नुसार desktop i7 च्या 8 threads वर 102 सेकंदांत 13 मिनिटांचे audio transcribe होते. हा वेग real time पेक्षा सुमारे 7.6x आहे आणि 1,477 MB RAM वापरतो. Shared vCPU plan यापेक्षा धीमा असतो, त्यामुळे आपल्या server वर स्वतः मोजमाप करा. Piper सह text to speech आणखी सोपे आहे आणि कोणत्याही परिस्थितीत GPU आवश्यक नसतो.

मी कोणता Whisper model size वापरावा?

int8 मधील small पासून सुरुवात करा. तो disk वर 484 MB जागा घेतो आणि स्पष्टपणे रेकॉर्ड केलेले speech चांगल्या प्रकारे हाताळतो. Accents किंवा background noise मुळे सहन न होणाऱ्या चुका होत असतील, तर medium वापरा. Accuracy ला इतर सर्व गोष्टींपेक्षा अधिक महत्त्व असल्यासच large-v3 वापरा, कारण त्याला disk वर 3,090 MB आणि 3 GB पेक्षा अधिक memory आवश्यक असते. उलट, 75.5 MB असलेले tiny language detection आणि pipeline चाचणीसाठी उपयुक्त आहे; एखादी व्यक्ती वाचणार असलेल्या transcripts साठी नाही.

मूळ Whisper package पेक्षा faster-whisper अधिक वेगवान का आहे?

Model समान आहे. Runtime समान नाही. Reference package PyTorch मध्ये Whisper चालवते, तर faster-whisper त्याच weights ला CTranslate2 वर चालवते. CTranslate2 हे transformer inference साठी तयार केलेले engine आहे. ते load करताना weights चे quantization करते आणि PyTorch install आवश्यक करत नाही. प्रकाशित CPU benchmark मध्ये reference package चा वेग real time पेक्षा 1.9x आहे, तर int8 मधील faster-whisper चा वेग 7.6x आहे आणि त्यात कमी memory वापरली जाते.

माझा transcript तेच वाक्य वारंवार का दोहरवतो?

Whisper silence किंवा music ला speech म्हणून decode करते आणि शेवटच्या confident guess वर fallback करते. vad_filter=True हे transcribe() call मध्ये सेट करा. यामुळे model audio पाहण्यापूर्वी Silero voice activity detection चालते आणि silent stretches काढून टाकले जातात. तरीही तेच वाक्य दोहरले जात असल्यास audio level तपासा. संपूर्ण recording जवळजवळ silent असल्यास model कडे काम करण्यासाठी पुरेसा input राहत नाही.

माझ्या स्वतःच्या server वर OpenAI-compatible audio endpoint कसा मिळवू?

POST /v1/audio/transcriptions आणि POST /v1/audio/speech लागू करणारा server चालवा. त्यानंतर नवीन base URL देऊन client ला त्या server कडे निर्देशित करा. Speaches हा एक पर्याय आहे. तो CPU build असलेल्या container image म्हणून प्रकाशित केला आहे आणि transcription साठी faster-whisper, तर speech साठी Piper किंवा Kokoro वापरतो. vox-box हा आणखी एक पर्याय आहे. तो pip install vox-box ने install करून vox-box start --huggingface-repo-id ने सुरू करता येतो आणि प्रत्येक process मध्ये एक model serve करतो. यापैकी कोणतेही authentication default ने enable करत नाही. त्यामुळे localhost वर bind करा आणि त्यासमोर proxy किंवा VPN ठेवा.