Come eseguire il riconoscimento vocale locale su CPU con VibeASR.cpp

Il riconoscimento vocale automatico è migliorato notevolmente negli ultimi anni. I modelli speech-to-text che un tempo richiedevano potenti GPU e producevano risultati incostanti ora possono offrire trascrizioni accurate su comuni computer di tutti i giorni. 

Allo stesso tempo, le dimensioni dei modelli si sono ridotte, l'inferenza su CPU è diventata più veloce e il supporto multilingue si è ampliato, offrendo una migliore combinazione di qualità di trascrizione, velocità, accessibilità e privacy.

VibeVoice-ASR-BitNet di Microsoft è un buon esempio di questi progressi. 

Il runtime ottimizzato VibeASR.cpp rende possibile eseguire localmente il riconoscimento vocale multilingue su un computer Windows, Linux o macOS senza affidarsi a una GPU dedicata o inviare registrazioni a un servizio cloud.

In questa guida imparerai a installare e compilare VibeASR.cpp, scaricare il modello quantizzato, trascrivere file audio dalla riga di comando, eseguire il suo server di streaming persistente e usare l'interfaccia web Gradio per caricare o registrare parlato. 

Che cos'è Microsoft VibeASR.cpp? 

VibeASR.cpp è il runtime di inferenza C++ ufficiale di Microsoft per VibeVoice-ASR-BitNet, un modello multilingue di riconoscimento vocale automatico compresso progettato per un'inferenza locale efficiente su CPU. 

Invece di essere un modello vocale separato, VibeASR.cpp fornisce il motore ottimizzato necessario per eseguire il modello, consentendo la trascrizione in tempo reale senza una GPU dedicata o un servizio vocale basato su cloud. 

Questo lo rende adatto a laptop, desktop, dispositivi edge e altri sistemi con risorse di calcolo limitate. 

Fonte: microsoft/VibeVoice-ASR-BitNet

Per rendere pratico il deploy su CPU, Microsoft ha sostituito il componente language model Qwen2.5-7B usato dall'architettura originale di VibeVoice-ASR con il modello molto più piccolo Qwen2.5-1.5B. 

Applica inoltre diversi metodi di quantizzazione ai due componenti principali:

• I8_S per l'encoder audio VAE
• I2_S per il language model, con embedding a precisione più alta

Queste ottimizzazioni riducono la dimensione totale del modello da circa 4,62 GB a 1,58 GB, rendendone pratico l'uso su laptop e desktop. 

Nonostante la notevole riduzione delle dimensioni, il modello compresso mostra solo un piccolo aumento di circa 1–4 punti percentuali nel tasso di errore di parola rispetto all'architettura più grande. 

VibeASR.cpp utilizza il framework ggml, istruzioni CPU personalizzate e operator fusion per migliorare la velocità di inferenza. 

Secondo i benchmark di Microsoft, può essere 1,6–2,3 volte più veloce di Whisper.cpp a parità di dimensioni del modello e può raggiungere una trascrizione più veloce del tempo reale su CPU supportate quando si usano abbastanza thread.

Nei benchmark su CPU di Microsoft, il modello ha raggiunto un RTF di 0,63 con quattro thread e 0,42 con otto thread, pari a circa 1,59× e 2,38× la velocità del tempo reale. 

Il WER riportato include 8,25% su MLC English, 21,36% su audio AMI da cuffia, 25,87% su audio AMI da microfono distante e 2,41% su LibriSpeech clean, mostrando un buon equilibrio tra accuratezza di trascrizione, dimensione del modello e prestazioni su CPU. 

1. Installa gli strumenti di build necessari

VibeASR.cpp viene eseguito interamente sulla CPU, quindi non serve una GPU dedicata. Ti basta un computer Windows, Linux o macOS supportato, Python 3.9 o successivo, Git, un compilatore C++ e circa 4 GB di spazio libero su disco per codice sorgente, file di build e modello.

Il processo di build richiede anche CMake e Ninja. 

Su Windows, l'opzione più semplice è usare w64devkit, che fornisce compilatore e strumenti di build in un terminale preconfigurato. 

Su Linux, i pacchetti richiesti possono essere installati direttamente tramite il gestore pacchetti del sistema.

Windows

Scarica l'ultima .exe x64 dalla pagina dei rilasci di w64devkit.

Il file scaricato è un archivio autoestraente. Eseguilo ed estrai la cartella in una posizione semplice, ad esempio:

C:\w64devkit

Poi apri:

C:\w64devkit\w64devkit.exe

Questo avvia un terminale pronto all'uso che contiene GCC, CMake, Make e Ninja. Puoi usare questo terminale per i passaggi restanti su Windows senza configurare manualmente le variabili d'ambiente.

Linux

Su Ubuntu, Debian e distribuzioni Linux correlate, il compilatore e gli strumenti di build necessari possono essere installati con un unico comando:

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

