Zelfgehoste Whisper en Piper op een VPS draaien

Zelfgehoste spraak-naar-tekst en TTS, in het kort

Zelfgehoste spraak-naar-tekst en TTS (text-to-speech) is de meest voordelige vorm van AI die u kunt draaien op een server in eigen beheer. Transcriptie verloopt via Whisper met de faster-whisper runtime. Synthese verloopt via Piper. Beide werken op een standaard CPU VPS zonder enige GPU. Het kleine Whisper-model vereist ongeveer 484 MB schijfruimte en een Piper-stem is één enkel bestand van ruim onder de 150 MB.

Daarom is audio het juiste startpunt. Een zelfgehoste afbeeldingsgenerator en zelfgehoste videogeneratie vereisen beide een GPU voordat ze überhaupt bruikbaar zijn. Audio niet.

Deze handleiding behandelt beide richtingen en de laag die ze verbindt. Whisper zet audio om in tekst. Piper zet tekst om in audio. Een OpenAI-compatibele HTTP-server voor beide zorgt ervoor dat een bestaande client naar uw server kan wijzen zonder dat er iets anders nodig is dan een base URL.

Elke hier genoemde versie was actueel in augustus 2026.

Waarom faster-whisper en niet het referentiepakket van Whisper

Het whisper-pakket van OpenAI voert het model uit in PyTorch. faster-whisper voert dezelfde modelgewichten uit op CTranslate2, een inference-engine die specifiek is geschreven voor transformatormodellen. De gewichten zijn identiek, dus het transcript is hetzelfde transcript. Het verschil zit volledig in de runtime.

CTranslate2 kwantiseert gewichten tijdens het laden; daarom is compute_type="int8" één argument en geen afzonderlijke conversiestap. Het heeft bovendien geen PyTorch-afhankelijkheid. pip install faster-whisper haalt CTranslate2, een tokenizer en PyAV voor audiodecodering op, waardoor de virtuele omgeving honderden megabytes groot is in plaats van enkele gigabytes. Op een VPS met een schijf van 40 GB is dat verschil bepalend voor of de omgeving comfortabel of krap is.

Hieronder staan de door het project gepubliceerde cijfers voor het small-model op de CPU. De benchmark transcribeert 13 minuten audio met 8 threads op een Intel Core i7-12700K. De kolom x_realtime is die 13 minuten gedeeld door de gemeten tijd: 7.6 betekent dat een opname van 13 minuten in iets meer dan 1 minuut 40 klaar was.

[
  {
    "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"
  }
]

Bekijk de tweede rij kritisch. Bij fp32 is whisper.cpp sneller dan faster-whisper op deze CPU, 6.2x tegenover 5.0x, en dat met minder dan de helft van het geheugen. Het is dezelfde ggml-familie die ten grondslag ligt aan de llama.cpp-kant van de lokale LLM-stack. faster-whisper neemt de leiding zodra int8 en batching zijn ingeschakeld, waarbij 15.3x wordt bereikt, en het verbruikt daarvoor 3,608 MB RAM. Dus: kies faster-whisper voor de Python API en de batching, kies whisper.cpp wanneer RAM de beperkende factor is waar u niet omheen kunt.

De eerste rij is de kern van deze sectie. Het referentiepakket is 1.9x real-time op dezelfde machine, wat betekent dat een uur audio een half uur CPU-tijd kost.

Hoeveel schijfruimte vereisen de Whisper-modelgewichten?

[
  {
    "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"
  }
]

Dit zijn de gepubliceerde CTranslate2-conversies in float16. Let op wat compute_type="int8" niet doet: het verkleint de download niet. De gewichten worden aangeleverd in float16 en CTranslate2 kwantiseert deze in het geheugen tijdens het laden. Daarom kost large-v3 3,090 MB op schijf, ongeacht of u het uitvoert in float16 of int8. int8 levert winst op in RAM en snelheid, niet in schijfruimte.

Modellen worden bij het eerste gebruik gedownload naar ~/.cache/huggingface/hub. Op een VPS met een kleine root-partitie kunt u dit pad naar een locatie met voldoende ruimte verwijzen met het download_root-argument of de HF_HOME-omgevingsvariabele. Doet u dit niet, dan raakt de schijf vol tijdens de eerste uitvoering en stopt het proces halverwege de download.

