Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Késleltetés és valós idejű optimalizálás

17. lecke 18 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Késleltetés és valós idejű optimalizálás
  2. A késleltetés anatómiája
  3. A VAD-észlelés optimalizálása
  4. Rendszerutasítások optimalizálása
  5. Hálózati késleltetés csökkentése
  6. Függvényhívások optimalizálása
  7. Késleltetés-monitorozás
  8. Főbb megállapítások

Frissítve: 2026. november 2. – Hangmodellek. A tanfolyam több modellje elavult: a tts-1, tts-1-hd és a gpt-4o-mini-tts támogatása 2027. január 6-án megszűnik (utód: gpt-realtime-2.1-mini, amelyet az OpenAI TTS útmutatója szerint a /v1/audio/speech nem támogat: a hangszintézis migrációja a Realtime API felé történik); a gpt-realtime, gpt-4o-realtime és a régi hangmodellek támogatása 2027. január 20-án szűnik meg (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); a whisper-1, gpt-4o-transcribe és a /v1/audio/translations támogatása 2027. február 26-án ér véget (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). A teljes duplex hangkommunikációhoz a GPT-Live 1 már 2026. szeptember 10. óta elérhető az API-ban.

Helyesbítve: 2026. november 3. Az egyes lépésekhez rendelt időtartamok („VAD 300–700 ms“, „hálózat 20–100 ms“, „modell 200–800 ms“) és az észlelési küszöbértékek („500 ms felett“) forrás nélkül maradtak: az OpenAI nem tesz közzé ilyen adatokat, ezért ez a lecke most arra tanít, hogyan mérd le ezeket. Az utasítást, miszerint a szerveredet az „OpenAI szerverekkel azonos régióba (US East)“ kell helyezned, forráshiány miatt eltávolítottuk. Dokumentált kiegészítések: semantic_vad, WARP a WebRTC munkamenet-létesítés gyorsítására. Források: Voice activity detection · WebRTC with WARP · Cost optimization.

Késleltetés és valós idejű optimalizálás

A késleltetés a hangalapú ügynökök első számú ellensége: a kérdés végén beálló csendet azonnal észreveszik telefonon vagy alkalmazásban. Ez a lecke részletezi a késleltetés forrásait, a mérésük módját, valamint a csökkentésükre szolgáló technikákat.

A késleltetés anatómiája

Egy hangügynök teljes késleltetése több komponens összege:

VAD
Várakozás a fordulót lezáró csendre (`silence_duration_ms`)
Hálózat
Körutak a felhasználó, a szervered és az API között
Modell
Kontextusfeldolgozás, majd az első hangcsomag

Az architektúrádtól függően add hozzá az ügynök által hívott eszközök idejét és a munkamenet-beállítási időt. Ezen időtartamok egyike sem rögzített: a beállításaidtól, a beszélgetés hosszától és a hálózati útvonaltól függenek. Az egyetlen módja annak, hogy tudd, hol megy el az idő, ha minden lépést időzítesz, ahogy az alábbi monitor is teszi.

A VAD-észlelés optimalizálása

A server_vad használatakor a válasz nem indulhat el a silence_duration_ms által meghatározott csend vége előtt: ez tehát közvetlen beállítás az észlelt késleltetésre, amelyet egyensúlyba kell hozni a felhasználó félbeszakításának kockázatával. Az alábbi értékek kiindulópontok tesztelésre, nem OpenAI-ajánlások:

# Agresszív konfiguráció (gyors válasz, kockázat: felhasználó levágása)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Magasabb küszöb = kevesebb téves pozitív
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Gyors reakció
}

# Türelmes konfiguráció (kevesebb megszakítás, nagyobb késleltetés)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternatíva: szemantikai VAD, amely szavak alapján ítéli meg a mondat végét;
# az "high" eagerness azonnal válaszol, a "low" megvárja, míg a felhasználó befejezi
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Kontextus alapú adaptív konfiguráció
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
    }

Rendszerutasítások optimalizálása

A tömör utasítások csökkentik a feldolgozandó kontextust. Ne feledd azt sem, hogy a Realtime API automatikusan alkalmazza a prompt-gyorsítótárazást: a stabil utasítások és eszközök, amelyeket a session elejére helyezel, és a munkamenet során soha nem módosítasz, fordulóról fordulóra újrahasznosításra kerülnek.

