Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Controllo della latenza

Lezione 12 di 16 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Il compromesso tra latenza e accuratezza
  2. Il parametro target_streaming_delay_ms
  3. Il pattern Dual Delay
  4. Gestione della sostituzione a schermo
  5. Scelta della latenza giusta per il tuo caso d’uso
  6. Misurazione della latenza effettiva ottenuta
  7. Punti chiave

Corso aggiornato il 3 novembre 2026 per Voxtral 3, basato sulla guida Migrate from Voxtral 2 di Mistral: i modelli Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), deprecati il 31 ottobre 2026 e ritirati il 30 aprile 2027, sono sostituiti negli esempi da voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 e voxtral-mini-tts-3-0. Cambiamenti principali: timestamping solo per segmento (word restituisce un errore 400), diarizzazione in tempo reale possibile, impostazioni di sessione in tempo reale bloccate dopo il primo chunk audio e input context_bias in formato libero (frasi con spazi). Fonti: Migrate from Voxtral 2 · Speech to Text.

Il compromesso tra latenza e accuratezza

La trascrizione in tempo reale si basa su un compromesso inevitabile: la velocità di risposta ha un costo in termini di accuratezza. Più il modello attende prima di emettere una parola, più contesto ha per distinguere tra ipotesi acustiche simili — e più l’utente deve aspettare. Una frase come “he took the sea” contro “he took the bitter” potrebbe diventare chiara solo dal seguito; un modello frettoloso sceglierà talvolta quella sbagliata.

Voxtral Realtime non nasconde questo compromesso dietro un’impostazione automatica: te lo affida esplicitamente tramite il parametro target_streaming_delay_ms. Sei tu a decidere il punto di equilibrio, caso per caso.

Il parametro target_streaming_delay_ms

Questo valore esprime in millisecondi il ritardo target tra la ricezione dell’audio e l’emissione del testo corrispondente. Con Voxtral 3, accetta qualsiasi intero da 80 a 1.200, oppure 2.400; qualsiasi altro valore attiva un evento di errore. Lo passi direttamente alla chiamata di streaming, proprio come il modello e il formato audio, e come tutte le impostazioni di sessione, si blocca dopo il primo chunk 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)

# Bassa latenza: risposta veloce, meno accurata
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)

Tre intervalli di valori coprono quasi tutti i casi d’uso. Tra 200 e 300 millisecondi, la trascrizione è ultra-reattiva: questa è l’impostazione per gli assistenti vocali, dove l’immediatezza conta più di tutto e il testo può contenere più correzioni. Tra 500 e 1.000 millisecondi, ottieni un buon equilibrio, adatto ai sottotitoli in diretta e alla dettatura. Oltre questo limite, tra 2.000 e 3.000 millisecondi, il modello lavora con molto più contesto e produce un testo significativamente più pulito, al costo di un ritardo che l’utente percepisce chiaramente.

Il pattern Dual Delay

Devi davvero scegliere? Voxtral Realtime offre una soluzione alternativa: avvia due stream in parallelo sullo stesso audio, con latenze diverse, rifiutando così il compromesso. Lo stream veloce, impostato ad esempio a 240 millisecondi, fornisce un feedback visivo immediato che rassicura l’utente e mostra che il sistema sta ascoltando. Lo stream lento, impostato a 2.400 millisecondi, produce una trascrizione più accurata che sostituisce gradualmente il testo provvisorio.

Conosci già questo comportamento anche se non gli hai dato un nome: è così che funzionano i sottotitoli in diretta su YouTube o Google Meet, dove il testo appare quasi istantaneamente per poi correggersi qualche istante dopo. L’implementazione consiste nel definire due coroutine identiche eccetto per il ritardo, ed eseguirle insieme con 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):
    """Esegue due trascrizioni in parallelo con latenze diverse."""
    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)
                # Visualizza immediatamente (verrà sostituito dallo stream lento)
                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)
                # Visualizza la versione corretta
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Esegui entrambi gli stream in parallelo
    await asyncio.gather(fast_stream(), slow_stream())

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

Nota che la funzione riceve due sorgenti audio separate, non una: un generatore asincrono può essere consumato una sola volta, quindi devi duplicare lo stream a monte per alimentare entrambe le trascrizioni.

Gestione della sostituzione a schermo

In un terminale, il doppio output del codice sopra è sufficiente per capire il meccanismo, ma un’interfaccia reale deve fondere i due stream in un unico testo leggibile. La convenzione consolidata consiste nel visualizzare il testo provvisorio in una tonalità sottile — grigio — e il testo confermato in bianco, con il confine tra i due che avanza man mano che lo stream lento raggiunge quello veloce. La classe sottostante implementa questo confine con final_position: tutto ciò che lo precede proviene dallo stream lento e non cambierà, tutto ciò che segue proviene dallo stream veloce e rimane soggetto a correzione.

class DualLatencyDisplay:
    """Gestisce la visualizzazione con doppia latenza."""

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

    def on_fast_text(self, text: str):
        """Nuovo testo dallo stream veloce (provvisorio)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Nuovo testo dallo stream lento (finale)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Visualizza il testo finale + il testo veloce non ancora confermato."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Questo comfort ha un costo che sarebbe disonesto ignorare: due stream significano due connessioni e il doppio del volume audio elaborato. Riserva il Dual Delay alle interfacce in cui l’utente legge il testo mentre viene prodotto; per l’elaborazione in background, un singolo stream ben calibrato è più che sufficiente.

Scelta della latenza giusta per il tuo caso d’uso

Caso d’usoLatenza consigliataMotivo
Assistente vocale200-300 msL’utente si aspetta una reazione immediata
Dettatura vocale500-800 msEquilibrio tra reattività e accuratezza
Sottotitoli in diretta800-1.200 msAccuratezza importante, leggero ritardo accettabile
Trascrizione di conferenze1.200 o 2.400 msMassima accuratezza, il ritardo non è critico

Misurazione della latenza effettiva ottenuta

Il valore che richiedi è un target, non una garanzia: la distanza di rete, il carico del servizio e la dimensione dei tuoi chunk vi si aggiungono. Prima di citare un numero ai tuoi utenti, misuralo dal luogo in cui la tua applicazione verrà effettivamente eseguita. La funzione sottostante cronometra il ritardo fino all’arrivo del primo frammento e lo confronta con il target richiesto.

import time

async def measure_latency(source_audio, delay_ms):
    """Misura la latenza effettiva della trascrizione."""
    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"Primo testo dopo {latency:.0f} ms "
                      f"(target: {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

    print(f"\nDurata totale: {time.time() - start:.1f}s")

Esegui questa misurazione con 240, poi 800, infine 2.400 millisecondi sullo stesso estratto e leggi le tre trascrizioni fianco a fianco. Il divario di qualità tra la prima e l’ultima ti dirà, meglio di qualsiasi raccomandazione generale, quale latenza la tua applicazione può permettersi.

Punti chiave

  • target_streaming_delay_ms controlla il compromesso latenza/accuratezza
  • Valori bassi (da 80 a 300 ms): reattivi ma meno accurati
  • Valori alti (1.200 ms o 2.400 ms): accurati ma con ritardo percepibile; sono accettati solo valori da 80 a 1.200 e 2.400
  • Il pattern Dual Delay combina due stream per ottenere sia reattività CHE accuratezza
  • Lo stream veloce fornisce un feedback immediato, quello lento corregge il testo
  • Scegli la latenza in base al tuo caso d’uso (assistente vocale vs sottotitoli)