faster-whisper installeren zonder het systeem-Python te verstoren

Ubuntu 24.04 en Debian 13 markeren het systeem-Python als extern beheerd. Het uitvoeren van pip install faster-whisper buiten een virtuele omgeving stopt onmiddellijk met:

error: externally-managed-environment

Dit is het pakketbeheersysteem dat bestanden beschermt die eigendom zijn van apt. Gebruik een virtuele omgeving.

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

Versie 1.2.1 is de huidige release, gepubliceerd in oktober 2025. faster-whisper decodeert audio via PyAV, dat zijn eigen ffmpeg-bibliotheken bundelt, waardoor het een mp3 of m4a leest zonder een afzonderlijk ffmpeg-binary. Het ffmpeg-pakket hierboven is bedoeld voor het videowerk later in deze handleiding.

Controleer de installatie voordat u drie gigabyte aan gewichten downloadt:

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

Een regel met ok betekent dat de wheels correct zijn geïnstalleerd. Een ImportError die ctranslate2 benoemt, betekent dat het wheel voor uw architectuur niet is geïnstalleerd; dit gebeurt op 32-bit ARM-images.

Een vergaderopname of spraaknotitie transcriberen

Sla dit op als 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))

Voer het uit met ~/stt/bin/python transcribe.py. De eerste keer dat u dit uitvoert, worden de gewichten gedownload, waardoor er enige tijd niets in de terminal verschijnt. Daarna laadt het model binnen enkele seconden vanuit de cache.

segments is een generator, dus de transcriptie begint pas zodra u erover itereert. Gebruikers timen vaak de aanroep van transcribe(), zien dat deze direct terugkeert en denken dat er iets kapot is. Er is niets kapot. Het werk vindt plaats in de lus.

vad_filter=True voert eerst Silero VAD (voice activity detection) uit en verwijdert de stille gedeelten voordat Whisper ze verwerkt. Bij een vergaderopname met lange stiltes is dit de grootste snelheidswinst die u kunt behalen, omdat Whisper geen tijd besteedt aan audio die geen spraak bevat. Het onderdrukt ook de herhalende zinnen die Whisper produceert wanneer het stilte krijgt aangeboden en probeert daar woorden in te vinden.

Stel cpu_threads in op het aantal cores waarover u daadwerkelijk beschikt. Het instellen van een waarde hoger dan uw aantal vCPU's maakt de transcriptie trager, omdat de extra threads strijden om dezelfde core en de scheduler kosten in rekening brengt voor elke context-switch.

Ondertiteling voor een Jellyfin-bibliotheek

Jellyfin leest externe ondertitelingsbestanden die naast de video staan en dezelfde naam hebben. Hierdoor verschijnt Movie (2019).en.srt naast Movie (2019).mkv als een Engels spoor zonder transcodering en zonder dat de bibliotheek opnieuw hoeft te worden opgebouwd.

Extraheer eerst de audio. Whisper resamplet intern alles naar 16 kHz mono, dus door 16 kHz mono aan te leveren, bespaart u werk aan beide kanten:

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

faster-whisper heeft geen SRT-schrijver, dus formatteer de segmenten zelf. Sla dit op als 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())

Doorloop vervolgens de bibliotheek:

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 is geen decoratie. Zonder dit leest ffmpeg van de standaardinvoer van de lus, slokt het de rest van de bestandslijst op en stopt de lus na één film zonder foutmelding.

Plan de tijd in voordat u begint. Bij het hierboven genoemde cijfer van 7.6x realtime heeft een film van 100 minuten ongeveer 13 minuten CPU-tijd nodig. Een bibliotheek van vijftig films is dus een klus voor een hele nacht. Op een gedeeld vCPU-abonnement is het trager, en daar is nice voor: het genereren van ondertitels geeft dan voorrang aan alle andere taken die de server uitvoert.

Tekst-naar-spraak met Piper

