Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Kontrole de la latence

Nodarbība 12 no 16 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Le compromis latence vs précision
  2. Le paramètre target_streaming_delay_ms
  3. Le motif Dual Delay
  4. Gérer le remplacement à l’écran
  5. Choisir la bonne latence pour ton cas d’usage
  6. Mesurer la latence réelle obtenue
  7. Galvenās atziņas

Cours mis à jour le 3 novembre 2026 pour Voxtral 3, basé sur le guide Migrate from Voxtral 2 de Mistral : les modèles Voxtral 2 (voxtral-mini-2602, voxtral-mini-transcribe-realtime-2602, voxtral-mini-tts-2603), dépréciés le 31 octobre 2026 et retirés le 30 avril 2027, sont remplacés dans les exemples par voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 et voxtral-mini-tts-3-0. Changements clés : horodatage par segment uniquement (word renvoie une erreur 400), la diarisation en temps réel est possible, les paramètres de session en temps réel sont verrouillés après le premier chunk audio, et les entrées context_bias sont en texte libre (phrases avec espaces). Sources : Migrate from Voxtral 2 · Speech to Text.

Le compromis latence vs précision

La transcription en temps réel repose sur un compromis inévitable : la vitesse de réponse se fait au détriment de la précision. Plus le modèle attend avant d’émettre un mot, plus il dispose de contexte pour distinguer des hypothèses acoustiques similaires — et plus ton utilisateur doit attendre. Une phrase comme « il a pris la mer » versus « il a pris l’amer » ne devient claire qu’avec la suite ; un modèle trop pressé choisira parfois la mauvaise option.

Voxtral Realtime ne cache pas ce compromis derrière un réglage automatique : il te le confie explicitement via le paramètre target_streaming_delay_ms. C’est toi qui décides du point d’équilibre, cas par cas.

Le paramètre target_streaming_delay_ms

Cette valeur exprime en millisecondes le délai cible entre la réception de l’audio et l’émission du texte correspondant. Avec Voxtral 3, il accepte n’importe quel entier de 80 à 1 200, ou 2 400 ; toute autre valeur déclenche une erreur. Tu le passes directement à l’appel de streaming, tout comme le modèle et le format audio, et comme tous les paramètres de session, il se verrouille après le premier 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)

# Faible latence : réponse rapide, moins précise
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)

Trois plages de valeurs couvrent presque tous les cas d’usage. Entre 200 et 300 millisecondes, la transcription est ultra-réactive : c’est le réglage pour les assistants vocaux, où l’immédiateté prime et où le texte peut contenir plus de corrections. Entre 500 et 1 000 millisecondes, tu obtiens un bon équilibre, adapté au sous-titrage en direct et à la dictée. Au-delà, entre 2 000 et 3 000 millisecondes, le modèle travaille avec beaucoup plus de contexte et produit un texte nettement plus propre, au prix d’un délai que l’utilisateur perçoit clairement.

Le motif Dual Delay

Dois-tu vraiment choisir ? Voxtral Realtime offre une parade : lance deux flux en parallèle sur le même audio, avec des latences différentes, et refuse ainsi le compromis. Le flux rapide, réglé par exemple à 240 millisecondes, donne un retour visuel immédiat qui rassure l’utilisateur et montre que le système écoute. Le flux lent, réglé à 2 400 millisecondes, produit une transcription plus précise qui remplace progressivement le texte provisoire.

Tu connais ce comportement même si tu ne l’as pas nommé : c’est ainsi que fonctionnent les sous-titres en direct sur YouTube ou Google Meet, où le texte apparaît presque instantanément puis se corrige quelques instants plus tard. La mise en œuvre consiste à définir deux corroutines identiques sauf pour le délai, puis à les exécuter ensemble avec 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):
    """Exécute deux transcriptions en parallèle avec des latences différentes."""
    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)
                # Affichage immédiat (sera remplacé par le flux 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)
                # Affichage de la version corrigée
                print(f"\n[ACCURATE] {''.join(results['slow'][-10:])}",
                      flush=True)

    # Exécution des deux flux en parallèle
    await asyncio.gather(fast_stream(), slow_stream())

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

