Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Das Mikrofon mit PyAudio erfassen

Lektion 11 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Vom Datei- zum Mikrofon-Eingang
  2. Installation von PyAudio
  3. Der Mikrofon-Generator
  4. Komplettes Programm: Vom Mikrofon zur Transkription
  5. Das richtige Gerät auswählen
  6. Kernaussagen

Kurs aktualisiert am 3. November 2026 für Voxtral 3, basierend auf Mistrals Leitfaden Migrate from Voxtral 2: Die Voxtral 2-Modelle (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), die am 31. Oktober 2026 veraltet und am 30. April 2027 zurückgezogen wurden, werden in den Beispielen durch voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 und voxtral-mini-tts-3-0 ersetzt. Wesentliche Änderungen: Zeitstempel sind segmentbezogen (die Rückgabe von word führt zu einem 400-Fehler), Echtzeit-Diarisierung wird unterstützt, Echtzeit-Sitzungseinstellungen werden nach dem ersten Audio-Chunk gesperrt, und context_bias-Eingaben sind flexibel (Phrasen mit Leerzeichen). Quellen: Migrate from Voxtral 2 · Speech to Text.

Vom Datei- zum Mikrofon-Eingang

Die vorherige Lektion hat eine Architektur etabliert, bei der die Audioquelle ein einfacher, austauschbarer asynchroner Generator ist. Sie werden dies sofort nutzen: Indem Sie den Datei-Lese-Generator durch einen ersetzen, der von Ihrer Soundkarte liest, beginnt Ihr Programm, Ihre Stimme live zu transkribieren, ohne eine einzige Zeile des übrigen Codes zu ändern.

Das Werkzeug für diese Lektion ist PyAudio, die Standard-Bibliothek in Python für den Zugriff auf Audio-Geräte. Sie stützt sich auf PortAudio, eine native Schicht, die je nach System möglicherweise separat installiert werden muss.

Installation von PyAudio

# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Der Mikrofon-Generator

