Zachyť mikrofon pomocí PyAudio
Na této stránce
Kurz aktualizován 3. listopadu 2026 pro Voxtral 3 na základě průvodce Mistralu Migrate from Voxtral 2: Modely Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603'), které byly zastaralé k 31. říjnu 2026 a vyřazené k 30. dubnu 2027, jsou v příkladech nahrazeny modelyvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3avoxtral-mini-tts-3-0. Klíčové změny: časová razítka jsou pouze pro segmenty (wordvrací chybu 400), je podporována diarizace v reálném čase, nastavení relace v reálném čase jsou uzamčena po prvním zvukovém bloku a vstupycontext_bias` jsou flexibilní (fráze s mezerami). Zdroje: Migrate from Voxtral 2 · Speech to Text.
Od souboru k mikrofonu
Minulá lekce stanovila architekturu, kde je zvukový zdroj jednoduchý, zaměnitelný asynchronní generátor. Toho okamžitě využiješ: výměnou generátoru čtoucího soubor za ten, který čte ze zvukové karty, začne tvůj program transkribovat tvůj hlas živě, aniž bys musel měnit jedinou řádku zbytku kódu.
Nástrojem pro tuto lekci je PyAudio, standardní knihovna Pythonu pro přístup ke zvukovým zařízením. Spoléhá na PortAudio, nativní vrstvu, kterou možná budeš muset nainstalovat samostatně v závislosti na svém systému.
Instalace 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 mikrofonu
Jádro této lekce se vejde do zhruba třiceti řádků. Funkce otevře vstupní proud na výchozím zařízení, donekonečna čte bloky pevné velikosti a předává každý z nich transkripčnímu enginu. Blok finally není jen okrasný: garantuje, že se proud zastaví, zavře a PyAudio uvolní hardware, i když je program náhle přerušen. Bez něj by mikrofon mohl zůstat uzamčený a blokovat jiné aplikace.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Zachyť mikrofon a vydávej PCM bloky.
Args:
sample_rate: Vzorkovací frekvence (16000 Hz pro Voxtral)
chunk_duration_ms: Doba trvání každého bloku v milisekundách
Yields:
bytes: 16bitové mono PCM zvukové bloky
"""
p = pyaudio.PyAudio()
# Počet vzorků na blok
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Otevři proud mikrofonu
stream = p.open(
format=pyaudio.paInt16, # 16bit PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Režim zachytávání
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Mikrofon aktivní — mluv...")
while True:
# Čti blok neblokujícím způsobem
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 uzavřen")
Každý parametr má svůj specifický důvod. sample_rate=16000 odráží požadavek modelu, nikoliv preferenci: Voxtral očekává 16 kHz, takže tuto hodnotu neměň. pyaudio.paInt16 odpovídá formátu signed 16-bit PCM, což je přesně ekvivalentní pcm_s16le deklarovanému na straně API, a channels=1 vynucuje mono, což je také požadavek. Zbývá chunk_duration_ms=480, jediné skutečně diskutabilní nastavení: každý blok představuje 480 milisekund zvuku, což je dobrý kompromis mezi odezvou a efektivitou sítě. Kratší blok, řekněme 100 ms, zlepší odezvu, ale znásobí síťové požadavky; delší blok ušetří šířku pásma za cenu vyšší latence, než model zvuk zpracuje.
Volání loop.run_in_executor si také zaslouží vysvětlení. stream.read je blokující funkce: drží vlákno, dokud není k dispozici požadovaný počet vzorků. Spuštění přímo v korutině by zmrazilo celou smyčku asyncio, včetně přijímání transkripčních událostí. Přesunutím do executoru zajistíš, že je čtení kompatibilní se zbytkem asynchronního programu.
Výpočet velikosti bloku mechanicky vyplývá ze dvou nastavení, pro sample_rate=16000 a chunk_duration_ms=480:
chunk_samples = 16000 × 480 / 1000 = 7680 vzorků
byte_size = 7680 × 2 bajty = 15360 bajtů na blok
Kompletní program: Od mikrofonu k transkripci
Následující skript kombinuje zachytávání a transkripci do nástroje pro diktování připraveného k použití. Novým prvkem oproti předchozímu generátoru je elegantní řešení ukončení: obslužná rutina signálu zachytí Ctrl+C, přepne příznak running na False, což ukončí smyčku zachytávání, zavře proud a umožní programu uložit nahromaděný text. Bez tohoto mechanismu by klávesová zkratka ukončila proces před uložením a přišel bys o diktát.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Příznak pro čisté ukončení
running = True
def signal_handler(sig, frame):
global running
print("\n\nUkončuji...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Zachyť mikrofon až do přerušení (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("ŽIVÁ TRANSKRIPCE")
print("Mluv do mikrofonu (Ctrl+C pro zastavení)")
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žení
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\nTranskripce uložena do dictee.txt")
print(f"Délka: {len(final_text)} znaků")
else:
print("\n\nŽádný text netranskribován.")
asyncio.run(main())
Spusť to, mluv, zastav pomocí Ctrl+C: text se objevuje, jak mluvíš, a nakonec skončí v souboru dictee.txt.
python dictee_vocale.py
# Mluv do svého mikrofonu
# Text se objevuje v reálném čase
# Ctrl+C pro zastavení
Vyzkoušej to s asi třiceti sekundami souvislé francouzštiny, měň tempo a porovnej, co jsi řekl, s tím, co obsahuje soubor. Je to nejlepší způsob, jak si kalibrovat očekávání před laděním latence v další lekci.
Výběr správného zařízení
Na stroji s vestavěným mikrofonem, USB headsetem a webovou kamerou není výchozí zařízení vždy to, za které ho považuješ, a prázdná transkripce obvykle pramení právě z tohoto detailu. Nejprve vypiš dostupné vstupy s jejich indexem:
def list_microphones():
"""Vypiš všechna dostupná audio vstupní zařízení."""
p = pyaudio.PyAudio()
print("Dostupná vstupní zařízení:")
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"frekvence: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Poté jednoduše vynuť zvolený index při otevírání proudu prostřednictvím parametru input_device_index:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Index zařízení
frames_per_buffer=chunk_samples
)
Klíčové poznatky
- PyAudio zachytává mikrofon v 16bitovém mono PCM při 16 kHz, přesně tak, jak Voxtral očekává
- Generátor
iter_microphoneve výchozím nastavení vydává bloky o délce 480 ms loop.run_in_executorčiní čtení z mikrofonu neblokujícím v asyncio- Ctrl+C čistě zastaví zachytávání pomocí obslužné rutiny signálu
- Vypiš zařízení pomocí
get_device_count()pro výběr správného mikrofonu