VPS-ல் Whisper மற்றும் Piper மூலம் சொந்தமாக STT, TTS

Self-hosted speech to text மற்றும் TTS, சுருக்கமாக

Self-hosted speech to text மற்றும் TTS (text to speech) என்பது உங்கள் சொந்த server-ல் நீங்கள் இயக்கக்கூடிய மிக மலிவான AI வகை ஆகும். Transcription-க்கு Whisper, faster-whisper runtime மூலம் இயங்குகிறது. Synthesis-க்கு Piper பயன்படுகிறது. இவை இரண்டுமே GPU இல்லாத சாதாரண CPU VPS-ல் சிறப்பாக இயங்கும். சிறிய Whisper model-க்கு 484 MB disk இடம் தேவைப்படும், Piper voice என்பது 150 MB-க்கும் குறைவான அளவுள்ள ஒரு கோப்பு மட்டுமே.

இதனால்தான் ஆடியோ மூலம் தொடங்குவது சிறந்தது. Self-hosted image generator மற்றும் self-hosted video generation ஆகிய இரண்டுக்கும் அவை பயன்பாட்டுக்கு வருவதற்கு முன்பே GPU கட்டாயம் தேவை. ஆடியோவுக்கு அது தேவையில்லை.

இந்த வழிகாட்டி இரண்டு திசைகளையும், அவற்றை இணைக்கும் அடுக்கையும் விளக்குகிறது. Whisper ஆடியோவை உரையாக மாற்றுகிறது. Piper உரையை ஆடியோவாக மாற்றுகிறது. இவை இரண்டிற்கும் முன்னால் ஒரு OpenAI-compatible HTTP server-ஐ வைப்பதன் மூலம், ஏற்கனவே உள்ள client-களை base URL-ஐ மட்டும் மாற்றி உங்கள் server-டன் இணைக்க முடியும்.

இங்கு குறிப்பிடப்பட்டுள்ள ஒவ்வொரு பதிப்பும் August 2026 நிலவரப்படி நடைமுறையில் இருந்தது.

ஏன் faster-whisper, OpenAI-ன் அதிகாரப்பூர்வ Whisper package அல்ல?

OpenAI-ன் whisper package, PyTorch-ல் மாதிரியை (model) இயக்குகிறது. faster-whisper, அதே மாதிரியின் எடைகளை (weights) CTranslate2-ல் இயக்குகிறது; இது transformer மாதிரிகளுக்காகவே பிரத்யேகமாக உருவாக்கப்பட்ட ஒரு inference engine ஆகும். மாதிரியின் எடைகள் ஒன்றாக இருப்பதால், கிடைக்கும் transcript-ம் ஒன்றாகவே இருக்கும். இந்த இரண்டிற்கும் இடையிலான வித்தியாசம் அதன் runtime-ல் மட்டுமே உள்ளது.

CTranslate2 மாதிரிகளை ஏற்றும்போதே அவற்றை quantize செய்கிறது, இதனால்தான் compute_type="int8" என்பது ஒரு தனிப்பட்ட conversion படிநிலை இல்லாமல், ஒரு argument-ஆக மட்டுமே உள்ளது. இதற்கு PyTorch dependency தேவையில்லை. pip install faster-whisper, CTranslate2, ஒரு tokenizer மற்றும் ஆடியோவை decode செய்ய PyAV ஆகியவற்றை உள்ளடக்கியது. இதனால், virtual environment-ன் அளவு பல gigabytes-க்கு பதிலாக, சில நூறு megabytes-க்குள் அடங்கிவிடும். 40 GB disk கொண்ட ஒரு VPS-ல், இந்த அளவு வித்தியாசம் என்பது வசதியான பயன்பாட்டிற்கும், இட நெருக்கடிக்கும் இடையிலான வேறுபாடாகும்.

