Cum rulezi local Speech-to-Text pe CPU cu VibeASR.cpp

Recunoașterea automată a vorbirii a progresat semnificativ în ultimii ani. Modelele speech-to-text care cândva necesitau GPU-uri puternice și produceau rezultate inconsistente pot acum oferi transcrieri precise pe computere obișnuite. 

În același timp, dimensiunile modelelor au scăzut, inferența pe CPU a devenit mai rapidă, iar suportul multilingv s-a extins, oferind utilizatorilor o combinație mai bună de calitate a transcrierii, viteză, accesibilitate și confidențialitate.

VibeVoice-ASR-BitNet de la Microsoft este un bun exemplu al acestui progres. 

Runtime-ul optimizat VibeASR.cpp face posibilă rularea locală a conversiei vorbirii în text, în mai multe limbi, pe un computer cu Windows, Linux sau macOS, fără a depinde de un GPU dedicat sau de trimiterea înregistrărilor către un serviciu cloud.

În acest ghid, vei învăța cum să instalezi și să compilezi VibeASR.cpp, să descarci modelul cuantizat, să transcrii fișiere audio din linia de comandă, să rulezi serverul de streaming persistent și să folosești interfața web Gradio pentru a încărca sau înregistra vorbire. 

Ce este Microsoft VibeASR.cpp? 

VibeASR.cpp este runtime-ul oficial de inferență C++ al Microsoft pentru VibeVoice-ASR-BitNet, un model multilingv de recunoaștere automată a vorbirii comprimat, conceput pentru inferență locală eficientă pe CPU-uri. 

În loc să fie un model de vorbire separat, VibeASR.cpp oferă motorul optimizat necesar pentru a rula modelul, permițând transcriere în timp real fără GPU dedicat sau serviciu de vorbire în cloud. 

Acest lucru îl face potrivit pentru laptopuri, desktopuri, dispozitive edge și alte sisteme cu resurse de calcul limitate. 

Sursă: microsoft/VibeVoice-ASR-BitNet

Pentru a face implementarea pe CPU practică, Microsoft a înlocuit componenta de limbaj Qwen2.5-7B folosită de arhitectura originală VibeVoice-ASR cu modelul mult mai mic Qwen2.5-1.5B. 

Aplică, de asemenea, metode de cuantizare diferite celor două componente principale:

• I8_S pentru encoderul audio VAE
• I2_S pentru modelul de limbaj, cu embeddings de precizie mai mare

Aceste optimizări reduc dimensiunea totală a modelului de la aproximativ 4,62 GB la 1,58 GB, făcându-l practic de rulat pe laptopuri și desktopuri. 

În ciuda reducerii semnificative a dimensiunii, modelul comprimat arată doar o creștere relativ mică, de aproximativ 1–4 puncte procentuale în rata de eroare pe cuvinte, comparativ cu arhitectura mai mare. 

VibeASR.cpp folosește framework-ul ggml, instrucțiuni CPU personalizate și fuziune de operatori pentru a îmbunătăți viteza de inferență. 

Conform benchmarkurilor Microsoft, poate rula de 1,6–2,3 ori mai rapid decât Whisper.cpp la dimensiuni de model comparabile și poate atinge transcriere mai rapidă decât în timp real pe CPU-urile acceptate când se folosesc suficiente threaduri.

În benchmarkurile pe CPU ale Microsoft, modelul a atins un RTF de 0,63 cu patru threaduri și 0,42 cu opt threaduri, echivalând cu aproximativ 1,59× și 2,38× viteza în timp real. 

WER-ul raportat include 8,25% pe MLC English, 21,36% pe audio AMI cu cască, 25,87% pe audio AMI cu microfon la distanță și 2,41% pe LibriSpeech clean, arătând un echilibru solid între acuratețea transcrierii, dimensiunea modelului și performanța pe CPU. 

1. Instalează uneltele de build necesare