Piper is een neurale tekst-naar-spraak-engine die een ONNX-stemmodel op de CPU uitvoert. Het bevat espeak-ng om tekst naar fonemen om te zetten, waardoor er geen afzonderlijke fonemizer geïnstalleerd hoeft te worden. De huidige release is 1.6.0, gepubliceerd in juli 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 schrijft twee bestanden naar de werkmap: de .onnx gewichten en een .onnx.json configuratiebestand met de samplefrequentie en de lijst met sprekers. Deze moeten bij elkaar blijven. Als u stemmen op een vaste locatie bewaart, geef dan --data-dir mee aan beide commando's, omdat de speler anders in de werkmap zoekt en een stem die daar niet staat niet kan vinden.

De -- vóór de tekst is ook van belang. Zonder deze wordt elke zin die met een koppelteken begint, geparseerd als een opdrachtregeloptie.

Stemmen worden geleverd in verschillende kwaliteitsniveaus. Een gemiddelde Engelse stem is ongeveer 60 MB en een stem van hoge kwaliteit is ongeveer het dubbele daarvan. Een hogere kwaliteit betekent een groter model en meer CPU-gebruik per seconde spraak, niet een andere spreker.

Roep de CLI niet aan in een lus. Het model wordt bij elke aanroep geladen en het laden van het model vormt het grootste deel van de tijd bij een korte zin. Draai in plaats daarvan de 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

Een test.wav die u kunt afspelen betekent dat het werkt. Dat eindpunt heeft de eigen structuur van Piper, niet die van OpenAI, dus een client die /v1/audio/speech verwacht, zal er niet mee communiceren. De volgende sectie lost dat op.

Houd het draaiende met een unit-bestand in plaats van een terminal die u zult sluiten:

[Unit]
Description=Piper text to speech HTTP server
After=network-online.target

[Service]
User=piper
ExecStart=/home/piper/tts/bin/python -m piper.http_server -m en_US-lessac-medium --data-dir /home/piper/voices --host 127.0.0.1 --port 5000
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now piper start het en brengt het terug na een herstart. Als de bovenstaande curl niets teruggeeft, bevat journalctl -u piper -n 50 de reden, en een ontbrekend stemmenbestand is meestal de oorzaak.

De OpenAI-compatibele serverstructuur

De meeste software die audio verwerkt, ondersteunt al de OpenAI audio-API: een multipart POST naar /v1/audio/transcriptions voor een bestand, en een JSON POST naar /v1/audio/speech voor een zin. Als u deze twee paden zelf host, hoeft de client slechts één wijziging door te voeren: de base URL.

Speaches is een server die beide richtingen ondersteunt. Deze draait faster-whisper voor transcriptie en Piper of Kokoro voor spraak, achter de OpenAI-paden. De huidige release is v0.9.0-rc.3 van december 2025. Aangezien dit nog voor de 1.0-versie is, dient u de image-tag vast te zetten en de release notes te lezen voordat u een upgrade uitvoert.

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

De single-container vorm, voor het geval u liever geen compose-bestanden beheert:

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

Het named volume is het onderdeel dat vaak wordt vergeten. Zonder dit volume bevindt de model-cache zich in de container, waardoor bij elke herstart gigabytes aan gewichten opnieuw worden gedownload voordat het eerste verzoek kan worden beantwoord.

Voor spraak moet er een stem zijn gedownload voordat /v1/audio/speech antwoord geeft:

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

Daarna werkt elke OpenAI-client met een gewijzigde base URL:

from pathlib import Path
from openai import OpenAI

openai = OpenAI(base_url="http://localhost:8000/v1", api_key="cant-be-empty")
res = openai.audio.speech.create(
    model="speaches-ai/Kokoro-82M-v1.0-ONNX",
    voice="af_heart",
    input="Hello, world!",
    response_format="mp3",
    speed=1,
)
with Path("output.mp3").open("wb") as f:
    f.write(res.response.read())

De placeholder api_key is vereist omdat de OpenAI-clientbibliotheek weigert een verzoek te verzenden zonder API-sleutel. De server negeert de waarde totdat u een echte sleutel configureert.

vox-box is het andere project dat hier het vermelden waard is. Dit is een Python-pakket in plaats van een container, en het bedient dezelfde paden met Whisper, FunASR, Bark, Dia of CosyVoice erachter. Versie 0.0.21 is de huidige versie van december 2025 en vereist Python 3.10 of hoger.

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

Het voorbeeld van het project zelf bindt poort 80, waarvoor root-rechten nodig zijn. Een hoge poort achter een reverse proxy is de betere structuur op een server die ook andere taken uitvoert. vox-box start accepteert één model, dus voor beide richtingen is een tweede instantie op een tweede poort met een speech repo id nodig.

