Capturer le microphone avec PyAudio
Šiame puslapyje
Cours mis à jour le 3 novembre 2026 pour Voxtral 3, basé sur le guide Migrate from Voxtral 2 de Mistral : les modèles Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), dépréciés le 31 octobre 2026 et retirés le 30 avril 2027, sont remplacés dans les exemples parvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3etvoxtral-mini-tts-3-0. Changements clés : les horodatages sont uniquement par segment (wordrenvoie une erreur 400), la diarisation en temps réel est prise en charge, les paramètres de session en temps réel sont verrouillés après le premier bloc audio, et les entréescontext_biassont flexibles (phrases avec espaces). Sources : Migrate from Voxtral 2 · Speech to Text.
Du fichier au microphone
La leçon précédente a établi une architecture où la source audio est un générateur asynchrone simple et interchangeable. Tu vas l’exploiter immédiatement : en remplaçant le générateur de lecture de fichier par un autre qui lit depuis ta carte son, ton programme commence à transcrire ta voix en direct sans modifier une seule ligne du reste du code.
L’outil de cette leçon est PyAudio, la bibliothèque Python standard pour accéder aux périphériques audio. Elle s’appuie sur PortAudio, une couche native que tu devras peut-être installer séparément selon ton système.
Installation de PyAudio
# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio
# macOS
brew install portaudio
pip install pyaudio
# Windows
pip install pyaudio
Le générateur de microphone
Le cœur de cette leçon tient en une trentaine de lignes. La fonction ouvre un flux d’entrée sur le périphérique par défaut, boucle indéfiniment pour lire des blocs de taille fixe et yield chaque bloc au moteur de transcription. Le bloc finally n’est pas décoratif : il garantit l’arrêt du flux, sa fermeture et la libération du matériel par PyAudio, même si le programme est interrompu brutalement. Sans cela, le microphone peut rester verrouillé, bloquant d’autres applications.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Capture le microphone et yield des blocs PCM.
Args:
sample_rate: Fréquence d'échantillonnage (16000 Hz pour Voxtral)
chunk_duration_ms: Durée de chaque bloc en millisecondes
Yields:
bytes: Blocs audio PCM mono 16 bits
"""
p = pyaudio.PyAudio()
# Nombre d'échantillons par bloc
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Ouvrir le flux du microphone
stream = p.open(
format=pyaudio.paInt16, # PCM 16 bits
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Mode capture
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Microphone actif — parle...")
while True:
# Lire le bloc sans blocage
data = await loop.run_in_executor(
None,
stream.read,
chunk_samples,
False # exception_on_overflow
)
yield data
finally:
stream.stop_stream()
stream.close()
p.terminate()
print("Microphone fermé")
Chaque paramètre a une raison précise. sample_rate=16000 reflète une exigence du modèle, pas une préférence : Voxtral attend 16 kHz, donc ne change pas cette valeur. pyaudio.paInt16 correspond au format PCM signé 16 bits, exactement équivalent au pcm_s16le déclaré côté API, et channels=1 impose le mono, également requis. Il reste chunk_duration_ms=480, le seul réglage vraiment discutable : chaque bloc représente 480 millisecondes d’audio, un bon compromis entre réactivité et efficacité réseau. Un bloc plus court, disons 100 ms, améliore la réactivité mais multiplie les requêtes réseau ; un bloc plus long économise de la bande passante au prix d’une latence accrue avant que le modèle ne voie l’audio.
L’appel loop.run_in_executor mérite aussi une explication. stream.read est une fonction bloquante : elle retient le thread jusqu’à ce que le nombre d’échantillons demandé soit disponible. L’exécuter directement dans une coroutine gèlerait toute la boucle asyncio, y compris la réception des événements de transcription. En la déléguant à un executor, tu rends la lecture compatible avec le reste du programme asynchrone.
Le calcul de la taille du bloc découle mécaniquement des deux réglages, pour sample_rate=16000 et chunk_duration_ms=480 :
chunk_samples = 16000 × 480 / 1000 = 7680 échantillons
byte_size = 7680 × 2 octets = 15360 octets par bloc
Programme complet : du microphone à la transcription
Le script suivant combine capture et transcription en un outil de dictée prêt à l’emploi. Le nouvel élément par rapport au générateur précédent est la gestion propre de l’arrêt : un gestionnaire de signal intercepte Ctrl+C, bascule le drapeau running à False, ce qui sort de la boucle de capture, ferme le flux et permet au programme de sauvegarder le texte accumulé. Sans ce mécanisme, une interruption clavier tuerait le processus avant la sauvegarde et tu perdrais la dictée.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Drapeau pour un arrêt propre
running = True
def signal_handler(sig, frame):
global running
print("\n\nArrêt en cours...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Capture le microphone jusqu'à interruption (Ctrl+C)."""
p = pyaudio.PyAudio()
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
while running:
data = await loop.run_in_executor(
None, stream.read, chunk_samples, False
)
yield data
finally:
stream.stop_stream()
stream.close()
p.terminate()
async def main():
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
print("=" * 50)
print("TRANSCRIPTION EN DIRECT")
print("Parle dans le microphone (Ctrl+C pour arrêter)")
print("=" * 50)
print()
full_text = []
async for event in client.audio.realtime.transcribe_stream(
audio_stream=iter_microphone(),
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
):
if isinstance(event, TranscriptionStreamTextDelta):
print(event.text, end="", flush=True)
full_text.append(event.text)
elif isinstance(event, TranscriptionStreamDone):
break
# Sauvegarde
final_text = "".join(full_text)
if final_text.strip():
with open("dictee.txt", "w", encoding="utf-8") as f:
f.write(final_text)
print(f"\n\nTranscription sauvegardée dans dictee.txt")
print(f"Longueur : {len(final_text)} caractères")
else:
print("\n\nAucun texte transcrit.")
asyncio.run(main())
Lance-le, parle, arrête avec Ctrl+C : le texte apparaît pendant que tu parles, puis atterrit dans dictee.txt.
python dictee_vocale.py
# Parle dans ton microphone
# Le texte apparaît en temps réel
# Ctrl+C pour arrêter
Essaie avec environ trente secondes de français continu, en variant ton rythme, et compare ce que tu as dit avec le contenu du fichier. C’est la meilleure façon de calibrer tes attentes avant d’ajuster la latence dans la prochaine leçon.
Choisir le bon périphérique
Sur une machine équipée d’un micro intégré, d’un casque USB et d’une webcam, le périphérique par défaut n’est pas toujours celui que tu crois, et une transcription vide vient souvent de ce détail. Commence par lister les entrées disponibles avec leur index :
def list_microphones():
"""Liste tous les périphériques d'entrée audio disponibles."""
p = pyaudio.PyAudio()
print("Périphériques d'entrée disponibles :")
for i in range(p.get_device_count()):
info = p.get_device_info_by_index(i)
if info["maxInputChannels"] > 0:
print(f" [{i}] {info['name']} "
f"(canaux : {info['maxInputChannels']}, "
f"fréquence : {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Ensuite, impose simplement l’index choisi lors de l’ouverture du flux, via le paramètre input_device_index :
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Index du périphérique
frames_per_buffer=chunk_samples
)
Svarbiausi punktai
- PyAudio capture le microphone en PCM mono 16 bits à 16 kHz, exactement ce que Voxtral attend
- Le générateur
iter_microphoneyield des blocs de 480 ms par défaut loop.run_in_executorrend la lecture du microphone non bloquante dans asyncio- Ctrl+C arrête proprement la capture via un gestionnaire de signal
- Liste les périphériques avec
get_device_count()pour choisir le bon microphone