Comment exécuter la reconnaissance vocale locale sur CPU avec VibeASR.cpp

La reconnaissance automatique de la parole a énormément progressé ces dernières années. Des modèles de speech-to-text qui nécessitaient autrefois des GPU puissants pour des résultats inégaux offrent désormais des transcriptions fiables sur des ordinateurs du quotidien. 

Parallèlement, les modèles ont gagné en compacité, l'inférence sur CPU s'est accélérée et la prise en charge multilingue s'est étendue, offrant un meilleur équilibre entre qualité de transcription, vitesse, accessibilité et confidentialité.

VibeVoice-ASR-BitNet de Microsoft illustre bien ces avancées. 

Son runtime optimisé VibeASR.cpp permet d'exécuter localement du speech-to-text multilingue sur Windows, Linux ou macOS, sans GPU dédié ni envoi d'enregistrements vers un service cloud.

Dans ce guide, vous apprendrez à installer et compiler VibeASR.cpp, télécharger le modèle quantifié, transcrire des fichiers audio en ligne de commande, exécuter le serveur de streaming persistant et utiliser l'interface web Gradio pour téléverser ou enregistrer de la parole. 

Qu'est-ce que Microsoft VibeASR.cpp ?

VibeASR.cpp est le runtime d'inférence C++ officiel de Microsoft pour VibeVoice-ASR-BitNet, un modèle multilingue de reconnaissance automatique de la parole compressé, conçu pour une inférence locale efficace sur CPU. 

VibeASR.cpp n'est pas un modèle vocal distinct : il fournit le moteur optimisé nécessaire pour exécuter le modèle, ce qui autorise la transcription en temps réel sans GPU dédié ni service vocal dans le cloud. 

Cela le rend adapté aux ordinateurs portables, de bureau, appareils edge et autres systèmes aux ressources limitées. 

Source : microsoft/VibeVoice-ASR-BitNet

Pour rendre le déploiement sur CPU réellement praticable, Microsoft a remplacé le composant modèle de langue Qwen2.5-7B de l'architecture VibeVoice-ASR d'origine par le modèle beaucoup plus compact Qwen2.5-1.5B. 

Deux méthodes de quantification différentes sont aussi appliquées aux deux composants principaux :

• I8_S pour l'encodeur audio VAE
• I2_S pour le modèle de langue, avec des embeddings en précision plus élevée

Ces optimisations font passer la taille totale du modèle d'environ 4,62 Go à 1,58 Go, ce qui le rend réellement exploitable sur des ordinateurs portables et de bureau. 

Malgré cette réduction substantielle, le modèle compressé n'affiche qu'une légère hausse d'environ 1 à 4 points de taux d'erreur de mots par rapport à l'architecture plus grande. 

VibeASR.cpp s'appuie sur le framework ggml, des instructions CPU dédiées et la fusion d'opérateurs pour accélérer l'inférence. 

D'après les benchmarks de Microsoft, il peut être 1,6 à 2,3 fois plus rapide que Whisper.cpp à taille de modèle comparable, et atteindre une vitesse supérieure au temps réel sur CPU pris en charge lorsque suffisamment de threads sont utilisés.

Dans les benchmarks CPU de Microsoft, le modèle a atteint un RTF de 0,63 avec quatre threads et de 0,42 avec huit threads, soit environ 1,59× et 2,38× la vitesse du temps réel. 

Les WER reportés incluent 8,25 % sur MLC English, 21,36 % sur AMI (casque), 25,87 % sur AMI (micro distant) et 2,41 % sur LibriSpeech clean, témoignant d'un bon compromis entre précision, taille du modèle et performances CPU. 

1. Installer les outils de build nécessaires

VibeASR.cpp fonctionne entièrement sur CPU, sans GPU dédié. Il vous faut uniquement un ordinateur Windows, Linux ou macOS pris en charge, Python 3.9 ou plus récent, Git, un compilateur C++ et environ 4 Go d'espace disque libre pour le code source, les fichiers de build et le modèle.

Le processus de compilation nécessite également CMake et Ninja. 

Sous Windows, l'option la plus simple est d'utiliser w64devkit, qui fournit le compilateur et les outils de build dans un terminal préconfiguré. 

Sous Linux, les paquets requis peuvent être installés directement via le gestionnaire de paquets du système.

Windows

Téléchargez le dernier fichier x64 .exe depuis la page des publications w64devkit.

Le fichier téléchargé est une archive auto-extractible. Exécutez-la et extrayez le dossier à un emplacement simple, par exemple :

C:\w64devkit

Puis ouvrez :

C:\w64devkit\w64devkit.exe

Cela lance un terminal prêt à l'emploi contenant GCC, CMake, Make et Ninja. Vous pouvez l'utiliser pour la suite sous Windows sans configurer manuellement les variables d'environnement.

Linux

Sous Ubuntu, Debian et distributions apparentées, installez le compilateur et les outils de build requis avec une seule commande :

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

