Salt la conținutul principal
Română— Alege o limbă
Meniu

Controlul latenței

Lecția 12 din 16 Actualizată 3 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Compromisul dintre latență și acuratețe
  2. Parametrul target_streaming_delay_ms
  3. Modelul Dual Delay (Întârziere Dublă)
  4. Gestionarea înlocuirii pe ecran
  5. Alegerea latenței potrivite pentru cazul dumneavoastră de utilizare
  6. Măsurarea latenței reale obținute
  7. Puncte cheie

Curs actualizat la 3 noiembrie 2026 pentru Voxtral 3, pe baza ghidului Migrate from Voxtral 2 de la Mistral: modelele Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), depreciate la 31 octombrie 2026 și retrase la 30 aprilie 2027, sunt înlocuite în exemple de voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 și voxtral-mini-tts-3-0. Modificări cheie: marcarea temporală doar pe segment (word returnează o eroare 400), diarizarea în timp real este posibilă, setările sesiunii în timp real sunt blocate după primul fragment audio, iar intrările context_bias sunt în format liber (fraze cu spații). Surse: Migrate from Voxtral 2 · Speech to Text.

Compromisul dintre latență și acuratețe

Transcrierea în timp real se bazează pe un compromis pe care nu îl puteți evita: viteza de răspuns se obține în detrimentul acurateței. Cu cât modelul așteaptă mai mult înainte de a emite un cuvânt, cu atât are mai mult context pentru a distinge între ipoteze acustice similare—și cu atât utilizatorul dumneavoastră așteaptă mai mult. O frază precum „he took the sea“ față de „he took the bitter“ poate deveni clară doar din ceea ce urmează; un model grăbit va alege uneori varianta greșită.

Voxtral Realtime nu ascunde acest compromis în spatele unei setări automate: vi-l pune la dispoziție în mod explicit prin parametrul target_streaming_delay_ms. Dumneavoastră decideți punctul de echilibru, de la caz la caz.

Parametrul target_streaming_delay_ms

Această valoare exprimă în milisecunde întârzierea țintă între primirea audio și emiterea textului corespunzător. Cu Voxtral 3, acceptă orice număr întreg de la 80 la 1.200 sau 2.400; orice altă valoare declanșează un eveniment de eroare. Îl transmiteți direct apelului de streaming, la fel ca modelul și formatul audio, și, ca toate setările sesiunii, acesta se blochează după primul fragment 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)

# Latență scăzută: răspuns rapid, mai puțin precis
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)

Trei intervale de valori acoperă aproape toate cazurile de utilizare. Între 200 și 300 de milisecunde, transcrierea este ultra-reactivă: aceasta este setarea pentru asistenții vocali, unde imediatitatea contează cel mai mult, iar textul poate conține mai multe corecturi. Între 500 și 1.000 de milisecunde, obțineți un echilibru bun, potrivit pentru subtitrarea în direct și dictare. Dincolo de aceasta, între 2.000 și 3.000 de milisecunde, modelul lucrează cu mult mai mult context și produce un text semnificativ mai curat, cu costul unei întârzieri pe care utilizatorul o percepe clar.

Modelul Dual Delay (Întârziere Dublă)

Trebuie neapărat să alegeți? Voxtral Realtime oferă o soluție ocolitoare: lansați două fluxuri în paralel pe același audio, cu latențe diferite, refuzând astfel compromisul. Fluxul rapid, setat de exemplu la 240 de milisecunde, oferă un feedback vizual imediat care liniștește utilizatorul și arată că sistemul ascultă. Fluxul lent, setat la 2.400 de milisecunde, produce o transcriere mai precisă care înlocuiește treptat textul provizoriu.

