Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Valdymo delsos

Paskaita 12 iš 16 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Delsos ir tikslumo kompromisas
  2. Parametras target_streaming_delay_ms
  3. „Dual Delay“ šablonas
  4. Ekrane rodomo pakeitimo valdymas
  5. Tinkamos delsos pasirinkimas tavo atvejui
  6. Faktinės pasiektos delsos matavimas
  7. Svarbiausi punktai

Kursas atnaujintas 2026 m. lapkričio 3 d. Voxtral 3 versijai, remiantis „Mistral“ vadovu Migrate from Voxtral 2: Voxtral 2 modeliai (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), pasenę 2026 m. spalio 31 d. ir pašalinti 2027 m. balandžio 30 d., pavyzdžiuose pakeisti modeliais voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 ir voxtral-mini-tts-3-0. Pagrindiniai pokyčiai: laiko žymėjimas tik pagal segmentus (word grąžina 400 klaidą), galima realaus laiko diarizacija, realaus laiko sesijos nustatymai užrakinami po pirmojo garso fragmento, o context_bias įvestys yra laisvos formos (frazės su tarpais). Šaltiniai: Migrate from Voxtral 2 · Speech to Text.

Delsos ir tikslumo kompromisas

Transkripcija realiuoju laiku remiasi neišvengiamu kompromisu: atsako greitis kainuoja tikslumą. Kuo ilgiau modelis laukia prieš išvesdamas žodį, tuo daugiau konteksto jis turi, kad atskirtų panašias akustines hipotezes – ir tuo ilgiau tenka laukti naudotojui. Frazė „he took the sea“ („jis plaukė jūra“) prieš „he took the bitter“ („jis ragavo kartumo“) gali paaiškėti tik iš to, kas seka; per skubotas modelis kartais pasirinks neteisingą variantą.

„Voxtral Realtime“ neslepia šio kompromiso už automatinio nustatymo: jis perduoda jį tau tiesiogiai per parametrą target_streaming_delay_ms. Tu pats nusprendi, kur yra pusiausvyros taškas, kiekvienu atveju atskirai.

Parametras target_streaming_delay_ms

Ši reikšmė milisekundėmis išreiškia numatomą delsą tarp garso gavimo ir atitinkamo teksto išvedimo. Naudojant „Voxtral 3“, ji priima bet kokį sveikąjį skaičių nuo 80 iki 1 200 arba 2 400; bet kuri kita reikšmė sukelia klaidos įvykį. Jį perduodi tiesiogiai į srautinio perdavimo užklausą, lygiai taip pat kaip modelį ir garso formatą, ir, kaip visi sesijos nustatymai, jis užrakinamas po pirmojo garso fragmento:

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)

# Maža delsa: greitas atsakas, mažesnis tikslumas
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)

Trys reikšmių diapazonai apima beveik visus naudojimo atvejus. Nuo 200 iki 300 milisekundžių transkripcija yra itin reaktyvi: tai nustatymas balso asistentams, kur svarbiausias yra neatidėliotinas atsakas, o tekste gali būti daugiau taisymų. Nuo 500 iki 1 000 milisekundžių gaunamas geras balansas, tinkamas tiesioginėms subtitrams ir diktavimui. Viršijus šias ribas, tarp 2 000 ir 3 000 milisekundžių, modelis dirba su daug didesniu kontekstu ir kuria žymiai švaresnį tekstą, tačiau naudotojas aiškiai jaučia delsą.

„Dual Delay“ šablonas

Ar tikrai turi rinktis? „Voxtral Realtime“ siūlo apėjimo būdą: paleisk du srautus lygiagrečiai tame pačiame garso įraše, bet su skirtinga delsa, ir taip atsisakyk kompromiso. Greitas srautas, nustatytas, pavyzdžiui, 240 milisekundžių, suteikia neatidėliotiną vizualinį grįžtamąjį ryšį, kuris nuramina naudotoją ir parodo, kad sistema klauso. Lėtas srautas, nustatytas 2 400 milisekundžių, sukuria tikslesnę transkripciją, kuri palaipsniui pakeičia preliminarų tekstą.

Tu pažįsti šį elgesį, net jei jo nepavadini: taip veikia tiesioginiai subtitrai „YouTube“ arba „Google Meet“, kur tekstas atsiranda beveik akimirksniu, o po kelių akimirkų pasitaiso. Įgyvendinimas reiškia dviejų korutinų, identiškų išskyrus delsą, apibrėžimą ir jų paleidimą kartu naudojant 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):
    """Vydo dvi transkripcijas lygiagrečiai su skirtinga delsa."""
    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)
                # Rodyti iškart (bus pakeista lėto srauto)
                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)
                # Rodyti pataisytą versiją
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Paleisti abu srautus lygiagrečiai
    await asyncio.gather(fast_stream(), slow_stream())

    return {
        "fast": "".join(results["fast"]),
        "slow": "".join(results["slow"])
    }

