Контрол на латентността
На тази страница
Курсът е актуализиран на 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 комбинира два потока едновременно за отзивчивост И точност
- Бързият поток дава незабавна обратна връзка, бавният поток коригира текста
- Изберете латентност въз основа на Вашия случай на употреба (гласов асистент срещу субтитри)