Implémentation d’inférence CPU uniquement en pur C pour le modèle de reconnaissance vocale Mistral Voxtral Realtime 4B

• Mistral Voxtral Realtime 4B : un pipeline d’inférence implémenté uniquement en C, avec une architecture autonome sans aucune dépendance externe
• Prend en charge les backends Metal GPU acceleration (MPS) et BLAS (OpenBLAS/Accelerate), et traite l’entrée vocale en temps réel ainsi que la sortie des tokens via une API de streaming
• Grâce à des poids BF16 mappés en mémoire, un encodeur à fenêtre glissante et un rolling KV cache, l’utilisation mémoire reste stable même sur de longues entrées audio
• Prend en charge plusieurs modes d’entrée audio via microphone, pipe stdin et conversion ffmpeg, avec affichage de tokens alternatifs et option de réglage de la latence (-I)
• Publié sous licence MIT, avec des performances d’environ 2,5 fois le temps réel sur Apple M3 Max, rendant possible une reconnaissance vocale locale allégée

---

Présentation de Voxtral.c

• Moteur d’inférence en pur C pour le modèle Voxtral Realtime 4B de Mistral AI, sans dépendance en dehors de la bibliothèque standard C
  • Le backend MPS offre des performances d’inférence rapides, tandis que BLAS (OpenBLAS/Accelerate) fonctionne dans les environnements basés CPU
  • Inférence entièrement locale possible sans runtime Python, CUDA ni vLLM
• Une implémentation de référence Python simple est également fournie via le fichier python_simple_implementation.py
  • Nécessite seulement PyTorch, safetensors, soundfile et soxr

Fonctionnalités principales

• Zero dependencies : exécutable uniquement en C, sans bibliothèque externe
• Accélération GPU Metal : activée automatiquement sur Apple Silicon, avec fusion des opérations GPU et traitement batché de l’attention
• Sortie en streaming : les tokens générés sont immédiatement affichés sur stdout
• API C de streaming : permet d’alimenter l’audio séquentiellement et de recevoir les chaînes de tokens en temps réel
• Poids mappés en mémoire : chargement direct des fichiers safetensors via mmap, immédiatement exploitables
• Prise en charge du microphone (macOS) : avec détection automatique du silence
• Chunked Encoder : traite l’audio en chunks qui se chevauchent afin de maintenir une utilisation mémoire stable
• Rolling KV Cache : compression automatique du cache avec une fenêtre glissante de 8192 positions, permettant de traiter de l’audio de longueur illimitée

Utilisation

• Commandes de base
  • ./voxtral -d voxtral-model -i audio.wav : reconnaissance vocale à partir d’un fichier
  • ./voxtral -d voxtral-model --from-mic : reconnaissance en temps réel depuis le microphone (macOS)
  • Les entrées dans divers formats audio sont possibles via un pipe ffmpeg
• Affichage des tokens alternatifs
  • L’option --alt <cutoff> permet d’afficher aussi des candidats à prononciation similaire
  • Plus la valeur cutoff est élevée, plus le nombre de candidats affichés est important
• Réglage de la latence (option -I)
  • Définit en secondes la fréquence d’appel de l’encodeur
  • Une valeur basse (ex. 0,5 s) réduit la latence mais augmente la charge GPU / une valeur élevée (ex. 5 s) améliore l’efficacité du traitement
  • La valeur par défaut est de 2,0 s ; 1,0 à 2,0 s est recommandé pour le streaming en temps réel

Structure de l’API C

• API de streaming fournie autour de vox_stream_t
  • feed() : entrée audio
  • get() : réception des tokens
  • finish() : traite l’audio restant
  • flush() : force le traitement du buffer
• vox_stream_set_alt() permet de configurer le nombre de tokens alternatifs
• La fonction vox_transcribe() permet aussi de traiter un fichier unique en mode batch

Téléchargement et configuration du modèle

• Téléchargement d’environ 8,9 Go de poids du modèle depuis HuggingFace
  • consolidated.safetensors (poids BF16)
  • tekken.json (vocabulaire du tokenizer)
  • params.json (configuration du modèle)
• Modèle sous licence Apache-2.0, code sous licence MIT

Benchmarks de performance

• Référence : Apple M3 Max (GPU 40 cœurs, 128 Go de RAM)
  • Backend MPS : encodeur 284 ms, décodeur 23,5 ms/étape
  • Backend BLAS : encodeur ~8 s, décodeur 335 ms/étape
• Moyenne de 31,6 ms/étape sur un audio de 60 secondes, soit environ 2,5 fois plus rapide que le temps réel
• Le décodeur exécute l’ensemble des opérations par token via un unique appel à un command buffer Metal

Architecture du modèle

• Modèle streaming voix-vers-texte de 4 milliards de paramètres (4B)
  • Encodeur audio : transformer causal à 32 couches, dimension 1280, 32 têtes, fenêtre 750
  • Adaptateur : Linear(5120→3072) → GELU → Linear(3072→3072)
  • Décodeur LLM : transformer à 26 couches (basé sur Ministral-3), dimension 3072, GQA (32 têtes / 8KV)
• Tokenizer Tekken, vocabulaire de 131 072 éléments
• Langues prises en charge : anglais, espagnol, français, portugais, hindi, allemand, néerlandais, italien, arabe, russe, chinois, japonais, coréen

Exigences mémoire

• Poids du modèle : 8,9 Go (mmap à la demande)
• Cache GPU : environ 8,4 Go (après conversion BF16→F16)
• KV cache : jusqu’à 1,8 Go (limité par la fenêtre glissante)
• Buffer de travail : environ 200 Mo

Build et plateformes

• macOS Apple Silicon : make mps (le plus rapide)
• macOS Intel / Linux (OpenBLAS) : make blas
• Ubuntu/Debian : sudo apt install libopenblas-dev
• Fedora : sudo dnf install openblas-devel

Licence

• Code : MIT
• Modèle : Apache-2.0
• Disponible en open source, modifiable et redistribuable par tous