Latenzi juhtimine
Sellel lehel
Kursust uuendati 3. novembril 2026 Voxtral 3 jaoks, tuginedes Mistrali juhendile Migrate from Voxtral 2: Voxtral 2 mudelid (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), mis tunnistati aegunuks 31. oktoobril 2026 ja eemaldatakse kasutusest 30. aprillil 2027, on näidetes asendatud mudelitegavoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3javoxtral-mini-tts-3-0. Peamised muudatused: ajatemplid ainult lõigu kaupa (wordtagastab vea 400), reaalajas kõneleja eristamine on võimalik, reaalajas seansi seaded lukustuvad pärast esimest helilõiku jacontext_biassisendid on vabas vormingus (fraasid tühikutega). Allikad: Migrate from Voxtral 2 · Speech to Text.
Latentsuse ja täpsuse vaheline kompromiss
Reaalajas transkriptsioon põhineb vältimatul kompromissil: kiirus maksab täpsuse arvelt. Mida kauem mudel ootab enne sõna väljastamist, seda rohkem konteksti tal on sarnaste akustiliste hüpoteeside eristamiseks – ja seda kauem peab kasutaja ootama. Fraas nagu „he took the sea“ versus „he took the bitter“ võib selguda alles järgneva teksti põhjal; liiga kiirustav mudel valib mõnikord vale variandi.
Voxtral Realtime ei peida seda kompromissi automaatse seade taha: see annab selle sulle otseselt kätte parameetri target_streaming_delay_ms kaudu. Sina otsustad tasakaalupunkti, juhtum haaval.
Parameeter target_streaming_delay_ms
See väärtus väljendab millisekundites sihtviidet heli vastuvõtmise ja vastava teksti väljastamise vahelisele viivitusele. Voxtral 3 puhul aktsepteerib see suvalist täisarvu vahemikus 80 kuni 1200 või väärtust 2400; iga muu väärtus käivitab veasündmuse. Sa edastad selle otse voogedastuse väljakutsele, täpselt nagu mudeli ja helivormingu, ning nagu kõik seansi seaded, lukustub see pärast esimest helilõiku:
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)
# Madal latentsus: kiire vastus, vähem täpne
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)
Kolm väärtuste vahemikku katavad peaaegu kõik kasutusjuhud. Vahemikus 200 kuni 300 millisekundit on transkriptsioon ülikiire: see on seade häälteabistajatele, kus vahetu reaktsioon on kõige olulisem ja tekst võib sisaldada rohkem parandusi. Vahemikus 500 kuni 1000 millisekundit saad hea tasakaalu, mis sobib otseülekande subtiitriteks ja dikteerimiseks. Sellest kaugemal, vahemikus 2000 kuni 3000 millisekundit, töötab mudel palju suurema kontekstiga ja toodab oluliselt puhtamat teksti, kuid kasutaja tajub selgelt viivitust.
Topeltviivituse muster (Dual Delay)
Kas sa pead tõesti valima? Voxtral Realtime pakub lahendust: käivita samale helile paralleelselt kaks voogu erineva latentsusega ja keeldu seeläbi kompromissist. Kiire voog, seatud näiteks 240 millisekundile, annab kohese visuaalse tagasiside, mis rahustab kasutajat ja näitab, et süsteem kuulab. Aeglane voog, seatud 2400 millisekundile, toodab täpsema transkriptsiooni, mis asendab järk-järgult esialgset teksti.
Sa tunned seda käitumist isegi siis, kui sa seda pole nimega nimetanud: nii toimivad otseülekande subtiitrid YouTube’is või Google Meetis, kus tekst ilmub peaaegu kohe ja parandab ennast mõni hetk hiljem. Rakendamine eeldab kahe korutiini defineerimist, mis on identsed välja arvatud viivitus, ning nende koos käivitamist funktsiooniga 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):
"""Käivitab kaks transkriptsiooni paralleelselt erineva latentsusega."""
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)
# Kuva kohe (aeglane voog asendab selle hiljem)
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)
# Kuva parandatud versioon
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Käivita mõlemad vood paralleelselt
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Pane tähele, et funktsioon saab vastu kaks eraldiseisvat heliallikat, mitte ühte: asünkroonset generaatorit saab tarbida ainult üks kord, seega pead voogu ülesvoolu dubleerima, et toita mõlemat transkriptsiooni.
Ekraanil asendamise haldamine
Terminalis piisab ülaltoodud koodi topeltväljundist mehhanismi mõistmiseks, kuid tegelik kasutajaliides peab liitma kaks voogu üheks loetavaks tekstiks. Väljakujunenud konventsioon on kuvada esialgne tekst peenes toonis – hallina – ja kinnitatud tekst valgena, kusjuures piir nende vahel liigub edasi, kui aeglane voog jõuab kiirele järele. Allpool olev klass rakendab seda piiri muutujaga final_position: kõik, mis on sellest eespool, pärineb aeglasest voost ja ei muutu; kõik, mis on tagapool, pärineb kiirest voost ja on endiselt parandamisele avatud.
class DualLatencyDisplay:
"""Haldab kuva topeltviivitusega."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Uus tekst kiirest voost (esialgne)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Uus tekst aeglasest voost (lõplik)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Kuvab lõpliku teksti + veel kinnitamata kiire teksti."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
See mugavus tuleb hinnaga, mida oleks ebaaus eirata: kaks voogu tähendavad kahte ühendust ja kaks korda suuremat töödeldava heli mahtu. Kasuta topeltviivitust (Dual Delay) liidestes, kus kasutaja loeb teksti selle tekkimise hetkel; taustatöötluseks piisab ühest hästi häälestatud voost.
Õige latentsuse valimine sinu kasutusjuhuks
| Kasutusjuht | Soovitatav latentsus | Põhjus |
|---|---|---|
| Häälteabistaja | 200–300 ms | Kasutaja ootab koheseid reaktsioone |
| Häälte dikteerimine | 500–800 ms | Tasakaal reageerimisvõime ja täpsuse vahel |
| Otseülekande subtiitrid | 800–1200 ms | Täpsus on oluline, väike viivitus on vastuvõetav |
| Konverentsi transkriptsioon | 1200 või 2400 ms | Maksimaalne täpsus, viivitus pole kriitiline |
Tegelikult saavutatud latentsuse mõõtmine
Väärtus, mida sa taotled, on sihtmärk, mitte garantii: võrgu kaugus, teenuse koormus ja sinu lõigu suurus lisavad sellele omalt poolt. Enne kui lubad kasutajatele kindlat numbrit, mõõda see kohast, kus sinu rakendus tegelikult töötab. Allpool olev funktsioon ajastab viivituse kuni esimese fragmendi saabumiseni ja võrdleb seda taotletud sihtmärgiga.
import time
async def measure_latency(source_audio, delay_ms):
"""Mõõdab transkriptsiooni tegelikku latentsust."""
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"Esimene tekst pärast {latency:.0f} ms "
f"(siht: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nKogukestus: {time.time() - start:.1f}s")
Käivita see mõõtmine väärtustega 240, seejärel 800 ja lõpuks 2400 millisekundit sama lõigu peal ning loe kolme transkriptsiooni kõrvuti. Kvaliteedivahe esimese ja viimase vahel ütleb sulle paremini kui ükski üldine soovitus, millist latentsust sinu rakendus endale lubada saab.
Peamised punktid
target_streaming_delay_mskontrollib latentsuse ja täpsuse vahelist kompromissi- Madalad väärtused (80 kuni 300 ms): reageerimisvõimeline, kuid vähem täpne
- Kõrged väärtused (1200 ms või 2400 ms): täpne, kuid tajutava viivitusega; aktsepteeritakse ainult väärtusi vahemikus 80–1200 ja 2400
- Topeltviivituse muster (Dual Delay) ühendab kaks voogu nii reageerimisvõime kui ka täpsuse saavutamiseks
- Kiire voog annab kohese tagasiside, aeglane voog parandab teksti
- Vali latentsus vastavalt oma kasutusjuhule (häälteabistaja vs subtiitrid)