Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Řízení latence

Lekce 12 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Kompromis mezi latencí a přesností
  2. Parametr target_streaming_delay_ms
  3. Vzorec Dual Delay
  4. Zpracování nahrazování na obrazovce
  5. Výběr správné latence pro tvůj případ použití
  6. Měření skutečně dosažené latence
  7. Klíčové poznatky

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 modely voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 a voxtral-mini-tts-3-0. Klíčové změny: časové razítkování pouze po segmentech (word vrací 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 vstupy context_bias jsou 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á latenceDůvod
Hlasový asistent200–300 msUživatel očekává okamžitou reakci
Hlasové diktování500–800 msRovnováha mezi responzivitou a přesností
Živé titulky800–1 200 msPřesnost je důležitá, mírné zpoždění přijatelné
Transkripce konferencí1 200 nebo 2 400 msMaximá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)