Fånga ljudet från mikrofonen med PyAudio
På denna sida
Kursen uppdaterad den 3 november 2026 för Voxtral 3, baserat på Mistral:s guide Migrate from Voxtral 2: Voxtral 2-modellerna (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), som avvecklades den 31 oktober 2026 och tas bort helt den 30 april 2027, ersätts i exemplen avvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ochvoxtral-mini-tts-3-0. Viktiga ändringar: tidsstämplar finns endast på segmentnivå (wordreturnerar ett 400-fel), talardifferentiering i realtid stöds, inställningar för realtidssessioner låses efter den första ljudbiten, och indata förcontext_biasär flexibla (fraser med mellanslag). Källor: Migrate from Voxtral 2 · Speech to Text.
Från fil till mikrofon
I den föregående lektionen etablerade vi en arkitektur där ljudkällan är en enkel, utbytbar asynkron generator. Du kommer att dra nytta av detta omedelbart: genom att byta ut generatorn som läser från fil mot en som läser från ditt ljudkort börjar ditt program transkribera din röst live utan att du behöver ändra en enda rad i resten av koden.
Verktyget för denna lektion är PyAudio, standardbiblioteket för Python för att komma åt ljudenheter. Det förlitar sig på PortAudio, ett nativt lager som du kan behöva installera separat beroende på ditt system.
Installera 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-generatorn
Kärnan i denna lektion ryms på cirka trettio rader. Funktionen öppnar en inmatningsström på standardenheten, loopar oändligt för att läsa block av fast storlek och yield-ar varje block till transkriberingsmotorn. finally-blocket är inte bara dekoration: det garanterar att strömmen stoppas, stängs och att PyAudio frigör hårdvaran även om programmet avbryts abrupt. Utan detta kan mikrofonen förbli låst och blockera andra applikationer.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Fånga ljud från mikrofonen och yield:a PCM-bitar.
Args:
sample_rate: Samplingsfrekvens (16000 Hz för Voxtral)
chunk_duration_ms: Varje bits längd i millisekunder
Yields:
bytes: 16-bitars mono PCM-ljudbitar
"""
p = pyaudio.PyAudio()
# Antal sampel per bit
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Öppna mikrofonströmmen
stream = p.open(
format=pyaudio.paInt16, # 16-bitars PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Inspelningsläge
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Mikrofon aktiv — prata...")
while True:
# Läs biten utan blockering
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 stängd")
Varje parameter har ett specifikt syfte. sample_rate=16000 speglar ett modellkrav, inte en preferens: Voxtral förväntar sig 16 kHz, så ändra inte detta värde. pyaudio.paInt16 matchar det signerade 16-bitars PCM-formatet, vilket är exakt ekvivalent med pcm_s16le som deklareras på API-sidan, och channels=1 tvingar fram mono, vilket också krävs. Kvar finns chunk_duration_ms=480, den enda inställningen som verkligen är öppen för diskussion: varje bit representerar 480 millisekunder ljud, en bra kompromiss mellan responsivitet och nätverkseffektivitet. En kortare bit, säg 100 ms, förbättrar responsiviteten men mångfaldigar nätverksförfrågningarna; en längre bit sparar bandbredd på bekostnad av ökad latens innan modellen ser ljudet.
Anropet loop.run_in_executor förtjänar också en förklaring. stream.read är en blockerande funktion: den håller tråden upptagen tills begärt antal sampel är tillgängliga. Om du kör den direkt i en coroutine skulle hela asyncio-loopen frysa, inklusive mottagandet av transkriberingshändelser. Genom att offload:a den till en executor gör du inläsningen kompatibel med resten av det asynkrona programmet.
Beräkningen av blockstorleken följer mekaniskt från de två inställningarna, för sample_rate=16000 och chunk_duration_ms=480:
chunk_samples = 16000 × 480 / 1000 = 7680 sampel
byte_size = 7680 × 2 byte = 15360 byte per bit
Komplett program: Från mikrofon till transkribering
Följande skript kombinerar inspelning och transkribering till ett dikteringsverktyg som är redo att användas. Det nya inslaget jämfört med den tidigare generatorn är hanteringen av en ren avstängning: en signalhanterare fångar upp Ctrl+C, växlar flaggan running till False, vilket avslutar inspelningsloopen, stänger strömmen och låter programmet spara den ackumulerade texten. Utan denna mekanism skulle ett tangentbordsavbrott döda processen innan sparande sker, och du skulle förlora dikteringen.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Flagga för ren avstängning
running = True
def signal_handler(sig, frame):
global running
print("\n\nStänger ner...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Fånga ljud från mikrofonen tills det avbryts (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("LIVETRANSKRIBERING")
print("Prata i mikrofonen (Ctrl+C för att stoppa)")
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
# Spara
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\nTranskribering sparad till dictee.txt")
print(f"Längd: {len(final_text)} tecken")
else:
print("\n\nIngen text transkriberad.")
asyncio.run(main())
Kör det, prata, stoppa med Ctrl+C: texten visas medan du pratar och hamnar sedan i dictee.txt.
python dictee_vocale.py
# Prata i din mikrofon
# Texten visas i realtid
# Ctrl+C för att stoppa
Testa med cirka trettio sekunders kontinuerligt franskt tal, variera ditt tempo och jämför det du sa med vad filen innehåller. Det är det bästa sättet att kalibrera dina förväntningar innan du finjusterar latensen i nästa lektion.
Välja rätt enhet
På en maskin med inbyggd mikrofon, ett USB-headset och en webbkamera är standardenheten inte alltid den du tror, och en tom transkribering beror oftast på denna detalj. Lista först tillgängliga inmatningar med deras index:
def list_microphones():
"""Lista alla tillgängliga ljudinmatningsenheter."""
p = pyaudio.PyAudio()
print("Tillgängliga inmatningsenheter:")
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"frekvens: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Tvinga sedan helt enkelt fram det valda indexet när du öppnar strömmen, via parametern input_device_index:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Enhetsindex
frames_per_buffer=chunk_samples
)
Viktiga punkter
- PyAudio fångar ljud från mikrofonen i 16-bitars mono PCM vid 16 kHz, exakt vad Voxtral förväntar sig
- Generatorn
iter_microphoneyield-ar bitar på 480 ms som standard loop.run_in_executorgör mikrofoninläsningen icke-blockerande i asyncio- Ctrl+C stoppar inspelningen rent via en signalhanterare
- Lista enheter med
get_device_count()för att välja rätt mikrofon