Atkreipk dėmesį, kad funkcija gauna du atskirus garso šaltinius, o ne vieną: asinchroninis generatorius gali būti suvartotas tik vieną kartą, todėl turi dubliuoti srautą aukštesniame lygmenyje, kad maitintum abi transkripcijas.

Ekrane rodomo pakeitimo valdymas

Terminale aukščiau pateikto kodo dviguba išvestis pakankama mechanizmui suprasti, tačiau tikroje sąsajoje reikia sujungti du srautus į vieną, lengvai skaitomą tekstą. Nusistovėjusi konvencija yra rodyti preliminarų tekstą subtiliu atspalviu – pilkai, o patvirtintą tekstą – baltai, kai riba tarp jų slenka pirmyn, lėtam srautui genant greitąjį. Toliau pateikta klasė įgyvendina šią ribą naudodama final_position: viskas prieš ją yra iš lėto srauto ir nebesikeis, viskas po jos yra iš greito srauto ir vis dar gali būti taisoma.

class DualLatencyDisplay:
    """Valdo rodymą su dviguba delsa."""

    def __init__(self):
        self.fast_text = ""
        self.final_text = ""
        self.final_position = 0

    def on_fast_text(self, text: str):
        """Naujas tekstas iš greito srauto (preliminarus)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Naujas tekstas iš lėto srauto (galutinis)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Rodo galutinį tekstą + dar nepatvirtintą greitą tekstą."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Šis komfortas turi kainą, kurios būtų nesąžininga ignoruoti: du srautai reiškia du ryšius ir dvigubai daugiau apdorojamo garso kiekio. Naudok „Dual Delay“ tik tose sąsajose, kur naudotojas skaito tekstą jam atsirandant; foniniam apdorojimui visiškai pakanka vieno gerai sureguliuoto srauto.

Tinkamos delsos pasirinkimas tavo atvejui

Naudojimo atvejisRekomenduojama delsaPriežastis
Balso asistentas200–300 msNaudotojas tikisi neatidėliotinos reakcijos
Balso diktavimas500–800 msBalansas tarp reaktyvumo ir tikslumo
Tiesioginiai subtitrai800–1 200 msTikslumas svarbus, nedidelė delsa priimtina
Konferencijų transkripcija1 200 arba 2 400 msMaksimalus tikslumas, delsa nėra kritinė

Faktinės pasiektos delsos matavimas

Tavo prašoma reikšmė yra tikslas, o ne garantija: atstumas tinkle, serverio apkrova ir tavo fragmentų dydis ją didina. Prieš nurodydamas skaičių savo naudotojams, išmatuok jį ten, kur tavo programa iš tikrųjų veiks. Toliau pateikta funkcija matuoja delsą iki pirmojo fragmento atvykimo ir palygina ją su prašomu tikslu.

import time

async def measure_latency(source_audio, delay_ms):
    """Matuoja faktinę transkripcijos delsą."""
    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"Pirmas tekstas po {latency:.0f} ms "
                      f"(tikslas: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nBendra trukmė: {time.time() - start:.1f}s")

Paleisk šį matavimą su 240, tada 800, tada 2 400 milisekundžių tame pačiame ištraukoje ir gretink tris transkripcijas. Kokybės skirtumas tarp pirmosios ir paskutinės tau pasakys geriau nei bet kuri bendra rekomendacija, kokią delsą gali sau leisti tavo programa.

Svarbiausi punktai

  • target_streaming_delay_ms valdo delsos ir tikslumo kompromisą
  • Mažos reikšmės (nuo 80 iki 300 ms): reaktyvios, bet mažiau tikslios
  • Didelės reikšmės (1 200 ms arba 2 400 ms): tikslios, bet su juntama delsa; priimamos tik reikšmės nuo 80 iki 1 200 ir 2 400
  • „Dual Delay“ šablonas sujungia du srautus reaktyvumui IR tikslumui užtikrinti
  • Greitas srautas suteikia neatidėliotiną grįžtamąjį ryšį, lėtas srautas taiso tekstą
  • Pasirink delsą pagal savo naudojimo atvejį (balso asistentas prieš subtitrus)