Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Zamuda in optimizacija v realnem času

Lekcija 17 od 18 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Zamuda in optimizacija v realnem času
  2. Anatomija zamude
  3. Optimizacija zaznavanja VAD
  4. Optimizacija sistemskih navodil
  5. Zmanjševanje omrežne zamude
  6. Optimizacija klicanja funkcij
  7. Spremljanje zamude
  8. Ključne ugotovitve

Posodobljeno 2. novembra 2026 — Zvočni modeli. Nekateri modeli v tem tečaju so zastareli: tts-1, tts-1-hd in gpt-4o-mini-tts bodo prenehali delovati 6. januarja 2027 (naslednik: gpt-realtime-2.1-mini, ki ga vodnik za OpenAI TTS navaja kot nepodprt s strani /v1/audio/speech: selitev sinteze glasu prehaja na Realtime API); gpt-realtime, gpt-4o-realtime in stari zvočni modeli 20. januarja 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe in /v1/audio/translations 26. februarja 2027 (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za polnodupleksni glas je GPT-Live 1 na voljo v API-ju od 10. septembra 2026.

Popravljeno 3. novembra 2026. Trajanja, dodeljena posameznim korakom („VAD 300–700 ms”, „omrežje 20–100 ms”, „model 200–800 ms”), in pragovi zaznavanja („več kot 500 ms”) niso imeli virov: OpenAI takšnih številk ne objavlja, zato te lekcija zdaj uči, kako jih izmeriti. Navodilo za namestitev strežnika „v isto regijo kot strežniki OpenAI (US East)” je bilo odstranjeno zaradi pomanjkanja virov. Dodane dokumentirane funkcije: semantic_vad, WARP za pospešitev vzpostavitve seje WebRTC. Viri: Zaznavanje govorne aktivnosti · WebRTC z WARP · Optimizacija stroškov.

Zamuda in optimizacija v realnem času

Zamuda je sovražnik številka ena za glasovnega agenta: tišina, ki sledi koncu vprašanja, je takoj opazna po telefonu ali v aplikaciji. Ta lekcija podrobno opisuje vire zamude, načine njihovega merjenja in tehnike za njihovo zmanjšanje.

Anatomija zamude

Skupna zamuda glasovnega agenta je vsota več komponent:

VAD
Čakanje na tišino, ki konča govor (`silence_duration_ms`)
Omrežje
Potovanja sem in tja med uporabnikom, tvojim strežnikom in API-jem
Model
Obdelava konteksta, nato prvi zvočni delček

Glede na tvojo arhitekturo dodaj še čas, ki ga porabijo orodja, ki jih agent kliče, in čas vzpostavitve seje. Nobeno od teh trajanj ni fiksno: odvisna so od tvojih nastavitev, dolžine pogovora in omrežne poti. Edini način, da ugotoviš, kam gre čas, je merjenje vsakega koraka, kar počne spodaj predstavljeni monitor.

Optimizacija zaznavanja VAD

Pri server_vad se odgovor ne more začeti, preden se ne konča tišina, določena z silence_duration_ms: to je torej neposredna nastavitev za zaznano zamudo, ki jo je treba uravnotežiti s tveganjem prekinitve uporabnika. Spodnje vrednosti so izhodišča za testiranje, ne priporočila OpenAI:

# Agresivna konfiguracija (hiter odziv, tveganje prereza uporabnika)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Višji prag = manj lažnih pozitivnih rezultatov
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Hiter odziv
}

# Potrpežljiva konfiguracija (manj prekinitev, več zamude)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternativa: semantični VAD, ki konec stavka oceni na podlagi besed;
# eagerness "high" odgovori takoj, "low" pusti uporabniku, da konča
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Prilagodljiva konfiguracija glede na 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
    }

Optimizacija sistemskih navodil

Jedrnata navodila zmanjšajo kontekst, ki ga je treba obdelati. Ne pozabi tudi, da Realtime API samodejno uporablja predpomnenje pozivov: stabilna navodila in orodja, postavljena na vrh in med sejo nikoli spremenjena, se ponovno uporabijo iz obrata v obrat.

# Obširna navodila (več žetonov za obdelavo)
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.
"""

# Optimizirana navodila (isti učinek, manj žetonov)
good_instructions = """
Corsen AI voice assistant. French, concise, professional.
Use tools for appointments and reservations.
Ask for clarification if needed.
"""

Zmanjševanje omrežne zamude

Merjenje potovanja sem in tja

Postavi svoj WebSocket relej čim bližje svojim uporabnikom in izmeri pot, namesto da bi jo ugibal. Preprost dogodek, kot je brisanje vhodnega medpomnilnika, zadostuje za merjenje potovanja sem in tja:

import time

async def measure_roundtrip(ws):
    """Measures network latency to the 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  # ignore other events arriving in between
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Network latency: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Ohranjanje povezave in ponovna vzpostavitev

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Robust connection with automatic reconnection."""
    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 vsakih 20 s
                ping_timeout=10,       # Časovna omejitev pinga 10 s
                close_timeout=5        # Časovna omejitev zaprtja 5 s
            ) as ws:
                retry_count = 0  # Ponastavi ob uspešni povezavi
                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)

Ponovna vzpostavitev odpre novo sejo: prejšnji pogovor ni več prisoten, seja pa tako ali tako traja največ 60 minut. Zato vodi lastno evidenco izmenjav (prepisi, rezultati orodij) in po ponovni vzpostavitvi bistvene dele znova vnesi z conversation.item.create.

Pospeševanje vzpostavitve WebRTC: WARP

Na strani brskalnika ali nativne aplikacije OpenAI dokumentira WARP (WebRTC Abridged Roundtrip Protocol), ki skrajša čas vzpostavitve seje WebRTC s kombinacijo treh optimizacij prenosa: DTLS 1.3, SPED in SNAP. To so osnutki IETF, ki jih podpirajo novejše različice libwebrtc; omogočiš lahko tiste, ki jih tvoj odjemalec podpira, enega za drugim. Vodnik WebRTC with WARP podrobno opisuje konfiguracijo.

Optimizacija klicanja funkcij

Klici funkcij dodajajo zamudo. Optimiziraj njihovo izvajanje:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Executes function calls in parallel."""
    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

# Predpomnilnik za pogoste funkcije
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Caches results of frequent requests."""
    # Poizvedba v bazo podatkov ali API
    return {"data": "..."}

Spremljanje zamude

Vgradi sistem merjenja za prepoznavanje ozkih grl:

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)

Ključne ugotovitve

  • Skupna zamuda sešteva VAD, omrežje, model in orodja: izmeri vsak korak, OpenAI ne objavlja tipičnih trajanj
  • silence_duration_ms neposredno nadzira čakanje pred odgovorom; semantic_vad in njegov eagerness sta drug vzvod
  • Jedrnata sistemska navodila zmanjšajo čas obdelave modela
  • Vzporedno izvajanje klicev funkcij in predpomnenje zmanjšata zamudo aplikacije
  • Sistem spremljanja s TTFA (Time-to-First-Audio) je bistven za stalno optimizacijo