Przechwyć mikrofon za pomocą PyAudio
Na tej stronie
Kurs zaktualizowany 3 listopada 2026 r. dla Voxtral 3, na podstawie przewodnika Mistral Migrate from Voxtral 2: modele Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603, wycofane 31 października 2026 r. i usunięte 30 kwietnia 2027 r.) zostały zastąpione w przykładach przezvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3orazvoxtral-mini-tts-3-0. Kluczowe zmiany: znaczniki czasu dotyczą tylko segmentów (wordzwraca błąd 400), obsługiwana jest diarizacja w czasie rzeczywistym, ustawienia sesji w czasie rzeczywistym są blokowane po pierwszym fragmencie audio, a dane wejściowecontext_biassą elastyczne (frazy ze spacjami). Źródła: Migrate from Voxtral 2 · Speech to Text.
Od pliku do mikrofonu
Poprzednia lekcja ustaliła architekturę, w której źródłem audio jest prosty, wymienny asynchroniczny generator. Wykorzystasz to natychmiast: zamieniając generator odczytujący plik na taki, który odczytuje dane z karty dźwiękowej, Twój program zaczyna transkrybować Twój głos na żywo, nie zmieniając ani jednej linii w pozostałej części kodu.
Narzędziem do tej lekcji jest PyAudio, standardowa biblioteka Pythona do obsługi urządzeń audio. Opiera się ona na PortAudio, warstwie natywnej, którą w zależności od systemu możesz potrzebować zainstalować osobno.
Instalacja 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 mikrofonu
Sedno tej lekcji mieści się w około trzydziestu liniach kodu. Funkcja otwiera strumień wejściowy na domyślnym urządzeniu, nieskończenie pętli odczytuje bloki o stałym rozmiarze i zwraca każdy z nich do silnika transkrypcji. Blok finally nie jest ozdobnikiem: gwarantuje on zatrzymanie strumienia, jego zamknięcie i zwolnienie sprzętu przez PyAudio, nawet jeśli program zostanie gwałtownie przerwany. Bez niego mikrofon może pozostać zablokowany, uniemożliwiając działanie innym aplikacjom.
import asyncio
import pyaudio
async def iter_microphone(
sample_rate: int = 16000,
chunk_duration_ms: int = 480
):
"""Przechwyć mikrofon i zwracaj fragmenty PCM.
Args:
sample_rate: Częstotliwość próbkowania (16000 Hz dla Voxtral)
chunk_duration_ms: Czas trwania każdego fragmentu w milisekundach
Yields:
bytes: 16-bitowe mono fragmenty audio PCM
"""
p = pyaudio.PyAudio()
# Liczba próbek na fragment
chunk_samples = int(sample_rate * chunk_duration_ms / 1000)
# Otwórz strumień mikrofonu
stream = p.open(
format=pyaudio.paInt16, # 16-bitowe PCM
channels=1, # Mono
rate=sample_rate, # 16 kHz
input=True, # Tryb przechwytywania
frames_per_buffer=chunk_samples
)
loop = asyncio.get_running_loop()
try:
print("Mikrofon aktywny — mów...")
while True:
# Odczytaj fragment w trybie nieblokującym
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 zamknięty")
Każdy parametr ma swoje konkretne uzasadnienie. sample_rate=16000 wynika z wymogu modelu, a nie preferencji: Voxtral oczekuje 16 kHz, więc nie zmieniaj tej wartości. pyaudio.paInt16 odpowiada formatowi PCM ze znakiem 16-bitowemu, dokładnie równoważnemu pcm_s16le zadeklarowanemu po stronie API, a channels=1 wymusza mono, co również jest wymagane. Pozostaje chunk_duration_ms=480, jedyne ustawienie, które można poddawać dyskusji: każdy fragment reprezentuje 480 milisekund audio, co stanowi dobry kompromis między responsywnością a wydajnością sieciową. Krótszy fragment, np. 100 ms, poprawia responsywność, ale mnoży żądania sieciowe; dłuższy fragment oszczędza przepustowość kosztem dodatkowego opóźnienia, zanim model zobaczy audio.
Wywołanie loop.run_in_executor również zasługuje na wyjaśnienie. stream.read jest funkcją blokującą: wstrzymuje wątek, dopóki nie będzie dostępna żądana liczba próbek. Uruchomienie jej bezpośrednio w korutynie zamroziłoby całą pętlę asyncio, w tym odbieranie zdarzeń transkrypcji. Przenosząc ją do wykonawcy (executor), sprawiasz, że odczyt jest kompatybilny z resztą programu asynchronicznego.
Obliczenie rozmiaru bloku wynika mechanicznie z dwóch ustawień, dla sample_rate=16000 i chunk_duration_ms=480:
chunk_samples = 16000 × 480 / 1000 = 7680 próbek
byte_size = 7680 × 2 bajty = 15360 bajtów na fragment
Kompletny program: od mikrofonu do transkrypcji
Poniższy skrypt łączy przechwytywanie i transkrypcję w gotowe do użycia narzędzie do dyktowania. Nowym elementem w porównaniu z poprzednim generatorem jest obsługa czystego zamykania: handler sygnału przechwytuje Ctrl+C, zmienia flagę running na False, co powoduje wyjście z pętli przechwytywania, zamknięcie strumienia i pozwala programowi zapisać zgromadzony tekst. Bez tego mechanizmu przerwanie klawiaturą zabiłoby proces przed zapisem, a Ty straciłbyś dyktando.
import asyncio
import os
import signal
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
import pyaudio
# Flaga dla czystego zamykania
running = True
def signal_handler(sig, frame):
global running
print("\n\nZamykanie...")
running = False
signal.signal(signal.SIGINT, signal_handler)
async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
"""Przechwyć mikrofon aż do przerwania (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("TRANSKRYPCJA NA ŻYWO")
print("Mów do mikrofonu (Ctrl+C, aby zatrzymać)")
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
# Zapisz
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\nTranskrypcja zapisana w dictee.txt")
print(f"Długość: {len(final_text)} znaków")
else:
print("\n\nNie przetłumaczono żadnego tekstu.")
asyncio.run(main())
Uruchom go, mów, zatrzymaj Ctrl+C: tekst pojawia się w miarę mówienia, a następnie trafia do pliku dictee.txt.
python dictee_vocale.py
# Mów do mikrofonu
# Tekst pojawia się w czasie rzeczywistym
# Ctrl+C, aby zatrzymać
Wypróbuj to, mówiąc przez około trzydzieści sekund ciągłym francuskim, zmieniając tempo, i porównaj to, co powiedziałeś, z zawartością pliku. To najlepszy sposób na skalibrowanie oczekiwań przed dostrojeniem opóźnień w następnej lekcji.
Wybór właściwego urządzenia
Na komputerze z wbudowanym mikrofonem, zestawem słuchawkowym USB i kamerą internetową urządzenie domyślne nie zawsze jest tym, za które je uważasz, a pusta transkrypcja zazwyczaj wynika właśnie z tego szczegółu. Najpierw wyświetl listę dostępnych wejść z ich indeksami:
def list_microphones():
"""Wyświetl listę wszystkich dostępnych urządzeń wejścia audio."""
p = pyaudio.PyAudio()
print("Dostępne urządzenia wejściowe:")
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"(kanały: {info['maxInputChannels']}, "
f"częstotliwość: {int(info['defaultSampleRate'])} Hz)")
p.terminate()
list_microphones()
Następnie po prostu wymuś wybrany indeks podczas otwierania strumienia, używając parametru input_device_index:
stream = p.open(
format=pyaudio.paInt16,
channels=1,
rate=sample_rate,
input=True,
input_device_index=2, # Indeks urządzenia
frames_per_buffer=chunk_samples
)
Kluczowe wnioski
- PyAudio przechwytuje mikrofon w formacie 16-bitowym mono PCM przy 16 kHz, dokładnie tak, jak oczekuje Voxtral
- Generator
iter_microphonedomyślnie zwraca fragmenty trwające 480 ms loop.run_in_executorsprawia, że odczyt z mikrofonu jest nieblokujący w asyncio- Ctrl+C czysto zatrzymuje przechwytywanie dzięki handlerowi sygnału
- Wyświetl listę urządzeń za pomocą
get_device_count(), aby wybrać odpowiedni mikrofon