Microfoon vastleggen met PyAudio
Op deze pagina
Cursus bijgewerkt op 3 november 2026 voor Voxtral 3, gebaseerd op de gids Migrate from Voxtral 2 van Mistral: Voxtral 2-modellen (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603, verouderd op 31 oktober 2026 en buiten gebruik gesteld op 30 april 2027) worden in de voorbeelden vervangen doorvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3envoxtral-mini-tts-3-0. Belangrijkste wijzigingen: tijdstempels zijn alleen per segment (wordgeeft een 400-fout), real-time sprekerherkenning (diarization) wordt ondersteund, instellingen voor real-time sessies zijn vergrendeld na het eerste audioblok, encontext_bias-invoer is flexibel (zinnen met spaties). Bronnen: Migrate from Voxtral 2 · Speech to Text.
Van bestand naar microfoon
De vorige les heeft een architectuur neergezet waarbij de audiobron een eenvoudige, uitwisselbare asynchrone generator is. Daar maakt u direct gebruik van: door de generator die bestanden leest te vervangen door een generator die uw geluidskaart uitleest, begint uw programma uw stem live te transcriberen zonder ook maar één regel van de rest van de code te wijzigen.
Het hulpmiddel voor deze les is PyAudio, de standaard Python-bibliotheek voor toegang tot audioapparaten. Deze bibliotheek steunt op PortAudio, een native laag die u afhankelijk van uw systeem mogelijk apart moet installeren.
PyAudio installeren
# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio
# macOS
brew install portaudio
pip install pyaudio
# Windows
pip install pyaudio
De microfoongenerator
De kern van deze les past in ongeveer dertig regels. De functie opent een invoerstream op het standaardapparaat, loopt oneindig door terwijl ze blokken van vaste grootte leest, en yieldt elk blok aan de transcriptiemotor. Het finally-blok is niet louter decoratief: het garandeert dat de stream stopt, sluit en dat PyAudio de hardware vrijgeeft, zelfs als het programma abrupt wordt onderbroken. Zonder dit blok kan de microfoon vergrendeld blijven, waardoor andere toepassingen geblokkeerd worden.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Leg de microfoon vast en yield PCM-blokken.
Args:
sample_rate: Bemonsteringsfrequentie (16000 Hz voor Voxtral)
chunk_duration_ms: Duur van elk blok in milliseconden
Yields:
bytes: 16-bit mono PCM-audioblokken
"""
p = pyaudio.PyAudio()
# Aantal samples per blok
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Open de microfoonstream
stream = p.open(
format=pyaudio.paInt16, # 16-bit PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Opnamemodus
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Microfoon actief — spreek...")
while True:
# Lees het blok non-blocking
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("Microfoon gesloten")
Elke parameter heeft een specifieke reden. sample_rate=16000 weerspiegelt een modelvereiste, geen voorkeur: Voxtral verwacht 16 kHz, wijzig deze waarde dus niet. pyaudio.paInt16 komt overeen met het signed 16-bit PCM-formaat, exact equivalent aan het pcm_s16le dat aan de API-kant is gedeclareerd, en channels=1 forceert mono, wat eveneens vereist is. Dat laat chunk_duration_ms=480 over, de enige echt discussieerbare instelling: elk blok vertegenwoordigt 480 milliseconden audio, een goed compromis tussen responsiviteit en netwerkefficiëntie. Een korter blok, bijvoorbeeld 100 ms, verbetert de responsiviteit maar vermenigvuldigt netwerkaanvragen; een langer blok bespaart bandbreedte ten koste van extra latentie voordat het model de audio ziet.
De aanroep loop.run_in_executor verdient eveneens uitleg. stream.read is een blokkerende functie: deze houdt de thread vast totdat het gevraagde aantal samples beschikbaar is. Als u deze direct in een coroutine uitvoert, bevriest de volledige asyncio-lus, inclusief de ontvangst van transcriptie-events. Door dit naar een executor over te hevelen, maakt u het uitlezen compatibel met de rest van het asynchrone programma.
De berekening van de blokgrootte volgt mechanisch uit de twee instellingen, voor sample_rate=16000 en chunk_duration_ms=480:
chunk_samples = 16000 × 480 / 1000 = 7680 samples
byte_size = 7680 × 2 bytes = 15360 bytes per blok
Volledig programma: van microfoon naar transcriptie
Het volgende script combineert opname en transcriptie tot een kant-en-klaar dicteerhulpmiddel. Het nieuwe element ten opzichte van de vorige generator is de afhandeling van een nette afsluiting: een signal handler onderschept Ctrl+C, zet de running-vlag op False, wat de opnamelus beëindigt, de stream sluit en het programma in staat stelt de verzamelde tekst op te slaan. Zonder dit mechanisme zou een toetsenbordonderbreking het proces doden voordat het opslaat, en zou u het dictaat verliezen.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Vlag voor nette afsluiting
running = True
def signal_handler(sig, frame):
global running
print("\n\nAfsluiten...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Leg de microfoon vast tot onderbreking (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 TRANSCRIPTIE")
print("Spreek in de microfoon (Ctrl+C om te 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
# Opslaan
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\nTranscriptie opgeslagen in dictee.txt")
print(f"Lengte: {len(final_text)} tekens")
else:
print("\n\nGeen tekst getranscribeerd.")
asyncio.run(main())
Voer het uit, spreek, stop met Ctrl+C: de tekst verschijnt terwijl u spreekt en belandt vervolgens in dictee.txt.
python dictee_vocale.py
# Spreek in uw microfoon
# Tekst verschijnt in real-time
# Ctrl+C om te stoppen
Probeer het met ongeveer dertig seconden continu Frans, varieer uw tempo en vergelijk wat u zei met wat het bestand bevat. Dit is de beste manier om uw verwachtingen af te stellen voordat u in de volgende les de latentie optimaliseert.
Het juiste apparaat kiezen
Op een machine met een ingebouwde microfoon, een USB-headset en een webcam is het standaardapparaat niet altijd datgene wat u denkt, en een lege transcriptie komt meestal door dit detail. Som eerst de beschikbare invoeren op met hun index:
def list_microphones():
"""Som alle beschikbare audio-invoerapparaten op."""
p = pyaudio.PyAudio()
print("Beschikbare invoerapparaten:")
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"(kanalen: {info['maxInputChannels']}, "
f"frequentie: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Forceer vervolgens simpelweg de gekozen index bij het openen van de stream, via de parameter input_device_index:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Apparaatindex
frames_per_buffer=chunk_samples
)
Belangrijkste punten
- PyAudio legt de microfoon vast in 16-bit mono PCM op 16 kHz, precies wat Voxtral verwacht
- De
iter_microphone-generator yieldt standaard blokken van 480 ms loop.run_in_executormaakt microfoonuitlezing non-blocking in asyncio- Ctrl+C stopt de opname netjes via een signal handler
- Som apparaten op met
get_device_count()om de juiste microfoon te kiezen