SSD Nodes Learn Hosting plans →

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

మీ స్వంత VPSలో Whisper మరియు Piper ఉపయోగించి ఉచితంగా స్పీచ్-టు-టెక్స్ట్, TTS సేవలను ఎలా పొందాలో తెలుసుకోండి. CPU వినియోగం, డిస్క్ అవసరాలు మరియు OpenAI అనుకూల 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 మోడల్‌కు సుమారు 484 MB డిస్క్ స్థలం అవసరం, మరియు Piper వాయిస్ అనేది రెండు ఫైళ్లు - ఒక ONNX మోడల్ మరియు ఒక చిన్న JSON కాన్ఫిగరేషన్ - వీటి మొత్తం పరిమాణం 150 MB లోపే ఉంటుంది.

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

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

ఇక్కడ కమాండ్‌లలో పేర్కొన్న ప్రతి వెర్షన్ అక్టోబర్ 11, 2026 నాటికి ఆయా ప్రాజెక్ట్‌ల release పేజీల ప్రకారం సరిచూడబడింది. Failure modes కింద పేర్కొన్న CTranslate2 వెర్షన్లు కేవలం compatibility మార్కర్లు మాత్రమే, ప్రస్తుత releases కావు.

ఎందుకు faster-whisper, reference 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 సెకన్ల కంటే కొంచెం ఎక్కువ సమయంలో పూర్తయిందని అర్థం.

చార్ట్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 మధ్య ఉంటుంది, మరియు ఇది సగం కంటే తక్కువ మెమరీని ఉపయోగిస్తుంది. ఇది local LLM stack లోని llama.cpp వెనుక ఉన్న అదే ggml ఫ్యామిలీకి చెందినది. int8 మరియు బ్యాచింగ్ ఆన్ చేసినప్పుడు faster-whisper ముందుంటుంది, ఇది 15.3x వేగాన్ని అందుకుంటుంది, దీని కోసం ఇది 3,608 MB RAMని తీసుకుంటుంది. కాబట్టి: Python API మరియు బ్యాచింగ్ కోసం faster-whisperని ఎంచుకోండి, RAM పరిమితి ఎక్కువగా ఉన్నప్పుడు whisper.cppని ఎంచుకోండి.

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

Whisper మోడల్ వెయిట్స్ (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"
  }
]

ఇవి 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 ఇమేజ్‌లలో CTranslate2 వీల్ (wheel) అందుబాటులో ఉండదు, కాబట్టి అటువంటి సందర్భాల్లో ఇన్‌స్టాలేషన్ సమయంలోనే pip విఫలమవుతుంది.

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

దీనిని 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 ఉంటే, లైబ్రరీని మళ్ళీ బిల్డ్ చేయాల్సిన అవసరం లేకుండానే అది ఇంగ్లీష్ ట్రాక్‌గా కనిపిస్తుంది. ఒక నిర్దిష్ట క్లయింట్ ఆ సబ్‌టైటిల్‌ను నేరుగా ప్లే చేస్తుందా, లేదా సర్వర్ దానిని 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 యొక్క కీబోర్డ్ ఇంటరాక్షన్‌ను నిలిపివేస్తుంది. ఇది standard input నుండి ఫైల్ పేర్లను చదివే లూప్‌లో ffmpeg రన్ అయినప్పుడు, అది ఫైల్ పేర్లను వినియోగించుకోకుండా కూడా ఆపుతుంది. పైన పేర్కొన్న glob-based లూప్ దాని ఫైల్ జాబితాను standard input నుండి చదవదు.

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

Piper తో టెక్స్ట్-టు-స్పీచ్

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

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

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

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

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

~/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 అంటే అది పనిచేస్తుందని అర్థం. ఆ ఎండ్‌పాయింట్ Piper సొంత ఆకృతి, OpenAI ది కాదు, కాబట్టి /v1/audio/speech ని ఆశించే క్లయింట్ దీనితో కనెక్ట్ అవ్వదు. తదుపరి విభాగం దీనిని సరిచేస్తుంది.

