Премини към основното съдържание
Български— Изберете език
Меню

Прихващане на микрофона с PyAudio

Урок 11 от 16 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. От файл към микрофон
  2. Инсталиране на PyAudio
  3. Генераторът за микрофон
  4. Пълна програма: От микрофон към транскрипция
  5. Избор на правилното устройство
  6. Ключови изводи

Курсът е актуализиран на 3 ноември 2026 г. за Voxtral 3, въз основа на ръководството на Mistral Migrate from Voxtral 2: Моделите Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603, депрекирани на 31 октомври 2026 г. и премахнати на 30 април 2027 г.) са заменени в примерите с voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 и voxtral-mini-tts-3-0. Основни промени: временните марки са само за сегменти (word връща грешка 400), поддържа се диаризация в реално време, настройките на сесията в реално време се заключват след първия аудио чънк, а входовете за context_bias са гъвкави (фрази с интервали). Източници: Migrate from Voxtral 2 · Speech to Text.

От файл към микрофон

Предишният урок установи архитектура, при която аудио източникът е прост, взаимозаменяем асинхронен генератор. Вие ще се възползвате от това веднага: чрез замяна на генератора, който чете от файл, с такъв, който чете от звуковата ви карта, програмата Ви започва да транскрибира гласа Ви на живо, без да променяте нито един ред от останалата част на кода.

Инструментът за този урок е PyAudio, стандартната библиотека на Python за достъп до аудио устройства. Тя разчита на PortAudio, нативен слой, който може да се наложи да инсталирате отделно в зависимост от Вашата система.

Инсталиране на PyAudio

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

# macOS
brew install portaudio
pip install pyaudio

# Windows
pip install pyaudio

Генераторът за микрофон

Същината на този урок се събира в около тридесет реда. Функцията отваря входен поток към устройството по подразбиране, влиза в безкраен цикъл, четейки блокове с фиксиран размер, и предава всеки от тях на двигателя за транскрипция. Блокът finally не е декоративен: той гарантира, че потокът спира, затваря се и PyAudio освобождава хардуера, дори ако програмата бъде прекъсната рязко. Без него микрофонът може да остане заключен, блокирайки други приложения.

import asyncio
import pyaudio

async def iter_microphone(
    sample_rate: int = 16000,
    chunk_duration_ms: int = 480
):
    """Capture the microphone and yield PCM chunks.

    Args:
        sample_rate: Sampling rate (16000 Hz for Voxtral)
        chunk_duration_ms: Duration of each chunk in milliseconds

    Yields:
        bytes: 16-bit mono PCM audio chunks
    """
    p = pyaudio.PyAudio()

    # Number of samples per chunk
    chunk_samples = int(sample_rate * chunk_duration_ms / 1000)

    # Open the microphone stream
    stream = p.open(
        format=pyaudio.paInt16,    # 16-bit PCM
        channels=1,                 # Mono
        rate=sample_rate,           # 16 kHz
        input=True,                 # Capture mode
        frames_per_buffer=chunk_samples
    )

    loop = asyncio.get_running_loop()

    try:
        print("Microphone active — speak...")
        while True:
            # Read the chunk non-blocking
            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("Microphone closed")

Всеки параметър има конкретна причина. sample_rate=16000 отразява изискване на модела, а не предпочитание: Voxtral очаква 16 kHz, така че не променяйте тази стойност. pyaudio.paInt16 съответства на форматирането signed 16-bit PCM, което е напълно еквивалентно на обявеното от страната на API pcm_s16le, а channels=1 налага моно, което също е задължително. Остава chunk_duration_ms=480, единствената наистина обсъждаема настройка: всеки чънк представлява 480 милисекунди аудио, добър компромис между отзивчивост и мрежова ефективност. По-къс чънк, да речем 100 мс, подобрява отзивчивостта, но умножава мрежовите заявки; по-дълъг чънк пести честотна лента за сметка на добавена латентност, преди моделът да види аудиото.

Извикването на loop.run_in_executor също заслужава обяснение. stream.read е блокираща функция: тя задържа нишката, докато не стане наличен поисканият брой проби. Изпълнението ѝ директно в корутина би замразило целия цикъл на asyncio, включително получаването на събития за транскрипция. Чрез прехвърлянето ѝ към изпълнител (executor), Вие правите четенето съвместимо с останалата част от асинхронната програма.

Изчислението на размера на блока следва механично от двете настройки, за sample_rate=16000 и chunk_duration_ms=480:

chunk_samples = 16000 × 480 / 1000 = 7680 samples
byte_size = 7680 × 2 bytes = 15360 bytes per chunk

Пълна програма: От микрофон към транскрипция

Следващият скрипт комбинира улавянето и транскрипцията в готов за употреба инструмент за диктовка. Новият елемент в сравнение с предишния генератор е чистото обработване на спиране: обработчик на сигнали прихваща Ctrl+C, обръща флага running на False, което излиза от цикъла на улавяне, затваря потока и позволява на програмата да запази натрупания текст. Без този механизъм прекъсване от клавиатурата би убило процеса преди запазването и Вие бихте загубили диктовката.

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

# Flag for clean shutdown
running = True

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

signal.signal(signal.SIGINT, signal_handler)

async def iter_microphone(sample_rate=16000, chunk_duration_ms=480):
    """Capture the microphone until interrupted (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("LIVE TRANSCRIPTION")
    print("Speak into the microphone (Ctrl+C to stop)")
    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

    # Save
    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\nTranscription saved to dictee.txt")
        print(f"Length: {len(final_text)} characters")
    else:
        print("\n\nNo text transcribed.")

asyncio.run(main())

Стартирайте го, говорете, спрете с Ctrl+C: текстът се появява, докато говорите, и след това попада във файла dictee.txt.

python dictee_vocale.py
# Speak into your microphone
# Text appears in real time
# Ctrl+C to stop

Опитайте го с около тридесет секунди непрекъснат френски език, варирайки темпото си, и сравнете казаното от Вас със съдържанието на файла. Това е най-добрият начин да калибрирате очакванията си, преди да настроите латентността в следващия урок.

Избор на правилното устройство

На машина с вграден микрофон, USB слушалки и уеб камера, устройството по подразбиране не винаги е това, което мислите, а една празна транскрипция обикновено се свежда до този детайл. Първо, избройте наличните входове с техния индекс:

def list_microphones():
    """List all available audio input devices."""
    p = pyaudio.PyAudio()
    print("Available input devices:")
    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"(channels: {info['maxInputChannels']}, "
                  f"rate: {int(info['defaultSampleRate'])} Hz)")
    p.terminate()

list_microphones()

След това просто наложете избрания индекс при отваряне на потока, чрез параметъра input_device_index:

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

Ключови изводи

  • PyAudio улавя микрофона в 16-битов моно PCM при 16 kHz, точно както очаква Voxtral
  • Генераторът iter_microphone предава чънкове от 480 мс по подразбиране
  • loop.run_in_executor прави четенето от микрофона неблокиращо в asyncio
  • Ctrl+C спира чисто улавянето чрез обработчик на сигнали
  • Избройте устройствата с get_device_count(), за да изберете правилния микрофон