Kontrole de la latence
Šajā lapā
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 parvoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3etvoxtral-mini-tts-3-0. Changements clés : horodatage par segment uniquement (wordrenvoie 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éescontext_biassont 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’usage | Latence recommandée | Raison |
|---|---|---|
| Assistant vocal | 200-300 ms | L’utilisateur attend une réaction immédiate |
| Dictée vocale | 500-800 ms | Équilibre entre réactivité et précision |
| Sous-titrage en direct | 800-1 200 ms | Précision importante, léger délai acceptable |
| Transcription de conférence | 1 200 ou 2 400 ms | Pré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_mscontrô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)