Lokale spraak-naar-tekst draaien op je CPU met VibeASR.cpp

Automatische spraakherkenning is de afgelopen jaren flink verbeterd. Spraak-naar-tekstsmodellen die vroeger krachtige GPU’s nodig hadden en wisselvallige resultaten gaven, leveren nu nauwkeurige transcripties op doorsnee computers. 

Tegelijkertijd zijn modellen kleiner geworden, CPU-inferentie is sneller geworden en meertalige ondersteuning is uitgebreid. Dat geeft gebruikers een betere combinatie van transcriptiekwaliteit, snelheid, toegankelijkheid en privacy.

Microsoft’s VibeVoice-ASR-BitNet is een goed voorbeeld van die vooruitgang. 

De geoptimaliseerde VibeASR.cpp-runtime maakt het mogelijk om meertalige spraak-naar-tekst lokaal te draaien op een Windows-, Linux- of macOS-computer, zonder een dedicated GPU of het uploaden van opnames naar een clouddienst.

In deze gids leer je hoe je VibeASR.cpp installeert en bouwt, het gequantiseerde model downloadt, audiobestanden vanaf de command line transcribeert, de persistente streamingserver draait en de Gradio-webinterface gebruikt om spraak te uploaden of op te nemen. 

Wat is Microsoft VibeASR.cpp? 

VibeASR.cpp is Microsofts officiële C++-inferentieruntime voor VibeVoice-ASR-BitNet, een gecomprimeerd meertalig ASR-model dat is ontworpen voor efficiënte lokale inferentie op CPU’s. 

In plaats van een apart spraakmodel te zijn, levert VibeASR.cpp de geoptimaliseerde engine om het model te draaien, waardoor realtime transcriptie mogelijk is zonder een dedicated GPU of cloudgebaseerde spraakdienst. 

Dit maakt het geschikt voor laptops, desktops, edge-apparaten en andere systemen met beperkte rekenkracht. 

Bron: microsoft/VibeVoice-ASR-BitNet

Om CPU-deployment praktisch te maken, verving Microsoft de Qwen2.5-7B-taalmodelcomponent uit de oorspronkelijke VibeVoice-ASR-architectuur door het veel kleinere Qwen2.5-1.5B-model. 

Ook worden verschillende kwantisatiemethoden toegepast op de twee hoofdcomponenten:

• I8_S voor de VAE-audio-encoder
• I2_S voor het taalmodel, met embeddings met hogere precisie

Deze optimalisaties verkleinen de totale modelgrootte van ongeveer 4,62 GB naar 1,58 GB, waardoor het praktisch wordt om op laptops en desktops te draaien. 

Ondanks de forse verkleining vertoont het gecomprimeerde model slechts een relatief kleine toename van ongeveer 1–4 procentpunt in word error rate vergeleken met de grotere architectuur. 

VibeASR.cpp gebruikt het ggml-framework, aangepaste CPU-instructies en operatorfusion om de inferentiesnelheid te verbeteren. 

Volgens Microsofts benchmarks kan het 1,6–2,3 keer sneller draaien dan Whisper.cpp bij vergelijkbare modelgroottes en sneller-dan-realtime transcriptie bereiken op ondersteunde CPU’s wanneer voldoende threads worden gebruikt.

In Microsofts CPU-benchmarks haalde het model een RTF van 0,63 met vier threads en 0,42 met acht threads, goed voor ongeveer 1,59× en 2,38× realtime snelheid. 

De gerapporteerde WER omvat 8,25% op MLC English, 21,36% op AMI-headsetaudio, 25,87% op AMI-afstandsmicrofoonaudio en 2,41% op LibriSpeech clean, wat een sterke balans laat zien tussen transcriptienauwkeurigheid, modelgrootte en CPU-prestaties. 

1. Installeer de vereiste buildtools

VibeASR.cpp draait volledig op de CPU, dus je hebt geen dedicated GPU nodig. Je hebt alleen een ondersteunde Windows-, Linux- of macOS-computer nodig, Python 3.9 of nieuwer, Git, een C++-compiler en ongeveer 4 GB vrije schijfruimte voor de broncode, buildbestanden en het model.

