Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Ovládanie oneskorenia

Lekcia 12 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Kompromis medzi oneskorením a presnosťou
  2. Parameter target_streaming_delay_ms
  3. Vzorec dvojitého oneskorenia (Dual Delay)
  4. Spracovanie nahradenia na obrazovke
  5. Výber správneho oneskorenia pre tvoj prípad použitia
  6. Meranie skutočne dosiahnutého oneskorenia
  7. Kľúčové poznatky

Kurz aktualizovaný 3. novembra 2026 pre Voxtral 3 na základe príručky Mistral Migrate from Voxtral 2: Modely Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), ktoré boli zastarané 31. októbra 2026 a vyradené 30. apríla 2027, sú v príkladoch nahradené modelmi voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 a voxtral-mini-tts-3-0. Kľúčové zmeny: časové značky iba podľa segmentov (word vráti chybu 400), diarizácia v reálnom čase je možná, nastavenia relácie v reálnom čase sú uzamknuté po prvom zvukovom bloku a vstupy context_bias sú voľného formátu (frázy s medzerami). Zdroje: Migrate from Voxtral 2 · Speech to Text.

Kompromis medzi oneskorením a presnosťou

Prepis v reálnom čase sa spolieha na kompromis, ktorému sa nevyhneš: rýchlosť odozvy ide na úkor presnosti. Čím dlhšie model čaká pred vydaním slova, tým viac kontextu má na rozlíšenie podobných akustických hypotéz – a tým dlhšie čaká tvoj používateľ. Fráza ako „he took the sea“ oproti „he took the bitter“ sa môže vyjasniť až z nasledujúceho textu; uponáhľaný model si niekedy vyberie tú nesprávnu.

Voxtral Realtime tento kompromis neskrýva za automatickým nastavením: odovzdáva ti ho explicitne prostredníctvom parametra target_streaming_delay_ms. Bod rovnováhy si určuješ ty, prípad od prípadu.

Parameter target_streaming_delay_ms

Táto hodnota vyjadruje v milisekundách cieľové oneskorenie medzi prijatím zvuku a vydaním zodpovedajúceho textu. Voxtral 3 akceptuje akékoľvek celé číslo od 80 do 1 200 alebo 2 400; akákoľvek iná hodnota spustí chybovú udalosť. Odovzdáš ho priamo do streamovacieho volania, rovnako ako model a formát zvuku, a ako všetky nastavenia relácie, aj toto sa uzamkne po prvom zvukovom bloku:

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ízke oneskorenie: rýchla odozva, menšia presnosť
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)

Tri rozsahy hodnôt pokrývajú takmer všetky prípady použitia. Medzi 200 a 300 milisekundami je prepis ultra-responzívny: toto je nastavenie pre hlasových asistentov, kde záleží najviac na okamžitosti a text môže obsahovať viac opráv. Medzi 500 a 1 000 milisekundami dosiahneš dobrú rovnováhu, vhodnú pre živé titulky a diktovanie. Nad touto hranicou, medzi 2 000 a 3 000 milisekundami, model pracuje s oveľa väčším kontextom a produkuje výrazne čistejší text za cenu oneskorenia, ktoré používateľ jasne vníma.

Vzorec dvojitého oneskorenia (Dual Delay)

Musíš si naozaj vybrať? Voxtral Realtime ponúka obchádzku: spusti dva streamy paralelne na rovnakom zvuku s rôznymi oneskoreniami, a tým odmietni kompromis. Rýchly stream, nastavený napríklad na 240 milisekúnd, poskytuje okamžitú vizuálnu spätnú väzbu, ktorá používateľa uistí a ukáže, že systém počúva. Pomalý stream, nastavený na 2 400 milisekúnd, produkuje presnejší prepis, ktorý postupne nahrádza predbežný text.