Questo installa il compilatore GCC, CMake, Ninja, Git, Python e il pacchetto richiesto per creare un ambiente virtuale Python.

macOS

Su macOS, installa gli strumenti di sviluppo da riga di comando di Apple:

xcode-select --install

Ti serviranno anche Git, Python 3.9 o successivo, CMake e Ninja. Il modo più semplice per installare gli strumenti restanti è tramite Homebrew:

brew install git python cmake ninja

2. Clona VibeASR.cpp e configura l'ambiente Python

Il seguente processo di configurazione è lo stesso per Windows, Linux e macOS. 

L'unico passaggio specifico del sistema operativo è il comando usato per attivare l'ambiente virtuale Python.

Apri il terminale, spostati nella cartella in cui vuoi salvare il progetto e clona il repository VibeASR.cpp:

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

L'opzione --recursive scarica anche il sotto-modulo richiesto llama.cpp. Senza di esso, mancherebbero alcuni file necessari per compilare il runtime di inferenza.

Crea un ambiente virtuale Python all'interno della cartella del progetto. 

python -m venv .venv

Attivalo usando il comando per il tuo sistema operativo.

Windows usando il terminale w64devkit:

. .venv/Scripts/activate

Linux e macOS:

source .venv/bin/activate

Dopo l'attivazione, il terminale dovrebbe mostrare (.venv) prima del prompt. Conferma che Python sia disponibile: 

python --version

Aggiorna pip e installa le dipendenze del progetto: 

python -m pip install --upgrade pip

pip install -r requirements.txt

Queste dipendenze includono i pacchetti Python usati dallo script di setup, dal processo di download del modello e dall'interfaccia web locale Gradio. 

3. Compila VibeASR.cpp e scarica il modello

VibeASR.cpp include uno script di setup che gestisce sia il processo di build C++ sia il download del modello.

Compila gli eseguibili a riga di comando e streaming, installa il pacchetto GGUF richiesto e scarica i file del modello pre-quantizzato nella directory del progetto.

Assicurati che l'ambiente virtuale Python sia attivo prima di eseguire lo script di setup.

Su Linux e macOS, esegui:

python setup_env.py

Su Windows, esegui il seguente comando all'interno del terminale w64devkit:

CMAKE_GENERATOR=Ninja python setup_env.py

Impostare CMAKE_GENERATOR=Ninja garantisce che CMake usi il sistema di build Ninja invece di tentare di usare Microsoft Visual C++, non disponibile nell'ambiente w64devkit.

Lo script di setup:

• Installa il pacchetto Python gguf richiesto.
• Configura e compila VibeASR.cpp.
• Compila gli eseguibili di inferenza e streaming.
• Scarica i file del modello VibeASR pre-quantizzati.
• Salva i modelli scaricati in models/vibeasr.

Al termine del processo, l'eseguibile principale di inferenza sarà disponibile nella seguente posizione.

Su Windows:

build/bin/asr_infer.exe

Su Linux e macOS:

build/bin/asr_infer

Verifica che l'eseguibile sia stato compilato correttamente visualizzando le opzioni disponibili a riga di comando.

Su Windows:

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

Su Linux e macOS:

./build/bin/asr_infer --help

4. Prova la trascrizione di file e in streaming

Ora che runtime e modello sono pronti, puoi testare due metodi di trascrizione. 

L'eseguibile standard di inferenza elabora un file audio e restituisce la trascrizione completa, mentre il server di streaming mantiene il modello carico e mostra la trascrizione in modo progressivo man mano che i token vengono generati.

Per prima cosa, scarica una breve registrazione di esempio all'interno della cartella del progetto VibeASR.cpp:

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

Il file audio verrà salvato come recording.wav nella directory corrente del progetto.

Trascrivi un file audio

Il comando di inferenza standard carica l'encoder audio e il language model, elabora la registrazione e stampa la trascrizione completa.

Su Windows, esegui:

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

Su Linux e macOS, usa lo stesso comando senza l'estensione .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

L'opzione -t 6 assegna sei thread CPU all'inferenza. Puoi aumentare o ridurre questo numero in base al tuo processore. 

L'opzione --greedy seleziona il token più probabile a ogni passo di decodifica, producendo risultati di trascrizione coerenti.

Sul mio computer, la registrazione da 14,085 secondi ha richiesto circa 13,7 secondi per essere elaborata:

RTF: 0.9726
Speed: approximately 1.03× real time

Il real-time factor, o RTF, confronta il tempo di elaborazione con la durata dell'audio. 

Un RTF inferiore a 1.0 significa che la registrazione è stata trascritta più velocemente della sua reale durata di riproduzione. Le prestazioni variano in base al processore, al sistema operativo, al numero di thread e alla lunghezza della registrazione.

Prova lo streaming token-per-token

VibeASR.cpp include anche un server di streaming persistente. Carica i due file del modello una volta e rimane attivo, permettendoti di inviare più registrazioni senza riavviare e ricaricare il modello ogni volta.

