Řízení latence
Na této stránce
Kurz aktualizován 3. listopadu 2026 pro Voxtral 3 na základě průvodce Mistralu Migrate from Voxtral 2: Modely Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), které byly zastaralé k 31. říjnu 2026 a vyřazené k 30. dubnu 2027, jsou v příkladech nahrazeny modelyvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3avoxtral-mini-tts-3-0. Klíčové změny: časové razítkování pouze po segmentech (wordvrací chybu 400), diarizace v reálném čase je možná, nastavení relace v reálném čase jsou uzamčena po prvním zvukovém bloku a vstupycontext_biasjsou volného formátu (fráze s mezerami). Zdroje: Migrate from Voxtral 2 · Speech to Text.
Kompromis mezi latencí a přesností
Transkripce v reálném čase stojí na kompromisu, kterému se nevyhneš: rychlost odezvy jde na úkor přesnosti. Čím déle model čeká před vydáním slova, tím více kontextu má k rozlišení podobných akustických hypotéz – a tím déle čeká tvůj uživatel. Fráze jako „he took the sea“ versus „he took the bitter“ může být jasná až z následujícího kontextu; uspěchaný model si někdy vybere tu špatnou.
Voxtral Realtime tento kompromis neschovává za automatické nastavení: předává ti ho explicitně prostřednictvím parametru target_streaming_delay_ms. Bod rovnováhy si určuješ sám, případ od případu.
Parametr target_streaming_delay_ms
Tato hodnota vyjadřuje v milisekundách cílové zpoždění mezi přijetím zvuku a vydáním odpovídajícího textu. Ve Voxtral 3 přijímá jakékoli celé číslo od 80 do 1 200 nebo 2 400; jakákoli jiná hodnota spustí chybovou událost. Předáváš jej přímo do streamovacího volání, stejně jako model a formát zvuku, a jako všechna nastavení relace se po prvním zvukovém bloku uzamkne:
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)
# Nízká latence: rychlá odezva, menší přesnost
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)
Tři rozsahy hodnot pokrývají téměř všechny případy použití. Mezi 200 a 300 milisekundami je transkripce ultra-responzivní: toto je nastavení pro hlasové asistenty, kde záleží nejvíce na okamžité reakci a text může obsahovat více oprav. Mezi 500 a 1 000 milisekundami získáš dobrou rovnováhu, vhodnou pro živé titulky a diktování. Nad touto hranicí, mezi 2 000 a 3 000 milisekundami, pracuje model s mnohem větším kontextem a produkuje výrazně čistší text, za cenu zpoždění, které uživatel jasně vnímá.
Vzorec Dual Delay
Musíš si opravdu vybírat? Voxtral Realtime nabízí obchvat: spusť dva streamy paralelně na stejném zvuku s různou latencí, a tím se kompromisu vzdej. Rychlý stream, nastavený například na 240 milisekund, poskytuje okamžitou vizuální zpětnou vazbu, která uživatele ujišťuje, že systém poslouchá. Pomalý stream, nastavený na 2 400 milisekund, produkuje přesnější transkripci, která postupně nahrazuje předběžný text.
Toto chování znáš, i když jsi ho nepojmenoval: takto fungují živé titulky na YouTube nebo Google Meet, kde se text objeví téměř okamžitě a o chvíli později se opraví. Implementace zahrnuje definování dvou korutin identických kromě zpoždění a jejich společné spuštění pomocí 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):
"""Spustí dvě transkripce paralelně s různou latencí."""
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)
# Okamžité zobrazení (bude nahrazeno pomalým streamem)
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)
# Zobrazení opravené verze
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Spuštění obou streamů paralelně
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Všimni si, že funkce přijímá dva samostatné zvukové zdroje, nikoli jeden: asynchronní generátor lze spotřebovat pouze jednou, takže musíš stream upstream duplikovat, aby napájel obě transkripce.
Zpracování nahrazování na obrazovce
V terminálu je duální výstup z výše uvedeného kódu dostatečný k pochopení mechanismu, ale skutečné rozhraní musí sloučit dva streamy do jednoho čitelného textu. Zavedená konvence zobrazuje předběžný text v jemném odstínu – šedě – a potvrzený text bíle, přičemž hranice mezi nimi postupuje, jak pomalý stream dohání ten rychlý. Níže uvedená třída implementuje tuto hranici pomocí final_position: vše před ní pochází z pomalého streamu a nezmění se, vše po ní pochází z rychlého streamu a stále podléhá opravám.
class DualLatencyDisplay:
"""Spravuje zobrazení s duální latencí."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Nový text z rychlého streamu (předběžný)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Nový text z pomalého streamu (konečný)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Zobrazí konečný text + rychlý text ještě nepotvrzený."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Tento komfort má svou cenu, kterou by bylo nepoctivé ignorovat: dva streamy znamenají dvě připojení a dvojnásobný objem zpracovávaného zvuku. Vzorec Dual Delay si rezervuj pro rozhraní, kde uživatel čte text v reálném čase; pro zpracování na pozadí stačí jeden dobře naladěný stream.
Výběr správné latence pro tvůj případ použití
| Případ použití | Doporučená latence | Důvod |
|---|---|---|
| Hlasový asistent | 200–300 ms | Uživatel očekává okamžitou reakci |
| Hlasové diktování | 500–800 ms | Rovnováha mezi responzivitou a přesností |
| Živé titulky | 800–1 200 ms | Přesnost je důležitá, mírné zpoždění přijatelné |
| Transkripce konferencí | 1 200 nebo 2 400 ms | Maximální přesnost, zpoždění není kritické |
Měření skutečně dosažené latence
Hodnota, kterou požaduješ, je cíl, nikoli záruka: vzdálenost v síti, zatížení služby a velikost tvých bloků se k ní přičítají. Než uvedeš číslo svým uživatelům, změř ji z místa, kde bude tvoje aplikace skutečně běžet. Níže uvedená funkce měří zpoždění do příchodu prvního fragmentu a porovnává jej s požadovaným cílem.
import time
async def measure_latency(source_audio, delay_ms):
"""Měří efektivní latenci transkripce."""
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"První text po {latency:.0f} ms "
f"(cíl: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nCelková doba trvání: {time.time() - start:.1f}s")
Spusť toto měření s 240, poté s 800 a nakonec s 2 400 milisekundami na stejném úryvku a přečti si tři transkripce vedle sebe. Rozdíl v kvalitě mezi první a poslední ti lépe než jakékoli obecné doporučení řekne, jakou latenci si tvoje aplikace může dovolit.
Klíčové poznatky
target_streaming_delay_msřídí kompromis mezi latencí a přesností- Nízké hodnoty (80 až 300 ms): responzivní, ale méně přesné
- Vysoké hodnoty (1 200 ms nebo 2 400 ms): přesné, ale se znatelným zpožděním; přijímány jsou pouze hodnoty od 80 do 1 200 a 2 400
- Vzorec Dual Delay kombinuje dva streamy pro responzivitu I přesnost
- Rychlý stream poskytuje okamžitou zpětnou vazbu, pomalý stream text opravuje
- Latenci vybírej podle svého případu použití (hlasový asistent vs. titulky)