Rögzítsd a mikrofont a PyAudio segítségével
Ezen az oldalon
A tanfolyam frissítve: 2026. november 3., Voxtral 3 verzió, a Mistral Migrate from Voxtral 2 útmutatója alapján: a 2026. október 31-én elavult és 2027. április 30-án kivont Voxtral 2 modelleket (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603) a példákban avoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ésvoxtral-mini-tts-3-0modellek váltják fel. Főbb változások: az időbélyegek csak szegmensszinten érhetők el (awordhasználata 400-as hibát eredményez), támogatott a valós idejű beszélőazonosítás (diarization), a valós idejű munkamenet beállításai az első hangcsomag után rögzülnek, acontext_biasbemenetek pedig rugalmasak (szóközöket tartalmazó kifejezések is megengedettek). Források: Migrate from Voxtral 2 · Speech to Text.
Fájltól a mikrofonig
Az előző leckében felépítettünk egy olyan architektúrát, ahol a hangforrás egy egyszerű, cserélhető aszinkron generátor. Ezt most azonnal kamatoztatni fogod: ha a fájlt olvasó generátort kicseréled egy olyanra, amely a hangkártyádról olvas, a programod azonnal elkezdi élőben átírni a beszédedet anélkül, hogy a kód többi részében egyetlen sort is módosítanod kellene.
A lecke eszköze a PyAudio, a szabványos Python-könyvtár hangeszközök eléréséhez. Ez a PortAudio rétegre épül, amelyet a rendszeredtől függően külön telepítened kell.
A PyAudio telepítése
# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio
# macOS
brew install portaudio
pip install pyaudio
# Windows
pip install pyaudio
A mikrofon-generátor
A lecke lényege körülbelül harminc sorba sűríthető. A függvény megnyit egy bemeneti streamet az alapértelmezett eszközön, végtelen ciklusban rögzített méretű blokkokat olvas, és mindegyiket továbbítja az átíró motornak. A finally blokk nem díszítés: ez garantálja, hogy a stream leálljon, bezáródjon, és a PyAudio felszabadítsa a hardvert akkor is, ha a programot hirtelen megszakítják. Enélkül a mikrofon zárolva maradhat, és blokkolhatja más alkalmazásokat.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Rögzíti a mikrofont és PCM csomagokat szolgáltat.
Args:
sample_rate: Mintavételezési frekvencia (16000 Hz a Voxtralhoz)
chunk_duration_ms: Az egyes csomagok időtartama milliszekundumban
Yields:
bytes: 16 bites mono PCM hangcsomagok
"""
p = pyaudio.PyAudio()
# Minták száma csomagonként
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# A mikrofon stream megnyitása
stream = p.open(
format=pyaudio.paInt16, # 16 bites PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Rögzítési mód
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Mikrofon aktív — beszélj...")
while True:
# A csomag nem blokkoló olvasása
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 lezárva")
Minden paraméternek megvan a maga oka. A sample_rate=16000 nem preferencia, hanem modellkövetelmény: a Voxtral 16 kHz-et vár, ezért ne változtasd meg ezt az értéket. A pyaudio.paInt16 megfelel az előjeles 16 bites PCM formátumnak, ami pontosan egyenértékű az API oldalon deklarált pcm_s16le-vel, a channels=1 pedig kényszeríti a mono hangot, ami szintén kötelező. Marad a chunk_duration_ms=480, az egyetlen igazán vitatható beállítás: minden csomag 480 millisekund hangot reprezentál, ami jó kompromisszum a válaszidő és a hálózati hatékonyság között. Egy rövidebb csomag, mondjuk 100 ms, javítja a válaszidőt, de megsokszorozza a hálózati kéréseket; egy hosszabb csomag sávszélességet takarít meg, de növeli a késleltetést, mire a modell látja a hangot.
A loop.run_in_executor hívás is magyarázatra szorul. A stream.read egy blokkoló függvény: addig tartja fogva a szálat, amíg a kért számú minta rendelkezésre nem áll. Ha közvetlenül egy korutinban futtatnád, az egész asyncio ciklust befagyasztaná, beleértve az átírási események fogadását is. A végrehajtóhoz (executor) történő áthárítással biztosítod, hogy az olvasás kompatibilis legyen a többi aszinkron programrésszel.
A blokk méretének kiszámítása mechanikusan következik a két beállításból, sample_rate=16000 és chunk_duration_ms=480 esetén:
chunk_samples = 16000 × 480 / 1000 = 7680 minta
byte_size = 7680 × 2 bájt = 15360 bájt csomagonként
Teljes program: Mikrofontól az átírásig
Az alábbi szkript egyesíti a rögzítést és az átírást egy használatra kész diktáló eszközzé. Az előző generátorhoz képest az új elem a tiszta leállás kezelése: egy szignálkezelő elfogja a Ctrl+C-t, átállítja a running zászlót False értékre, ami kilépteti a rögzítési ciklust, bezárja a streamet, és lehetővé teszi a program számára az addig felhalmozott szöveg mentését. E mechanizmus nélkül a billentyűzet-megszakítás megölné a folyamatot mentés előtt, és elveszítenéd a diktálást.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Zászló a tiszta leálláshoz
running = True
def signal_handler(sig, frame):
global running
print("\n\nLeállítás...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Rögzíti a mikrofont megszakításig (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("ÉLŐ ÁTÍRÁS")
print("Beszélj a mikrofonba (Ctrl+C a leállításhoz)")
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
# Mentés
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\nÁtírás elmentve ide: dictee.txt")
print(f"Hossz: {len(final_text)} karakter")
else:
print("\n\nNem történt átírás.")
asyncio.run(main())
Futtasd, beszélj, majd állítsd le Ctrl+C-vel: a szöveg beszéd közben jelenik meg, majd a dictee.txt fájlba kerül.
python dictee_vocale.py
# Beszélj a mikrofonodba
# A szöveg valós időben jelenik meg
# Ctrl+C a leállításhoz
Próbáld ki körülbelül harminc másodperc folyamatos franciával, változtatva a tempódat, és hasonlítsd össze az elmondottakat a fájl tartalmával. Ez a legjobb módszer a várakozások kalibrálására, mielőtt a következő leckében a késleltetést hangolnád.
A megfelelő eszköz kiválasztása
Olyan gépen, amelyen van beépített mikrofon, USB-s fejhallgató és webcam, az alapértelmezett eszköz nem mindig az, amire gondolsz, és az üres átírás általában erre a részletre vezethető vissza. Először listázd ki a rendelkezésre álló bemeneteket az indexükkel együtt:
def list_microphones():
"""Listázza az összes elérhető hangbemeneti eszközt."""
p = pyaudio.PyAudio()
print("Elérhető bemeneti eszközök:")
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"(csatornák: {info['maxInputChannels']}, "
f"ráta: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Ezután egyszerűen kényszerítsd ki a választott indexet a stream megnyitásakor az input_device_index paraméter segítségével:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Eszköz indexe
frames_per_buffer=chunk_samples
)
Főbb megállapítások
- A PyAudio 16 bites mono PCM formátumban, 16 kHz-en rögzíti a mikrofont, pontosan úgy, ahogy a Voxtral elvárja
- Az
iter_microphonegenerátor alapértelmezetten 480 ms-os csomagokat szolgáltat - A
loop.run_in_executornem blokkolóvá teszi a mikrofonolvasást az asyncio-ban - A Ctrl+C egy szignálkezelőn keresztül tisztán leállítja a rögzítést
- Listázd az eszközöket a
get_device_count()függvénnyel, hogy kiválaszd a megfelelő mikrofont