Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Latens og optimering i realtid

Lektion 17 af 18 Opdateret 3. november 2026 Udvikler
På denne side
  1. Latens og optimering i realtid
  2. Anatomien bag latens
  3. Optimering af VAD-detektering
  4. Optimering af systeminstruktioner
  5. Reducering af netværkslatens
  6. Optimering af funktionskald
  7. Latensovervågning
  8. Vigtige pointer

Opdateret 2. november 2026 — Lydmodeller. Flere modeller i dette kursus er udfaset: tts-1, tts-1-hd og gpt-4o-mini-tts stopper den 6. januar 2027 (efterfølger: gpt-realtime-2.1-mini, som OpenAI TTS-guiden angiver ikke understøttes af /v1/audio/speech: migration af talesyntese flytter til Realtime API); gpt-realtime, gpt-4o-realtime og ældre lydmodeller den 20. januar 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe og /v1/audio/translations den 26. februar 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Til fuld-duplex tale har GPT-Live 1 været tilgængelig i API’en siden 10. september 2026.

Korrigeret 3. november 2026. Varighederne tildelt hvert trin (“VAD 300-700 ms”, “netværk 20-100 ms”, “model 200-800 ms”) og perceptionstærskler (“over 500 ms”) manglede kilder: OpenAI offentliggør ikke sådanne tal, og lektionen lærer dig nu, hvordan du måler dem. Instruktionen om at placere din server “i samme region som OpenAI-servere (US East)” blev fjernet på grund af manglende kildehenvisning. Dokumenterede tilføjelser: semantic_vad, WARP til at accelerere WebRTC-sessionsetablering. Kilder: Voice activity detection · WebRTC with WARP · Cost optimization.

Latens og optimering i realtid

Latens er voice agentens værste fjende: stilheden efter slutningen på et spørgsmål bemærkes øjeblikkeligt i telefonen eller i en applikation. Denne lektion gennemgår kilderne til latens, hvordan du måler dem, og teknikker til at reducere dem.

Anatomien bag latens

Den samlede latens for en voice agent er summen af flere komponenter:

VAD
Venter på stilheden, der afslutter tur (`silence_duration_ms`)
Netværk
Rundture mellem bruger, din server og API'en
Model
Kontekstbehandling, derefter første lydblok

Afhængigt af din arkitektur skal du lægge de værktøjer, som agenten kalder, og sessionens opsætningstid til. Ingen af disse varigheder er faste: de afhænger af dine indstillinger, samtalelængde og netværksrute. Den eneste måde at vide, hvor tiden går, er at tage tid på hvert trin, præcis som monitoren nedenfor gør.

Optimering af VAD-detektering

Med server_vad kan svaret ikke starte, før stilheden defineret af silence_duration_ms er slut: dette er derfor en direkte indstilling for den oplevede latens, som skal afvejes mod risikoen for at afbryde brugeren. Værdierne nedenfor er udgangspunkter til test, ikke OpenAI-anbefalinger:

# Aggressiv konfiguration (hurtigt svar, risiko for at afbryde bruger)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Højere tærskel = færre falske positiver
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Hurtig reaktion
}

# Tålmodig konfiguration (færre afbrydelser, mere latens)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternativ: semantisk VAD, der bedømmer sætningsafslutning baseret på ord;
# eagerness "high" svarer ASAP, "low" lader brugeren gøre færdig
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Adaptiv konfiguration baseret på kontekst
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
    }

Optimering af systeminstruktioner

Koncise instruktioner reducerer den kontekst, der skal behandles. Husk også, at Realtime API automatisk anvender prompt-caching: stabile instruktioner og værktøjer, placeret øverst og aldrig ændret under en session, genbruges fra tur til tur.

# Omstændelige instruktioner (flere tokens at behandle)
bad_instructions = """
Du er en intelligent og kompetent voice-assistent, der arbejder
for Corsen AI, et fransk firma specialiseret i
kunstig intelligens. Du skal besvare brugerspørgsmål
professionelt, koncist og på fransk.
Du har adgang til forskellige værktøjer til at konsultere aftaler,
tjekke tilgængelighed og foretage reservationer.
Tøv ikke med at bede om afklaring, hvis anmodningen er uklar.
"""

# Optimerede instruktioner (samme effekt, færre tokens)
good_instructions = """
Corsen AI voice-assistent. Fransk, koncis, professionel.
Brug værktøjer til aftaler og reservationer.
Bed om afklaring ved behov.
"""

Reducering af netværkslatens

Måling af rundtur

Placer dit WebSocket-relæ så tæt på dine brugere som muligt og mål ruten i stedet for at gætte. En simpel begivenhed, som at rydde input-bufferen, er nok til at tage tid på en rundtur:

import time

async def measure_roundtrip(ws):
    """Måler netværkslatens til Realtime API."""
    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  # ignorer andre begivenheder, der ankommer imellem
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Netværkslatens: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive og genforbindelse

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Robust forbindelse med automatisk genforbindelse."""
    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 hvert 20. sekund
                ping_timeout=10,       # Ping-timeout 10 sekunder
                close_timeout=5        # Luk-timeout 5 sekunder
            ) as ws:
                retry_count = 0  # Nulstil ved succesfuld forbindelse
                yield ws

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

En genforbindelse åbner en ny session: den tidligere samtale er væk, og en session varer alligevel højst 60 minutter. Så hold din egen registrering af udvekslinger (transskriptioner, værktøjsresultater) og injicer det vigtigste igen med conversation.item.create efter en genforbindelse.

Acceleration af WebRTC-opsætning: WARP

På browser- eller native app-siden dokumenterer OpenAI WARP (WebRTC Abridged Roundtrip Protocol), som reducerer tiden til etablering af WebRTC-sessioner ved at kombinere tre transportoptimeringer: DTLS 1.3, SPED og SNAP. Dette er IETF-udkast, understøttet af nyere versioner af libwebrtc; du kan aktivere dem, din klient understøtter, én efter én. Guiden WebRTC with WARP beskriver konfigurationen i detaljer.

Optimering af funktionskald

Funktionskald tilføjer latens. Optimer deres udførelse:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Udfører funktionskald parallelt."""
    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 til hyppige funktioner
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Cacher resultater af hyppige forespørgsler."""
    # Database- eller API-forespørgsel
    return {"data": "..."}

Latensovervågning

Integrer et målesystem for at identificere flaskehalse:

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)

Vigtige pointer

  • Samlet latens lægger VAD, netværk, model og værktøjer sammen: mål hvert trin, OpenAI offentliggør ikke typiske varigheder
  • silence_duration_ms styrer direkte ventetiden før svar; semantic_vad og dets eagerness er den anden løftestang
  • Koncise systeminstruktioner reducerer modellens behandlingstid
  • Parallel udførelse af funktionskald og caching reducerer applikationslatens
  • Et overvågningssystem med TTFA (Time-to-First-Audio) er afgørende for løbende optimering