Het buildproces vereist ook CMake en Ninja. 

Op Windows is de makkelijkste optie w64devkit, dat de compiler en buildtools levert in een vooraf geconfigureerde terminal. 

Op Linux kunnen de vereiste pakketten rechtstreeks via de pakketbeheerder geïnstalleerd worden.

Windows

Download het nieuwste x64-.exe-bestand van de w64devkit releases-pagina.

Het gedownloade bestand is een zelfuitpakkend archief. Voer het uit en pak de map uit op een eenvoudige locatie, zoals:

C:\w64devkit

Open vervolgens:

C:\w64devkit\w64devkit.exe

Dit start een direct bruikbare terminal met GCC, CMake, Make en Ninja. Je kunt deze terminal gebruiken voor de overige Windows-stappen zonder handmatig omgevingsvariabelen te configureren.

Linux

Op Ubuntu, Debian en aanverwante Linuxdistributies kunnen de vereiste compiler en buildtools met één commando worden geïnstalleerd:

sudo apt update
sudo apt install build-essential cmake ninja-build git python3 python3-venv

Dit installeert de GCC-compiler, CMake, Ninja, Git, Python en het pakket dat nodig is om een virtuele Python-omgeving te maken.

macOS

Installeer op macOS Apple’s command line-ontwikkeltools:

xcode-select --install

Je hebt ook Git, Python 3.9 of nieuwer, CMake en Ninja nodig. De eenvoudigste manier om de overige tools te installeren is via Homebrew:

brew install git python cmake ninja

2. VibeASR.cpp clonen en de Python-omgeving instellen

Het onderstaande installatieproces is hetzelfde voor Windows, Linux en macOS. 

De enige OS-specifieke stap is het commando om de virtuele Python-omgeving te activeren.

Open je terminal, ga naar de map waar je het project wilt opslaan en kloon de VibeASR.cpp-repository:

git clone --recursive https://github.com/microsoft/VibeASR.cpp.git
cd VibeASR.cpp

De optie --recursive downloadt ook de vereiste submodule llama.cpp. Zonder die submodule zouden sommige bestanden ontbreken die nodig zijn om de inferentieruntime te bouwen.

Maak een virtuele Python-omgeving in de projectmap. 

python -m venv .venv

Activeer die met het commando voor jouw besturingssysteem.

Windows via de w64devkit-terminal:

. .venv/Scripts/activate

Linux en macOS:

source .venv/bin/activate

Na activatie zou (.venv) vóór de prompt moeten staan. Controleer of Python beschikbaar is: 

python --version

Upgrade pip en installeer de projectafhankelijkheden: 

python -m pip install --upgrade pip

pip install -r requirements.txt

Deze afhankelijkheden omvatten de Python-pakketten die worden gebruikt door het setupscript, het modeldownloadproces en de lokale Gradio-webinterface. 

3. Bouw VibeASR.cpp en download het model

VibeASR.cpp bevat een setupscript dat zowel het C++-buildproces als het downloaden van het model afhandelt.

Het compileert de command line- en streaming-uitvoerbare bestanden, installeert het vereiste GGUF-pakket en downloadt de voorgekwantiseerde modelbestanden naar de projectmap.

Zorg dat de virtuele Python-omgeving actief is voordat je het setupscript uitvoert.

Op Linux en macOS, voer uit:

python setup_env.py

Op Windows, voer het volgende commando uit in de w64devkit-terminal:

CMAKE_GENERATOR=Ninja python setup_env.py

Met CMAKE_GENERATOR=Ninja dwing je CMake om het Ninja-buildsysteem te gebruiken in plaats van Microsoft Visual C++, dat niet beschikbaar is in de w64devkit-omgeving.

Het setupscript zal:

• Het vereiste gguf-Python-pakket installeren.
• VibeASR.cpp configureren en compileren.
• De inferentie- en streaminguitvoerbare bestanden bouwen.
• De voorgekwantiseerde VibeASR-modelbestanden downloaden.
• De gedownloade modellen opslaan in models/vibeasr.

