Zachytenie mikrofónu pomocou PyAudio
Na tejto strane
Kurz aktualizovaný 3. novembra 2026 pre Voxtral 3 na základe príručky Mistral Migrate from Voxtral 2: Modely Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603, vyradené 31. októbra 2026 a úplne odstavené 30. apríla 2027) sú v príkladoch nahradené modelmivoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3avoxtral-mini-tts-3-0. Kľúčové zmeny: časové pečiatky sú dostupné len pre segmenty (wordvráti chybu 400), je podporovaná diarizácia v reálnom čase, nastavenia relácie v reálnom čase sú uzamknuté po prvom zvukovom bloku a vstupycontext_biassú flexibilné (frázy s medzerami). Zdroje: Migrate from Voxtral 2 · Speech to Text.
Od súboru k mikrofónu
Predchádzajúca lekcia stanovila architektúru, kde je zvukový zdroj jednoduchý, vymeniteľný asynchrónny generátor. To okamžite využiješ: výmenou generátora čítajúceho súbor za generátor čítajúci z tvojej zvukovej karty začne tvoj program prepisovať tvoj hlas naživo bez zmeny jediného riadku zvyšku kódu.
Nástrojom pre túto lekciu je PyAudio, štandardná knižnica Pythonu na prístup k zvukovým zariadeniam. Spolieha sa na PortAudio, natívnu vrstvu, ktorú môžeš potrebovať nainštalovať samostatne v závislosti od tvojho systému.
Inštalácia PyAudio
# Linux (Debian/Ubuntu)
sudo apt-get install portaudio19-dev
pip install pyaudio
# macOS
brew install portaudio
pip install pyaudio
# Windows
pip install pyaudio
Generátor mikrofónu
Jadro tejto lekcie sa zmestí asi do tridsiatich riadkov. Funkcia otvorí vstupný stream na predvolenom zariadení, donekonečna číta bloky pevnej veľkosti a každý z nich odovzdáva (yield) prepisovaciemu enginu. Blok finally nie je len ozdobný: garantuje, že stream sa zastaví, uzavrie a PyAudio uvoľní hardvér, aj keď je program náhle prerušený. Bez neho by mikrofón mohol zostať uzamknutý a blokovať iné aplikácie.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Zachytenie mikrofónu a odovzdávanie PCM blokov.
Args:
sample_rate: Vzorkovacia frekvencia (16000 Hz pre Voxtral)
chunk_duration_ms: Dĺžka každého bloku v milisekundách
Yields:
bytes: 16-bitové mono PCM zvukové bloky
"""
p = pyaudio.PyAudio()
# Počet vzoriek na blok
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Otvorenie streamu mikrofónu
stream = p.open(
format=pyaudio.paInt16, # 16-bit PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Režim zachytávania
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Mikrofón aktívny — hovorte...")
while True:
# Čítanie bloku bez blokovania
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("Mikrofón uzavretý")
Každý parameter má svoj konkrétny dôvod. sample_rate=16000 odráža požiadavku modelu, nie preferenciu: Voxtral očakáva 16 kHz, takže túto hodnotu nemeníš. pyaudio.paInt16 zodpovedá formátu signed 16-bit PCM, čo je presne ekvivalentné pcm_s16le deklarovanému na strane API, a channels=1 vynucuje mono, čo je tiež požadované. Zostáva chunk_duration_ms=480, jediné skutočne diskutabilné nastavenie: každý blok predstavuje 480 milisekúnd zvuku, čo je dobrý kompromis medzi odozvou a efektivitou siete. Kratší blok, povedzme 100 ms, zlepšuje odozvu, ale znásobuje sieťové požiadavky; dlhší blok šetrí šírku pásma na úkor pridanej latencie, kým model zvuk uvidí.
Volanie loop.run_in_executor si tiež zaslúži vysvetlenie. stream.read je blokujúca funkcia: drží vlákno, kým nie je dostupný požadovaný počet vzoriek. Jej priame spustenie v korutine by zmrazilo celý asyncio loop, vrátane prijímania udalostí prepisu. Odovzdaním do executora zabezpečíš, že čítanie bude kompatibilné so zvyškom asynchrónneho programu.
Výpočet veľkosti bloku mechanicky vyplýva z dvoch nastavení, pre sample_rate=16000 a chunk_duration_ms=480:
chunk_samples = 16000 × 480 / 1000 = 7680 vzoriek
byte_size = 7680 × 2 bajty = 15360 bajtov na blok
Kompletný program: Od mikrofónu k prepisu
Nasledujúci skript kombinuje zachytávanie a prepis do nástroja na diktovanie pripraveného na použitie. Novým prvkom oproti predchádzajúcemu generátoru je elegantné riešenie ukončovania: obsluha signálu zachytí Ctrl+C, prepne príznak running na False, čím sa ukončí cyklus zachytávania, uzavrie stream a umožní programu uložiť nahromadený text. Bez tohto mechanizmu by klávesová skratka zabila proces pred uložením a prišiel by si o diktát.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Príznak pre čisté ukončenie
running = True
def signal_handler(sig, frame):
global running
print("\n\nVypínam...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Zachytenie mikrofónu až do prerušenia (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 NAŽIVO")
print("Hovorte do mikrofónu (Ctrl+C pre zastavenie)")
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
# Uloženie
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 uložený do dictee.txt")
print(f"Dĺžka: {len(final_text)} znakov")
else:
print("\n\nŽiadny text nebol prepísaný.")
asyncio.run(main())
Spusti ho, hovorte, zastav pomocou Ctrl+C: text sa objaví, keď hovoríš, a nakoniec skončí v súbore dictee.txt.
python dictee_vocale.py
# Hovorte do svojho mikrofónu
# Text sa objavuje v reálnom čase
# Ctrl+C pre zastavenie
Vyskúšaj to s približne tridsiatimi sekundami súvislej francúzštiny, meniac tempo, a porovnaj to, čo si povedal, s tým, čo obsahuje súbor. Je to najlepší spôsob, ako si kalibrovať očakávania pred ladením latencie v ďalšej lekcii.
Výber správneho zariadenia
Na stroji so vstavaným mikrofónom, USB headsetom a webovou kamerou nie je predvolené zariadenie vždy to, za ktoré ho považuješ, a prázdny prepis zvyčajne vyplýva práve z tohto detailu. Najprv si vypíš dostupné vstupy s ich indexom:
def list_microphones():
"""Výpis všetkých dostupných zvukových vstupných zariadení."""
p = pyaudio.PyAudio()
print("Dostupné vstupné zariadenia:")
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"(kanály: {info['maxInputChannels']}, "
f"frekvencia: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Potom jednoducho vynúť vybraný index pri otváraní streamu pomocou parametra input_device_index:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Index zariadenia
frames_per_buffer=chunk_samples
)
Kľúčové poznatky
- PyAudio zachytáva mikrofón v 16-bitovom mono PCM pri 16 kHz, presne tak, ako očakáva Voxtral
- Generátor
iter_microphoneštandardne odovzdáva bloky s dĺžkou 480 ms loop.run_in_executorzabezpečuje, že čítanie z mikrofónu v asyncio neblokuje- Ctrl+C čisto zastaví zachytávanie vďaka obsluhe signálu
- Zoznam zariadení získaš pomocou
get_device_count(), aby si si vybral správny mikrofón