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

Optimisation de la latence

Nodarbība 13 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. La latence : l’ennemie de la conversation naturelle
  2. Anatomie de la latence totale
  3. Streaming contre Batch : les chiffres
  4. Trois leviers côté serveur
  5. Deux leviers côté client
  6. Mesurer avant d’optimiser
  7. Galvenās atziņas

Cours mis à jour le 3 novembre 2026 pour Voxtral TTS 3, sur la base du guide Migrate from Voxtral 2 et des pages Text to Speech de Mistral : voxtral-mini-tts-2603, déprécié le 31 octobre 2026 et retiré le 30 avril 2027, est remplacé dans les exemples par voxtral-mini-tts-3-0. Les voix prédéfinies de Voxtral 2 (gb_jane_neutral…) restent prises en charge ; Voxtral 3 ajoute les balises [emotion=…] et [pace=…] dans le texte, le paramètre expressiveness, la prononciation personnalisée (phoneme_hints) et 35 langues. Mistral recommande de remesurer la latence après la migration. Sources : Migrate from Voxtral 2 · Speech generation.

La latence : l’ennemie de la conversation naturelle

Dans une conversation humaine, le temps de réponse moyen se situe autour de 200 millisecondes. Au-delà de 500 ms, ton interlocuteur perçoit un délai ; au-delà d’une seconde, il suppose que tu ne l’as pas entendu et répète sa question. Pour qu’un assistant vocal paraisse naturel, le délai entre la fin de la question et le début de la réponse doit rester inférieur à une seconde.

Voxtral annonce une latence modèle d’environ 90 ms, et c’est là que de nombreuses équipes se trompent : ce chiffre ne décrit qu’un maillon d’une chaîne bien plus longue. Ce que l’utilisateur ressent est la somme de tous les maillons. L’optimisation exige donc de connaître le coût de chaque composant.

Anatomie de la latence totale

Le trajet commence par le réseau sortant : le temps nécessaire pour acheminer ta requête vers les serveurs de Mistral. Cela dépend de ta localisation et de la qualité de ta connexion ; depuis l’Europe, compte entre 20 et 80 ms. Vient ensuite la latence du modèle, ces fameux 90 ms de traitement avant le premier fragment audio — la seule partie sur laquelle tu n’as aucun contrôle, car elle appartient à l’infrastructure de Mistral.

L’étape suivante est l’encodage, et c’est là que se cachent les pires surprises. Le PCM ne coûte rien, ou presque, car il n’y a rien à encoder. L’Opus ajoute 5 à 10 ms, ce qui reste négligeable. Le MP3, en revanche, exige 200 à 500 ms : son codec doit accumuler suffisamment de données avant de produire la première trame. En d’autres termes, un développeur qui laisse response_format="mp3" par habitude ajoute plus de délai de son côté que l’ensemble du modèle.

Enfin, le réseau de retour pèse peu en streaming puisque les fragments sont petits. Il reste le tampon côté client : ton application accumule généralement deux ou trois fragments avant de lancer la lecture pour éviter les micro-coupures. Ajoute 50 à 150 ms — un coût délibéré qui achète de la fluidité.

Streaming contre Batch : les chiffres

MétriqueBatch (sans streaming)Streaming PCMStreaming MP3
Premier son1-3 secondes~0,7 seconde~2 secondes
Latence perçueÉlevéeTrès faibleMoyenne
Bande passantePic uniqueDistribuéeDistribuée

Ces ordres de grandeur ont été enregistrés avec Voxtral 2. Mistral annonce environ 90 ms avant le premier son pour Voxtral TTS 3 côté modèle, et recommande de remesurer la latence depuis ton application après la migration : refais ces mesures avec ton réseau et ton format.

Passer du batch au streaming PCM divise la latence perçue par trois ou quatre. Aucune autre optimisation dans cette leçon n’aura un effet comparable : c’est la première chose à changer, même avant de mesurer.

Trois leviers côté serveur

Le premier levier est le format. Pour toute application conversationnelle, le streaming PCM est le paramètre de référence, et le changement s’opère sans réécrire ta logique.

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input=text,
    voice_id=voice_id,
    response_format="pcm",  # Latence minimale
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            play_audio(base64.b64decode(event.data.audio_data))

