Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Contrôle de la latence

Les 12 van 16 Bijgewerkt op 3 november 2026 Ontwikkelaar
Op deze pagina
  1. Le compromis entre latence et 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 votre cas d’usage
  6. Mesurer la latence réelle atteinte
  7. Belangrijkste punten

Cours mis à jour le 3 novembre 2026 pour Voxtral 3, sur la base du 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 fragment audio, et les entrées context_bias sont en texte libre (phrases avec espaces). Sources : Migrate from Voxtral 2 · Speech to Text.

Le compromis entre latence et 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 votre utilisateur doit attendre. Une phrase comme « he took the sea » contre « he took the bitter » 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 vous le confie explicitement via le paramètre target_streaming_delay_ms. Vous décidez 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 tout entier de 80 à 1 200, ou 2 400 ; toute autre valeur déclenche une erreur. Vous le transmettez 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 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)

# 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, vous obtenez 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 clairement perceptible par l’utilisateur.

Le motif Dual Delay

Devez-vous vraiment choisir ? Voxtral Realtime propose une parade : lancez deux flux en parallèle sur le même audio, avec des latences différentes, et refusez ainsi le compromis. Le flux rapide, réglé par exemple à 240 millisecondes, offre 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.

Vous connaissez ce comportement même si vous ne l’avez 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écuter les deux flux en parallèle
    await asyncio.gather(fast_stream(), slow_stream())

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

Notez que la fonction reçoit deux sources audio distinctes, pas une seule : un générateur asynchrone ne peut être consommé qu’une fois, vous devez 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 flux rapide. La classe ci-dessous implémente cette frontière avec final_position : tout ce qui la précède provient du flux lent et ne changera plus, tout ce qui la suit provient 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éservez 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 votre 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 atteinte

La valeur que vous demandez est une cible, pas une garantie : la distance réseau, la charge du service et la taille de vos fragments s’y ajoutent. Avant de communiquer un chiffre à vos utilisateurs, mesurez-la depuis l’endroit où votre 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"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")

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

Belangrijkste punten

  • target_streaming_delay_ms contrôle le compromis latence/précision
  • Valeurs faibles (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
  • Choisissez la latence en fonction de votre cas d’usage (assistant vocal vs sous-titrage)