Cunoașteți acest comportament chiar dacă nu i-ați dat un nume: așa funcționează subtitrările în direct pe YouTube sau Google Meet, unde textul apare aproape instantaneu, apoi se corectează singur câteva momente mai târziu. Implementarea implică definirea a două coroutine identice, cu excepția întârzierii, și rularea lor împreună cu 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):
    """Rulează două transcrieri în paralel cu latențe diferite."""
    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)
                # Afișare imediată (va fi înlocuită de fluxul lent)
                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)
                # Afișare versiune corectată
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Rulează ambele fluxuri în paralel
    await asyncio.gather(fast_stream(), slow_stream())

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

Rețineți că funcția primește două surse audio separate, nu una singură: un generator asincron poate fi consumat o singură dată, așa că trebuie să duplicați fluxul în amonte pentru a alimenta ambele transcrieri.

Gestionarea înlocuirii pe ecran

Într-un terminal, ieșirea duală din codul de mai sus este suficientă pentru a înțelege mecanismul, dar o interfață reală trebuie să fuzioneze cele două fluxuri într-un singur text lizibil. Convenția stabilită este afișarea textului provizoriu într-o nuanță subtilă—gri—și a textului confirmat în alb, cu limita dintre ele avansând pe măsură ce fluxul lent îl ajunge din urmă pe cel rapid. Clasa de mai jos implementează această limită cu final_position: tot ce se află înainte provine din fluxul lent și nu se va schimba, tot ce urmează provine din fluxul rapid și rămâne supus corectării.

class DualLatencyDisplay:
    """Gestionează afișajul cu latență dublă."""

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

    def on_fast_text(self, text: str):
        """Text nou de la fluxul rapid (provizoriu)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Text nou de la fluxul lent (final)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Afișează textul final + textul rapid neconfirmat încă."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Acest confort are un cost pe care ar fi necinstit să îl ignorăm: două fluxuri înseamnă două conexiuni și dublul volumului de audio procesat. Rezervați modelul Dual Delay pentru interfețele în care utilizatorul citește textul în timp real; pentru procesarea în fundal, un singur flux bine reglat este mai mult decât suficient.

Alegerea latenței potrivite pentru cazul dumneavoastră de utilizare

Caz de utilizareLatență recomandatăMotiv
Asistent vocal200-300 msUtilizatorul se așteaptă la o reacție imediată
Dictare vocală500-800 msEchilibru între reactivitate și acuratețe
Subtitrare în direct800-1.200 msAcuratețea este importantă, o mică întârziere este acceptabilă
Transcriere conferință1.200 sau 2.400 msAcuratețe maximă, întârzierea nu este critică

Măsurarea latenței reale obținute

Valoarea pe care o solicitați este o țintă, nu o garanție: distanța de rețea, încărcarea serviciului și dimensiunea fragmentelor dumneavoastră se adaugă toate la aceasta. Înainte de a cita o cifră utilizatorilor dumneavoastră, măsurați-o din locul în care va rula efectiv aplicația. Funcția de mai jos cronometrează întârzierea până la sosirea primului fragment și o compară cu ținta solicitată.

import time

async def measure_latency(source_audio, delay_ms):
    """Măsoară latența efectivă a transcrierii."""
    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"First text after {latency:.0f} ms "
                      f"(target: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nTotal duration: {time.time() - start:.1f}s")

Rulați această măsurătoare cu 240, apoi 800, apoi 2.400 de milisecunde pe același extras și citiți cele trei transcrieri una lângă alta. Diferența de calitate dintre prima și ultima vă va spune, mai bine decât orice recomandare generală, ce latență își poate permite aplicația dumneavoastră.

Puncte cheie

  • target_streaming_delay_ms controlează compromisul latență/acuratețe
  • Valori mici (80 până la 300 ms): reactive, dar mai puțin precise
  • Valori mari (1.200 ms sau 2.400 ms): precise, dar cu întârziere perceptibilă; sunt acceptate doar valori de la 80 la 1.200 și 2.400
  • Modelul Dual Delay combină două fluxuri pentru reactivitate ȘI acuratețe
  • Fluxul rapid oferă feedback imediat, fluxul lent corectează textul
  • Alegeți latența în funcție de cazul dumneavoastră de utilizare (asistent vocal vs. subtitrare)