How to Run Local Speech-to-Text on CPU with VibeASR.cpp

Learn how to run fast, accurate, multilingual speech-to-text locally on a CPU using Microsoft VibeASR.cpp, with file transcription, real-time streaming, and a Gradio web interface on Windows, Linux, and macOS.

Uppdaterad 10 aug. 2026 · 9 min läsa

Utforska med AI

Öppna i ChatGPT Öppna i Claude Öppna i Perplexity

Automatisk taligenkänning har förbättrats avsevärt de senaste åren. Tal-till-text-modeller som tidigare krävde kraftfulla GPU:er och gav ojämna resultat kan nu leverera träffsäkra transkriptioner på vanliga datorer.

Samtidigt har modellerna blivit mindre, CPU-inferens har blivit snabbare och flerspråkigt stöd har utökats, vilket ger användare en bättre kombination av transkriptionskvalitet, hastighet, tillgänglighet och integritet.

Microsofts VibeVoice-ASR-BitNet är ett bra exempel på denna utveckling.

Dess optimerade VibeASR.cpp-runtime gör det möjligt att köra flerspråkig tal-till-text lokalt på en Windows-, Linux- eller macOS-dator utan att vara beroende av ett dedikerat grafikkort eller att skicka inspelningar till en molntjänst.

I den här guiden lär du dig hur du installerar och bygger VibeASR.cpp, laddar ner den kvantiserade modellen, transkriberar ljudfiler från kommandoraden, kör dess persistenta strömningsserver och använder Gradio-webbgränssnittet för att ladda upp eller spela in tal.

Vad är Microsoft VibeASR.cpp?

VibeASR.cpp är Microsofts officiella C++-runtime för inferens av VibeVoice-ASR-BitNet, en komprimerad flerspråkig modell för automatisk taligenkänning utformad för effektiv lokal inferens på CPU:er.

VibeASR.cpp är inte en separat talmodell, utan tillhandahåller den optimerade motorn som krävs för att köra modellen och möjliggör transkribering i realtid utan dedikerad GPU eller molnbaserad tal-tjänst.

Det gör den lämplig för bärbara datorer, stationära datorer, edge-enheter och andra system med begränsade beräkningsresurser.

Källa: microsoft/VibeVoice-ASR-BitNet

För att göra CPU-distribution praktisk bytte Microsoft ut språkmodulkomponenten Qwen2.5-7B som användes i den ursprungliga VibeVoice-ASR-arkitekturen mot den betydligt mindre Qwen2.5-1.5B-modellen.

Den tillämpar också olika kvantiseringsmetoder på de två huvudkomponenterna:

I8_S för VAE-ljudkodaren
I2_S för språkmodellen, med embeddingar i högre precision

Dessa optimeringar minskar den totala modellstorleken från cirka 4,62 GB till 1,58 GB, vilket gör den praktisk att köra på bärbara och stationära datorer.

Trots den betydande storleksminskningen visar den komprimerade modellen bara en relativt liten ökning på omkring 1–4 procentenheter i word error rate jämfört med den större arkitekturen.

VibeASR.cpp använder ramverket ggml, anpassade CPU-instruktioner och operatorfusion för att förbättra inferenshastigheten.

Enligt Microsofts benchmarktester kan den köra 1,6–2,3 gånger snabbare än Whisper.cpp vid jämförbara modellstorlekar och uppnå snabbare-än-realtid-transkribering på stödda CPU:er när tillräckligt många trådar används.

I Microsofts CPU-benchmark nådde modellen en RTF på 0,63 med fyra trådar och 0,42 med åtta trådar, vilket motsvarar ungefär 1,59× och 2,38× realtidshastighet.

Rapporterad WER inkluderar 8,25 % på MLC English, 21,36 % på AMI headset-ljud, 25,87 % på AMI fjärrmikrofon-ljud och 2,41 % på LibriSpeech clean, vilket visar en bra balans mellan transkriptionsnoggrannhet, modellstorlek och CPU-prestanda.

1. Installera nödvändiga byggverktyg

VibeASR.cpp körs helt på CPU, så du behöver inget dedikerat grafikkort. Du behöver bara en dator med Windows, Linux eller macOS som stöds, Python 3.9 eller nyare, Git, en C++-kompilator och cirka 4 GB ledigt diskutrymme för källkod, byggfiler och modell.

Byggprocessen kräver också CMake och Ninja.

På Windows är det enklaste alternativet att använda w64devkit, som tillhandahåller kompilator och byggverktyg i en förkonfigurerad terminal.

På Linux kan de nödvändiga paketen installeras direkt via systemets pakethanterare.

Windows

Ladda ner den senaste x64-.exe-filen från w64devkits releasesida.

Den nedladdade filen är ett självuppackande arkiv. Kör den och extrahera mappen till en enkel plats, till exempel:

C:\w64devkit

Öppna sedan:

C:\w64devkit\w64devkit.exe

