Vėlavimas ir realiojo laiko optimizavimas
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 2 d. — Garso modeliai. Keli šio kurso modeliai yra pasenę:
tts-1,tts-1-hdirgpt-4o-mini-ttsnustos 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-realtimeir 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-transcribeir/v1/audio/translationsnustos 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:
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_mstiesiogiai valdo laukimo laiką prieš atsakymą;semantic_vadir joeagernessyra 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