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

Реализация на транскрипция в реално време с Python

Урок 10 от 16 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Пълният асинхронен поток в Python
  2. Архитектура на стрийминг програмата
  3. Основна реализация
  4. Структуриране на обработката за продукция
  5. Оцеляване при прекъсвания на мрежата
  6. Подготовка на съществуващ файл
  7. Ключови изводи

Курсът е актуализиран на 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.

Пълният асинхронен поток в Python

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

Архитектура на стрийминг програмата

Независимо от приложението, структурата остава същата и се чете от ляво надясно. В началото има аудио източник: асинхронен генератор, който произвежда чънкове с PCM аудио. Днес това може да е файл, утре – микрофон или мрежов поток. В центъра е клиентът на Voxtral, тоест SDK, който изпраща тези чънкове към модела и връща събития към вас. В края е обработката на събитията: вашата бизнес логика, която показва текста, го натрупва, запазва го или го препраща към друга услуга.

Audio Source → [PCM chunks] → Mistral SDK → [events] → Your Code

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

Основна реализация

Два детайла в тази първа програма заслужават вниманието Ви. Генераторът source_audio_fichier разделя файла на блокове от 32 000 байта, което съответства точно на една секунда 16-битово моно PCM аудио при 16 kHz: 16 000 проби, умножени по 2 байта. Следващият await asyncio.sleep след всяко yield симулира реално време; ако коментирате този ред и стартирате програмата с откъс от няколко минути, ще видите как файлът се консумира за част от секундата, което не Ви учи на нищо относно поведението при стрийминг. От страната на получаването, texte_complet натрупва фрагменти, така че да разполагате с пълния текст в края, в допълнение към дисплея на живо.

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

async def source_audio_fichier(chemin: str, taille_chunk: int = 32000):
    """Асинхронен генератор, който чете PCM файл на чънкове.

    taille_chunk = 32000 байта = 1 секунда 16-битово моно PCM аудио при 16kHz
    (16000 проби × 2 байта = 32000 байта)
    """
    with open(chemin, "rb") as f:
        while True:
            chunk = f.read(taille_chunk)
            if not chunk:
                break
            yield chunk
            # Симулиране на реално време (1 чънк = 1 секунда)
            await asyncio.sleep(len(chunk) / 32000)