Cela installe le compilateur GCC, CMake, Ninja, Git, Python et le paquet nécessaire pour créer un environnement virtuel Python.

macOS

Sous macOS, installez les outils de développement en ligne de commande d'Apple :

xcode-select --install

Il vous faudra aussi Git, Python 3.9 ou plus, CMake et Ninja. Le plus simple est de passer par Homebrew :

brew install git python cmake ninja

2. Cloner VibeASR.cpp et préparer l'environnement Python

La procédure suivante est identique sur Windows, Linux et macOS. 

La seule différence selon l'OS est la commande d'activation de l'environnement virtuel Python.

Ouvrez votre terminal, placez-vous dans le dossier où stocker le projet et clonez le dépôt VibeASR.cpp :

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

L'option --recursive télécharge également le sous-module requis llama.cpp. Sans lui, certains fichiers nécessaires à la construction du runtime d'inférence manqueraient.

Créez un environnement virtuel Python dans le dossier du projet. 

python -m venv .venv

Activez-le avec la commande propre à votre système.

Windows avec le terminal w64devkit :

. .venv/Scripts/activate

Linux et macOS :

source .venv/bin/activate

Après activation, (.venv) doit s'afficher avant l'invite de commande. Vérifiez que Python est disponible : 

python --version

Mettez pip à jour et installez les dépendances du projet : 

python -m pip install --upgrade pip

pip install -r requirements.txt

Ces dépendances incluent les paquets Python utilisés par le script d'installation, le téléchargement du modèle et l'interface web Gradio locale. 

3. Compiler VibeASR.cpp et télécharger le modèle

VibeASR.cpp contient un script de configuration qui gère à la fois la compilation C++ et le téléchargement du modèle.

Il compile les exécutables en ligne de commande et de streaming, installe le paquet GGUF nécessaire et télécharge les fichiers du modèle pré-quantifié dans le répertoire du projet.

Assurez-vous que l'environnement virtuel Python est actif avant d'exécuter le script.

Sous Linux et macOS, exécutez :

python setup_env.py

Sous Windows, lancez la commande suivante dans le terminal w64devkit :

CMAKE_GENERATOR=Ninja python setup_env.py

Définir CMAKE_GENERATOR=Ninja force CMake à utiliser Ninja au lieu d'essayer d'utiliser Microsoft Visual C++, indisponible dans l'environnement w64devkit.

Le script va :

• Installer le paquet Python gguf requis.
• Configurer et compiler VibeASR.cpp.
• Construire les exécutables d'inférence et de streaming.
• Télécharger les fichiers du modèle VibeASR pré-quantifié.
• Enregistrer les modèles téléchargés dans models/vibeasr.

Une fois terminé, l'exécutable principal d'inférence sera disponible à l'emplacement suivant.

Sous Windows :

build/bin/asr_infer.exe

Sous Linux et macOS :

build/bin/asr_infer

Vérifiez la bonne construction de l'exécutable en affichant ses options de ligne de commande.

Sous Windows :

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

Sous Linux et macOS :

./build/bin/asr_infer --help

4. Tester la transcription de fichiers et en streaming

Maintenant que le runtime et le modèle sont prêts, vous pouvez tester deux modes de transcription. 

L'exécutable standard traite un fichier audio et renvoie la transcription complète, tandis que le serveur de streaming garde le modèle chargé et affiche progressivement la transcription au fil des jetons générés.

Commencez par télécharger un court enregistrement d'exemple depuis le dossier du projet VibeASR.cpp :

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

Le fichier audio sera enregistré sous recording.wav dans le répertoire actuel du projet.

Transcrire un fichier audio

La commande d'inférence standard charge l'encodeur audio et le modèle de langue, traite l'enregistrement et affiche la transcription complète.

Sous Windows, exécutez :

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

Sous Linux et macOS, utilisez la même commande sans l'extension .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'option -t 6 assigne six threads CPU à l'inférence. Adaptez ce nombre selon votre processeur. 

L'option --greedy sélectionne le jeton le plus probable à chaque étape de décodage, ce qui produit des transcriptions cohérentes.

Sur mon ordinateur, l'enregistrement de 14,085 secondes a été traité en environ 13,7 secondes :

RTF: 0.9726
Vitesse : environ 1,03× le temps réel

Le real-time factor (RTF) compare le temps de traitement à la durée de l'audio. 

Un RTF inférieur à 1,0 signifie que l'enregistrement a été transcrit plus vite que sa durée de lecture. Les performances varient selon le processeur, l'OS, le nombre de threads et la longueur de l'enregistrement.

Tester le streaming jeton par jeton

VibeASR.cpp comprend aussi un serveur de streaming persistant. Il charge une fois les deux fichiers de modèle et reste actif, vous permettant de soumettre plusieurs enregistrements sans redémarrer ni recharger le modèle à chaque fois.

