Ovládanie oneskorenia
Na tejto strane
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é modelmivoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3avoxtral-mini-tts-3-0. Kľúčové zmeny: časové značky iba podľa segmentov (wordvrá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 vstupycontext_biassú 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žitia | Odporúčané oneskorenie | Dôvod |
|---|---|---|
| Hlasový asistent | 200 – 300 ms | Používateľ očakáva okamžitú reakciu |
| Hlasové diktovanie | 500 – 800 ms | Rovnováha medzi responzívnosťou a presnosťou |
| Živé titulky | 800 – 1 200 ms | Presnosť je dôležitá, mierne oneskorenie je prijateľné |
| Prepis konferencie | 1 200 alebo 2 400 ms | Maximá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_msriadi 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)