Kontrola kašnjenja
Na ovoj stranici
Tečaj ažuriran 3. studenoga 2026. za Voxtral 3, na temelju Mistralovog vodiča Migrate from Voxtral 2: modeli Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), zastarjeli 31. listopada 2026. i povučeni 30. travnja 2027., zamijenjeni su u primjerima svoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ivoxtral-mini-tts-3-0. Ključne promjene: vremenske oznake samo po segmentima (wordvraća grešku 400), dijatizacija u stvarnom vremenu je moguća, postavke sesije u stvarnom vremenu zaključane su nakon prvog audio isječka, a unosicontext_biassu slobodnog oblika (fraze s razmacima). Izvori: Migrate from Voxtral 2 · Speech to Text.
Kompromis između kašnjenja i točnosti
Transkripcija u stvarnom vremenu oslanja se na kompromis kojeg ne možeš izbjeći: brzina odgovora ide na uštrb točnosti. Što duže model čeka prije emitiranja riječi, to ima više konteksta za razlikovanje sličnih akustičkih hipoteza – i to duže tvoj korisnik čeka. Fraza poput „uzeo je more“ naspram „uzeo je gorko“ možda će postati jasna tek iz onoga što slijedi; požuren model ponekad će odabrati pogrešnu.
Voxtral Realtime ne skriva ovaj kompromis iza automatske postavke: stavlja ga ti izričito na raspolaganje putem parametra target_streaming_delay_ms. Ti odlučuješ o točki ravnoteže, slučaj po slučaj.
Parametar target_streaming_delay_ms
Ova vrijednost izražava u milisekundama ciljno kašnjenje između primanja zvuka i emitiranja odgovarajućeg teksta. S Voxtralom 3, prihvaća bilo koji cijeli broj od 80 do 1.200 ili 2.400; bilo koja druga vrijednost pokreće događaj greške. Proslijeđuješ ga izravno pozivu strujanja (streaming), baš kao i model te audio format, a poput svih postavki sesije, zaključava se nakon prvog audio isječka:
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)
# Nisko kašnjenje: brz odgovor, manje toč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 raspona vrijednosti pokrivaju gotovo sve slučajeve upotrebe. Između 200 i 300 milisekundi transkripcija je ultra-odgovorna: ovo je postavka za glasovne asistente, gdje je neposrednost najvažnija, a tekst može sadržavati više ispravaka. Između 500 i 1.000 milisekundi dobivaš dobru ravnotežu, prikladnu za titlove uživo i diktat. Iznad toga, između 2.000 i 3.000 milisekundi, model radi s puno više konteksta i proizvodi znatno čistiji tekst, uz cijenu kašnjenja koje korisnik jasno percipira.
Uzorak dvostrukog kašnjenja (Dual Delay)
Moraš li doista birati? Voxtral Realtime nudi zaobilazno rješenje: pokreni dva strujanja paralelno na istom zvuku, s različitim kašnjenjima, i time odbij kompromis. Brzo strujanje, postavljeno primjerice na 240 milisekundi, daje trenutnu vizualnu povratnu informaciju koja smiruje korisnika i pokazuje da sustav sluša. Sporo strujanje, postavljeno na 2.400 milisekundi, proizvodi točniju transkripciju koja postupno zamjenjuje privremeni tekst.
Poznaš ovo ponašanje čak i ako ga nisi imenovao: tako rade titlovi uživo na YouTubeu ili Google Meetu, gdje se tekst pojavljuje gotovo trenutno, a zatim se ispravlja nekoliko trenutaka kasnije. Implementacija uključuje definiranje dviju korutina identičnih osim po kašnjenju, a zatim njihovo zajedničko pokretanje s 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):
"""Pokreće dvije transkripcije paralelno s različitim kašnjenjima."""
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)
# Prikaži odmah (bit će zamijenjeno sporim strujanjem)
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)
# Prikaži ispravljenu verziju
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Pokreni oba strujanja paralelno
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Imaj na umu da funkcija prima dva odvojena audio izvora, a ne jedan: asinkroni generator može se potrošiti samo jednom, stoga moraš duplicirati strujanje uzvodno kako bi nahranio obje transkripcije.
Rukovanje zamjenom na zaslonu
U terminalu je dvostruki izlaz iz gornjeg koda dovoljan za razumijevanje mehanizma, ali stvarno sučelje mora spojiti dva strujanja u jedan čitljiv tekst. Ustaljena konvencija je prikazivanje privremenog teksta u suptilnoj nijansi – sivoj – a potvrđenog teksta u bijeloj boji, pri čemu se granica između njih pomiče kako sporo strujanje sustiže brzo. Donja klasa implementira ovu granicu s final_position: sve prije toga dolazi iz sporog strujanja i neće se mijenjati, sve nakon toga dolazi iz brzog strujanja i podložno je ispravcima.
class DualLatencyDisplay:
"""Upravlja prikazom s dvostrukim kašnjenjem."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Novi tekst iz brzog strujanja (privremeni)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Novi tekst iz sporog strujanja (konačni)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Prikazuje konačni tekst + brzi tekst koji još nije potvrđen."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Ova udobnost ima cijenu koju bi bilo nepošteno ignorirati: dva strujanja znače dvije veze i dvostruku količinu obrađenog zvuka. Rezerviraj Dual Delay za sučelja gdje korisnik čita tekst dok se događa; za pozadinsku obradu, jedno dobro podešeno strujanje je više nego dovoljno.
Odabir pravog kašnjenja za tvoj slučaj upotrebe
| Slučaj upotrebe | Preporučeno kašnjenje | Razlog |
|---|---|---|
| Glasovni asistent | 200–300 ms | Korisnik očekuje trenutnu reakciju |
| Glasovni diktat | 500–800 ms | Ravnoteža između odzivnosti i točnosti |
| Titlovi uživo | 800–1.200 ms | Točnost je važna, malo kašnjenje je prihvatljivo |
| Transkripcija konferencije | 1.200 ili 2.400 ms | Maksimalna točnost, kašnjenje nije kritično |
Mjerenje stvarno postignutog kašnjenja
Vrijednost koju zatražiš je cilj, a ne jamstvo: udaljenost mreže, opterećenje usluge i veličina tvojih isječaka tome dodaju svoj doprinos. Prije nego što navedeš broj svojim korisnicima, izmjeri ga s mjesta gdje će se tvoja aplikacija zapravo izvršavati. Donja funkcija mjeri vrijeme kašnjenja dok ne stigne prvi fragment i uspoređuje ga sa zatraženim ciljem.
import time
async def measure_latency(source_audio, delay_ms):
"""Mjeri stvarno kašnjenje transkripcije."""
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"Prvi tekst nakon {latency:.0f} ms "
f"(cilj: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nUkupno trajanje: {time.time() - start:.1f}s")
Pokreni ovo mjerenje s 240, zatim 800, pa 2.400 milisekundi na istom isječku i pročitaj tri transkripcije jednu uz drugu. Razlika u kvaliteti između prve i zadnje reći će ti, bolje od bilo koje opće preporuke, koje kašnjenje tvoja aplikacija može priuštiti.
Ključne točke
target_streaming_delay_mskontrolira kompromis između kašnjenja i točnosti- Niske vrijednosti (80 do 300 ms): odzivne, ali manje točne
- Visoke vrijednosti (1.200 ms ili 2.400 ms): točne, ali s percipibilnim kašnjenjem; prihvaćene su samo vrijednosti od 80 do 1.200 i 2.400
- Uzorak Dual Delay kombinira dva strujanja za odzivnost I točnost
- Brzo strujanje daje trenutnu povratnu informaciju, sporo strujanje ispravlja tekst
- Odaberi kašnjenje na temelju svog slučaja upotrebe (glasovni asistent naspram titlova)