Le deuxième levier réside dans le choix entre une voix enregistrée et un clonage à la volée. Un voice_id désigne une voix déjà traitée côté serveur, tandis que ref_audio force le retraitement de l’échantillon à chaque requête. Pour un agent répondant cent fois par heure avec la même voix, ce détail économise 50 à 100 ms par tour de parole.

Le troisième levier consiste à raccourcir ce que tu demandes. Plus le texte est court, plus le premier fragment arrive vite : générer une réponse de cinq phrases en un seul bloc signifie faire attendre l’utilisateur pour un contenu qu’il n’entendra pas avant quinze secondes. Le générateur suivant découpe la réponse phrase par phrase et produit l’audio pour la première pendant que les autres attendent.

def generate_by_sentence(full_text, voice_id):
    """Génère l'audio phrase par phrase pour minimiser la latence."""
    sentences = full_text.split(". ")

    for sentence in sentences:
        sentence = sentence.strip()
        if not sentence:
            continue
        if not sentence.endswith("."):
            sentence += "."

        with client.audio.speech.complete(
            model="voxtral-mini-tts-3-0",
            input=sentence,
            voice_id=voice_id,
            response_format="pcm",
            stream=True,
        ) as stream:
            for event in stream:
                if event.event == "speech.audio.delta":
                    yield base64.b64decode(event.data.audio_data)

Deux leviers côté client

Un tampon fixe est toujours un compromis mal placé : trop petit, il laisse passer des micro-coupures sur un réseau chargé ; trop grand, il ajoute un délai inutile sur une bonne connexion. La classe ci-dessous lance la lecture dès que deux fragments sont disponibles, puis laisse passer les suivants au fur et à mesure qu’ils arrivent, sans jamais accumuler plus de cinq éléments.

class AdaptiveBuffer:
    def __init__(self):
        self.buffer = []
        self.min_threshold = 2   # Minimum de chunks avant lecture
        self.max_threshold = 5   # Ne pas accumuler plus
        self.playback_started = False

    def add_chunk(self, chunk):
        self.buffer.append(chunk)

        if not self.playback_started:
            if len(self.buffer) >= self.min_threshold:
                self.playback_started = True
                return self.empty_buffer()
        else:
            return chunk
        return None

    def empty_buffer(self):
        data = b"".join(self.buffer)
        self.buffer = []
        return data

Le deuxième levier ne coûte que quelques lignes : envoie une requête de test au démarrage de ton application. Cela établit la connexion TCP et la poignée de main TLS une fois pour toutes, et le keep-alive HTTP permet à toutes les requêtes suivantes de bénéficier de cette préparation. Sans cet échauffement, ton premier utilisateur de la journée en paie le prix.

Mesurer avant d’optimiser

Toutes ces estimations doivent être validées sur ta configuration réelle. La mesure minimale consiste à chronométrer le délai jusqu’à la réception du premier fragment, puis à sortir de la boucle : c’est ce chiffre, et non la durée totale, qui correspond à ce que l’utilisateur ressent.

import time

t0 = time.perf_counter()

with client.audio.speech.complete(
    model="voxtral-mini-tts-3-0",
    input="Latency test.",
    voice_id=voice_id,
    response_format="pcm",
    stream=True,
) as stream:
    for event in stream:
        if event.event == "speech.audio.delta":
            t1 = time.perf_counter()
            print(f"First chunk received in {(t1 - t0)*1000:.0f} ms")
            break

Exécute cette mesure depuis ton serveur de production, pas depuis ton poste de travail : la différence réseau suffit souvent à expliquer l’écart entre une démo convaincante et un déploiement décevant.

Galvenās atziņas

  • La latence totale inclut le réseau, le modèle (~90 ms), l’encodage et le tampon client
  • Le format PCM offre la latence la plus faible car il n’y a pas d’encodage
  • Le streaming réduit la latence perçue d’un facteur 3 à 4 par rapport au batch
  • Utilise un voice_id plutôt que ref_audio pour économiser 50-100 ms
  • Génère phrase par phrase pour minimiser le temps jusqu’au premier son