Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Saisie du microphone avec PyAudio

Nodarbība 11 no 16 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Du fichier au microphone
  2. Installation de PyAudio
  3. Le générateur de microphone
  4. Programme complet : du microphone à la transcription
  5. Choisir le bon périphérique
  6. Galvenās atziņas

Cours mis à jour le 3 novembre 2026 pour Voxtral 3, sur la base du 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 par voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 et voxtral-mini-tts-3-0. Changements clés : les horodatages sont limités aux segments (word renvoie 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ées context_bias sont 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 fournit chacun d’eux 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 fournit 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)

    # Ouverture du flux 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 — parlez...")
        while True:
            # Lecture du 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, ce qui est é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 exécuteur, 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("Parlez 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 se retrouve 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 disposant 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 penses, 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
)

Galvenās atziņas

  • PyAudio capture le microphone en PCM mono 16 bits à 16 kHz, exactement ce que Voxtral attend
  • Le générateur iter_microphone fournit des blocs de 480 ms par défaut
  • loop.run_in_executor rend 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