A késleltetés szabályozása
Ezen az oldalon
A tanfolyam frissítve: 2026. november 3., Voxtral 3 verzió, a Mistral Migrate from Voxtral 2 útmutatója alapján: a 2026. október 31-én elavult és 2027. április 30-án kivont Voxtral 2 modellek (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603) helyét a példákban avoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3ésvoxtral-mini-tts-3-0veszi át. Főbb változások: az időbélyegzés kizárólag szegmensenként történik (awordparaméter 400-as hibát eredményez), a valós idejű beszélőmegkülönböztetés lehetséges, a valós idejű munkamenet beállításai az első hangcsomag után rögzülnek, acontext_biasbemenetek pedig kötötlen szövegek (szóközöket tartalmazó kifejezések). Források: Migrate from Voxtral 2 · Speech to Text.
A késleltetés és a pontosság közötti kompromisszum
A valós idejű átírás egy elkerülhetetlen kompromisszumon alapul: a válaszsebesség a pontosság rovására megy. Minél tovább vár a modell egy szó kibocsátása előtt, annál több kontextusa van ahhoz, hogy megkülönböztesse a hasonló akusztikai hipotéziseket – és annál tovább vár a felhasználód. Egy olyan kifejezés, mint a „he took the sea“ (a tengerhez ment) szemben a „he took the bitter“ (a keserűt választotta) esetében, csak a következő szövegrészből válhat egyértelművé; egy kapkodó modell néha rosszul választ.
A Voxtral Realtime nem rejti el ezt a kompromisszumot egy automatikus beállítás mögé: kifejezetten a kezedbe adja a döntést a target_streaming_delay_ms paraméteren keresztül. Te döntöd el az egyensúlyi pontot, esetről esetre.
A target_streaming_delay_ms paraméter
Ez az érték milliszekundumban adja meg a célzott késleltetést a hang fogadása és a megfelelő szöveg kibocsátása között. A Voxtral 3 esetében bármely 80 és 1200 közötti egész számot elfogad, illetve a 2400-at; bármely más érték hibaeseményt vált ki. Ezt közvetlenül a streaming hívásnak adod át, ugyanúgy, mint a modellt és a hangformátumot, és mint minden munkamenet-beállítás, ez is rögzül az első hangcsomag után:
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)
# Alacsony késleltetés: gyors válasz, kevésbé pontos
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)
Három értéktartomány lefedi szinte az összes használati esetet. 200 és 300 milliszekundum között az átírás ultra-gyors reakcióidejű: ez a beállítás a hangalapú asszisztensekhez való, ahol a közvetlenség a legfontosabb, és a szöveg több javítást tartalmazhat. 500 és 1000 milliszekundum között jó egyensúlyt kapsz, ami élő feliratozáshoz és diktáláshoz alkalmas. Efelett, 2000 és 3000 milliszekundum között, a modell sokkal több kontextussal dolgozik, és jelentősen tisztább szöveget állít elő, annak a felhasználó által is észlelt késésnek az árán.
A Dual Delay (Kettős Késleltetés) minta
Tényleg választanod kell? A Voxtral Realtime kínál egy kiskaput: indíts két streamet párhuzamosan ugyanazon a hanganyagon, eltérő késleltetéssel, és így utasítsd el a kompromisszumot. A gyors stream, amelyet például 240 milliszekundumra állítasz, azonnali vizuális visszajelzést ad, ami megnyugtatja a felhasználót, és mutatja, hogy a rendszer figyel. A lassú stream, amelyet 2400 milliszekundumra állítasz, pontosabb átírást produkál, amely fokozatosan felváltja az ideiglenes szöveget.
Ismered ezt a viselkedést, még ha nem is nevezted így: így működnek az élő feliratok a YouTube-on vagy a Google Meeten, ahol a szöveg szinte azonnal megjelenik, majd néhány pillanattal később kijavítja önmagát. A megvalósítás két, a késleltetés kivételével azonos korutin definiálását, majd ezek együttes futtatását jelenti az asyncio.gather segítségével.
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ét átírást futtat párhuzamosan, eltérő késleltetéssel."""
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)
# Azonnali megjelenítés (a lassú stream felülírja)
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)
# Javított verzió megjelenítése
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Mindkét stream párhuzamos futtatása
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Vedd figyelembe, hogy a függvény két különálló hangforrást kap, nem egyet: egy aszinkron generátor csak egyszer fogyasztható el, így a streamet upstream meg kell dupláznod, hogy mindkét átírást ellásd adatokkal.
A képernyőn történő felülírás kezelése
Egy terminálban a fenti kód kimenete elég a mechanizmus megértéséhez, de egy valódi felületnek egyesítenie kell a két streamet egyetlen, olvasható szöveggé. A bevett konvenció az ideiglenes szöveg halvány árnyalatban (szürke), a megerősített szöveget pedig fehérrel megjeleníteni, ahol a határvonal a lassú stream utolérésekor halad előre. Az alábbi osztály ezt a határt kezeli a final_position változóval: minden, ami ez előtt van, a lassú streamből származik és nem változik; minden, ami utána következik, a gyors streamből jön, és még javításra szorulhat.
class DualLatencyDisplay:
"""Kijelzés kezelése kettős késleltetéssel."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Új szöveg a gyors streamből (ideiglenes)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Új szöveg a lassú streamből (végleges)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Megjeleníti a végleges szöveget plusz a még nem megerősített gyors szöveget."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Ennek a kényelemnek ára van, amit nem lenne becsületes figyelmen kívül hagyni: két stream két kapcsolatot és kétszer akkora feldolgozandó hangmennyiséget jelent. A Dual Delay mintát olyan felületeknek tartogasd, ahol a felhasználó valós időben olvassa a szöveget; háttérfeldolgozásra egy jól behangolt egyetlen stream több mint elég.
A megfelelő késleltetés kiválasztása a használati esetedhez
| Használati eset | Ajánlott késleltetés | Ok |
|---|---|---|
| Hangasszisztens | 200–300 ms | A felhasználó azonnali reakciót vár |
| Hangdiktálás | 500–800 ms | Egyensúly a reakciókészség és a pontosság között |
| Élő feliratozás | 800–1200 ms | A pontosság fontos, a csekély késés elfogadható |
| Konferencia-átírás | 1200 vagy 2400 ms | Maximális pontosság, a késés nem kritikus |
Az elért tényleges késleltetés mérése
A kért érték egy cél, nem garancia: a hálózati távolság, a szolgáltatás terheltsége és a csomagméreted mind hozzáadódnak ehhez. Mielőtt számot mondanál a felhasználóidnak, mérd meg ezt onnan, ahol az alkalmazásod valójában futni fog. Az alábbi függvény méri a késleltetést az első töredék megérkezéséig, és összehasonlítja azt a kért céllal.
import time
async def measure_latency(source_audio, delay_ms):
"""Méri az átírás tényleges késleltetését."""
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"First text after {latency:.0f} ms "
f"(target: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nTotal duration: {time.time() - start:.1f}s")
Futtasd ezt a mérést 240, majd 800, végül 2400 milliszekundummal ugyanazon a részleten, és olvasd össze a három átírást egymás mellett. A minőségbeli különbség az első és az utolsó között jobban megmutatja, mint bármely általános ajánlás, mekkora késleltetést engedhet meg magának az alkalmazásod.
Főbb megállapítások
- A
target_streaming_delay_msszabályozza a késleltetés és a pontosság közötti kompromisszumot - Alacsony értékek (80–300 ms): gyors reakció, de kevésbé pontos
- Magas értékek (1200 ms vagy 2400 ms): pontos, de észlelhető késéssel; csak a 80–1200 közötti és a 2400 értékek elfogadottak
- A Dual Delay minta két streamet kombinál a reakciókészség ÉS a pontosság érdekében
- A gyors stream azonnali visszajelzést ad, a lassú stream kijavítja a szöveget
- A késleltetést a használati eseted alapján válaszd meg (hangasszisztens vs. feliratozás)