Przejdź do głównej treści
Polski— Wybierz język
Menu

Kontrola opóźnień

Lekcja 12 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Kompromis między opóźnieniem a dokładnością
  2. Parametr target_streaming_delay_ms
  3. Wzorzec Dual Delay
  4. Obsługa zastępowania tekstu na ekranie
  5. Wybór odpowiedniego opóźnienia dla Twojego przypadku użycia
  6. Pomiar faktycznie osiągniętego opóźnienia
  7. Kluczowe wnioski

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 przez voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 oraz voxtral-mini-tts-3-0. Kluczowe zmiany: znaczniki czasu tylko dla segmentów (word zwraca błąd 400), diarization w czasie rzeczywistym jest możliwy, ustawienia sesji w czasie rzeczywistym są blokowane po pierwszym fragmencie audio, a dane wejściowe context_bias mają 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życiaZalecane opóźnieniePowód
Asystent głosowy200–300 msUżytkownik oczekuje natychmiastowej reakcji
Dyktowanie głosowe500–800 msBalans między responsywnością a dokładnością
Napisy na żywo800–1200 msDokładność ważna, niewielkie opóźnienie akceptowalne
Transkrypcja konferencji1200 lub 2400 msMaksymalna 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_ms kontroluje 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)