# Bőbeszédű utasítások (több token feldolgozása)
bad_instructions = """
Te egy intelligens és hozzáértő hangasszisztens vagy,
aki a Corsen AI-nak dolgozik, egy mesterséges intelligenciára
specializálódott francia cégnek. Profi módon, tömören
és franciául kell válaszolnod a felhasználók kérdéseire.
Hozzáférésed van különböző eszközökhöz időpontok lekérdezéséhez,
rendelkezésre állás ellenőrzéséhez és foglalások készítéséhez.
Ne habozz tisztázást kérni, ha a kérés nem egyértelmű.
"""

# Optimalizált utasítások (ugyanaz a hatás, kevesebb token)
good_instructions = """
Corsen AI hangasszisztens. Francia, tömör, professzionális.
Használd az eszközöket időpontokhoz és foglalásokhoz.
Kérj tisztázást, ha szükséges.
"""

Hálózati késleltetés csökkentése

Körút mérése

Helyezd a WebSocket közvetítődet (relay) a lehető legközelebb a felhasználóidhoz, és mérd le az útvonalat, ne pedig feltételezd azt. Egy egyszerű esemény, például a bemeneti puffer törlése, elegendő egy körút időzítéséhez:

import time

async def measure_roundtrip(ws):
    """Méri a hálózati késleltetést a Realtime API felé."""
    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  # figyelmen kívül hagyja a közben érkező egyéb eseményeket
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Hálózati késleltetés: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive és újracsatlakozás

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Robusztus kapcsolat automatikus újracsatlakozással."""
    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 minden 20 mp-ben
                ping_timeout=10,       # Ping időtúllépés 10 mp
                close_timeout=5        # Zárás időtúllépés 5 mp
            ) as ws:
                retry_count = 0  # Alaphelyzetbe állítás sikeres csatlakozás esetén
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Újracsatlakozás {wait} mp múlva...")
            await asyncio.sleep(wait)

Egy újracsatlakozás egy új munkamenetet nyit meg: az előző beszélgetés már nincs ott, és egy munkamenet amúgy is maximum 60 percig tart. Ezért tartsd saját magadnál a váltások rekordját (átiratok, eszközeredmények), és újracsatlakozás után a conversation.item.create segítségével injektáld vissza a lényeges elemeket.

WebRTC-beállítás gyorsítása: WARP

Böngésző vagy natív alkalmazás oldalán az OpenAI dokumentálja a WARP-ot (WebRTC Abridged Roundtrip Protocol), amely három transzportoptimalizálás kombinálásával csökkenti a WebRTC munkamenet-létesítési idejét: DTLS 1.3, SPED és SNAP. Ezek IETF-tervezetek, amelyeket a libwebrtc legújabb verziói támogatnak; engedélyezheted azokat, amelyeket a kliensed támogat, egyesével. A WebRTC with WARP útmutató részletezi a konfigurációt.

Függvényhívások optimalizálása

A függvényhívások késleltetést adnak hozzá. Optimalizáld a végrehajtásukat:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Párhuzamosan hajtja végre a függvényhívásokat."""
    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

# Gyorsítótár gyakori függvényekhez
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Gyorsítótárazza a gyakori kérések eredményeit."""
    # Adatbázis vagy API lekérdezés
    return {"data": "..."}

Késleltetés-monitorozás

Integrálj egy mérőrendszert a szűk keresztmetszetek azonosításához:

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)

Főbb megállapítások

  • A teljes késleltetés a VAD, a hálózat, a modell és az eszközök összegéből adódik: mérd le minden lépést, az OpenAI nem tesz közzé tipikus időtartamokat
  • A silence_duration_ms közvetlenül szabályozza a válasz előtti várakozást; a semantic_vad és annak eagerness paramétere a másik szabályozókar
  • A tömör rendszerutasítások csökkentik a modell feldolgozási idejét
  • A függvényhívások párhuzamos végrehajtása és gyorsítótárazása csökkenti az alkalmazás késleltetését
  • A TTFA-val (Time-to-First-Audio) rendelkező monitorozó rendszer elengedhetetlen a folyamatos optimalizáláshoz