Detta startar en färdig terminal som innehåller GCC, CMake, Make och Ninja. Du kan använda den här terminalen för återstående Windows-steg utan att manuellt konfigurera miljövariabler.

Linux

På Ubuntu, Debian och besläktade Linux-distributioner kan den nödvändiga kompilatorn och byggverktygen installeras med ett enda kommando:

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

Detta installerar GCC-kompilatorn, CMake, Ninja, Git, Python och paketet som krävs för att skapa en virtuell Python-miljö.

macOS

På macOS, installera Apples kommandoradsverktyg:

xcode-select --install

Du behöver också Git, Python 3.9 eller nyare, CMake och Ninja. Det enklaste sättet att installera återstående verktyg är via Homebrew:

brew install git python cmake ninja

2. Klona VibeASR.cpp och ställ in Python-miljön

Följande installationsprocess är densamma för Windows, Linux och macOS.

Det enda operativsystemspecifika steget är kommandot som används för att aktivera den virtuella Python-miljön.

Öppna din terminal, gå till mappen där du vill spara projektet och klona VibeASR.cpp-repot:

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

--recursive-flaggan laddar också ner den nödvändiga undermodulen llama.cpp. Utan den skulle vissa filer som krävs för att bygga inferens-runtime saknas.

Skapa en virtuell Python-miljö i projektmappen.

python -m venv .venv

Aktivera den med kommandot för ditt operativsystem.

Windows med w64devkit-terminalen:

. .venv/Scripts/activate

Linux och macOS:

source .venv/bin/activate

Efter aktivering bör terminalen visa (.venv) före kommandotolken. Bekräfta att Python finns tillgängligt:

python --version

Uppgradera pip och installera projektets beroenden:

python -m pip install --upgrade pip

pip install -r requirements.txt

Dessa beroenden inkluderar Python-paketen som används av installationsskriptet, modellnedladdningen och det lokala Gradio-webbgränssnittet.

3. Bygg VibeASR.cpp och ladda ner modellen

VibeASR.cpp innehåller ett installationsskript som hanterar både C++-byggprocessen och modellnedladdningen.

Det kompilerar kommandorads- och strömningskörbara filer, installerar det nödvändiga GGUF-paketet och laddar ner de förkvantiserade modelfilerna till projektkatalogen.

Se till att den virtuella Python-miljön är aktiv innan du kör installationsskriptet.

På Linux och macOS, kör:

python setup_env.py

På Windows, kör följande kommando i w64devkit-terminalen:

CMAKE_GENERATOR=Ninja python setup_env.py

Att sätta CMAKE_GENERATOR=Ninja säkerställer att CMake använder byggsystemet Ninja istället för att försöka använda Microsoft Visual C++, som inte finns tillgängligt i w64devkit-miljön.

Installationsskriptet kommer att:

Installera det nödvändiga Python-paketet gguf.
Konfigurera och kompilera VibeASR.cpp.
Bygga körbara filer för inferens och strömning.
Ladda ner de förkvantiserade VibeASR-modellerna.
Spara de nedladdade modellerna i models/vibeasr.

Efter att processen är klar finns den huvudsakliga körbara filen för inferens på följande plats.

Windows:

build/bin/asr_infer.exe

Linux och macOS:

build/bin/asr_infer

Verifiera att den körbara filen byggdes korrekt genom att visa dess tillgängliga kommandoradsflaggor.

Windows:

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

Linux och macOS:

./build/bin/asr_infer --help

4. Testa fil- och strömningstranskribering

Nu när runtime och modellen är redo kan du testa två transkriptionsmetoder.

Det vanliga inferensprogrammet bearbetar en ljudfil och returnerar den färdiga transkriptionen, medan strömningsservern håller modellen laddad och visar transkriptionen gradvis allteftersom token genereras.

Ladda först ner en kort exempelinspelning inifrån VibeASR.cpp-projektmappen:

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

Ljudfilen sparas som recording.wav i den aktuella projektkatalogen.

Transkribera en ljudfil

Det vanliga inferenskommandot laddar ljudkodaren och språkmodellen, bearbetar inspelningen och skriver ut den färdiga transkriberingen.

På Windows, kör:

./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

På Linux och macOS, använd samma kommando utan .exe-ändelsen:

./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

Flaggan -t 6 tilldelar sex CPU-trådar till inferensen. Du kan öka eller minska detta antal beroende på din processor.

Flaggan --greedy väljer den mest sannolika token vid varje avkodningssteg och ger konsekventa transkriptionsresultat.

På min dator tog den 14,085 sekunder långa inspelningen cirka 13,7 sekunder att bearbeta:

RTF: 0.9726
Speed: approximately 1.03× real time

Real-time factor, eller RTF, jämför bearbetningstid med ljudets längd.

En RTF under 1,0 innebär att inspelningen transkriberades snabbare än dess faktiska uppspelningstid. Prestanda varierar beroende på processor, operativsystem, antal trådar och inspelningens längd.

Testa token-för-token-strömning

