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

Latence et optimisation temps réel

Nodarbība 17 no 18 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Latence et optimisation temps réel
  2. Anatomie de la latence
  3. Optimisation de la détection VAD
  4. Optimisation des instructions système
  5. Réduction de la latence réseau
  6. Optimisation des appels de fonction
  7. Surveillance de la latence
  8. Galvenās atziņas

Mis à jour le 2 novembre 2026 — Modèles audio. Plusieurs modèles de ce cours sont obsolètes : tts-1, tts-1-hd et gpt-4o-mini-tts cesseront de fonctionner le 6 janvier 2027 (successeur : gpt-realtime-2.1-mini, que le guide TTS d’OpenAI indique comme non pris en charge par /v1/audio/speech : la migration de la synthèse vocale passe vers l’API Realtime) ; gpt-realtime, gpt-4o-realtime et les anciens modèles audio le 20 janvier 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5) ; whisper-1, gpt-4o-transcribe et /v1/audio/translations le 26 février 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pour la voix en full-duplex, GPT-Live 1 est disponible dans l’API depuis le 10 septembre 2026.

Corrigé le 3 novembre 2026. Les durées attribuées à chaque étape (« VAD 300-700 ms », « réseau 20-100 ms », « modèle 200-800 ms ») et les seuils de perception (« au-delà de 500 ms ») manquaient de sources : OpenAI ne publie pas ces chiffres, et cette leçon t’apprend désormais à les mesurer. L’instruction de placer ton serveur « dans la même région que les serveurs OpenAI (US East) » a été supprimée faute de source. Ajouts documentés : semantic_vad, WARP pour accélérer l’établissement de session WebRTC. Sources : Détection d’activité vocale · WebRTC avec WARP · Optimisation des coûts.

Latence et optimisation temps réel

La latence est l’ennemi numéro un d’un agent vocal : le silence suivant la fin d’une question est immédiatement perceptible au téléphone ou dans une application. Cette leçon détaille les sources de latence, comment les mesurer et les techniques pour les réduire.

Anatomie de la latence

La latence totale d’un agent vocal est la somme de plusieurs composants :

VAD
Attente du silence qui termine le tour (`silence_duration_ms`)
Réseau
Allers-retours entre l'utilisateur, ton serveur et l'API
Modèle
Traitement du contexte, puis premier chunk audio

Selon ton architecture, ajoute les outils que l’agent appelle et le temps de configuration de session. Aucune de ces durées n’est fixe : elles dépendent de tes paramètres, de la longueur de la conversation et du chemin réseau. La seule façon de savoir où le temps passe est de chronométrer chaque étape, comme le fait le moniteur présenté ci-dessous.

Optimisation de la détection VAD

Avec server_vad, la réponse ne peut pas commencer avant la fin du silence défini par silence_duration_ms : c’est donc un réglage direct de la latence perçue, à équilibrer avec le risque d’interrompre l’utilisateur. Les valeurs ci-dessous sont des points de départ à tester, pas des recommandations d’OpenAI :

# Configuration agressive (réponse rapide, risque de couper l'utilisateur)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Seuil plus élevé = moins de faux positifs
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Réaction rapide
}

# Configuration patiente (moins d'interruptions, plus de latence)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternative : VAD sémantique, qui juge la fin de phrase selon les mots ;
# eagerness "high" répond ASAP, "low" laisse l'utilisateur finir
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Configuration adaptative selon le contexte
def get_vad_config(context: str) -> dict:
    configs = {
        "menu_ivr": {"threshold": 0.6, "silence_duration_ms": 400},
        "conversation": {"threshold": 0.5, "silence_duration_ms": 600},
        "dictation": {"threshold": 0.3, "silence_duration_ms": 1200},
    }
    config = configs.get(context, configs["conversation"])
    return {
        "type": "server_vad",
        "prefix_padding_ms": 300,
        **config
    }

Optimisation des instructions système

Des instructions concises réduisent le contexte à traiter. Rappelle-toi aussi que l’API Realtime applique automatiquement la mise en cache des prompts : des instructions et outils stables, placés en haut et jamais modifiés durant une session, sont réutilisés d’un tour à l’autre.

# Instructions verbeuses (plus de tokens à traiter)
bad_instructions = """
You are an intelligent and competent voice assistant working
for Corsen AI, a French company specializing in
artificial intelligence. You must answer user questions
professionally, concisely, and in French.
You have access to various tools to consult appointments,
check availability, and make reservations.
Do not hesitate to ask for clarification if the request is unclear.
"""

# Instructions optimisées (même effet, moins de tokens)
good_instructions = """
Corsen AI voice assistant. French, concise, professional.
Use tools for appointments and reservations.
Ask for clarification if needed.
"""