Na afronding is het belangrijkste inferentie-uitvoerbare bestand beschikbaar op de volgende locatie.

Op Windows:

build/bin/asr_infer.exe

Op Linux en macOS:

build/bin/asr_infer

Controleer of het uitvoerbare bestand succesvol is gebouwd door de beschikbare command line-opties te tonen.

Op Windows:

./build/bin/asr_infer.exe --help

Op Linux en macOS:

./build/bin/asr_infer --help

4. Test bestand- en streamingtranscriptie

Nu de runtime en het model klaar zijn, kun je twee transcriptiemethoden testen. 

De standaard inferentie-uitvoerbare verwerkt één audiobestand en retourneert de complete transcriptie, terwijl de streamingserver het model geladen houdt en de transcriptie geleidelijk toont naarmate tokens worden gegenereerd.

Download eerst een korte voorbeeldopname vanuit de VibeASR.cpp-projectmap:

curl -L "https://homepages.inf.ed.ac.uk/htang2/notes/speech-samples/103-1240-0000.wav" -o recording.wav

Het audiobestand wordt opgeslagen als recording.wav in de huidige projectmap.

Transcribeer een audiobestand

Het standaard inferentiecommando laadt de audio-encoder en het taalmodel, verwerkt de opname en print de volledige transcriptie.

Op Windows, voer uit:

./build/bin/asr_infer.exe \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  --audio recording.wav \
  -t 6 \
  --greedy

Op Linux en macOS gebruik je hetzelfde commando zonder de .exe-extensie:

./build/bin/asr_infer \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  --audio recording.wav \
  -t 6 \
  --greedy

De optie -t 6 wijst zes CPU-threads toe aan inferentie. Je kunt dit aantal verhogen of verlagen afhankelijk van je processor. 

De optie --greedy kiest bij elke decodestap het meest waarschijnlijke token, wat consistente transcriptieresultaten oplevert.

Op mijn computer duurde het verwerken van de opname van 14,085 seconden ongeveer 13,7 seconden:

RTF: 0.9726
Speed: approximately 1.03× real time

De real-time factor, of RTF, vergelijkt de verwerkingstijd met de duur van het audiofragment. 

Een RTF onder 1.0 betekent dat de opname sneller is getranscribeerd dan de daadwerkelijke afspeelduur. De prestaties variëren per processor, besturingssysteem, aantal threads en opnamelengte.

Token-voor-token streaming testen

VibeASR.cpp bevat ook een persistente streamingserver. Die laadt de twee modelbestanden één keer en blijft actief, zodat je meerdere opnames kunt indienen zonder het model telkens opnieuw te starten en te laden.

De output werkt vergelijkbaar met streaming vanuit een groot taalmodel. 

In plaats van te wachten tot de volledige transcriptie klaar is, zie je tekst verschijnen terwijl de decoder elk token genereert. 

Sommige tokens staan voor volledige woorden, andere voor delen van woorden of leestekens, maar ze worden progressief weergegeven totdat de transcriptie compleet is.

Windows: start de server met:

./build/bin/asr_stream_server.exe \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  -t 6 \
  --greedy

Linux en macOS: voer uit:

./build/bin/asr_stream_server \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  -t 6 \
  --greedy

Wacht tot de server klaar is met het laden van de modellen en weergeeft:

---READY---

Voer het pad naar het audiobestand in en druk op Enter:

recording.wav

De transcriptie verschijnt vervolgens token voor token. Wanneer de opname volledig is verwerkt, toont de server:

---END---

Je kunt daarna een nieuw audiobestand opgeven zonder de modellen te herladen. Om de server te stoppen, typ je:

exit

Deze persistente workflow is vooral handig bij het transcriberen van meerdere opnames of wanneer je VibeASR.cpp koppelt aan een andere applicatie die progressieve transcriptie-output nodig heeft.

5. Start en test de webinterface

