Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Vėlavimas ir realiojo laiko optimizavimas

Paskaita 17 iš 18 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Vėlavimas ir realiojo laiko optimizavimas
  2. Vėlavimo anatomija
  3. VAD aptikimo optimizavimas
  4. Sistemos instrukcijų optimizavimas
  5. Tinklo vėlavimo mažinimas
  6. WebRTC nustatymo spartinimas: WARP
  7. Funkcijų kvietimo optimizavimas
  8. Vėlavimo stebėsena
  9. Svarbiausi punktai

Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę: tts-1, tts-1-hd ir gpt-4o-mini-tts nustos veikti 2027 m. sausio 6 d. (įpėdinis: gpt-realtime-2.1-mini, kurio, kaip nurodyta OpenAI TTS gide, nepalaiko /v1/audio/speech: balso sintezės migracija perkeliama į Realtime API); gpt-realtime, gpt-4o-realtime ir senieji garso modeliai nustos veikti 2027 m. sausio 20 d. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ir /v1/audio/translations nustos veikti 2027 m. vasario 26 d. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Pilno dublekso (full-duplex) balsui GPT-Live 1 API yra prieinamas nuo 2026 m. rugsėjo 10 d.

Ištaisyta 2026 m. lapkričio 3 d. Kiekvienam žingsniui priskirtos trukmės („VAD 300–700 ms“, „tinklas 20–100 ms“, „modelis 200–800 ms“) ir suvokimo slenksčiai („virš 500 ms“) neturėjo šaltinių: OpenAI neskelbia tokių duomenų, todėl šioje pamokoje dabar mokomasi, kaip juos išmatuoti. Instrukcija patalpinti serverį „tame pačiame regione kaip ir OpenAI serveriai (JAV Rytai)“ buvo pašalinta dėl šaltinių trūkumo. Dokumentuoti papildymai: semantic_vad, WARP WebRTC sesijos nustatymo spartinimui. Šaltiniai: Balso aktyvumo aptikimas · WebRTC su WARP · Išlaidų optimizavimas.

Vėlavimas ir realiojo laiko optimizavimas

Vėlavimas yra pagrindinis balso agento priešas: tyla, sekanti po klausimo pabaigos, telefonu ar programėlėje pastebima akimirksniu. Šioje pamokoje išsamiai nagrinėjami vėlavimo šaltiniai, jo matavimo būdai ir mažinimo technikos.

Vėlavimo anatomija

Bendras balso agento vėlavimas yra kelių komponentų suma:

VAD
Laukiama tylos, kuri užbaigia ėjimą (`silence_duration_ms`)
Tinklas
Grįžtamieji ryšiai tarp naudotojo, tavo serverio ir API
Modelis
Konteksto apdorojimas, tada pirmasis garso fragmentas

Priklausomai nuo tavo architektūros, pridėk agento naudojamų įrankių vykdymo laiką ir sesijos nustatymo laiką. Jokia iš šių trukmių nėra fiksuota: jos priklauso nuo tavo nustatymų, pokalbio ilgio ir tinklo kelio. Vienintelis būdas sužinoti, kur dingsta laikas – chronometruoti kiekvieną žingsnį, kaip tai daro toliau pateiktas stebėsenos įrankis.

VAD aptikimo optimizavimas

Naudojant server_vad, atsakas negali prasidėti anksčiau, nei pasibaigs silence_duration_ms nustatyta tyla: tai yra tiesioginis nustatymas, veikiantis suvokiamą vėlavimą, kurį reikia subalansuoti su rizika pertraukti naudotoją. Toliau pateiktos vertės yra pradiniai taškai testavimui, o ne OpenAI rekomendacijos:

# Agresyvi konfigūracija (greitas atsakas, rizika nutraukti naudotoją)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Didesnis slenkstis = mažiau klaidingų teigiamų rezultatų
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Greita reakcija
}

# Kantri konfigūracija (mažiau pertraukimų, daugiau vėlavimo)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternatyva: semantinis VAD, kuris sakinio pabaigą vertina pagal žodžius;
# „eagerness“ reikšmė „high“ atsako kuo greičiau, „low“ leidžia naudotojui baigti
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Adaptyvi konfigūracija pagal 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
    }