Note que la fonction reçoit deux sources audio distinctes, pas une seule : un générateur asynchrone ne peut être consommé qu’une fois, tu dois donc dupliquer le flux en amont pour alimenter les deux transcriptions.

Gérer le remplacement à l’écran

Dans un terminal, la double sortie du code ci-dessus suffit à comprendre le mécanisme, mais une interface réelle doit fusionner les deux flux en un seul texte lisible. La convention établie consiste à afficher le texte provisoire dans une nuance subtile — gris — et le texte confirmé en blanc, la frontière entre les deux avançant au fur et à mesure que le flux lent rattrape le rapide. La classe ci-dessous implémente cette frontière avec final_position : tout ce qui la précède vient du flux lent et ne changera plus, tout ce qui la suit vient du flux rapide et reste sujet à correction.

class DualLatencyDisplay:
    """Gère l'affichage avec double latence."""

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

    def on_fast_text(self, text: str):
        """Nouveau texte du flux rapide (provisoire)."""
        self.fast_text += text
        self._display()

    def on_slow_text(self, text: str):
        """Nouveau texte du flux lent (final)."""
        self.final_text += text
        self.final_position = len(self.final_text)
        self._display()

    def _display(self):
        """Affiche le texte final + le texte rapide non encore confirmé."""
        provisional_text = self.fast_text[self.final_position:]
        display = self.final_text + provisional_text
        print(f"\r{display}", end="", flush=True)

Ce confort a un coût qu’il serait malhonnête d’ignorer : deux flux signifient deux connexions et deux fois le volume audio traité. Réserve le motif Dual Delay aux interfaces où l’utilisateur lit le texte au fur et à mesure ; pour un traitement en arrière-plan, un seul flux bien réglé suffit amplement.

Choisir la bonne latence pour ton cas d’usage

Cas d’usageLatence recommandéeRaison
Assistant vocal200-300 msL’utilisateur attend une réaction immédiate
Dictée vocale500-800 msÉquilibre entre réactivité et précision
Sous-titrage en direct800-1 200 msPrécision importante, léger délai acceptable
Transcription de conférence1 200 ou 2 400 msPrécision maximale, délai non critique

Mesurer la latence réelle obtenue

La valeur que tu demandes est une cible, pas une garantie : la distance réseau, la charge du service et la taille de tes chunks s’y ajoutent. Avant de communiquer un chiffre à tes utilisateurs, mesure-la depuis l’endroit où ton application s’exécutera réellement. La fonction ci-dessous chronomètre le délai jusqu’à l’arrivée du premier fragment et le compare à la cible demandée.

import time

async def measure_latency(source_audio, delay_ms):
    """Mesure la latence effective de la transcription."""
    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"Premier texte après {latency:.0f} ms "
                      f"(cible : {delay_ms} ms)")
            print(event.text, end="", flush=True)
        elif isinstance(event, TranscriptionStreamDone):
            break

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

Exécute cette mesure avec 240, puis 800, puis 2 400 millisecondes sur le même extrait, et lis les trois transcriptions côte à côte. L’écart de qualité entre la première et la dernière te dira, mieux que n’importe quelle recommandation générale, quelle latence ton application peut se permettre.

Galvenās atziņas

  • target_streaming_delay_ms contrôle le compromis latence/précision
  • Valeurs basses (80 à 300 ms) : réactif mais moins précis
  • Valeurs élevées (1 200 ms, ou 2 400 ms) : précis mais avec un délai perceptible ; seules les valeurs de 80 à 1 200 et 2 400 sont acceptées
  • Le motif Dual Delay combine deux flux pour obtenir à la fois réactivité ET précision
  • Le flux rapide donne un retour immédiat, le flux lent corrige le texte
  • Choisis la latence selon ton cas d’usage (assistant vocal vs sous-titrage)