Valdymo delsos
Šiame puslapyje
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 modeliaisvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3irvoxtral-mini-tts-3-0. Pagrindiniai pokyčiai: laiko žymėjimas tik pagal segmentus (wordgrąžina 400 klaidą), galima realaus laiko diarizacija, realaus laiko sesijos nustatymai užrakinami po pirmojo garso fragmento, ocontext_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 atvejis | Rekomenduojama delsa | Priežastis |
|---|---|---|
| Balso asistentas | 200–300 ms | Naudotojas tikisi neatidėliotinos reakcijos |
| Balso diktavimas | 500–800 ms | Balansas tarp reaktyvumo ir tikslumo |
| Tiesioginiai subtitrai | 800–1 200 ms | Tikslumas svarbus, nedidelė delsa priimtina |
| Konferencijų transkripcija | 1 200 arba 2 400 ms | Maksimalus 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_msvaldo 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)