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

Контрол на латентността

Урок 12 от 16 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Компромисът между латентност и точност
  2. Параметърът target_streaming_delay_ms
  3. Шаблонът Dual Delay (Двойно забавяне)
  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.

Компромисът между латентност и точност

Транскрипцията в реално време разчита на компромис, който не можете да избегнете: скоростта на отговор се постига за сметка на точността. Колкото по-дълго моделът изчаква, преди да изведе дума, толкова повече контекст има, за да различи сходните акустични хипотези – и толкова по-дълго чака Вашият потребител. Фраза като „he took the sea“ срещу „he took the bitter“ може да стане ясна едва от последващия текст; прибързаният модел понякога ще избере грешната.

Voxtral Realtime не крие този компромис зад автоматична настройка: той Ви го предоставя изрично чрез параметъра target_streaming_delay_ms. Вие решавате точката на баланс за всеки конкретен случай.

Параметърът target_streaming_delay_ms

Тази стойност изразява в милисекунди целевото забавяне между получаването на аудио и издаването на съответния текст. При Voxtral 3 той приема всяко цяло число от 80 до 1200 или 2400; всяка друга стойност задейства събитие за грешка. Предавате го директно на стрийминг повикването, точно както модела и аудио формата, и като всички настройки на сесията, той се заключва след първия аудио чанк:

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

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,
    target_streaming_delay_ms=240,  # 240 ms
):
    if isinstance(event, TranscriptionStreamTextDelta):
        print(event.text, end="", flush=True)

Три диапазона от стойности покриват почти всички случаи на употреба. Между 200 и 300 милисекунди транскрипцията е ултра-отзивчива: това е настройката за гласови асистенти, където непосредствеността е най-важна, а текстът може да съдържа повече корекции. Между 500 и 1000 милисекунди получавате добър баланс, подходящ за субтитри на живо и диктовка. Отвъд това, между 2000 и 3000 милисекунди, моделът работи с много повече контекст и произвежда значително по-чист текст, за сметка на забавяне, което потребителят ясно усеща.

Шаблонът Dual Delay (Двойно забавяне)

Наистина ли трябва да избирате? Voxtral Realtime предлага заобиколен път: стартирайте два потока паралелно върху едно и също аудио, с различни латентности, и по този начин откажете компромиса. Бързият поток, настроен например на 240 милисекунди, осигурява незабавна визуална обратна връзка, която успокоява потребителя и показва, че системата слуша. Бавният поток, настроен на 2400 милисекунди, произвежда по-точна транскрипция, която постепенно замества предварителния текст.

Вие познавате това поведение, дори да не сте му дали име: така работят субтитрите на живо в YouTube или Google Meet, където текстът се появява почти мигновено, след което се коригира няколко момента по-късно. Внедряването включва дефиниране на две корутини, идентични с изключение на забавянето, след което стартирането им заедно с asyncio.gather.

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

async def dual_latency_stream(source_audio_fast, source_audio_slow):
    """Изпълнява две транскрипции паралелно с различни латентности."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    results = {"fast": [], "slow": []}

    async def fast_stream():
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio_fast,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=240,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                results["fast"].append(event.text)
                # Показване веднага (ще бъде заменено от бавния поток)
                print(f"\r[FAST] {''.join(results['fast'][-10:])}",
                      end="", flush=True)

    async def slow_stream():
        async for event in client.audio.realtime.transcribe_stream(
            audio_stream=source_audio_slow,
            model="voxtral-mini-transcribe-realtime-3",
            audio_format=audio_format,
            target_streaming_delay_ms=2400,
        ):
            if isinstance(event, TranscriptionStreamTextDelta):
                results["slow"].append(event.text)
                # Показване на коригираната версия
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Стартиране на двата потока паралелно
    await asyncio.gather(fast_stream(), slow_stream())

    return {
        "fast": "".join(results["fast"]),
        "slow": "".join(results["slow"])
    }

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

Управление на заместването на екрана

В терминала двойният изход от горния код е достатъчен, за да разберете механизма, но един реален интерфейс трябва да обедини двата потока в един единствен, четим текст. Утвърдената конвенция е да се показва предварителният текст в нюанс на сиво, а потвърденият текст – в бяло, като границата между тях се придвижва напред, докато бавният поток настигне бързия. Класът по-долу реализира тази граница с final_position: всичко преди него идва от бавния поток и няма да се промени, всичко след него идва от бързия поток и остава обект на корекция.

class DualLatencyDisplay:
    """Управлява дисплея с двойна латентност."""

    def __init__(self):
        self.fast_text = ""
        self.final_text = ""
        self.final_position = 0

    def on_fast_text(self, text: str):
        """Нов текст от бързия поток (предварителен)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Нов текст от бавния поток (окончателен)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Показва окончателния текст плюс бързия текст, все още непотвърден."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

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

Избор на правилната латентност за Вашия случай на употреба

Случай на употребаПрепоръчителна латентностПричина
Гласов асистент200-300 мсПотребителят очаква незабавна реакция
Гласова диктовка500-800 мсБаланс между отзивчивост и точност
Субтитри на живо800-1200 мсТочността е важна, леко забавяне е приемливо
Транскрипция на конференции1200 или 2400 мсМаксимална точност, забавянето не е критично

Измерване на действително постигнатата латентност

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

import time

async def measure_latency(source_audio, delay_ms):
    """Измерва ефективната латентност на транскрипцията."""
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
    audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)

    start = time.time()
    first_text = None

    async for event in client.audio.realtime.transcribe_stream(
        audio_stream=source_audio,
        model="voxtral-mini-transcribe-realtime-3",
        audio_format=audio_format,
        target_streaming_delay_ms=delay_ms,
    ):
        if isinstance(event, TranscriptionStreamTextDelta):
            if first_text is None:
                first_text = time.time()
                latency = (first_text - start) * 1000
                print(f"First text after {latency:.0f} ms "
                      f"(target: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nTotal duration: {time.time() - start:.1f}s")

Изпълнете това измерване със 240, след това 800 и след това 2400 милисекунди върху един и същи откъс и прочетете трите транскрипции една до друга. Разликата в качеството между първата и последната ще Ви каже, по-добре от всяка обща препоръка, каква латентност може да си позволи Вашето приложение.

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

  • target_streaming_delay_ms контролира компромиса между латентност и точност
  • Ниски стойности (80 до 300 мс): отзивчиви, но по-малко точни
  • Високи стойности (1200 мс или 2400 мс): точни, но с усетимо забавяне; приемат се само стойности от 80 до 1200 и 2400
  • Шаблонът Dual Delay комбинира два потока едновременно за отзивчивост И точност
  • Бързият поток дава незабавна обратна връзка, бавният поток коригира текста
  • Изберете латентност въз основа на Вашия случай на употреба (гласов асистент срещу субтитри)