Der Kern dieser Lektion fasst sich in etwa dreißig Zeilen zusammen. Die Funktion öffnet einen Eingangsstrom auf dem Standardgerät, liest in einer Endlosschleife Blöcke fester Größe und gibt jeden an den Transkriptions-Engine weiter. Der finally-Block ist nicht dekorativ: Er garantiert, dass der Strom gestoppt, geschlossen wird und PyAudio die Hardware freigibt, selbst wenn das Programm abrupt unterbrochen wird. Ohne ihn kann das Mikrofon weiterhin gesperrt bleiben und andere Anwendungen blockieren.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Erfasse das Mikrofon und gib PCM-Blöcke aus.

    Args:
        sample_rate: Abtastrate (16000 Hz für Voxtral)
        chunk_duration_ms: Dauer jedes Chunks in Millisekunden

    Yields:
        bytes: 16-Bit Mono PCM Audio-Blöcke
    """
    p = pyaudio.PyAudio()

    # Anzahl der Samples pro Chunk
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Öffne den Mikrofon-Strom
    stream = p.open(
        format=pyaudio.paInt16,    # 16-Bit PCM
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Erfassungsmodus
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Mikrofon aktiv — sprechen...")
        while True:
            # Lies das Chunk nicht-blockierend
            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("Mikrofon geschlossen")

Jeder Parameter hat einen spezifischen Grund. sample_rate=16000 spiegelt eine Modellanforderung wider, keine Präferenz: Voxtral erwartet 16 kHz, ändern Sie diesen Wert daher nicht. pyaudio.paInt16 entspricht dem vorzeichenbehafteten 16-Bit PCM-Format, was exakt dem pcm_s16le entspricht, das auf der API-Seite deklariert ist, und channels=1 erzwingt Mono, was ebenfalls erforderlich ist. Das bleibt chunk_duration_ms=480, die einzige wirklich diskutierbare Einstellung: Jedes Chunk repräsentiert 480 Millisekunden Audio, ein guter Kompromiss zwischen Reaktionsfähigkeit und Netzwerkeffizienz. Ein kürzeres Chunk, sagen wir 100 ms, verbessert die Reaktionsfähigkeit, vervielfacht aber die Netzwerkanfragen; ein längeres Chunk spart Bandbreite, kostet aber Latenz, bevor das Modell das Audio sieht.

Der Aufruf loop.run_in_executor verdient ebenfalls eine Erklärung. stream.read ist eine blockierende Funktion: Sie hält den Thread, bis die angeforderte Anzahl an Samples verfügbar ist. Wenn man sie direkt in einer Coroutine ausführt, würde der gesamte asyncio-Loop eingefroren, einschließlich der Empfangsereignisse von Transkriptionen. Durch das Auslagern an einen Executor machen Sie das Lesen für den restlichen asynchronen Programmablauf kompatibel.

Die Berechnung der Blockgröße folgt mechanisch aus den beiden Einstellungen, für sample_rate=16000 und chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 Samples
byte_size = 7680 × 2 Bytes = 15360 Bytes pro Chunk

Komplettes Programm: Vom Mikrofon zur Transkription

Der folgende Skript kombiniert Erfassung und Transkription zu einem sofort einsatzbereiten Diktier-Tool. Das neue Element im Vergleich zum vorherigen Generator ist die saubere Beendigungsbearbeitung: Ein Signal-Handler fängt Ctrl+C ab, setzt die running-Flagge auf False, wodurch der Erfassungs-Loop beendet wird, der Strom geschlossen wird und das Programm den gesammelten Text speichern kann. Ohne diesen Mechanismus würde eine Tastaturunterbrechung den Prozess töten, bevor gespeichert wird, und Sie würden das Diktat verlieren.

import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)
import pyaudio

# Flagge für saubere Beendigung
running = True

def signal_handler(sig, frame):
    global running
    print("\n\nBeenden...")
    running = False

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Erfasse das Mikrofon bis zur Unterbrechung (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("LIVE-TRANSKRIPTION")
    print("Sprechen Sie in das Mikrofon (Ctrl+C zum Stoppen)")
    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

    # Speichern
    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\nTranskription gespeichert in dictee.txt")
        print(f"Länge: {len(final_text)} Zeichen")
    else:
        print("\n\nKein Text transkribiert.")

asyncio.run(main())

Führen Sie es aus, sprechen Sie, stoppen Sie mit Ctrl+C: Der Text erscheint, während Sie sprechen, und landet dann in dictee.txt.

python dictee_vocale.py
# Sprechen Sie in Ihr Mikrofon
# Text erscheint in Echtzeit
# Ctrl+C zum Stoppen

Probieren Sie es mit etwa dreißig Sekunden kontinuierlichem Französisch aus, variieren Sie das Tempo und vergleichen Sie, was Sie gesagt haben, mit dem, was die Datei enthält. Das ist der beste Weg, um Ihre Erwartungen zu kalibrieren, bevor Sie in der nächsten Lektion die Latenz anpassen.

Das richtige Gerät auswählen

Auf einem Gerät mit integriertem Mikrofon, einem USB-Headset und einer Webcam ist das Standardgerät nicht immer das, das man denkt, und eine leere Transkription kommt meist auf diese Detail zurück. Listen Sie zunächst verfügbare Eingänge mit ihrem Index auf:

def list_microphones():
    """Liste alle verfügbaren Audio-Eingabegeräte auf."""
    p = pyaudio.PyAudio()
    print("Verfügbare Eingabegeräte:")
    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"(Kanäle: {info['maxInputChannels']}, "
                  f"Rate: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Enforzen Sie dann einfach den gewählten Index beim Öffnen des Stroms über den Parameter input_device_index:

stream = p.open(
    format=pyaudio.paInt16,
    channels=1,
    rate=sample_rate,
    input=True,
    input_device_index=2,  # Geräteindex
    frames_per_buffer=chunk_samples
)

Kernaussagen

  • PyAudio erfasst das Mikrofon in 16-Bit Mono PCM bei 16 kHz, genau das, was Voxtral erwartet
  • Der iter_microphone-Generator gibt standardmäßig 480 ms-Blöcke aus
  • loop.run_in_executor macht das Mikrofon-Lesen in asyncio nicht-blockierend
  • Ctrl+C stoppt die Erfassung sauber über einen Signal-Handler
  • Listen Sie Geräte mit get_device_count() auf, um das richtige Mikrofon auszuwählen