VibeASR.cpp rulează complet pe CPU, deci nu ai nevoie de un GPU dedicat. Ai nevoie doar de un computer compatibil cu Windows, Linux sau macOS, Python 3.9 sau mai nou, Git, un compilator C++ și aproximativ 4 GB spațiu liber pe disc pentru codul sursă, fișierele de build și model.

Procesul de build necesită și CMake și Ninja. 

Pe Windows, cea mai simplă opțiune este să folosești w64devkit, care oferă compilatorul și uneltele de build într-un terminal preconfigurat. 

Pe Linux, pachetele necesare pot fi instalate direct prin managerul de pachete al sistemului.

Windows

Descarcă cel mai recent fișier x64 .exe de pe pagina de lansări w64devkit.

Fișierul descărcat este o arhivă auto-extractibilă. Ruleaz-o și extrage folderul într-un loc simplu, cum ar fi:

C:\w64devkit

Apoi deschide:

C:\w64devkit\w64devkit.exe

Aceasta pornește un terminal gata de utilizare care conține GCC, CMake, Make și Ninja. Poți folosi acest terminal pentru pașii rămași pe Windows fără a configura manual variabilele de mediu.

Linux

Pe Ubuntu, Debian și distribuțiile Linux înrudite, compilatorul și uneltele de build necesare pot fi instalate cu o singură comandă:

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

Aceasta instalează compilatorul GCC, CMake, Ninja, Git, Python și pachetul necesar pentru a crea un mediu virtual Python.

macOS

Pe macOS, instalează uneltele de dezvoltare în linie de comandă ale Apple:

xcode-select --install

Vei avea nevoie și de Git, Python 3.9 sau mai nou, CMake și Ninja. Cea mai simplă metodă de a instala restul uneltelor este prin Homebrew:

brew install git python cmake ninja

2. Clonează VibeASR.cpp și configurează mediul Python

Următorul proces de configurare este același pentru Windows, Linux și macOS. 

Singurul pas specific sistemului de operare este comanda folosită pentru activarea mediului virtual Python.

Deschide terminalul, mergi în folderul unde vrei să stochezi proiectul și clonează repository-ul VibeASR.cpp:

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

Opțiunea --recursive descarcă și submodulul necesar llama.cpp. Fără acesta, ar lipsi unele fișiere necesare pentru a construi runtime-ul de inferență.

Creează un mediu virtual Python în interiorul folderului proiectului. 

python -m venv .venv

Activează-l folosind comanda pentru sistemul tău de operare.

Windows folosind terminalul w64devkit:

. .venv/Scripts/activate

Linux și macOS:

source .venv/bin/activate

După activare, terminalul ar trebui să afișeze (.venv) înainte de prompt. Confirmă că Python este disponibil: 

python --version

Actualizează pip și instalează dependențele proiectului: 

python -m pip install --upgrade pip

pip install -r requirements.txt

Aceste dependențe includ pachetele Python folosite de scriptul de setup, procesul de descărcare a modelului și interfața web locală Gradio. 

3. Compilează VibeASR.cpp și descarcă modelul

VibeASR.cpp include un script de setup care gestionează atât procesul de build C++ cât și descărcarea modelului.

Compilează executabilele pentru linia de comandă și streaming, instalează pachetul GGUF necesar și descarcă fișierele de model pre-cuantalizate în directorul proiectului.

Asigură-te că mediul virtual Python este activ înainte de a rula scriptul de setup.

Pe Linux și macOS, rulează:

python setup_env.py

Pe Windows, rulează următoarea comandă în interiorul terminalului w64devkit:

CMAKE_GENERATOR=Ninja python setup_env.py

Setarea CMAKE_GENERATOR=Ninja asigură că CMake folosește sistemul de build Ninja în loc să încerce să utilizeze Microsoft Visual C++, care nu este disponibil în mediul w64devkit.

Scriptul de setup va:

