Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Kaapa mikrofon PyAudio abil

Õppetund 11 / 16 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Failist mikrofonini
  2. PyAudio paigaldamine
  3. Mikrofoni generaator
  4. Täielik programm: mikrofonist transkriptsioonini
  5. Õige seadme valimine
  6. Peamised punktid

Kursust uuendati 3. novembril 2026 Voxtral 3 jaoks, tuginedes Mistrali juhendile Migrate from Voxtral 2: Voxtral 2 mudelid (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), mis tunnistati igaüheks 31. oktoobril 2026 ja lõpetati 30. aprillil 2027, on näidetes asendatud mudelitega voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 ja voxtral-mini-tts-3-0. Peamised muudatused: ajatemplid on ainult lõigu tasemel (word tagastab vea 400), toetatud on reaalajas kõneleja eristamine, reaalajas seansi seaded lukustuvad pärast esimest helilõiku ja context_bias sisendid on paindlikud (fraasid tühikutega). Allikad: Migrate from Voxtral 2 · Speech to Text.

Failist mikrofonini

Eelmine tund lõi arhitektuuri, kus heliallikaks on lihtne, hõlpsasti vahetatav asünkroonne generaator. Kasutad seda kohe ära: asendades faili lugemise generaatori sellega, mis loeb andmeid sinu helikaardilt, hakkab su programm transkribeerima sinu häält reaalajas, muutmata ühtegi rida ülejäänud koodis.

Selle tunni tööriistaks on PyAudio, standardne Pythoni teek heliseadmetele juurdepääsuks. See tugineb PortAudiole, mis on süsteemne kiht ja mille võid olenevalt oma süsteemist vajada eraldi paigaldada.

PyAudio paigaldamine

# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Mikrofoni generaator