VibeASR.cpp bevat een lokale Gradio-webinterface om audiobestanden te uploaden of spraak op te nemen met je microfoon. Het proces is hetzelfde op Windows, Linux en macOS, al gebruikt Windows uitvoerbare bestanden die eindigen op .exe.

De afhankelijkheden voor de interface, waaronder Gradio, SoundFile en NumPy, zijn al geïnstalleerd via requirements.txt.

Controleer eerst of de virtuele omgeving actief is.

Windows via de w64devkit-terminal:

. .venv/Scripts/activate

Linux en macOS:

source .venv/bin/activate

Op Windows start je de interface met:

python demo/gradio_asr_demo.py \
  --port 7860 \
  --bin build/bin/asr_infer.exe \
  --server-bin build/bin/asr_stream_server.exe

Op Linux en macOS worden de standaardpaden naar de uitvoerbare bestanden automatisch gedetecteerd:

python demo/gradio_asr_demo.py --port 7860

De modelpaden zijn in het Gradio-script al geconfigureerd voor alle besturingssystemen, dus je hoeft ze niet in het commando op te nemen. 

Het script ondersteunt ook aparte paden voor het standaard inferentie-uitvoerbare bestand en de streamingserver.

Open het volgende adres in je browser:

http://127.0.0.1:7860

Verken de interface

De interface laat je:

• Het CPU-model selecteren.
• Het aantal CPU-threads kiezen.
• Schakelen tussen Online en Offline verwerking.
• Greedy decoding inschakelen of temperatuur en Top-p aanpassen.
• Een audiobestand uploaden of direct opnemen via je microfoon.
• Optionele hotwords toevoegen, zoals namen of vaktermen.
• De transcriptie, audioduur en real-time factor bekijken.

Hier betekent Online-modus niet dat je audio naar een online dienst wordt gestuurd.

Het verwerkt langere opnames stapsgewijs in chunks en gebruikt asr_stream_server wanneer beschikbaar. 

Offline-modus verwerkt het volledige audiobestand voordat het resultaat wordt getoond.

Test een korte opname

Voor de eerste test nam ik een korte zin op via de microfoon en koos ik Offline-modus met vier CPU-threads.

Een RTF van 0.9584 betekent dat het model ongeveer 0,96 seconden nodig had om elke seconde audio te verwerken. 

Dat is ongeveer 1,04× realtime, dus de transcriptie was net iets sneller klaar dan de daadwerkelijke duur van de opname.

Test een langere opname

Ik testte de interface ook met een langere opname van circa 109,7 seconden spraak. Het model produceerde succesvol de volledige transcriptie en rapporteerde:

RTF: 0.5305
Audio: 109.7s

Dit betekent dat het model ongeveer 0,53 seconden nodig had om elke seconde audio te verwerken. De volledige opname duurde ongeveer 58 seconden om te transcriberen, met een snelheid van ongeveer 1,88× realtime.

Tot slot

Ik ben onder de indruk van hoe praktisch lokale spraakherkenning is geworden. 

Zelfs op een oudere CPU kan VibeASR.cpp audio bijna of zelfs sneller dan realtime transcriberen, zonder GPU, veel geheugen of veel opslagruimte. 

Het gecompileerde uitvoerbare bestand kan ook worden geïntegreerd in een Python-applicatie, verpakt in een FastAPI-endpoint of gebruikt als de transcriptie-engine voor een grotere lokale tool.

De belangrijkste instelling om te overwegen is het aantal CPU-threads dat aan het proces is toegewezen. 

Ook moet je kiezen tussen online modus, die de transcriptie progressief streamt, en offline modus, die de complete transcriptie teruggeeft na het verwerken van de audio.

De setup kan nog steeds eenvoudiger, zeker op Windows, Linux en macOS. 

Aangezien het project nog in ontwikkeling is, verwacht ik dat installatie en ondersteuning voor kant-en-klare binaries in de loop van de tijd verbeteren. Zodra er een stabiele standalone binary beschikbaar is, zie ik mezelf dit model in veel meer lokale spraak-naar-tekstprojecten gebruiken.

Ik raad ook aan om onze GPT Live Transcribe API-tutorial te bekijken.