Vraag de server wat er is geladen en gebruik dat id in het veld 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"

Een JSON-body in de vorm van {"text": "..."} betekent dat het volledige pad correct werkt. Een 404-foutmelding op de modelnaam betekent dat u heeft gegokt in plaats van de output van /v1/models te lezen.

Geen van deze servers schakelt standaard authenticatie in. Bind ze aan 127.0.0.1 en benader ze via een VPN of een reverse proxy die om inloggegevens vraagt. Een open /v1/audio/transcriptions op een publiek IP-adres is gratis CPU-kracht voor iedereen die het vindt, en ze zullen het vinden.

Een voice-frontend voor een zelfgehoste assistent

Zodra beide richtingen reageren op OpenAI-paden, kan een chat-frontend deze aansturen. Open WebUI en alternatieven accepteren in hun instellingen een OpenAI-compatibele base URL voor audio, waardoor één systeem een lokale LLM met Ollama kan draaien en de voice-loop aan beide kanten kan sluiten.

Wees realistisch bij het inschatten van de latentie, aangezien deze drie stappen na elkaar op dezelfde cores worden uitgevoerd. Een vraag van 10 seconden duurt ongeveer 1,3 seconden om te transcriberen bij de 7.6x-waarde hierboven, en dat is nog voordat het model een enkel token heeft gelezen. Tel daar de CPU-tokengeneratie bij op en de round-trip is traag genoeg om testers te laten denken dat het systeem is vastgelopen. Batch-transcriptie werkt prima op een CPU. Een gesprek voeren niet, en dat is het punt waarop een VPS met een GPU zijn prijs begint terug te verdienen.

Wanneer is de GPU daadwerkelijk de moeite waard?

[
  {
    "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"
  }
]

Op de GPU draait het grote model in int8 op 13.2x real-time binnen 2,926 MB VRAM, en batching brengt dit naar 48.8x. Let goed op wat de twee grafieken niet vermelden. Ze draaien verschillende modellen: de GPU-rijen zijn large-v2, de CPU-rijen zijn small. Een GPU maakt het kleine model niet zes keer zo snel. Het maakt het nauwkeurige model bruikbaar.

Een gedeeld vCPU-abonnement zal de CPU-cijfers niet halen. Die benchmark had 8 threads van een snelle desktop-processor volledig tot zijn beschikking. Beschouw 7.6x als een bovengrens en meet uw eigen systeem met time op een echte opname voordat u hier plannen omheen maakt.

Vier vuistregels die in de praktijk standhouden:

• Incidentele transcriptie van uw eigen opnames: CPU, small, int8. Twee toegewezen vCPU's zijn voldoende.
• Batchwerk 's nachts, zoals het genereren van ondertitels: CPU, small of medium, int8, verpakt in nice.
• Alles wat interactief is, of een volledige bibliotheek in één avond: GPU.
• Piper: CPU, altijd. Een spraakmodel van deze omvang wint vrijwel niets door een GPU.

Als u wilt bepalen wat de hardware nog meer aankan, behandelt de bredere vraag welke AI-modellen u zelf kunt hosten de groottes die wel en niet passen.

Foutmodi en de bijbehorende meldingen

error: externally-managed-environment tijdens de installatie. De systeem-Python wordt beschermd door de distributie. Maak een virtuele omgeving aan zoals hierboven getoond.

cuDNN-mismatch op een GPU-server. De foutmelding ziet er als volgt uit:

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 en later vereisen cuDNN 9 voor CUDA 12, terwijl de host cuDNN 8 gebruikt. Installeer cuDNN 9 of pin de oudere runtime met pip install --force-reinstall ctranslate2==4.4.0. Kies een van beide opties. Beide tegelijk uitvoeren brengt u terug bij af.

This CTranslate2 package was not compiled with CUDA support is een andere fout met een vergelijkbare oorzaak. De geïnstalleerde wheel is de build die alleen voor CPU geschikt is. Bouw de virtuele omgeving opnieuw op de GPU-host en laat pip de juiste wheel opnieuw selecteren.