Réduction de la latence réseau

Mesure de l’aller-retour

Place ton relais WebSocket aussi près que possible de tes utilisateurs et mesure le chemin plutôt que de le supposer. Un simple événement, comme l’effacement du tampon d’entrée, suffit à chronométrer un aller-retour :

import time

async def measure_roundtrip(ws):
    """Mesure la latence réseau vers l'API Realtime."""
    start = time.monotonic()
    await ws.send(json.dumps({"type": "input_audio_buffer.clear"}))
    while json.loads(await ws.recv())["type"] != "input_audio_buffer.cleared":
        pass  # ignore les autres événements arrivant entre-temps
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Network latency: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive et reconnexion

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Connexion robuste avec reconnexion automatique."""
    retry_count = 0

    while retry_count < max_retries:
        try:
            async with websockets.connect(
                REALTIME_URL,
                additional_headers={
                    "Authorization": f"Bearer {api_key}"
                },
                ping_interval=20,     # Ping toutes les 20s
                ping_timeout=10,       # Timeout ping 10s
                close_timeout=5        # Timeout fermeture 5s
            ) as ws:
                retry_count = 0  # Réinitialisation en cas de connexion réussie
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Reconnecting in {wait}s...")
            await asyncio.sleep(wait)

Une reconnexion ouvre une nouvelle session : la conversation précédente n’est plus là, et une session dure 60 minutes maximum de toute façon. Garde donc ta propre trace des échanges (transcriptions, résultats d’outils) et réinjecte l’essentiel avec conversation.item.create après une reconnexion.

Accélération de la configuration WebRTC : WARP

Côté navigateur ou application native, OpenAI documente WARP (WebRTC Abridged Roundtrip Protocol), qui réduit le temps d’établissement de session WebRTC en combinant trois optimisations de transport : DTLS 1.3, SPED et SNAP. Ce sont des brouillons IETF, pris en charge par les versions récentes de libwebrtc ; tu peux activer ceux que ton client supporte, un par un. Le guide WebRTC with WARP détaille la configuration.

Optimisation des appels de fonction

Les appels de fonction ajoutent de la latence. Optimise leur exécution :

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Exécute les appels de fonction en parallèle."""
    tasks = []
    for call in function_calls:
        task = execute_single_function(call["name"], call["arguments"])
        tasks.append(task)

    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Cache pour les fonctions fréquentes
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Met en cache les résultats des requêtes fréquentes."""
    # Requête base de données ou API
    return {"data": "..."}

Surveillance de la latence

Intègre un système de mesure pour identifier les goulots d’étranglement :

import time
from dataclasses import dataclass, field

@dataclass
class LatencyMetrics:
    speech_end_time: float = 0
    response_start_time: float = 0
    first_audio_time: float = 0
    response_complete_time: float = 0
    function_call_times: list = field(default_factory=list)

    @property
    def time_to_first_audio(self) -> float:
        if self.speech_end_time and self.first_audio_time:
            return (self.first_audio_time - self.speech_end_time) * 1000
        return 0

    @property
    def total_response_time(self) -> float:
        if self.speech_end_time and self.response_complete_time:
            return (self.response_complete_time - self.speech_end_time) * 1000
        return 0

    def report(self) -> dict:
        return {
            "ttfa_ms": round(self.time_to_first_audio),
            "total_ms": round(self.total_response_time),
            "function_calls_ms": [round(t * 1000) for t in self.function_call_times]
        }

class LatencyTracker:
    def __init__(self):
        self.current = LatencyMetrics()
        self.history = []

    def on_event(self, event_type: str):
        now = time.time()

        if event_type == "input_audio_buffer.speech_stopped":
            self.current.speech_end_time = now

        elif event_type == "response.output_audio.delta":
            if not self.current.first_audio_time:
                self.current.first_audio_time = now

        elif event_type == "response.done":
            self.current.response_complete_time = now
            self.history.append(self.current.report())
            self.current = LatencyMetrics()

    def average_ttfa(self) -> float:
        if not self.history:
            return 0
        return sum(h["ttfa_ms"] for h in self.history) / len(self.history)

Galvenās atziņas

  • La latence totale additionne VAD, réseau, modèle et outils : mesure chaque étape, OpenAI ne publie pas de durées types
  • silence_duration_ms contrôle directement l’attente avant réponse ; semantic_vad et son eagerness sont l’autre levier
  • Des instructions système concises réduisent le temps de traitement du modèle
  • L’exécution parallèle des appels de fonction et la mise en cache réduisent la latence applicative
  • Un système de surveillance avec TTFA (Time-to-First-Audio) est essentiel pour une optimisation continue