VibeASR.cpp inkluderar också en persistent strömningsserver. Den laddar de två modelfilerna en gång och förblir aktiv, vilket låter dig skicka flera inspelningar utan att starta om och ladda modellen på nytt varje gång.

Utmatningen fungerar på ett liknande sätt som strömning från en stor språkmodell.

Istället för att vänta på att hela transkriptionen ska bli klar börjar du se text när avkodaren genererar varje token.

Vissa token kan motsvara hela ord, medan andra kan representera orddelar eller skiljetecken, men de visas successivt tills transkriptionen är fullständig.

På Windows, starta servern med:

./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

På Linux och macOS, kör:

./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

Vänta tills servern har laddat modellerna klart och visar:

---READY---

Skriv in sökvägen till ljudfilen och tryck Enter:

recording.wav

Transkriptionen börjar visas token för token. När inspelningen är helt bearbetad visar servern:

---END---

Du kan sedan ange en annan ljudfilsökväg utan att ladda om modellerna. För att stoppa servern, skriv:

exit

Detta persistenta arbetsflöde är särskilt användbart när du transkriberar flera inspelningar eller kopplar VibeASR.cpp till en annan applikation som behöver progressiv transkriptionsutmatning.

5. Starta och testa webbgränssnittet

VibeASR.cpp innehåller ett lokalt Gradio-webbgränssnitt för att ladda upp ljudfiler eller spela in tal med din mikrofon. Processen är densamma på Windows, Linux och macOS, även om Windows använder körbara filer som slutar på .exe.

Beroendena som behövs för gränssnittet, inklusive Gradio, SoundFile och NumPy, installerades redan via requirements.txt.

Säkerställ först att den virtuella miljön är aktiv.

Windows med w64devkit-terminalen:

. .venv/Scripts/activate

Linux och macOS:

source .venv/bin/activate

På Windows, starta gränssnittet med:

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

På Linux och macOS upptäcks standardvägarna till de körbara filerna automatiskt:

python demo/gradio_asr_demo.py --port 7860

Modellvägarna är redan konfigurerade i Gradio-skriptet för alla operativsystem, så du behöver inte inkludera dem i kommandot.

Skriptet stöder också separata sökvägar för den vanliga inferenskörbara filen och strömningsservern.

Öppna följande adress i din webbläsare:

http://127.0.0.1:7860

Utforska gränssnittet

Gränssnittet låter dig:

Välja CPU-modellen.
Välja antal CPU-trådar.
Växla mellan Online och Offline-bearbetning.
Aktivera greedy-avkodning eller justera temperatur och Top-p.
Ladda upp en ljudfil eller spela in direkt från din mikrofon.
Lägga till valfria nyckelord, till exempel namn eller tekniska termer.
Visa transkription, ljudlängd och real-time factor.

Här betyder Online-läge inte att ditt ljud skickas till en onlinetjänst.

Det bearbetar längre inspelningar successivt i segment och använder asr_stream_server när den finns tillgänglig.

Offline-läget bearbetar hela ljudfilen innan resultatet visas.

Testa en kort inspelning

För det första testet spelade jag in en kort mening direkt via mikrofonen och valde Offline-läge med fyra CPU-trådar.

En RTF på 0,9584 betyder att modellen behövde cirka 0,96 sekunder för att bearbeta varje sekund ljud.

Detta motsvarar ungefär 1,04× realtid, så transkriberingen slutfördes något snabbare än inspelningens faktiska längd.

Testa en längre inspelning

Jag testade också gränssnittet med en längre inspelning som innehöll cirka 109,7 sekunder tal. Modellen producerade hela transkriptionen och rapporterade:

RTF: 0.5305
Audio: 109.7s

Detta betyder att modellen behövde cirka 0,53 sekunder för att bearbeta varje sekund ljud. Hela inspelningen tog omkring 58 sekunder att transkribera, vilket ger en hastighet på ungefär 1,88× realtid.

Avslutande tankar

Jag blev imponerad av hur praktisk lokal taligenkänning har blivit.

Även på en äldre CPU kan VibeASR.cpp transkribera ljud nära eller snabbare än i realtid utan att kräva GPU, stora mängder minne eller mycket lagring.

Den kompilerade körbara filen kan också integreras i en Python-applikation, kapslas in i en FastAPI-endpoint eller användas som transkriptionsmotor i ett större lokalt verktyg.

Den viktigaste inställningen att beakta är hur många CPU-trådar som tilldelas processen.

Du behöver också välja mellan online-läget, som strömmar transkriptionen stegvis, och offline-läget, som returnerar den kompletta transkriptionen efter att ha bearbetat ljudet.

Installationen kan fortfarande bli enklare, särskilt på Windows, Linux och macOS.

Eftersom projektet fortfarande utvecklas förväntar jag mig att installation och stöd för förkompilerade binärer förbättras över tid. När en stabil fristående binär finns tillgänglig kan jag se mig själv använda denna modell i många fler lokala tal-till-text-projekt.

Jag rekommenderar också att du kollar in vår handledning för GPT Live Transcribe API.