La sortie fonctionne de façon similaire au streaming d'un grand modèle de langue. 

Au lieu d'attendre la fin de toute la transcription, le texte apparaît au fur et à mesure que le décodeur génère chaque jeton. 

Certains jetons représentent des mots entiers, d'autres des fragments ou de la ponctuation, mais ils s'affichent progressivement jusqu'au transcript final.

Sous Windows, démarrez le serveur avec :

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

Sous Linux et macOS, lancez :

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

Patientez jusqu'à ce que le serveur ait chargé les modèles et affiche :

---READY---

Saisissez le chemin du fichier audio puis Entrée :

recording.wav

La transcription va apparaître jeton par jeton. Une fois l'enregistrement traité, le serveur affiche :

---END---

Vous pouvez ensuite fournir un autre chemin de fichier audio sans recharger les modèles. Pour arrêter le serveur, tapez :

exit

Ce flux persistant est particulièrement utile pour transcrire plusieurs enregistrements ou connecter VibeASR.cpp à une autre application nécessitant une sortie de transcription progressive.

5. Lancer et tester l'interface web

VibeASR.cpp inclut une interface web Gradio locale pour téléverser des fichiers audio ou enregistrer la parole via votre micro. La procédure est la même sur Windows, Linux et macOS, même si, sous Windows, les exécutables se terminent par .exe.

Les dépendances nécessaires à l'interface, dont Gradio, SoundFile et NumPy, ont déjà été installées via le fichier requirements.txt.

Vérifiez d'abord que l'environnement virtuel est actif.

Windows avec le terminal w64devkit :

. .venv/Scripts/activate

Linux et macOS :

source .venv/bin/activate

Sous Windows, lancez l'interface avec :

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

Sous Linux et macOS, les chemins par défaut des exécutables sont détectés automatiquement :

python demo/gradio_asr_demo.py --port 7860

Les chemins des modèles sont déjà configurés dans le script Gradio pour tous les systèmes, vous n'avez donc pas à les préciser dans la commande. 

Le script gère aussi des chemins distincts pour l'exécutable d'inférence standard et le serveur de streaming.

Ouvrez l'adresse suivante dans votre navigateur :

http://127.0.0.1:7860

Découvrir l'interface

L'interface permet de :

• Sélectionner le modèle CPU.
• Choisir le nombre de threads CPU.
• Basculer entre traitement en ligne (Online) et hors ligne (Offline).
• Activer le décodage greedy ou ajuster la température et le Top-p.
• Téléverser un fichier audio ou enregistrer directement depuis votre micro.
• Ajouter des hotwords facultatifs, comme des noms propres ou des termes techniques.
• Voir la transcription, la durée audio et le real-time factor.

Ici, Online ne signifie pas que votre audio est envoyé à un service en ligne.

Il traite progressivement les enregistrements longs par blocs et utilise asr_stream_server lorsqu'il est disponible. 

Le mode Offline traite le fichier audio complet avant d'afficher le résultat.

Tester un court enregistrement

Pour un premier test, j'ai enregistré une courte phrase via le micro et sélectionné le mode Offline avec quatre threads CPU.

Un RTF de 0,9584 signifie que le modèle a nécessité environ 0,96 seconde pour traiter chaque seconde d'audio. 

Cela correspond à environ 1,04× le temps réel, donc la transcription s'est terminée légèrement plus vite que la durée de l'enregistrement.

Tester un enregistrement plus long

J'ai également testé l'interface avec un enregistrement d'environ 109,7 secondes de parole. Le modèle a bien produit la transcription complète et indiqué :

RTF: 0.5305
Audio: 109.7s

Cela signifie que le modèle a pris environ 0,53 seconde pour chaque seconde d'audio. La transcription complète a demandé environ 58 secondes, soit une vitesse d'environ 1,88× le temps réel.

Pour conclure

J'ai été agréablement surpris par la maturité de la reconnaissance vocale locale. 

Même sur un CPU plus ancien, VibeASR.cpp transcrit proche voire au‑delà du temps réel, sans GPU, sans grosse mémoire ni beaucoup de stockage. 

L'exécutable compilé peut aussi s'intégrer dans une application Python, être enveloppé dans un endpoint FastAPI ou servir de moteur de transcription pour un outil local plus large.

Le principal paramètre à ajuster est le nombre de threads CPU alloués au processus. 

Vous devrez aussi choisir entre le mode en ligne, qui diffuse la transcription progressivement, et le mode hors ligne, qui renvoie le texte complet après traitement de l'audio.

L'installation pourrait encore gagner en simplicité, notamment sous Windows, Linux et macOS. 

Le projet évoluant encore, je m'attends à des améliorations côté installation et binaires précompilés. Une fois un binaire autonome stable disponible, je me vois bien utiliser ce modèle dans de nombreux projets de speech-to-text locaux.

Je vous recommande aussi de consulter notre tutoriel GPT Live Transcribe API.