Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Rögzítsd a mikrofont a PyAudio segítségével

11. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Fájltól a mikrofonig
  2. A PyAudio telepítése
  3. A mikrofon-generátor
  4. Teljes program: Mikrofontól az átírásig
  5. A megfelelő eszköz kiválasztása
  6. Főbb megállapítások

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 a voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 és voxtral-mini-tts-3-0 modellek váltják fel. Főbb változások: az időbélyegek csak szegmensszinten érhetők el (a word haszná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, a context_bias bemenetek 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_microphone generátor alapértelmezetten 480 ms-os csomagokat szolgáltat
  • A loop.run_in_executor nem 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