async def transcrire_realtime(source_audio):
    """Транскрибира аудио поток в реално време с Voxtral."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    audio_format = AudioFormat(
        encoding="pcm_s16le",
        sample_rate=16000
    )

    texte_complet = []

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=source_audio,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            print(event.text, end="", flush=True)
            texte_complet.append(event.text)

        elif isinstance(event, TranscriptionStreamDone):
            print("\n\n--- Транскрипцията приключи ---")

    return "".join(texte_complet)

async def main():
    source = source_audio_fichier("audio.pcm")
    texte = await transcrire_realtime(source)

    # Запазване на резултата
    with open("transcription_realtime.txt", "w", encoding="utf-8") as f:
        f.write(texte)
    print(f"\nТекстът е запазен ({len(texte)} знака)")

asyncio.run(main())

Дисплеят на живо разчита на print(event.text, end="", flush=True). Без flush=True, Python буферира изхода и текстът би се появявал на пакети: транскрипцията Ви би била технически в реално време, но визуално накъсана.

Структуриране на обработката за продукция

След като приложението Ви излезе извън рамките на демо версия, цикълът if/elif става тромав: искате да броите фрагменти, да измервате продължителността, да свържете дисплей или да захранвате база данни. Обгръщането на логиката в клас решава проблема веднъж завинаги. Всеки тип събитие получава свой собствен метод, а Вие можете да добавяте поведение – например изпращане на всяка делта към уеб интерфейс – без да докосвате цикъла за получаване.

class GestionnaireTranscription:
    """Управлява събитията за транскрипция в реално време."""

    def __init__(self):
        self.texte_complet = []
        self.nb_deltas = 0
        self.debut = None

    async def traiter(self, source_audio):
        """Стартира транскрипцията и обработва събитията."""
        import time
        self.debut = time.time()

        client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
        audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                self._on_text_delta(event)
            elif isinstance(event, TranscriptionStreamDone):
                self._on_done(event)

        return self.obtenir_resultat()

    def _on_text_delta(self, event):
        """Извиква се за всеки нов текстов фрагмент."""
        self.texte_complet.append(event.text)
        self.nb_deltas += 1
        # Дисплей на живо
        print(event.text, end="", flush=True)

    def _on_done(self, event):
        """Извиква се в края на транскрипцията."""
        import time
        duree = time.time() - self.debut
        print(f"\n\nПриключи за {duree:.1f}s")
        print(f"Получени фрагменти: {self.nb_deltas}")

    def obtenir_resultat(self) -> str:
        """Връща пълния транскрибиран текст."""
        return "".join(self.texte_complet)

async def main():
    gestionnaire = GestionnaireTranscription()
    source = source_audio_fichier("audio.pcm")
    texte = await gestionnaire.traiter(source)
    print(f"Резултат: {len(texte)} знака")

asyncio.run(main())

Броячът nb_deltas не е просто украса: спрямо продължителността на аудиото, той показва скоростта на емисия на модела и Ви предупреждава, ако потокът се влоши.

Оцеляване при прекъсвания на мрежата

Стрийминг връзката остава отворена през цялата продължителност на речта, което я излага на риск много повече от няколко секундна офлайн заявка. Прекъсващ Wi-Fi, превключване на мрежата на мобилно устройство или прекъсване на оператора могат да прекъснат потока. Долният шаблон рестартира транскрипцията до три пъти, със закъснение, което се увеличава с всяка попытка, за да се даде време на мрежата да се възстанови. Оттам нататък изключението се предава нататък: една явна грешка е по-добра от приложение, което изглежда, че не слуша нищо.

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

MAX_TENTATIVES = 3
DELAI_RECONNEXION = 2  # секунди

async def transcrire_avec_retry(source_audio, tentative=1):
    """Транскрипция с автоматично повторно свързване."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    try:
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                print(event.text, end="", flush=True)
            elif isinstance(event, TranscriptionStreamDone):
                print("\n[Приключи]")

    except ConnectionError as e:
        if tentative < MAX_TENTATIVES:
            print(f"\nМрежова грешка (опит {tentative}/{MAX_TENTATIVES})")
            await asyncio.sleep(DELAI_RECONNEXION * tentative)
            await transcrire_avec_retry(source_audio, tentative + 1)
        else:
            print(f"\nНеуспех след {MAX_TENTATIVES} опита: {e}")
            raise

Подготовка на съществуващ файл

За да тествате с MP3 или WAV файл, който вече имате под ръка, можете да автоматизирате конвертирането в PCM от Python, вместо да го изпълнявате ръчно. Функцията по-долу възлага работата на FFmpeg, извежда изходното име от входното име и връща получения път, готов за предаване на source_audio_fichier.

import subprocess

def convertir_en_pcm(chemin_entree: str, chemin_sortie: str = None) -> str:
    """Конвертира аудио файл в 16-битов 16kHz моно PCM чрез FFmpeg."""
    if chemin_sortie is None:
        chemin_sortie = chemin_entree.rsplit(".", 1)[0] + ".pcm"

    subprocess.run([
        "ffmpeg", "-y",
        "-i", chemin_entree,
        "-f", "s16le",
        "-acodec", "pcm_s16le",
        "-ar", "16000",
        "-ac", "1",
        chemin_sortie
    ], check=True, capture_output=True)

    return chemin_sortie

# Употреба
chemin_pcm = convertir_en_pcm("reunion.mp3")
# След това използвайте source_audio_fichier(chemin_pcm)

Две предпазни мерки с тази функция. check=True поражда изключение, ако FFmpeg се провали, което е по-добре от откриването на празен PCM файл по-късно в потока; а capture_output=True скрива изхода на инструмента, така че дългото конвертиране няма да накара програмата да изглежда замръзнала. За записи с продължителност един час, планирайте да отпечатате съобщение преди и след извикването.

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

  • Стриймингът използва асинхронни генератори (async for, yield)
  • Чънк от 32 000 байта = 1 секунда 16-битово моно PCM аудио при 16 kHz
  • Структурирайте обработката на събитията в клас за продукция
  • Внедрете механизъм за повторни опити за справяне с мрежови грешки
  • Използвайте FFmpeg за конвертиране на съществуващи аудио файлове в PCM
  • Дисплеят на живо използва print(text, end="", flush=True)