Optag mikrofonen med PyAudio
På denne side
Kurset opdateret 3. november 2026 til Voxtral 3, baseret på Mistral’s Migrate from Voxtral 2-guide: Voxtral 2-modellerne (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), der blev udfaset 31. oktober 2026 og trukket tilbage 30. april 2027, erstattes i eksemplerne afvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ogvoxtral-mini-tts-3-0. Vigtige ændringer: Tidsstempler er kun segmentbaserede (wordreturnerer en 400-fejl), realtids-diarisering understøttes, indstillinger for realtidssessioner låses efter det første lydchunk, ogcontext_bias-input er fleksible (sætninger med mellemrum). Kilder: Migrate from Voxtral 2 · Speech to Text.
Fra fil til mikrofon
Den foregående lektion etablerede en arkitektur, hvor lydkilden er en simpel, udskiftelig asynkron generator. Du drager straks fordel af dette: Ved at bytte fil-læsegeneratoren ud med en, der læser fra dit lydkort, begynder dit program at transskribere din stemme live uden at ændre en eneste linje i resten af koden.
Værktøjet til denne lektion er PyAudio, standardbiblioteket i Python til adgang til lydenheder. Det afhænger af PortAudio, et nativt lag, som du muligvis skal installere separat afhængigt af dit system.
Installation af PyAudio
# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio
# macOS
brew install portaudio
pip install pyaudio
# Windows
pip install pyaudio
Mikrofon-generatoren
Kernen i denne lektion fylder omkring tredive linjer. Funktionen åbner en input-strøm på standardenheden, kører i en uendelig løkke, der læser blokke af fast størrelse, og yield’er hver enkelt til transskriptionsmotoren. finally-blokken er ikke blot dekorativ: Den garanterer, at strømmen stoppes, lukkes, og at PyAudio frigiver hardwaren, selv hvis programmet afbrydes brat. Uden den kan mikrofonen forblive låst og blokere andre applikationer.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Optag mikrofonen og yield PCM-chunks.
Args:
sample_rate: Samplingfrekvens (16000 Hz til Voxtral)
chunk_duration_ms: Varighed af hvert chunk i millisekunder
Yields:
bytes: 16-bit mono PCM-lydchunks
"""
p = pyaudio.PyAudio()
# Antal samples per chunk
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Åbn mikrofon-strømmen
stream = p.open(
format=pyaudio.paInt16, # 16-bit PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Optagelsestilstand
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Mikrofon aktiv — tal...")
while True:
# Læs chunket ikke-blokerende
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 lukket")
Hver parameter har en specifik årsag. sample_rate=16000 afspejler et modelkrav, ikke en præference: Voxtral forventer 16 kHz, så ændr ikke denne værdi. pyaudio.paInt16 matcher det signerede 16-bit PCM-format, hvilket svarer nøjagtigt til pcm_s16le deklareret på API-siden, og channels=1 gennemtvinger mono, hvilket også er påkrævet. Det efterlader chunk_duration_ms=480, den eneste indstilling, der virkelig kan diskuteres: Hvert chunk repræsenterer 480 millisekunder lyd, et godt kompromis mellem responsivitet og netværkseffektivitet. Et kortere chunk, f.eks. 100 ms, forbedrer responsiviteten, men multiplicerer netværksanmodninger; et længere chunk sparer båndbredde på bekostning af øget latency, før modellen ser lyden.
Kaldet loop.run_in_executor fortjener også en forklaring. stream.read er en blokerende funktion: Den holder tråden besat, indtil det anmodede antal samples er tilgængelige. Hvis du kører den direkte i en coroutine, vil den fryse hele asyncio-løkken, herunder modtagelsen af transskriptionsbegivenheder. Ved at offloade den til en executor gør du læsningen kompatibel med resten af det asynkrone program.
Blokstørrelsens beregning følger mekanisk fra de to indstillinger, for sample_rate=16000 og chunk_duration_ms=480:
chunk_samples = 16000 × 480 / 1000 = 7680 samples
byte_size = 7680 × 2 bytes = 15360 bytes per chunk
Komplet program: Fra mikrofon til transskription
Følgende script kombinerer optagelse og transskription til et dikteringsværktøj, der er klar til brug. Det nye element sammenlignet med den tidligere generator er håndtering af pæn nedlukning: En signal-handler afbryder Ctrl+C, sætter flaget running til False, hvilket afslutter optagelsesløkken, lukker strømmen og tillader programmet at gemme den akkumulerede tekst. Uden denne mekanisme ville et tastaturafbrud dræbe processen, før den blev gemt, og du ville miste dikteringen.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Flag til pæn nedlukning
running = True
def signal_handler(sig, frame):
global running
print("\n\nLukker ned...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Optag mikrofonen indtil afbrydelse (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("Tal i mikrofonen (Ctrl+C for at stoppe)")
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
# Gem
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\nTransskription gemt i dictee.txt")
print(f"Længde: {len(final_text)} tegn")
else:
print("\n\nIngen tekst transskriberet.")
asyncio.run(main())
Kør det, tal, og stop med Ctrl+C: Teksten vises, mens du taler, og havner derefter i dictee.txt.
python dictee_vocale.py
# Tal i din mikrofon
# Tekst vises i realtid
# Ctrl+C for at stoppe
Prøv det med cirka tredive sekunders sammenhængende fransk, varier dit tempo, og sammenlign det, du sagde, med det, filen indeholder. Det er den bedste måde at kalibrere dine forventninger på, før du finjusterer latency i næste lektion.
Valg af den rigtige enhed
På en maskine med indbygget mikrofon, USB-headset og webcam er standardenheden ikke altid den, du tror, og en tom transskription skyldes oftest denne detalje. List først tilgængelige inputs med deres indeks:
def list_microphones():
"""List alle tilgængelige lyd-input-enheder."""
p = pyaudio.PyAudio()
print("Tilgængelige input-enheder:")
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"(kanaler: {info['maxInputChannels']}, "
f"rate: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Gennemtving derefter blot det valgte indeks, når du åbner strømmen, via parameteren input_device_index:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Enhedsindeks
frames_per_buffer=chunk_samples
)
Vigtige pointer
- PyAudio optager mikrofonen i 16-bit mono PCM ved 16 kHz, præcis hvad Voxtral forventer
- Generatoren
iter_microphoneyield’er chunks på 480 ms som standard loop.run_in_executorgør mikrofonlæsning ikke-blokerende i asyncio- Ctrl+C stopper optagelsen pænt via en signal-handler
- List enheder med
get_device_count()for at vælge den rigtige mikrofon