Sistemos instrukcijų optimizavimas

Glaustos instrukcijos sumažina apdorojamo konteksto apimtį. Taip pat atmink, kad Realtime API automatiškai taiko promptų kaupimą į sparčiąją atmintį (caching): stabilios instrukcijos ir įrankiai, pateikti viršuje ir niekada nemodifikuojami sesijos metu, yra pakartotinai naudojami nuo vieno ėjimo iki kito.

# Išsamios instrukcijos (daugiau tokenų apdoroti)
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.
"""

# Optimizuotos instrukcijos (tas pats efektas, mažiau tokenų)
good_instructions = """
Corsen AI voice assistant. French, concise, professional.
Use tools for appointments and reservations.
Ask for clarification if needed.
"""

Tinklo vėlavimo mažinimas

Grįžtamojo ryšio matavimas

Patalkink savo WebSocket relę kuo arčiau naudotojų ir matuok kelią, o ne spėliok. Paprastas įvykis, pavyzdžiui, įvesties buferio išvalymas, pakanka grįžtamajam ryšiui išmatuoti:

import time

async def measure_roundtrip(ws):
    """Matuoja tinklo vėlavimą iki 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  # ignoruoti kitus tarpinius įvykius
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Network latency: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Ryšio palaikymas ir prisijungimas iš naujo

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Patikimas ryšys su automatiniu prisijungimu iš naujo."""
    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 kas 20 s
                ping_timeout=10,       # Ping laikotarpio pabaiga 10 s
                close_timeout=5        # Uždarymo laikotarpio pabaiga 5 s
            ) as ws:
                retry_count = 0  # Nustatyti iš naujo sėkmingai prisijungus
                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)

Prisijungimas iš naujo atidaro naują sesiją: ankstesnio pokalbio joje nebėra, be to, sesija trunka daugiausia 60 minučių. Todėl saugok savo exchanges įrašus (transkripcijas, įrankių rezultatus) ir po prisijungimo iš naujo vėl įvesk svarbiausią informaciją naudodamas conversation.item.create.

WebRTC nustatymo spartinimas: WARP

Naršyklės arba vietinės programėlės pusėje OpenAI dokumentuoja WARP (WebRTC Abridged Roundtrip Protocol), kuris sumažina WebRTC sesijos nustatymo laiką derindamas tris transporto optimizacijas: DTLS 1.3, SPED ir SNAP. Tai yra IETF projektai, palaikomi naujausių libwebrtc versijų; savo kliente gali įjungti tuos, kuriuos jis palaiko, po vieną. Gidas WebRTC with WARP išsamiai aprašo konfigūraciją.

Funkcijų kvietimo optimizavimas

Funkcijų kvietimai didina vėlavimą. Optimizuok jų vykdymą:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Vydo funkcijų kvietimus lygiagrečiai."""
    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

# Dažnai naudojamų funkcijų kaupimas į sparčiąją atmintį
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Kaupia dažnų užklausų rezultatus į sparčiąją atmintį."""
    # Duomenų bazės arba API užklausa
    return {"data": "..."}

Vėlavimo stebėsena

Integruok matavimo sistemą, kad nustatytum „butelio kaklelius“:

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)

Svarbiausi punktai

  • Bendras vėlavimas susideda iš VAD, tinklo, modelio ir įrankių laiko: matuok kiekvieną žingsnį, nes OpenAI neskelbia tipinių trukmių
  • silence_duration_ms tiesiogiai valdo laukimo laiką prieš atsakymą; semantic_vad ir jo eagerness yra kitas svertas
  • Glaustos sistemos instrukcijos sumažina modelio apdorojimo laiką
  • Lygiagretus funkcijų kvietimų vykdymas ir kaupimas į sparčiąją atmintį mažina programos vėlavimą
  • Stebėsenos sistema su TTFA (Time-to-First-Audio) yra būtina nuolatiniam optimizavimui