దీనిని మీరు క్లోజ్ చేసే టెర్మినల్‌లో కాకుండా, ఒక unit file తో రన్ చేయండి. ఈ యూనిట్ Piper ను లాగిన్ లేని piper యూజర్‌గా, ఆ యూజర్ హోమ్ డైరెక్టరీ నుండి రన్ చేస్తుంది, కాబట్టి సర్వీస్ మీ అకౌంట్‌పై ఆధారపడదు. యూజర్‌ను క్రియేట్ చేసి, Piper మరియు వాయిస్‌ను అక్కడ ఇన్‌స్టాల్ చేయండి:

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

మీ టెర్మినల్‌లో స్టార్ట్ చేసిన సర్వర్‌ను ఆపివేసి, ఆపై యూనిట్ ఫైల్‌ను రాయండి:

[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-compatible సర్వర్ ఆకృతి

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

Speaches అనేది రెండు దిశలలో పనిచేసే ఒక సర్వర్. ఇది OpenAI పాత్‌ల వెనుక transcription కోసం faster-whisper ను, స్పీచ్ కోసం Piper లేదా Kokoro ను రన్ చేస్తుంది. ప్రస్తుత release డిసెంబర్ 2025 నాటి v0.9.0-rc.3, ఇది ఇంకా 1.0 కి చేరుకోలేదు, కాబట్టి మీ image tag ను పిన్ చేయండి మరియు అప్‌గ్రేడ్ చేసే ముందు 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 ఫైళ్లను ఉంచకూడదనుకుంటే, సింగిల్-కంటైనర్ ఫార్మాట్ ఇక్కడ ఉంది:

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 అనేది చాలామంది మర్చిపోయే భాగం. ఇది లేకపోతే, మోడల్ cache కంటైనర్ లోపలే ఉంటుంది, కాబట్టి కంటైనర్‌ను తొలగించి మళ్ళీ క్రియేట్ చేసినప్పుడు డౌన్‌లోడ్ చేసిన weights పోతాయి. అదే కంటైనర్‌ను రీస్టార్ట్ చేస్తే అవి అలాగే ఉంటాయి.

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

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 ప్లేస్‌హోల్డర్ తప్పనిసరి, ఎందుకంటే OpenAI క్లయింట్ లైబ్రరీ అది లేకుండా అభ్యర్థనను పంపదు. మీరు నిజమైన కీని కాన్ఫిగర్ చేసే వరకు సర్వర్ దాని విలువను పట్టించుకోదు.

vox-box అనేది ఇక్కడ పేర్కొనదగ్గ మరొక ప్రాజెక్ట్. ఇది కంటైనర్ కంటే Python ప్యాకేజీగా ఉంటుంది, మరియు ఇది Whisper, FunASR, Bark, Dia లేదా CosyVoice లతో అదే పాత్‌లను సర్వ్ చేస్తుంది. డిసెంబర్ 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

ఈ ప్రాజెక్ట్ యొక్క ఉదాహరణ 80 పోర్ట్‌ను బైండ్ చేస్తుంది, దీనికి root లేదా CAP_NET_BIND_SERVICE సామర్థ్యం అవసరం. సర్వర్‌లో ఇతర పనులు ఏవైనా ఉంటే, రివర్స్ ప్రాక్సీ వెనుక హై పోర్ట్ వాడటం మంచిది. vox-box start ఒక మోడల్‌ను మాత్రమే తీసుకుంటుంది, కాబట్టి రెండు దిశలను కవర్ చేయడానికి స్పీచ్ repo id తో రెండో పోర్ట్‌పై రెండో 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 బాడీ అంటే మొత్తం పాత్ పనిచేస్తుందని అర్థం. 404 ఎర్రర్ వస్తే, రెస్పాన్స్ బాడీని చదవండి మరియు మోడల్ id ని /v1/models తో సరిచూసుకోండి. స్థానికంగా ఇన్‌స్టాల్ చేయని సరైన మోడల్ కోసం కూడా Speaches 404ని రిటర్న్ చేస్తుంది. ఎర్రర్ అలా చెబితే, uvx speaches-cli model download MODEL_ID తో అడిగిన మోడల్‌ను డౌన్‌లోడ్ చేసి, మళ్ళీ ప్రయత్నించండి. దీని డౌన్‌లోడ్ రూట్ POST /v1/models/{model_id}.

ఈ సర్వర్లలో ఏవీ డిఫాల్ట్‌గా అథెంటికేషన్‌ను ఆన్ చేయవు. వీటిని 127.0.0.1 కి బైండ్ చేయండి మరియు VPN లేదా క్రెడెన్షియల్స్ అడిగే రివర్స్ ప్రాక్సీ ద్వారా వీటిని యాక్సెస్ చేయండి. పబ్లిక్ 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 ఎప్పుడు ఉపయోగకరంగా ఉంటుంది?

చార్ట్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 చిన్న మోడల్‌ను ఆరు రెట్లు వేగవంతం చేయదు. ఇది ఖచ్చితమైన (accurate) మోడల్‌ను ఉపయోగపడేలా చేస్తుంది.

ఈ గణాంకాలు ఎక్కడి నుండి వచ్చాయి

రెండు చార్ట్‌లు faster-whisper READMEలో ప్రచురించబడిన బెంచ్‌మార్క్‌ను అనుకరిస్తాయి. ఆడియో 13 నిమిషాల నిడివి గల ఒకే ఫైల్. CPU వరుసలు Intel Core i7-12700K పై 8 త్రెడ్‌లను, GPU వరుసలు NVIDIA RTX 3070 Ti (8 GB VRAM) పై CUDA 12.4 ను ఉపయోగించాయి. సెకన్లు మరియు మెమరీ కాలమ్స్ ప్రచురించబడిన గణాంకాలు. x_realtime కాలమ్ వీటిపై చేసిన గణితం: 780 సెకన్ల ఆడియోను కొలిచిన సమయంతో భాగించి, ఒక దశాంశ స్థానానికి సవరించబడింది. మెమరీ కాలమ్ CPU చార్ట్ కోసం సిస్టమ్ RAMని, GPU చార్ట్ కోసం VRAMని సూచిస్తుంది.

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

ఆచరణలో ఉపయోగపడే నాలుగు ప్రాథమిక సూత్రాలు:

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

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

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

error: externally-managed-environment ఇన్‌స్టాలేషన్ సమయంలో వస్తుంది. సిస్టమ్ Python పంపిణీదారులచే రక్షించబడుతుంది. పైన చూపిన విధంగా ఒక 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 తో పాత రన్‌టైమ్‌ను పిన్ చేయండి. ఈ రెండింటిలో ఏదో ఒకటి చేయండి. రెండూ చేస్తే మీరు మళ్ళీ మొదటికే వస్తారు.

This CTranslate2 package was not compiled with CUDA support అనేది ఇలాంటిదే కానీ భిన్నమైన లోపం. ఇన్‌స్టాల్ చేసిన CTranslate2 బిల్డ్‌లో CUDA సపోర్ట్ లేదు. అధికారిక Linux మరియు Windows వీల్స్ GPU ఎగ్జిక్యూషన్‌కు మద్దతు ఇస్తాయి; ప్లాట్‌ఫారమ్ మరియు ప్యాకేజీ మూలాన్ని తనిఖీ చేసి, CUDA-ఎనేబుల్డ్ బిల్డ్‌ను ఇన్‌స్టాల్ చేయండి. అదే CPU-మాత్రమే ఉండే బిల్డ్‌తో మళ్ళీ అదే ఎన్విరాన్‌మెంట్‌ను సృష్టించడం వల్ల సమస్య పరిష్కారం కాదు.

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

తప్పు భాష గుర్తించబడటం. డిఫాల్ట్‌గా faster-whisper మొదటి 30 సెకన్ల విండో నుండి మాత్రమే అంచనా వేస్తుంది. info.language_probability విలువ 1.0 కంటే తక్కువగా ఉంటే, అది అనిశ్చితంగా ఉందని అర్థం; రికార్డింగ్ సంగీతంతో లేదా క్రాస్-టాక్‌తో ప్రారంభమైనప్పుడు ఇలా జరుగుతుంది. మీకు భాష ముందే తెలిస్తే 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లో స్పీచ్-టు-టెక్స్ట్ రన్ చేయగలనా?

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

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

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

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

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

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

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

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

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

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

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