L'output funziona in modo simile allo streaming da un large language model. 

Invece di aspettare il completamento dell'intera trascrizione, inizi a vedere il testo man mano che il decoder genera ogni token. 

Alcuni token possono rappresentare parole complete, altri parti di parole o punteggiatura, ma vengono mostrati progressivamente fino al completamento della trascrizione.

Su Windows, avvia il server con:

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

Su Linux e macOS, esegui:

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

Attendi che il server finisca di caricare i modelli e mostri:

---READY---

Inserisci il percorso del file audio e premi Invio:

recording.wav

La trascrizione inizierà ad apparire token per token. Quando la registrazione è stata elaborata completamente, il server mostra:

---END---

Puoi quindi inserire un altro percorso di file audio senza ricaricare i modelli. Per arrestare il server, digita:

exit

Questo workflow persistente è particolarmente utile quando trascrivi più registrazioni o colleghi VibeASR.cpp a un'altra applicazione che necessita di output di trascrizione progressivo.

5. Avvia e testa l'interfaccia web

VibeASR.cpp include un'interfaccia web Gradio locale per caricare file audio o registrare parlato con il microfono. Il processo è lo stesso su Windows, Linux e macOS, anche se Windows usa file eseguibili con estensione .exe.

Le dipendenze necessarie per l'interfaccia, tra cui Gradio, SoundFile e NumPy, sono già state installate tramite requirements.txt.

Per prima cosa, assicurati che l'ambiente virtuale sia attivo.

Windows usando il terminale w64devkit:

. .venv/Scripts/activate

Linux e macOS:

source .venv/bin/activate

Su Windows, avvia l'interfaccia con:

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

Su Linux e macOS, i percorsi predefiniti degli eseguibili vengono rilevati automaticamente:

python demo/gradio_asr_demo.py --port 7860

I percorsi del modello sono già configurati all'interno dello script Gradio per tutti i sistemi operativi, quindi non è necessario includerli nel comando. 

Lo script supporta anche percorsi separati per l'eseguibile di inferenza standard e per il server di streaming.

Apri il seguente indirizzo nel browser:

http://127.0.0.1:7860

Esplora l'interfaccia

L'interfaccia ti consente di:

• Selezionare il modello CPU.
• Scegliere il numero di thread della CPU.
• Passare tra elaborazione Online e Offline.
• Abilitare il decoding greedy o regolare temperatura e Top-p.
• Caricare un file audio o registrare direttamente dal microfono.
• Aggiungere hotword opzionali, come nomi o termini tecnici.
• Visualizzare trascrizione, durata audio e real-time factor.

Qui, la modalità Online non significa che il tuo audio venga inviato a un servizio online.

Elabora progressivamente registrazioni più lunghe a blocchi e usa asr_stream_server quando disponibile. 

La modalità Offline elabora l'intero file audio prima di mostrare il risultato.

Prova una registrazione breve

Per il primo test, ho registrato una breve frase direttamente dal microfono e ho selezionato la modalità Offline con quattro thread CPU.

Un RTF di 0.9584 significa che il modello ha richiesto circa 0,96 secondi per elaborare ogni secondo di audio. 

Questo equivale a circa 1,04× il tempo reale, quindi la trascrizione è stata completata leggermente più velocemente della durata effettiva della registrazione.

Prova una registrazione più lunga

Ho testato l'interfaccia anche con una registrazione più lunga contenente circa 109,7 secondi di parlato. Il modello ha prodotto correttamente la trascrizione completa e ha riportato:

RTF: 0.5305
Audio: 109.7s

Ciò significa che il modello ha richiesto circa 0,53 secondi per elaborare ogni secondo di audio. L'intera registrazione ha impiegato circa 58 secondi per essere trascritta, per una velocità di circa 1,88× il tempo reale.

Considerazioni finali

Mi ha colpito quanto sia diventato pratico il riconoscimento vocale locale. 

Anche su una CPU datata, VibeASR.cpp può trascrivere l'audio a velocità vicine o superiori al tempo reale senza richiedere una GPU, grandi quantità di memoria o molto storage. 

L'eseguibile compilato può anche essere integrato in un'applicazione Python, incapsulato in un endpoint FastAPI o usato come motore di trascrizione per uno strumento locale più ampio.

L'impostazione principale da valutare è il numero di thread CPU assegnati al processo. 

Devi anche scegliere tra la modalità online, che esegue lo streaming progressivo della trascrizione, e la modalità offline, che restituisce la trascrizione completa dopo l'elaborazione dell'audio.

Il setup potrebbe essere ancora più semplice, soprattutto su Windows, Linux e macOS. 

Dato che il progetto è ancora in sviluppo, mi aspetto che l'installazione e il supporto a binari precompilati migliorino nel tempo. Una volta disponibile un binario standalone stabile, vedo questo modello usato in molti più progetti speech-to-text locali.

Ti consiglio anche di dare un'occhiata al nostro tutorial sulla GPT Live Transcribe API.