Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

A késleltetés szabályozása

12. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. A késleltetés és a pontosság közötti kompromisszum
  2. A target_streaming_delay_ms paraméter
  3. A Dual Delay (Kettős Késleltetés) minta
  4. A képernyőn történő felülírás kezelése
  5. A megfelelő késleltetés kiválasztása a használati esetedhez
  6. Az elért tényleges késleltetés mérése
  7. Főbb megállapítások

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 a voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 és voxtral-mini-tts-3-0 veszi át. Főbb változások: az időbélyegzés kizárólag szegmensenként történik (a word paramé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, a context_bias bemenetek 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 esetAjánlott késleltetésOk
Hangasszisztens200–300 msA felhasználó azonnali reakciót vár
Hangdiktálás500–800 msEgyensúly a reakciókészség és a pontosság között
Élő feliratozás800–1200 msA pontosság fontos, a csekély késés elfogadható
Konferencia-átírás1200 vagy 2400 msMaximá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_ms szabá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)