Herhaalde zinnen in het transcript. Een zin die tien keer wordt herhaald, is bijna altijd stilte of muziek die als spraak wordt geïnterpreteerd. Schakel eerst vad_filter=True in. Als het probleem aanhoudt, luister dan naar het fragment: bij bijna stil audio heeft Whisper geen houvast en herhaalt het de laatste zelfverzekerde gok.

Verkeerde taal gedetecteerd. Whisper baseert de gok alleen op de eerste 30 seconden. Een info.language_probability die ruim onder de 1.0 ligt, betekent dat het model onzeker was; dit gebeurt wanneer een opname begint met muziek of door elkaar pratende mensen. Gebruik language="en" als u de taal al kent.

Het proces print Killed en stopt. Dit is de kernel out-of-memory killer; dmesg toont de bijbehorende oom-kill-regel. large-v3 heeft meer dan 3 GB nodig voor alleen de gewichten, nog voordat er werkgeheugen wordt gebruikt. Op een 2 GB VPS is small met int8 het grootste model dat past.

Piper kan de stem niet vinden. De speler zoekt in de werkmap, tenzij u --data-dir meegeeft. Voer ls uit in de map die u verwacht en bevestig dat zowel de .onnx als de .onnx.json aanwezig zijn, want het ontbreken van een van beide leidt net zo zeker tot een fout als het ontbreken van beide.

FAQ

Kan ik spraak-naar-tekst draaien op een VPS zonder GPU?

Ja, en voor batchverwerking is dit de verstandige keuze. Bij gebruik van faster-whisper met het small-model op int8, transcribeert de gepubliceerde benchmark van het project 13 minuten audio in 102 seconden op 8 threads van een desktop i7, ongeveer 7.6x real-time, met 1,477 MB RAM. Een plan met gedeelde vCPU's presteert langzamer, dus meet dit op uw eigen systeem. Tekst-naar-spraak met Piper is nog eenvoudiger en vereist onder geen enkele omstandigheid een GPU.

Welk Whisper-modelformaat moet ik gebruiken?

Begin met small op int8. Dit neemt 484 MB in beslag op de schijf en verwerkt helder opgenomen spraak goed. Stap over naar medium wanneer accenten of achtergrondgeluid leiden tot fouten die onacceptabel zijn, en kies pas voor large-v3 wanneer nauwkeurigheid belangrijker is dan al het andere, aangezien dit 3,090 MB schijfruimte en meer dan 3 GB geheugen vereist. De andere kant op: tiny met 75.5 MB is nuttig voor taaldetectie en het testen van een pipeline, niet voor transcripties die door mensen gelezen moeten worden.

Waarom is faster-whisper sneller dan het originele Whisper-pakket?

Het model is hetzelfde. De runtime niet. Het referentiepakket draait Whisper in PyTorch, terwijl faster-whisper dezelfde gewichten draait op CTranslate2, een engine gebouwd voor transformer-inferentie die gewichten kwantiseert tijdens het laden en geen PyTorch-installatie vereist. In de gepubliceerde CPU-benchmark is dat 1.9x real-time voor het referentiepakket tegenover 7.6x voor faster-whisper op int8, met een lager geheugengebruik.

Waarom herhaalt mijn transcriptie steeds dezelfde zin?

Whisper decodeert stilte of muziek als spraak en valt terug op de laatste betrouwbare gok. Stel vad_filter=True in bij de transcribe()-aanroep, die eerst Silero voice activity detection uitvoert en de stille gedeelten verwijdert voordat het model ze ziet. Als het herhalen aanhoudt, controleer dan het audioniveau, omdat een opname die bijna volledig stil is het model geen input geeft om mee te werken.

Hoe krijg ik een OpenAI-compatibel audio-endpoint op mijn eigen server?

Draai een server die POST /v1/audio/transcriptions en POST /v1/audio/speech implementeert en wijs de client daarnaar met een nieuwe base URL. Speaches is een optie, gepubliceerd als container-image met een CPU-build, die faster-whisper gebruikt voor transcriptie en Piper of Kokoro voor spraak. vox-box is een andere optie, geïnstalleerd met pip install vox-box en gestart met vox-box start --huggingface-repo-id, die één model per proces serveert. Geen van beide schakelt standaard authenticatie in, dus bind aan localhost en plaats er een proxy of VPN voor.