Kontrola opóźnień
Na tej stronie
Kurs zaktualizowany 3 listopada 2026 r. dla Voxtral 3, na podstawie przewodnika Mistral Migrate from Voxtral 2: modele Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), wycofane 31 października 2026 r. i usuwane 30 kwietnia 2027 r., zostały zastąpione w przykładach przezvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3orazvoxtral-mini-tts-3-0. Kluczowe zmiany: znaczniki czasu tylko dla segmentów (wordzwraca błąd 400), diarization w czasie rzeczywistym jest możliwy, ustawienia sesji w czasie rzeczywistym są blokowane po pierwszym fragmencie audio, a dane wejściowecontext_biasmają dowolny format (frazy ze spacjami). Źródła: Migrate from Voxtral 2 · Speech to Text.
Kompromis między opóźnieniem a dokładnością
Transkrypcja w czasie rzeczywistym opiera się na kompromisie, którego nie da się uniknąć: szybkość odpowiedzi okupiona jest kosztem dokładności. Im dłużej model czeka przed wyemitowaniem słowa, tym więcej kontekstu posiada, aby rozróżnić podobne hipotezy akustyczne – i tym dłużej czeka Twój użytkownik. Fraza taka jak „he took the sea“ kontra „he took the bitter“ może stać się jasna dopiero dzięki temu, co następuje później; pospieszny model czasami wybierze niewłaściwą opcję.
Voxtral Realtime nie ukrywa tego kompromisu za automatycznym ustawieniem: przekazuje go Tobie explicite poprzez parametr target_streaming_delay_ms. To Ty decydujesz o punkcie równowagi, przypadek po przypadku.
Parametr target_streaming_delay_ms
Wartość ta wyraża w milisekundach docelowe opóźnienie między otrzymaniem audio a wyemitowaniem odpowiadającego mu tekstu. W Voxtral 3 akceptuje ona dowolną liczbę całkowitą od 80 do 1200 lub 2400; każda inna wartość wyzwala zdarzenie błędu. Przekazujesz ją bezpośrednio do wywołania strumieniowego, tak jak model i format audio, a podobnie jak wszystkie ustawienia sesji, jest ona blokowana po pierwszym fragmencie audio:
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)
# Niskie opóźnienie: szybka odpowiedź, mniejsza dokładność
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)
Trzy zakresy wartości pokrywają niemal wszystkie przypadki użycia. Między 200 a 300 milisekundami transkrypcja jest ultra-responsywna: to ustawienie dla asystentów głosowych, gdzie natychmiastowość jest najważniejsza, a tekst może zawierać więcej poprawek. Między 500 a 1000 milisekundami uzyskujesz dobry balans, odpowiedni do napisów na żywo i dyktowania. Powyżej tego, między 2000 a 3000 milisekundami, model pracuje z znacznie większym kontekstem i generuje znacznie czystszy tekst, kosztem opóźnienia wyraźnie odczuwalnego przez użytkownika.
Wzorzec Dual Delay
Czy naprawdę musisz wybierać? Voxtral Realtime oferuje obejście: uruchom dwa strumienie równolegle na tym samym audio, z różnymi opóźnieniami, i tym samym odrzuć kompromis. Szybki strumień, ustawiony np. na 240 milisekund, zapewnia natychmiastową informację zwrotną wizualną, która uspokaja użytkownika i pokazuje, że system słucha. Wolny strumień, ustawiony na 2400 milisekund, produkuje dokładniejszą transkrypcję, która stopniowo zastępuje tekst tymczasowy.
Znasz to zachowanie, nawet jeśli nie nadałeś mu nazwy: tak działają napisy na żywo w YouTube czy Google Meet, gdzie tekst pojawia się niemal natychmiast, a następnie koryguje się kilka chwil później. Implementacja polega na zdefiniowaniu dwóch korytin identycznych z wyjątkiem opóźnienia, a następnie uruchomieniu ich razem za pomocą 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):
"""Uruchamia dwie transkrypcje równolegle z różnymi opóźnieniami."""
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)
# Wyświetl natychmiast (zostanie zastąpione przez wolny strumień)
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)
# Wyświetl poprawioną wersję
print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
flush=True)
# Uruchom oba strumienie równolegle
await asyncio.gather(fast_stream(), slow_stream())
return {
"fast": "".join(results["fast"]),
"slow": "".join(results["slow"])
}
Zauważ, że funkcja otrzymuje dwa oddzielne źródła audio, a nie jedno: generator asynchroniczny może być zużyty tylko raz, więc musisz zduplikować strumień wcześniej (upstream), aby zasilić obie transkrypcje.
Obsługa zastępowania tekstu na ekranie
W terminalu podwójne wyjście z powyższego kodu wystarczy, aby zrozumieć mechanizm, ale rzeczywisty interfejs musi połączyć dwa strumienie w jeden, czytelny tekst. Ustalona konwencja polega na wyświetlaniu tekstu tymczasowego w subtelnym odcieniu – szarym – a tekstu potwierdzonego na biało, przy czym granica między nimi przesuwa się w miarę jak wolny strumień dogania szybki. Poniższa klasa implementuje tę granicę za pomocą final_position: wszystko przed nią pochodzi z wolnego strumienia i się nie zmieni, wszystko po niej pochodzi ze szybkiego strumienia i nadal podlega korekcie.
class DualLatencyDisplay:
"""Zarządza wyświetlaniem z podwójnym opóźnieniem."""
def __init__(self):
self.fast_text = ""
self.final_text = ""
self.final_position = 0
def on_fast_text(self, text: str):
"""Nowy tekst ze szybkiego strumienia (tymczasowy)."""
self.fast_text += text
self._display()
def on_slow_text(self, text: str):
"""Nowy tekst z wolnego strumienia (ostateczny)."""
self.final_text += text
self.final_position = len(self.final_text)
self._display()
def _display(self):
"""Wyświetla tekst ostateczny + tekst szybki jeszcze niepotwierdzony."""
provisional_text = self.fast_text[self.final_position:]
display = self.final_text + provisional_text
print(f"\r{display}", end="", flush=True)
Ten komfort ma koszt, którego nie byłoby uczciwie ignorować: dwa strumienie oznaczają dwa połączenia i dwukrotnie większą objętość przetwarzanego audio. Rezerwuj wzorzec Dual Delay dla interfejsów, w których użytkownik czyta tekst w miarę jego powstawania; do przetwarzania w tle jeden dobrze dostrojony strumień w zupełności wystarczy.
Wybór odpowiedniego opóźnienia dla Twojego przypadku użycia
| Przypadek użycia | Zalecane opóźnienie | Powód |
|---|---|---|
| Asystent głosowy | 200–300 ms | Użytkownik oczekuje natychmiastowej reakcji |
| Dyktowanie głosowe | 500–800 ms | Balans między responsywnością a dokładnością |
| Napisy na żywo | 800–1200 ms | Dokładność ważna, niewielkie opóźnienie akceptowalne |
| Transkrypcja konferencji | 1200 lub 2400 ms | Maksymalna dokładność, opóźnienie niekrytyczne |
Pomiar faktycznie osiągniętego opóźnienia
Wartość, której żądasz, jest celem, a nie gwarancją: odległość sieciowa, obciążenie usługi i rozmiar Twoich fragmentów (chunków) wszystko to do niego dodają. Zanim podasz liczbę swoim użytkownikom, zmierz ją z miejsca, w którym faktycznie będzie działać Twoja aplikacja. Poniższa funkcja mierzy czas do przyjścia pierwszego fragmentu i porównuje go z żądanym celem.
import time
async def measure_latency(source_audio, delay_ms):
"""Mierzy efektywne opóźnienie transkrypcji."""
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"Pierwszy tekst po {latency:.0f} ms "
f"(cel: {delay_ms} ms)")
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
print(f"\nCałkowity czas trwania: {time.time() - start:.1f}s")
Uruchom ten pomiar dla 240, następnie 800, a potem 2400 milisekund na tym samym fragmencie i przeczytaj trzy transkrypcje obok siebie. Różnica w jakości między pierwszą a ostatnią powie Ci lepiej niż jakakolwiek ogólna rekomendacja, na jakie opóźnienie może sobie pozwolić Twoja aplikacja.
Kluczowe wnioski
target_streaming_delay_mskontroluje kompromis między opóźnieniem a dokładnością- Niskie wartości (od 80 do 300 ms): responsywne, ale mniej dokładne
- Wysokie wartości (1200 ms lub 2400 ms): dokładne, ale z odczuwalnym opóźnieniem; akceptowane są tylko wartości od 80 do 1200 oraz 2400
- Wzorzec Dual Delay łączy dwa strumienie, aby uzyskać zarówno responsywność, JAK I dokładność
- Szybki strumień daje natychmiastową informację zwrotną, wolny strumień koryguje tekst
- Wybierz opóźnienie w zależności od przypadku użycia (asystent głosowy kontra napisy)