Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Nadzor zakasnitve

Lekcija 12 od 16 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Kompromis med zakasnitvijo in točnostjo
  2. Parameter target_streaming_delay_ms
  3. Vzorec dvojne zakasnitve (Dual Delay)
  4. Ravnanje z zamenjavo na zaslonu
  5. Izbira prave zakasnitve za tvojo uporabo
  6. Merjenje dejanske dosežene zakasnitve
  7. Ključne ugotovitve

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 z voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 in voxtral-mini-tts-3-0. Ključne spremembe: časovni žigi samo po segmentih (word vrne napako 400), diarizacija v realnem času je mogoča, nastavitve seje v realnem času so zaklenjene po prvem zvočnem delčku, vnosi context_bias pa 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 uporabePriporočena zakasnitevRazlog
Glasovni pomočnik200–300 msUporabnik pričakuje takojšen odziv
Glasovno diktiranje500–800 msRavnovesje med odzivnostjo in točnostjo
Podnapisi v živo800–1.200 msTočnost je pomembna, majhna zakasnitev je sprejemljiva
Prepis konferenc1.200 ali 2.400 msNajveč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_ms nadzira 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)