CPU-ல் small மாதிரிக்காக வெளியிடப்பட்ட தரவுகள் கீழே கொடுக்கப்பட்டுள்ளன. இந்த benchmark, Intel Core i7-12700K-ல் 8 threads-ஐப் பயன்படுத்தி 13 நிமிட ஆடியோவை transcribe செய்கிறது. x_realtime column என்பது 13 நிமிடங்களை அளவிடப்பட்ட நேரத்தால் வகுத்ததாகும்: 7.6 என்பது 13 நிமிடப் பதிவு, 1 நிமிடம் 40 வினாடிகளுக்குச் சற்று கூடுதலான நேரத்தில் முடிந்தது என்பதைக் குறிக்கிறது.

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

இரண்டாவது வரிசையை கவனமாகப் பார்க்கவும். fp32-ல், இந்த CPU-ல் whisper.cpp, faster-whisper-ஐ விட வேகமானது; இது 6.2x வேகத்தில் இயங்குகிறது, அதேசமயம் faster-whisper 5.0x வேகத்தில் இயங்குகிறது. மேலும், இது பாதியளவுக்கும் குறைவான நினைவகத்தையே (memory) பயன்படுத்துகிறது. இது local LLM stack-ன் llama.cpp-க்கு பின்னால் இருக்கும் அதே ggml குடும்பத்தைச் சேர்ந்தது. int8 மற்றும் batching வசதிகளைச் செயல்படுத்தும்போது faster-whisper முன்னிலை பெற்று 15.3x வேகத்தை எட்டுகிறது, இதற்கு 3,608 MB RAM தேவைப்படுகிறது. எனவே: Python API மற்றும் batching தேவைப்பட்டால் faster-whisper-ஐத் தேர்ந்தெடுக்கவும்; RAM பயன்பாடு மிகக் குறைவாக இருக்க வேண்டும் என்றால் whisper.cpp-ஐத் தேர்ந்தெடுக்கவும்.

முதல் வரிசைதான் இந்த பகுதியின் முக்கிய நோக்கம். அதே கணினியில் அதிகாரப்பூர்வ package 1.9x real time வேகத்தில் இயங்குகிறது; அதாவது, ஒரு மணி நேர ஆடியோவைச் செயலாக்க அரை மணி நேர CPU நேரம் தேவைப்படுகிறது.

Whisper model weights-க்கு எவ்வளவு disk இடம் தேவை?