• Instala pachetul Python gguf necesar.
• Configura și compila VibeASR.cpp.
• Construi executabilele de inferență și streaming.
• Descărca fișierele modelului VibeASR pre-cuantalizat.
• Salva modelele descărcate în models/vibeasr.

După finalizarea procesului, executabilul principal de inferență va fi disponibil la următoarea locație.

Pe Windows:

build/bin/asr_infer.exe

Pe Linux și macOS:

build/bin/asr_infer

Verifică dacă executabilul a fost construit cu succes afișând opțiunile sale disponibile în linia de comandă.

Pe Windows:

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

Pe Linux și macOS:

./build/bin/asr_infer --help

4. Testează transcrierea de fișiere și streaming

Acum că runtime-ul și modelul sunt pregătite, poți testa două metode de transcriere. 

Executabilul standard de inferență procesează un fișier audio și returnează transcrierea completă, în timp ce serverul de streaming menține modelul încărcat și afișează transcrierea progresiv, pe măsură ce sunt generate tokenurile.

Mai întâi, descarcă o înregistrare scurtă de probă din interiorul folderului proiectului VibeASR.cpp:

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

Fișierul audio va fi salvat ca recording.wav în directorul curent al proiectului.

Transcrie un fișier audio

Comanda standard de inferență încarcă encoderul audio și modelul de limbaj, procesează înregistrarea și afișează transcrierea completă.

Pe Windows, rulează:

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

Pe Linux și macOS, folosește aceeași comandă fără extensia .exe:

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

Opțiunea -t 6 alocă șase threaduri CPU pentru inferență. Poți crește sau reduce acest număr în funcție de procesorul tău. 

Opțiunea --greedy selectează cel mai probabil token la fiecare pas de decodare, producând rezultate de transcriere consistente.

Pe computerul meu, înregistrarea de 14,085 secunde a durat aproximativ 13,7 secunde pentru a fi procesată:

RTF: 0.9726
Speed: approximately 1.03× real time

Factorul de timp real, sau RTF, compară timpul de procesare cu durata audio. 

Un RTF sub 1.0 înseamnă că înregistrarea a fost transcrisă mai repede decât lungimea ei de redare efectivă. Performanța va varia în funcție de procesor, sistem de operare, numărul de threaduri și lungimea înregistrării.

Testează streamingul token cu token

VibeASR.cpp include și un server de streaming persistent. Încarcă cele două fișiere de model o singură dată și rămâne activ, permițându-ți să trimiți mai multe înregistrări fără a reporni și reîncărca modelul de fiecare dată.

Ieșirea funcționează similar streamingului dintr-un model mare de limbaj. 

În loc să aștepți finalizarea întregii transcrieri, începi să vezi textul pe măsură ce decodorul generează fiecare token. 

Unele tokenuri pot reprezenta cuvinte întregi, în timp ce altele pot reprezenta părți de cuvinte sau semne de punctuație, dar sunt afișate progresiv până când transcrierea este completă.

Pe Windows, pornește serverul cu:

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

Pe Linux și macOS, rulează:

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

Așteaptă până când serverul termină de încărcat modelele și afișează:

---READY---

Introdu calea către fișierul audio și apasă Enter:

recording.wav

Transcrierea va începe să apară token cu token. Când înregistrarea a fost procesată complet, serverul afișează:

---END---

Poți apoi să introduci o altă cale către un fișier audio fără a reîncărca modelele. Pentru a opri serverul, tastează:

exit

Acest flux de lucru persistent este deosebit de util când transcrii mai multe înregistrări sau conectezi VibeASR.cpp la o altă aplicație care are nevoie de ieșire de transcriere progresivă.

5. Pornește și testează interfața web

VibeASR.cpp include o interfață web Gradio locală pentru a încărca fișiere audio sau a înregistra vorbire cu microfonul. Procesul este același pe Windows, Linux și macOS, deși pe Windows se folosesc fișiere executabile care se termină în .exe.

