Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Latenzi juhtimine

Õppetund 12 / 16 Värskendatud 3. november 2026 Arendajatele
Sellel lehel
  1. Latentsuse ja täpsuse vaheline kompromiss
  2. Parameeter target_streaming_delay_ms
  3. Topeltviivituse muster (Dual Delay)
  4. Ekraanil asendamise haldamine
  5. Õige latentsuse valimine sinu kasutusjuhuks
  6. Tegelikult saavutatud latentsuse mõõtmine
  7. Peamised punktid

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 mudelitega voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 ja voxtral-mini-tts-3-0. Peamised muudatused: ajatemplid ainult lõigu kaupa (word tagastab vea 400), reaalajas kõneleja eristamine on võimalik, reaalajas seansi seaded lukustuvad pärast esimest helilõiku ja context_bias sisendid 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

KasutusjuhtSoovitatav latentsusPõhjus
Häälteabistaja200–300 msKasutaja ootab koheseid reaktsioone
Häälte dikteerimine500–800 msTasakaal reageerimisvõime ja täpsuse vahel
Otseülekande subtiitrid800–1200 msTäpsus on oluline, väike viivitus on vastuvõetav
Konverentsi transkriptsioon1200 või 2400 msMaksimaalne 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_ms kontrollib 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)