[
  {
    "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 conversions ஆகும். compute_type="int8" எதைச் செய்யாது என்பதைக் கவனிக்கவும்: இது download அளவைக் குறைக்காது. weights float16 வடிவிலேயே தரவிறக்கம் செய்யப்படுகின்றன; CTranslate2 அவற்றை load செய்யும்போதுதான் memory-ல் quantize செய்கிறது. எனவே, நீங்கள் float16 அல்லது int8 எதில் இயக்கினாலும், large-v3 மாடலுக்கு disk-ல் 3,090 MB இடம் தேவைப்படும். int8 என்பது RAM மற்றும் வேகத்தை மட்டுமே மேம்படுத்தும், disk இடத்தை அல்ல.

முதல்முறை பயன்படுத்தும்போது மாடல்கள் ~/.cache/huggingface/hub-க்குள் தரவிறக்கம் செய்யப்படும். சிறிய root volume கொண்ட VPS-ல், download_root argument அல்லது HF_HOME environment variable-ஐப் பயன்படுத்தி, அதிக இடவசதி உள்ள இடத்திற்கு இதை மாற்றவும். இல்லையெனில், முதல்முறை இயக்கும்போதே disk நிறைந்து, தரவிறக்கம் பாதியிலேயே நின்று process செயலிழந்துவிடும்.

system Python-ஐ பாதிக்காமல் faster-whisper-ஐ நிறுவுதல்

Ubuntu 24.04 மற்றும் Debian 13 ஆகிய இயங்குதளங்கள் system Python-ஐ externally managed ஆகக் கருதுகின்றன. virtual environment இல்லாமல் pip install faster-whisper-ஐ இயக்கினால், பின்வரும் பிழையுடன் செயல்முறை உடனடியாக நின்றுவிடும்:

error: externally-managed-environment

இது apt நிர்வகிக்கும் கோப்புகளைப் பாதுகாப்பதற்காக, packaging system மேற்கொள்ளும் நடவடிக்கையாகும். எனவே, 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

பதிப்பு 1.2.1 என்பது அக்டோபர் 2025-ல் வெளியிடப்பட்ட தற்போதைய release ஆகும். faster-whisper, PyAV வழியாக ஆடியோவை decode செய்கிறது. இது தனக்கென ffmpeg libraries-ஐக் கொண்டுள்ளதால், தனி ffmpeg binary இல்லாமலேயே mp3 அல்லது m4a கோப்புகளை வாசிக்க முடியும். மேலே உள்ள ffmpeg தொகுப்பு, இந்த வழிகாட்டியின் பிற்பகுதியில் வரும் வீடியோ பணிகளுக்காக வழங்கப்பட்டுள்ளது.

மூன்று 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 தரவிறக்கம் செய்யப்படும், எனவே சிறிது நேரம் எந்த வெளியீடும் வராது. அதன் பிறகு, model cache-லிருந்து சில நொடிகளில் load ஆகிவிடும்.

segments ஒரு generator என்பதால், நீங்கள் அதை iterate செய்யும் வரை transcription தொடங்காது. பலர் transcribe() அழைப்பை நேரத்தைக் கணக்கிட்டுப் பார்த்துவிட்டு, அது உடனடியாக முடிந்துவிடுவதால் ஏதோ தவறு என்று நினைக்கிறார்கள். எந்தத் தவறும் இல்லை. loop-க்குள் தான் வேலை நடக்கிறது.

vad_filter=True முதலில் Silero VAD (voice activity detection)-ஐ இயக்கி, Whisper-க்கு அனுப்பும் முன் அமைதியான பகுதிகளை நீக்கிவிடும். நீண்ட இடைவெளிகள் கொண்ட கூட்டப் பதிவுகளில், இதுவே வேகத்தை அதிகரிக்கும் மிக முக்கியமான வழியாகும், ஏனெனில் பேச்சில்லாத ஆடியோவில் Whisper நேரத்தை வீணடிக்காது. இது, அமைதியான ஆடியோவை உள்ளீடாகப் பெறும்போது Whisper மீண்டும் மீண்டும் ஒரே வாக்கியத்தை உருவாக்கும் சிக்கலையும் தவிர்க்கிறது.

cpu_threads-ஐ உங்களிடம் உள்ள உண்மையான cores எண்ணிக்கைக்கு அமைக்கவும். உங்கள் vCPU எண்ணிக்கையை விட அதிகமாக அமைத்தால் transcription வேகம் குறையும், ஏனெனில் கூடுதல் threads ஒரே core-க்காகப் போட்டியிடும் மற்றும் scheduler ஒவ்வொரு switch-க்கும் கூடுதல் சுமையைச் சுமக்க வேண்டியிருக்கும்.

Jellyfin library-க்கான Subtitles

Jellyfin, வீடியோ கோப்பின் அருகிலேயே இருக்கும் மற்றும் அதே பெயரைக் கொண்ட external subtitle கோப்புகளை வாசிக்கும். எனவே, Movie (2019).en.srt கோப்பிற்கு அருகில் Movie (2019).mkv கோப்பு இருந்தால், அது transcoding இல்லாமலும், library-ஐ மீண்டும் உருவாக்காமலும் ஒரு English track-ஆகத் தோன்றும்.

முதலில் audio-வை பிரித்தெடுக்கவும். Whisper உள்முகமாக அனைத்தையும் 16 kHz mono-க்கு resample செய்கிறது, எனவே 16 kHz mono கோப்பை வழங்குவது இருபுறமும் வேலைப்பளுவைக் குறைக்கும்:

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

பிறகு library-ஐ முழுமையாகச் சரிபார்க்கவும்:

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-லிருந்து வாசிக்கும், மீதமுள்ள கோப்புகளின் பட்டியலை முழுவதுமாக எடுத்துக்கொள்ளும், மேலும் எந்த error செய்தியும் இன்றி ஒரு படத்திற்குப் பிறகு loop நின்றுவிடும்.

தொடங்குவதற்கு முன் நேரத்தைத் திட்டமிடுங்கள். மேலே உள்ள 7.6x வேகத்தைக் கணக்கில் கொண்டால், 100 நிமிடப் படத்திற்குத் தோராயமாக 13 நிமிட CPU தேவைப்படும். எனவே, ஐம்பது படங்கள் கொண்ட library-ஐ முடிக்க ஒரு இரவு முழுவதும் ஆகும். பகிரப்பட்ட vCPU திட்டத்தில் இது இன்னும் மெதுவாக இருக்கும், அதற்காகவே nice பயன்படுத்தப்படுகிறது: இது subtitle உருவாக்கும் பணியை அந்த server-ல் நடக்கும் பிற முக்கிய பணிகளுக்கு விட்டுக்கொடுக்கும்.

Piper மூலம் Text to speech

Piper என்பது CPU-வில் ONNX voice model-ஐ இயக்கும் ஒரு neural text to speech engine ஆகும். இது உரையை phonemes-ஆக மாற்ற espeak-ng-ஐ உள்ளடக்கியுள்ளது, எனவே தனி phonemizer எதையும் நிறுவ வேண்டியதில்லை. தற்போதைய release 1.6.0, இது ஜூலை 2026-ல் வெளியிடப்பட்டது.

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

download_voices வேலை செய்யும் directory-க்குள் இரண்டு கோப்புகளை உருவாக்குகிறது: .onnx weights மற்றும் sample rate மற்றும் speaker பட்டியலைக் கொண்ட .onnx.json config. இவை இரண்டும் ஒன்றாகவே இருக்க வேண்டும். நீங்கள் குரல்களை (voices) ஒரு குறிப்பிட்ட இடத்தில் வைத்திருந்தால், இரண்டு கட்டளைகளுக்கும் --data-dir-ஐ வழங்கவும், இல்லையெனில் player வேலை செய்யும் directory-ல் தேடும், அங்கு குரல் கோப்பு இல்லையென்றால் அதைக் கண்டறிய முடியாது.

உரைக்கு முன்னால் உள்ள ---வும் முக்கியமானது. அது இல்லையென்றால், hyphen-ல் தொடங்கும் எந்த வாக்கியமும் command-line option-ஆகக் கருதப்படும்.

குரல்கள் பல தர நிலைகளில் (quality levels) கிடைக்கின்றன. ஒரு medium English குரல் சுமார் 60 MB இருக்கும், high தரத்திலான குரல் அதன் இருமடங்கு இருக்கும். அதிக தரம் என்பது பெரிய model மற்றும் ஒரு வினாடி பேச்சுக்கு அதிக CPU பயன்பாட்டைக் குறிக்கும், இது வேறொரு speaker-ஐக் குறிப்பதல்ல.

CLI-ஐ loop-ல் அழைக்க வேண்டாம். இது ஒவ்வொரு முறையும் 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 என்பது அது வேலை செய்கிறது என்பதைக் குறிக்கும். அந்த endpoint Piper-ன் சொந்த வடிவம், OpenAI-யினுடையது அல்ல, எனவே /v1/audio/speech-ஐ எதிர்பார்க்கும் client அதனுடன் தொடர்பு கொள்ளாது. அடுத்த பகுதி இதைச் சரிசெய்யும்.

இதை நீங்கள் மூடிவிடும் 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-ல் அதற்கான காரணம் இருக்கும், பெரும்பாலும் குரல் கோப்பு விடுபட்டிருப்பதே காரணமாக இருக்கும்.

OpenAI-இணக்கமான server அமைப்பு

ஆடியோவைக் கையாளும் பெரும்பாலான மென்பொருட்கள் ஏற்கனவே OpenAI ஆடியோ API-ஐ ஆதரிக்கின்றன: கோப்பிற்காக /v1/audio/transcriptions-க்கு ஒரு multipart POST, வாக்கியத்திற்காக /v1/audio/speech-க்கு ஒரு JSON POST. இந்த இரண்டு பாதைகளையும் நீங்களே வழங்கினால், client-ல் அதன் base URL-ஐ மட்டும் மாற்றினால் போதும்.

Speaches என்பது இரண்டு திசைகளிலும் செயல்படும் ஒரு server ஆகும். இது OpenAI பாதைகளுக்குப் பின்னால், transcription-க்காக faster-whisper-ஐயும், பேச்சுக்காக 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 கோப்புகளைப் பராமரிக்க விரும்பவில்லை என்றால், 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 செய்யும்போதும், முதல் கோரிக்கைக்குப் பதில் அளிக்கும் முன்பே பல gigabytes எடையுள்ள weights மீண்டும் பதிவிறக்கம் செய்யப்படும்.

/v1/audio/speech பதில் அளிக்கும் முன், பேச்சுக்குத் தேவையான voice-ஐப் பதிவிறக்கம் செய்ய வேண்டும்:

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 அதை இல்லாமல் கோரிக்கையை அனுப்ப மறுத்துவிடும். நீங்கள் உண்மையான key-ஐ அமைக்கும் வரை server அதன் மதிப்பை அலட்சியப்படுத்தும்.

vox-box என்பது இங்கே குறிப்பிட வேண்டிய மற்றொரு project. இது container-க்கு பதிலாக ஒரு Python package ஆகும். இது Whisper, FunASR, Bark, Dia அல்லது CosyVoice ஆகியவற்றைப் பயன்படுத்தி அதே பாதைகளை வழங்குகிறது. தற்போதைய பதிப்பு 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

இந்த project-ன் உதாரணம் port 80-ஐப் பயன்படுத்துகிறது, இதற்கு root அனுமதி தேவை. வேறு பணிகள் நடக்கும் server-ல், reverse proxy-க்கு பின்னால் ஒரு high port-ஐப் பயன்படுத்துவதே சிறந்த முறையாகும். vox-box start ஒரு model-ஐ மட்டுமே ஏற்கும், எனவே இரண்டு திசைகளையும் கையாள, speech repo id-யுடன் இரண்டாவது port-ல் மற்றொரு instance-ஐ இயக்க வேண்டும்.

Server எதை 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 இருந்தால், அந்தப் பாதை சரியாக வேலை செய்கிறது என்று அர்த்தம். Model பெயரில் 404 பிழை வந்தால், நீங்கள் /v1/models வெளியீட்டைப் பார்க்காமல் ஊகித்திருக்கிறீர்கள் என்று பொருள்.

இந்த server-கள் எதிலும் இயல்பாகவே authentication கிடையாது. அவற்றை 127.0.0.1-ல் bind செய்து, VPN அல்லது credentials கேட்கும் reverse proxy வழியாக அணுகவும். பொது IP-யில் திறந்திருக்கும் /v1/audio/transcriptions, அதைக் கண்டறியும் எவருக்கும் இலவச CPU-வாகிவிடும்; அவர்கள் நிச்சயமாக அதைக் கண்டறிவார்கள்.

சுய-வழங்கி (self-hosted) உதவியாளருக்கான குரல் இடைமுகம் (voice front end)

OpenAI பாதைகளில் இரு திசைகளிலும் பதில் கிடைத்தவுடன், ஒரு chat front end மூலம் அவற்றை இயக்க முடியும். Open WebUI மற்றும் அதன் மாற்றுகள் அவற்றின் அமைப்புகளில் ஆடியோவிற்கான OpenAI-இணக்கமான base URL-ஐ ஏற்றுக்கொள்கின்றன. எனவே, ஒரே பெட்டியில் Ollama மூலம் local LLM-ஐ இயக்கலாம் மற்றும் குரல் சுழற்சியை (voice loop) இரு முனைகளிலும் முடிக்கலாம்.

தாமதத்தை (latency) சரியாகக் கணக்கிடுங்கள், ஏனெனில் இந்த மூன்று படிகளும் ஒரே cores-ல் அடுத்தடுத்து இயங்குகின்றன. 10 வினாடி கேள்வியை transcribe செய்ய, மேலே உள்ள 7.6x விகிதத்தில் சுமார் 1.3 வினாடிகள் ஆகும். இது model ஒரு token-ஐக் கூட வாசிப்பதற்கு முன்பே நடக்கும் நிகழ்வு. இதனுடன் CPU token generation-ஐச் சேர்த்தால், round trip மிகவும் மெதுவாக இருக்கும்; இதனால் சோதனையாளர்கள் அது செயலிழந்துவிட்டதாக (crashed) நினைக்கக்கூடும். Batch transcription-ஐ CPU-வில் செய்வது எளிது. ஆனால் உரையாடலுக்கு இது உகந்ததல்ல; அந்த இடத்தில்தான் 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 அளவில் உள்ள பெரிய model 13.2x real time வேகத்தில் 2,926 MB VRAM-ஐப் பயன்படுத்தி இயங்குகிறது, batching செய்யும்போது இது 48.8x ஆக உயர்கிறது. இந்த இரண்டு வரைபடங்களும் எதைச் சொல்லவில்லை என்பதை கவனமாகப் பார்க்கவும். அவை வெவ்வேறு model-களைப் பயன்படுத்துகின்றன: GPU வரிசைகள் large-v2-ஐயும், CPU வரிசைகள் small-ஐயும் பயன்படுத்துகின்றன. ஒரு GPU, small model-ஐ ஆறு மடங்கு வேகமாக்குவதில்லை. அது துல்லியமான model-ஐப் பயன்படுத்தக்கூடியதாக மாற்றுகிறது.

பகிர்ந்தளிக்கப்பட்ட (shared) vCPU திட்டம் இந்த CPU புள்ளிவிவரங்களை எட்டாது. அந்த benchmark ஒரு வேகமான desktop processor-ன் 8 threads-ஐ முழுமையாகப் பயன்படுத்தியது. 7.6x என்பதை ஒரு உச்ச வரம்பாகக் கருதுங்கள், பின்னர் எதையும் திட்டமிடுவதற்கு முன்பு ஒரு உண்மையான recording-ஐ வைத்து time மூலம் உங்கள் கணினியில் அளவிடுங்கள்.

நடைமுறையில் பொருந்தக்கூடிய நான்கு பொதுவான விதிகள்:

• உங்கள் சொந்த recording-களை அவ்வப்போது transcription செய்ய: CPU, small, int8. இரண்டு dedicated vCPU போதுமானது.
• subtitle உருவாக்குவது போன்ற இரவு நேர batch வேலைகள்: CPU, small அல்லது medium, int8, nice-ல் இணைக்கப்பட்டது.
• interactive பயன்பாடு அல்லது ஒரே இரவில் முழு library-யையும் கையாள: GPU.
• Piper: எப்போதும் CPU. இந்த அளவுள்ள voice model-க்கு GPU-வினால் பெரிய பயன் ஏதுமில்லை.

அதே hardware-ல் வேறு என்னென்ன பணிகளைச் செய்ய முடியும் என்று நீங்கள் ஆராய்கிறீர்கள் என்றால், எந்தெந்த AI model-களை நீங்களே host செய்யலாம் என்ற விரிவான கேள்வி எந்தெந்த அளவுகள் பொருந்தும், எவை பொருந்தாது என்பதை விளக்குகிறது.

தோல்வி முறைகள் மற்றும் நீங்கள் காணக்கூடிய செய்திகள்

நிறுவலின் போது error: externally-managed-environment. கணினியின் Python, distribution-ஆல் பாதுகாக்கப்படுகிறது. மேலே காட்டப்பட்டுள்ளபடி ஒரு virtual environment-ஐ உருவாக்கவும்.

GPU பெட்டியில் cuDNN பொருந்தவில்லை. தோல்வி பின்வருமாறு தோன்றும்:

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

CTranslate2 4.5.0 மற்றும் அதற்குப் பிந்தைய பதிப்புகளுக்கு CUDA 12-க்கு cuDNN 9 தேவைப்படுகிறது, ஆனால் ஹோஸ்டில் cuDNN 8 உள்ளது. cuDNN 9-ஐ நிறுவவும் அல்லது pip install --force-reinstall ctranslate2==4.4.0 மூலம் பழைய runtime-ஐ நிலைநிறுத்தவும் (pin). இரண்டில் ஒன்றை மட்டும் செய்யவும். இரண்டையும் செய்தால், நீங்கள் மீண்டும் பழைய நிலைக்குச் சென்றுவிடுவீர்கள்.

This CTranslate2 package was not compiled with CUDA support என்பது இதே போன்ற உணர்வைக் கொண்ட ஒரு மாறுபட்ட பிழையாகும். நிறுவப்பட்ட wheel, CPU-மட்டும் கொண்ட build ஆகும். GPU ஹோஸ்டில் virtual environment-ஐ மீண்டும் உருவாக்கி, pip மூலம் wheel-ஐ மீண்டும் தேர்ந்தெடுக்க அனுமதிக்கவும்.

transcript-ல் மீண்டும் மீண்டும் வரும் சொற்றொடர்கள். ஒரு வாக்கியம் பத்து முறை சுழல்கிறது என்றால், அது பெரும்பாலும் மௌனம் அல்லது இசையை பேச்சாகத் தவறாகப் புரிந்துகொள்வதாகும். முதலில் vad_filter=True-ஐ இயக்கவும். அதன் பிறகும் இது தொடர்ந்தால், அந்தப் பகுதியைச் செவிமடுக்கவும்: மிகக் குறைந்த ஒலியுள்ள ஆடியோவில் Whisper-க்குத் துணையாக எதுவும் இல்லாததால், அது கடைசியாகத் தான் உறுதியாகக் கருதியதையே மீண்டும் மீண்டும் கூறுகிறது.

தவறான மொழி கண்டறியப்பட்டது. 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-ஆல் குரலைக் கண்டறிய முடியவில்லை. நீங்கள் --data-dir-ஐ வழங்காதவரை, player தற்போதைய working directory-ல் தேடும். நீங்கள் எதிர்பார்க்கும் directory-ல் ls-ஐ இயக்கி, .onnx மற்றும் .onnx.json ஆகிய இரண்டும் அங்கு இருப்பதை உறுதிப்படுத்தவும், ஏனெனில் ஒன்று மட்டும் இருந்தால் அது தோல்வியடையும்.

FAQ

CPU-மட்டும் கொண்ட VPS-ல் என்னால் speech to text இயக்க முடியுமா?

ஆம், batch வேலைகளுக்கு இதுவே சரியான தேர்வாகும். faster-whisper-ஐ small model மற்றும் int8 quantization-ல் பயன்படுத்தும்போது, திட்டத்தின் அதிகாரப்பூர்வ benchmark-ன்படி, ஒரு desktop i7-ன் 8 threads-ல் 13 நிமிட ஆடியோவை 102 வினாடிகளில், அதாவது 7.6x real time வேகத்தில், 1,477 MB RAM பயன்பாட்டுடன் மாற்ற முடியும். ஒரு shared vCPU திட்டம் இதைவிட மெதுவாகவே இயங்கும், எனவே உங்கள் server-ல் நீங்களே சோதித்துப் பார்க்கவும். Piper மூலம் text to speech செய்வது இன்னும் எளிது, இதற்கு எந்தச் சூழலிலும் GPU தேவையில்லை.

நான் எந்த Whisper model அளவைப் பயன்படுத்த வேண்டும்?

small model மற்றும் int8 உடன் தொடங்கவும். இது disk-ல் 484 MB அளவு மட்டுமே எடுக்கும், மேலும் தெளிவாகப் பதிவு செய்யப்பட்ட பேச்சுகளை இது சிறப்பாகக் கையாளும். உச்சரிப்பு அல்லது பின்னணி இரைச்சலால் பிழைகள் ஏற்பட்டு, அதை உங்களால் ஏற்றுக்கொள்ள முடியாவிட்டால் medium model-க்கு மாறவும். துல்லியம் மிக முக்கியம் என்றால் மட்டுமே large-v3 model-க்குச் செல்லவும், ஏனெனில் இதற்கு 3,090 MB disk இடமும், 3 GB-க்கும் அதிகமான memory-யும் தேவைப்படும். இதற்கு நேர்மாறாக, tiny model 75.5 MB அளவில் இருப்பதால், மொழியைக் கண்டறியவும் (language detection) அல்லது pipeline-ஐச் சோதிக்கவும் மட்டுமே பயனுள்ளது; மனிதர்கள் வாசிக்கும்படியான transcript-களுக்கு இது ஏற்றதல்ல.

அசல் Whisper package-ஐ விட faster-whisper ஏன் வேகமாக உள்ளது?

Model ஒன்றுதான், ஆனால் runtime மாறுபடுகிறது. அசல் package Whisper-ஐ PyTorch-ல் இயக்குகிறது, அதேசமயம் faster-whisper அதே weights-ஐ CTranslate2-ல் இயக்குகிறது. இது transformer inference-க்காக உருவாக்கப்பட்ட engine ஆகும்; இது load செய்யும்போது weights-ஐ quantize செய்கிறது மற்றும் PyTorch நிறுவல் தேவையில்லை. வெளியிடப்பட்ட CPU benchmark-ன்படி, அசல் package 1.9x real time வேகத்தில் இயங்கும்போது, faster-whisper (int8) 7.6x வேகத்தில், குறைந்த memory பயன்பாட்டுடன் இயங்குகிறது.

எனது transcript ஏன் ஒரே வாக்கியத்தை மீண்டும் மீண்டும் சொல்கிறது?

Whisper அமைதி அல்லது இசையை பேச்சாகத் தவறாகப் புரிந்துகொண்டு, தான் கடைசியாகக் கணித்த வாக்கியத்தையே மீண்டும் மீண்டும் கூறுகிறது. vad_filter=True-ஐ transcribe() அழைப்பில் (call) அமைக்கவும்; இது Silero voice activity detection-ஐ முதலில் இயக்கி, அமைதியான பகுதிகளை நீக்கிய பிறகே model-க்கு அனுப்பும். அப்படியும் மீண்டும் மீண்டும் வந்தால், ஆடியோ அளவைச் சரிபார்க்கவும்; ஏனெனில் ஆடியோ முழுவதும் அமைதியாக இருந்தால், model-க்குச் செயலாக்கத் தரவுகள் இருக்காது.

எனது சொந்த server-ல் OpenAI-க்கு இணக்கமான audio endpoint-ஐ எவ்வாறு பெறுவது?

POST /v1/audio/transcriptions மற்றும் POST /v1/audio/speech ஆகியவற்றைச் செயல்படுத்தும் server-ஐ இயக்கவும், பின்னர் client-ஐ ஒரு புதிய base URL மூலம் அதனுடன் இணைக்கவும். Speaches ஒரு சிறந்த தேர்வாகும்; இது CPU build-உடன் container image-ஆகக் கிடைக்கிறது. இது transcription-க்கு faster-whisper-ஐயும், பேச்சுக்கு Piper அல்லது Kokoro-வையும் பயன்படுத்துகிறது. vox-box மற்றொரு வழி; இது pip install vox-box மூலம் நிறுவப்பட்டு, vox-box start --huggingface-repo-id மூலம் தொடங்கப்படுகிறது, இது ஒரு process-க்கு ஒரு model-ஐ வழங்குகிறது. இவை எதிலும் default-ஆக authentication இருக்காது, எனவே localhost-ல் bind செய்து, முன்னால் ஒரு proxy அல்லது VPN-ஐ வைக்கவும்.