Kaapa mikrofon PyAudio abil
Sellel lehel
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 mudelitegavoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3javoxtral-mini-tts-3-0. Peamised muudatused: ajatemplid on ainult lõigu tasemel (wordtagastab vea 400), toetatud on reaalajas kõneleja eristamine, reaalajas seansi seaded lukustuvad pärast esimest helilõiku jacontext_biassisendid 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_microphoneannab vaikimisi välja 480 ms tükke loop.run_in_executormuudab mikrofoni lugemise asyncio-s mitteblokeerivaks- Ctrl+C peatab kaapimise puhtalt signaali töötleja kaudu
- Loetle seadmed funktsiooniga
get_device_count(), et valida õige mikrofon