Nadzor zakasnitve
Na tej strani
Tečaj posodobljen 3. novembra 2026 za Voxtral 3, na podlagi vodnika Mistral Migrate from Voxtral 2: modeli Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603, zastareli 31. oktobra 2026 in umaknjeni 30. aprila 2027) so v primerih nadomeščeni zvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3invoxtral-mini-tts-3-0. Ključne spremembe: časovni žigi samo po segmentih (wordvrne napako 400), diarizacija v realnem času je mogoča, nastavitve seje v realnem času so zaklenjene po prvem zvočnem delčku, vnosicontext_biaspa so prosto oblikovani (fraze s presledki). Viri: Migrate from Voxtral 2 · Speech to Text.
Kompromis med zakasnitvijo in točnostjo
Prepis v realnem času temelji na kompromisu, ki se mu ne moreš izogniti: hitrost odziva gre na račun točnosti. Daljše kot model čaka pred izpisom besede, več konteksta ima za razlikovanje med podobnimi akustičnimi hipotezami – in dlje mora čakati tvoj uporabnik. Fraza, kot je „he took the sea” nasproti „he took the bitter”, lahko postane jasna šele iz naslednjega besedila; prenagljen model bo včasih izbral napačno.
Voxtral Realtime tega kompromisa ne skriva za samodejno nastavitvijo: predloži ti ga eksplicitno prek parametra target_streaming_delay_ms. Točko ravnovesja določiš sam, od primera do primera.
Parameter target_streaming_delay_ms
Ta vrednost v milisekundah izraža ciljno zakasnitev med prejemanjem zvoka in izpisom ustreznega besedila. Pri Voxtral 3 sprejme katero koli celo število od 80 do 1.200 ali 2.400; katera koli druga vrednost sproži dogodek napake. Posreduješ ga neposredno klicu pretoka, tako kot model in zvočni format, in kot vse nastavitve seje se zaklene po prvem zvočnem delčku:
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)
# Nizka zakasnitev: hiter odziv, manj natančno
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 razponi vrednosti pokrivajo skoraj vse primere uporabe. Med 200 in 300 milisekundami je prepis izjemno odziven: to je nastavitev za glasovne pomočnike, kjer je neposrednost najpomembnejša, besedilo pa lahko vsebuje več popravkov. Med 500 in 1.000 milisekundami dobiš dobro ravnovesje, primerno za podnapise v živo in diktiranje. Onkraj tega, med 2.000 in 3.000 milisekundami, model dela z veliko več konteksta in ustvari bistveno čistejše besedilo, na račun zakasnitve, ki jo uporabnik jasno zazna.
Vzorec dvojne zakasnitve (Dual Delay)
Ali se moraš res odločiti? Voxtral Realtime ponuja obvod: zaženi dva pretoka vzporedno na istem zvoku z različnimi zakasnitvami in s tem zavrnij kompromis. Hitri pretok, nastavljen na primer na 240 milisekund, zagotovi takojšnjo vizualno povratno informacijo, ki pomiri uporabnika in pokaže, da sistem posluša. Počasni pretok, nastavljen na 2.400 milisekund, ustvari natančnejši prepis, ki postopoma nadomesti začasno besedilo.
To vedenje poznaš, tudi če ga nisi poimenoval: tako delujejo podnapisi v živo na YouTubu ali Google Meetu, kjer se besedilo prikaže skoraj takoj, nato pa se po nekaj trenutkih popravi. Implementacija vključuje definicijo dveh korutin, ki sta enaki razen zakasnitve, nato pa ju zaženeš skupaj z 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):
"""Zažene dva prepisa vzporedno z različnimi zakasnitvami."""
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)
# Takojšnji prikaz (nadomestil ga bo počasni pretok)
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)
# Prikaz popravljene različice
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Zagon obeh pretokov vzporedno
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Upoštevaj, da funkcija prejme dva ločena zvočna vira, ne enega: asinhroni generator lahko porabiš samo enkrat, zato moraš tok podvojiti navzgor, da napajaš oba prepisa.
Ravnanje z zamenjavo na zaslonu
V terminalu je dvojni izhod zgornje kode dovolj za razumevanje mehanizma, vendar mora pravi vmesnik združiti oba pretoka v eno samo berljivo besedilo. Uveljavljeno pravilo je prikaz začasnega besedila v nežnem odtenku – sivo – in potrjenega besedila v beli barvi, pri čemer se meja med njima premika, ko počasni pretok dohiti hitrega. Spodnji razred implementira to mejo z final_position: vse pred tem prihaja iz počasnega pretoka in se ne bo spremenilo, vse za tem prihaja iz hitrega pretoka in ostaja podvrženo popravkom.
class DualLatencyDisplay:
"""Upravlja prikaz z dvojno zakasnitvijo."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Novo besedilo iz hitrega pretoka (začasno)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Novo besedilo iz počasnega pretoka (končno)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Prikaže končno besedilo plus hitro besedilo, ki še ni potrjeno."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
To udobje ima ceno, ki bi bilo nepošteno ignorirati: dva pretoka pomenita dve povezavi in dvakratno količino obdelanega zvoka. Vzorec Dual Delay rezerviraj za vmesnike, kjer uporabnik bere besedilo, ko nastaja; za obdelavo v ozadju je en sam dobro uglašen pretok več kot dovolj.
Izbira prave zakasnitve za tvojo uporabo
| Primer uporabe | Priporočena zakasnitev | Razlog |
|---|---|---|
| Glasovni pomočnik | 200–300 ms | Uporabnik pričakuje takojšen odziv |
| Glasovno diktiranje | 500–800 ms | Ravnovesje med odzivnostjo in točnostjo |
| Podnapisi v živo | 800–1.200 ms | Točnost je pomembna, majhna zakasnitev je sprejemljiva |
| Prepis konferenc | 1.200 ali 2.400 ms | Največja točnost, zakasnitev ni kritična |
Merjenje dejanske dosežene zakasnitve
Vrednost, ki jo zahtevaš, je cilj, ne garancija: oddaljenost omrežja, obremenitev storitve in velikost tvojih delčkov se ji vštevajo. Preden uporabnikom navedeš številko, jo izmeri tam, kjer bo tvoja aplikacija dejansko tekla. Spodnja funkcija meri čas do prihoda prvega fragmenta in ga primerja z zahtevanim ciljem.
import time
async def measure_latency(source_audio, delay_ms):
"""Izmeri dejansko zakasnitev prepisa."""
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"Prvo besedilo po {latency:.0f} ms "
f"(cilj: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nSkupno trajanje: {time.time() - start:.1f}s")
To meritev zaženi z 240, nato 800 in nato 2.400 milisekundami na istem odlomku ter preberi tri prepise drug ob drugem. Razlika v kakovosti med prvim in zadnjim ti bo bolje kot katero koli splošno priporočilo povedala, kakšno zakasnitev si lahko tvoja aplikacija privošči.
Ključne ugotovitve
target_streaming_delay_msnadzira kompromis med zakasnitvijo in točnostjo- Nizke vrednosti (80 do 300 ms): odzivno, a manj natančno
- Visoke vrednosti (1.200 ms ali 2.400 ms): natančno, a z zaznavno zakasnitvijo; sprejete so samo vrednosti od 80 do 1.200 in 2.400
- Vzorec Dual Delay združuje dva pretoka za odzivnost IN natančnost
- Hitri pretok daje takojšnjo povratno informacijo, počasni pretok popravlja besedilo
- Zakasnitev izberi glede na svoj primer uporabe (glasovni pomočnik proti podnapisom)