Selle tunni tuumik mahub umbes kolmekümnesse realisse. Funktsioon avab vaikeseadmel sisendvoo, loeb lõputult kindla suurusega plokke ja annab üksiku transkriptsioonimootorile. Plokk finally ei ole ilu pärast: see garanteerib, et voog peatub, suletakse ja PyAudio vabastab riistvara isegi siis, kui programm järsult katkestatakse. Ilma selleta võib mikrofon jääda lukku, blokeerides teisi rakendusi.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Kaapa mikrofon ja anna välja PCM tükid.

    Args:
        sample_rate: Diskreetimissagedus (Voxtrali jaoks 16000 Hz)
        chunk_duration_ms: Iga tüki kestus millisekundites

    Yields:
        bytes: 16-bitine mono PCM heli tükid
    """
    p = pyaudio.PyAudio()

    # Proovide arv tüki kohta
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Ava mikrofoni voog
    stream = p.open(
        format=pyaudio.paInt16,    # 16-bitine PCM
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Salvestusrežiim
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Mikrofon aktiivne — räägi...")
        while True:
            # Loe tükk mitteblokeerivalt
            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 suletud")

Igal parameetril on kindel põhjus. sample_rate=16000 peegeldab mudeli nõuet, mitte eelistust: Voxtral eeldab 16 kHz, seega ära muuda seda väärtust. pyaudio.paInt16 vastab märgitud 16-bitisele PCM-vormingule, mis on täpselt samaväärne API poolel deklareeritud pcm_s16le-ga, ja channels=1 sunnib kasutama monoheli, mis on samuti kohustuslik. Üle jääb chunk_duration_ms=480, ainus tõeliselt vaieldav säte: iga tükk esindab 480 millisekundit heli, mis on hea kompromiss reageerimisvõime ja võrgu efektiivsuse vahel. Lühem tükk, näiteks 100 ms, parandab reageerimisvõimet, kuid korrutab võrgupäringuid; pikem tükk säästab ribalaiust, kuid suurendab latentsust enne, kui mudel heli näeb.

Ka loop.run_in_executor väljakutse väärib selgitust. stream.read on blokeeriv funktsioon: see hoiab lõnga kinni, kuni nõutud arv proove on saadaval. Selle otse korutiinis käivitamine külmutaks kogu asyncio tsükli, sealhulgas transkriptsioonisündmuste vastuvõtmise. Suunates selle täitjale (executor), muudad lugemise ühilduvaks ülejäänud asünkroonse programmiga.

Ploki suuruse arvutus tuleneb mehaaniliselt kahest seadistusest, kus sample_rate=16000 ja chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 proovi
byte_size = 7680 × 2 baiti = 15360 baiti tüki kohta

Täielik programm: mikrofonist transkriptsioonini

Järgnev skript ühendab kaapimise ja transkriptsiooni valmis dikteerimistööriistaks. Uueks elemendiks võrreldes eelmise generaatoriga on puhas sulgemise käsitlus: signaali töötleja püüab kinni Ctrl+C, lülitab lipu running väärtusele False, mis väljub kaapimistsüklist, sulgeb voo ja võimaldab programmil salvestada kogutud teksti. Ilma selle mehhanismita tapaks klaviatuuri katkestus protsessi enne salvestamist ja kaotaksid dikteeritud teksti.

import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
    AudioFormat,
    TranscriptionStreamTextDelta,
    TranscriptionStreamDone
)
import pyaudio

# Lipp puhtaks sulgemiseks
running = True

def signal_handler(sig, frame):
    global running
    print("\n\nSulgemine...")
    running = False

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Kaapa mikrofon kuni katkestamiseni (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("REAALAJAS TRANSKRIPTSIOON")
    print("Räägi mikrofoni (lõpetamiseks Ctrl+C)")
    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

    # Salvestamine
    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\nTranskriptsioon salvestatud faili dictee.txt")
        print(f"Pikkus: {len(final_text)} tähemärki")
    else:
        print("\n\nTeksti ei transkribeeritud.")

asyncio.run(main())

Käivita see, räägi, peata Ctrl+C-ga: tekst ilmub kõne ajal ja lõpuks satub faili dictee.txt.

python dictee_vocale.py
# Räägi mikrofoni
# Tekst ilmub reaalajas
# Lõpetamiseks Ctrl+C

Proovi seda umbes kolmekümne sekundi pideva prantsuse keelega, varieerides tempot, ja võrdle öeldut failis olevaga. See on parim viis oma ootuste kalibreerimiseks enne latentsuse häälestamist järgmises tunnis.

Õige seadme valimine

Masinas, kus on sisseehitatud mikrofon, USB-kõrvaklapid ja veebikaamera, ei ole vaikeseade alati see, mida arvad, ja tühi transkriptsioon tuleneb tavaliselt just sellest detailist. Kõigepealt loetle saadaolevad sisendid koos nende indeksiga:

def list_microphones():
    """Loetle kõik saadaolevad helisisendseadmed."""
    p = pyaudio.PyAudio()
    print("Saadaolevad sisendseadmed:")
    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"(kanaleid: {info['maxInputChannels']}, "
                  f"sagedus: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Seejärel sunni lihtsalt valitud indeks voo avamisel parameetri input_device_index kaudu:

stream = p.open(
    format=pyaudio.paInt16,
    channels=1,
    rate=sample_rate,
    input=True,
    input_device_index=2,  # Seadme indeks
    frames_per_buffer=chunk_samples
)

Peamised punktid

  • PyAudio kaapib mikrofoni 16-bitises mono PCM-vormingus sagedusega 16 kHz, täpselt nii nagu Voxtral eeldab
  • Generaator iter_microphone annab vaikimisi välja 480 ms tükke
  • loop.run_in_executor muudab mikrofoni lugemise asyncio-s mitteblokeerivaks
  • Ctrl+C peatab kaapimise puhtalt signaali töötleja kaudu
  • Loetle seadmed funktsiooniga get_device_count(), et valida õige mikrofon