Dependențele necesare pentru interfață, inclusiv Gradio, SoundFile și NumPy, au fost deja instalate prin requirements.txt.

Mai întâi, asigură-te că mediul virtual este activ.

Windows folosind terminalul w64devkit:

. .venv/Scripts/activate

Linux și macOS:

source .venv/bin/activate

Pe Windows, pornește interfața cu:

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

Pe Linux și macOS, căile implicite ale executabilelor sunt detectate automat:

python demo/gradio_asr_demo.py --port 7860

Căile către modele sunt deja configurate în scriptul Gradio pentru toate sistemele de operare, deci nu este nevoie să le incluzi în comandă. 

Scriptul acceptă, de asemenea, căi separate pentru executabilul standard de inferență și serverul de streaming.

Deschide următoarea adresă în browser:

http://127.0.0.1:7860

Explorează interfața

Interfața îți permite să:

• Selectezi modelul pentru CPU.
• Alegi numărul de threaduri CPU.
• Comuți între procesarea Online și Offline.
• Activezi decodarea greedy sau ajustezi temperature și Top-p.
• Încarci un fișier audio sau înregistrezi direct de la microfon.
• Adaugi hotwords opționale, precum nume sau termeni tehnici.
• Vizualizezi transcrierea, durata audio și factorul de timp real.

Aici, modul Online nu înseamnă că audio-ul tău este trimis la un serviciu online.

Procesează înregistrările mai lungi progresiv, în bucăți, și folosește asr_stream_server când este disponibil. 

Modul Offline procesează întregul fișier audio înainte de a afișa rezultatul.

Testează o înregistrare scurtă

Pentru primul test, am înregistrat o propoziție scurtă direct prin microfon și am selectat modul Offline cu patru threaduri CPU.

Un RTF de 0.9584 înseamnă că modelul a avut nevoie de aproximativ 0,96 secunde pentru a procesa fiecare secundă de audio. 

Aceasta înseamnă aproximativ 1,04× în timp real, deci transcrierea s-a încheiat ușor mai repede decât durata efectivă a înregistrării.

Testează o înregistrare mai lungă

Am testat interfața și cu o înregistrare mai lungă, conținând aproximativ 109,7 secunde de vorbire. Modelul a generat cu succes transcrierea completă și a raportat:

RTF: 0.5305
Audio: 109.7s

Asta înseamnă că modelul a avut nevoie de aproximativ 0,53 secunde pentru a procesa fiecare secundă de audio. Întreaga înregistrare a durat în jur de 58 de secunde pentru a fi transcrisă, oferind o viteză de aproximativ 1,88× în timp real.

Gânduri finale

Am fost impresionat de cât de practică a devenit recunoașterea locală a vorbirii. 

Chiar și pe un CPU mai vechi, VibeASR.cpp poate transcrie audio aproape de sau mai rapid decât în timp real, fără a necesita un GPU, cantități mari de memorie sau mult spațiu de stocare. 

Executabilul compilat poate fi, de asemenea, integrat într-o aplicație Python, învelit într-un endpoint FastAPI sau folosit ca motor de transcriere pentru un instrument local mai mare.

Setarea principală de luat în considerare este numărul de threaduri CPU alocate procesului. 

Trebuie, de asemenea, să alegi între modul online, care transmite transcrierea progresiv, și modul offline, care returnează transcrierea completă după procesarea audio.

Setup-ul ar putea fi în continuare mai ușor, în special pe Windows, Linux și macOS. 

Deoarece proiectul este încă în dezvoltare, mă aștept ca instalarea și suportul pentru binare precompilate să se îmbunătățească în timp. Odată ce va fi disponibil un binar standalone stabil, mă văd folosind acest model în mult mai multe proiecte locale de speech-to-text.

Îți recomand, de asemenea, să arunci o privire la tutorialul nostru GPT Live Transcribe API.