Toto správanie poznáš, aj keď si ho nepomenoval: takto fungujú živé titulky na YouTube alebo Google Meet, kde sa text objaví takmer okamžite a o niekoľko momentov neskôr sa opraví. Implementácia zahŕňa definovanie dvoch korutín identických okrem oneskorenia a ich spoločné spustenie pomocou 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í dva prepisy paralelne s rôznymi oneskoreniami."""
    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é zobrazenie (bude nahradené pomalým streamom)
                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)
                # Zobrazenie opravenej verzie
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Spustenie oboch streamov paralelne
    await asyncio.gather(fast_stream(), slow_stream())

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

Všimni si, že funkcia prijíma dva samostatné zvukové zdroje, nie jeden: async generátor možno spotrebovať iba raz, takže musíš stream duplikovať upstream, aby si nakŕmil oba prepisy.

Spracovanie nahradenia na obrazovke

V termináli je dvojitý výstup z vyššie uvedeného kódu dostatočný na pochopenie mechanizmu, ale skutočné rozhranie musí zlúčiť dva streamy do jedného čitateľného textu. Zavedenou konvenciou je zobraziť predbežný text v jemnom odtieni – šedej – a potvrdený text v bielej, pričom hranica medzi nimi postupuje, ako pomalý stream dobieha ten rýchly. Nižšie uvedená trieda implementuje túto hranicu pomocou final_position: všetko pred ňou pochádza z pomalého streamu a nezmení sa, všetko za ňou pochádza z rýchleho streamu a zostáva predmetom opráv.

class DualLatencyDisplay:
    """Spravuje zobrazenie s dvojitým oneskorením."""

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

    def on_fast_text(self, text: str):
        """Nový text z rýchleho streamu (predbež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 plus rýchly text, ktorý ešte nie je potvrdený."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Tento komfort má cenu, ktorú by bolo nečestné ignorovať: dva streamy znamenajú dve pripojenia a dvojnásobný objem spracovaného zvuku. Vzorec Dual Delay si vyhradź pre rozhrania, kde používateľ číta text v reálnom čase; pre spracovanie na pozadí úplne stačí jeden dobre vyladený stream.

Výber správneho oneskorenia pre tvoj prípad použitia

Prípad použitiaOdporúčané oneskorenieDôvod
Hlasový asistent200 – 300 msPoužívateľ očakáva okamžitú reakciu
Hlasové diktovanie500 – 800 msRovnováha medzi responzívnosťou a presnosťou
Živé titulky800 – 1 200 msPresnosť je dôležitá, mierne oneskorenie je prijateľné
Prepis konferencie1 200 alebo 2 400 msMaximálna presnosť, oneskorenie nie je kritické

Meranie skutočne dosiahnutého oneskorenia

Hodnota, ktorú požaduješ, je cieľ, nie záruka: vzdialenosť v sieti, zaťaženie služby a veľkosť tvojich blokov sa k nej pripočítavajú. Predtým, ako používateľom uvedieš konkrétne číslo, zmeraj ho z miesta, kde bude tvoja aplikácia skutočne bežať. Funkcia nižšie meria čas do príchodu prvého fragmentu a porovnáva ho s požadovaným cieľom.

import time

async def measure_latency(source_audio, delay_ms):
    """Meria efektívne oneskorenie prepisu."""
    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"Prvý text po {latency:.0f} ms "
                      f"(cieľ: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nCelková dĺžka trvania: {time.time() - start:.1f}s")

Spusť toto meranie s hodnotami 240, potom 800 a nakoniec 2 400 milisekúnd na rovnakom úryvku a prečítaj si tri prepisy vedľa seba. Rozdiel v kvalite medzi prvým a posledným ti povie lepšie než akékoľvek všeobecné odporúčanie, aké oneskorenie si tvoja aplikácia môže dovoliť.

Kľúčové poznatky

  • target_streaming_delay_ms riadi kompromis medzi oneskorením a presnosťou
  • Nízke hodnoty (80 až 300 ms): responzívne, ale menej presné
  • Vysoké hodnoty (1 200 ms alebo 2 400 ms): presné, ale so zreteľným oneskorením; akceptované sú iba hodnoty od 80 do 1 200 a 2 400
  • Vzorec Dual Delay kombinuje dva streamy pre responzívnosť AJ presnosť
  • Rýchly stream poskytuje okamžitú spätnú väzbu, pomalý stream opravuje text
  • Onesorenie vyberaj podľa svojho prípadu použitia (hlasový asistent vs. titulky)