Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Zajem zvoka z mikrofonom prek PyAudio

Lekcija 11 od 16 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Od datoteke do mikrofona
  2. Namestitev PyAudio
  3. Generator mikrofona
  4. Celoten program: Od mikrofona do prepisa
  5. Izbira prave naprave
  6. Ključne ugotovitve

Posodobitev tečaja z dne 3. novembra 2026 za Voxtral 3, na podlagi Mistralovega vodnika Migrate from Voxtral 2: modeli Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603, ki so bili opuščeni 31. oktobra 2026 in umaknjeni 30. aprila 2027) so v primerih nadomeščeni z voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 in voxtral-mini-tts-3-0. Ključne spremembe: časovni žigi so na voljo le za segmente (word vrne napako 400), podprta je diarizacija v realnem času, nastavitve seje v realnem času so zaklenjene po prvem zvočnem kosu, vnosi context_bias pa so prilagodljivi (besedne zveze s presledki). Viri: Migrate from Voxtral 2 · Speech to Text.

Od datoteke do mikrofona

Prejšnja lekcija je vzpostavila arhitekturo, kjer je zvočni vir preprost, zamenljiv asinhroni generator. To boš izkoristil takoj: z zamenjavo generatorja, ki bere iz datoteke, z generatorjem, ki bere iz tvoje zvočne kartice, bo tvoj program začel prepisovati tvoj glas v živo, ne da bi spremenil katero koli vrstico preostale kode.

Orodje za to lekcijo je PyAudio, standardna knjižnica Python za dostop do zvočnih naprav. Zanaša se na PortAudio, izvorno plast, ki jo boš morda moral namestiti ločeno, odvisno od tvojega sistema.

Namestitev PyAudio

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

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Generator mikrofona

Bistvo te lekcije je zajeto v približno tridesetih vrsticah. Funkcija odpre vhodni tok na privzeti napravi, se neskončno vrti v zanki in bere bloke fiksne velikosti ter vsakega posebej posreduje pogonu za prepis. Blok finally ni zgolj okras: zagotavlja, da se tok ustavi, zapre in da PyAudio sprosti strojno opremo, tudi če je program nenadoma prekinjen. Brez njega bi mikrofon lahko ostal zaklenjen in blokiral druge aplikacije.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Zajemi mikrofon in izloči kose PCM.

    Args:
        sample_rate: Vzorčna frekvenca (16000 Hz za Voxtral)
        chunk_duration_ms: Trajanje vsakega kosa v milisekundah

    Yields:
        bytes: 16-bitni mono PCM zvočni kosi
    """
    p = pyaudio.PyAudio()

    # Število vzorcev na kos
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Odpri tok mikrofona
    stream = p.open(
        format=pyaudio.paInt16,    # 16-bitni PCM
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Način zajema
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Mikrofon aktiven — govori...")
        while True:
            # Preberi kos brez blokiranja
            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 zaprt")

Vsak parameter ima svoj specifičen razlog. sample_rate=16000 odraža zahtevo modela, ne preference: Voxtral pričakuje 16 kHz, zato te vrednosti ne spreminjaj. pyaudio.paInt16 ustreza predznačenemu 16-bitnemu PCM formatu, kar je popolnoma enakovredno pcm_s16le, deklariranemu na strani API-ja, channels=1 pa vsili mono zvok, kar je prav tako obvezno. Ostane še chunk_duration_ms=480, edina res sporna nastavitev: vsak kos predstavlja 480 milisekund zvoka, kar je dober kompromis med odzivnostjo in učinkovitostjo omrežja. Krajši kos, recimo 100 ms, izboljša odzivnost, a pomnoži število omrežnih zahtev; daljši kos prihrani pasovno širino na račun dodane zakasnitve, preden model prejme zvok.

Klic loop.run_in_executor si prav tako zasluži pojasnilo. stream.read je blokirajoča funkcija: zadrži nit, dokler ni na voljo zahtevano število vzorcev. Če bi jo pognal neposredno v korutini, bi zamrznil celotno zanko asyncio, vključno s sprejemanjem dogodkov prepisa. S prenosom na izvajalca (executor) branje uskladiš s preostalim asinhronim programom.

Izračun velikosti bloka mehansko sledi obema nastavitvama, za sample_rate=16000 in chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 vzorcev
byte_size = 7680 × 2 bajta = 15360 bajtov na kos

Celoten program: Od mikrofona do prepisa

Naslednji skript združuje zajem in prepis v orodje za diktiranje, pripravljeno za uporabo. Nova prvina v primerjavi s prejšnjim generatorjem je urejeno ravnanje z izklopom: rokavec za signale prestreže Ctrl+C, preklopi zastavico running na False, kar izstopi iz zanke zajema, zapre tok in omogoči programu shranjevanje zbranega besedila. Brez tega mehanizma bi tipkovnična prekinitev ubila proces pred shranjevanjem in izgubil bi diktat.

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

# Zastavica za urejen izklop
running = True

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

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Zajemi mikrofon do prekinitve (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("PREPIS V ŽIVO")
    print("Govori v mikrofon (Ctrl+C za zaustavitev)")
    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

    # Shrani
    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\nPrepis shranjen v dictee.txt")
        print(f"Dolžina: {len(final_text)} znakov")
    else:
        print("\n\nBesedilo ni bilo prepisano.")

asyncio.run(main())

Zaženi ga, govori, ustavi s Ctrl+C: besedilo se pojavlja med govorjenjem, nato pa konča v dictee.txt.

python dictee_vocale.py
# Govori v svoj mikrofon
# Besedilo se pojavlja v realnem času
# Ctrl+C za zaustavitev

Preizkusi s približno tridesetimi sekundami neprekinjene francoščine, spreminjaj tempo in primerjaj, kaj si rekel, s tistim, kar vsebuje datoteka. To je najboljši način za umerjanje pričakovanj pred prilagajanjem zakasnitve v naslednji lekciji.

Izbira prave naprave

Na računalniku z vgrajenim mikrofonom, USB slušalkami in spletno kamero privzeta naprava ni vedno tista, za katero misliš, da je, in prazen prepis je običajno posledica prav te podrobnosti. Najprej izpiši razpoložljive vhode z njihovimi indeksi:

def list_microphones():
    """Izpiši vse razpoložljive vhodne zvočne naprave."""
    p = pyaudio.PyAudio()
    print("Razpoložljive vhodne naprave:")
    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"(kanali: {info['maxInputChannels']}, "
                  f"frekvenca: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

Nato preprosto vsili izbrani indeks pri odpiranju toka prek parametra input_device_index:

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

Ključne ugotovitve

  • PyAudio zajema mikrofon v 16-bitnem mono PCM pri 16 kHz, kar točno ustreza pričakovanjem Voxtrala
  • Generator iter_microphone privzeto izloča kose v trajanju 480 ms
  • loop.run_in_executor omogoča neblokirajoče branje mikrofona v okolju asyncio
  • Ctrl+C urejeno ustavi zajem prek rokavca za signale
  • Naprave izpiši z get_device_count(), da izbereš pravi mikrofon