Latenz ja reaalaja optimeerimine
Sellel lehel
Uuendatud 2. novembril 2026 – Helimudelid. Selles kursuses on mitu mudelit aegunud:
tts-1,tts-1-hdjagpt-4o-mini-ttslõpetavad töö 6. jaanuaril 2027 (järeltulija:gpt-realtime-2.1-mini, mille OpenAI TTS-i juhend märgib kui mittetoetatud/v1/audio/speechpoolt: häälesünteesi migratsioon liigub Realtime API-le);gpt-realtime,gpt-4o-realtimeja vanad helimudelid 20. jaanuaril 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeja/v1/audio/translations26. veebruaril 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Täisdupleks-hääle jaoks on GPT-Live 1 olnud API-s saadaval alates 10. septembrist 2026.
Parandatud 3. novembril 2026. Igale sammule omistatud kestused („VAD 300–700 ms“, „võrk 20–100 ms“, „mudel 200–800 ms“) ja tajuläved („üle 500 ms“) olid allikata: OpenAI ei avalda selliseid numbreid ja see õppetund õpetab sind nüüd neid mõõtma. Juhend paigutada oma server „samasse piirkonda OpenAI serveritega (US East)“ eemaldati allika puudumise tõttu. Dokumenteeritud lisandused:
semantic_vad, WARP WebRTC-seansi loomise kiirendamiseks. Allikad: Hääleaktiivsuse tuvastamine · WebRTC koos WARP-iga · Kulude optimeerimine.
Latenz ja reaalaja optimeerimine
Latenz on hääleagendi vaenlane number üks: vaikus pärast küsimuse lõppu on telefonis või rakenduses koheselt märgatav. See õppetund kirjeldab latentsuse allikaid, selle mõõtmise viise ja vähendamise tehnikaid.
Latentsuse anatoomia
Hääleagendi kogulatenz on mitme komponendi summa:
Sõltuvalt sinu arhitektuurist lisa agendi poolt kutsutavad tööriistad ja seansi lähtestamise aeg. Ükski neist kestustest ei ole fikseeritud: need sõltuvad sinu seadetest, vestluse pikkusest ja võrguteest. Ainuke viis teada saada, kuhu aeg kulub, on iga sammu ajastamine, nagu seda teeb allpool esitatud monitor.
VAD-tuvastuse optimeerimine
server_vad korral ei saa vastus alata enne, kui silence_duration_ms-ga määratud vaikus on lõppenud: see on seega otsene seade tajutava latentsuse jaoks, mida tuleb tasakaalustada kasutaja katkestamise riskiga. Allpool toodud väärtused on testitavad lähtepunktid, mitte OpenAI soovitused:
# Agresiivne konfiguratsioon (kiire vastus, oht kasutaja katkestamiseks)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Kõrgem lävi = vähem valepositiive
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Kiire reaktsioon
}
# Kannatlik konfiguratsioon (vähem katkestusi, suurem latentsus)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Alternatiiv: semantiline VAD, mis hindab lause lõppu sõnade põhjal;
# eagerness "high" vastab nii ruttu kui võimalik, "low" laseb kasutajal lõpetada
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Kontekstipõhine adaptiivne konfiguratsioon
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
}
Süsteemijuhiste optimeerimine
Lühikesed juhised vähendavad töödeldavat konteksti. Pea meeles ka, et Realtime API rakendab vihjete vahemällu salvestamist (prompt caching) automaatselt: stabiilsed juhised ja tööriistad, mis on paigutatud ülesossa ja mida seansi jooksul kunagi ei muudeta, kasutatakse pöördelt pöördele uuesti.
# Üleliia detailsed juhised (rohkem töödeldavaid tokeneid)
bad_instructions = """
Sa oled intelligentne ja pädev hääleassistent, kes töötab
Corsen AI jaoks, Prantsuse ettevõte, mis on spetsialiseerunud
tehisintellektile. Sa pead vastama kasutaja küsimustele
professionaalselt, lühidalt ja prantsuse keeles.
Sul on juurdepääs erinevatele tööriistadele kohtumiste konsulteerimiseks,
saadavuse kontrollimiseks ja broneeringute tegemiseks.
Ära kõhkle täpsustust küsida, kui päring on ebaselge.
"""
# Optimeeritud juhised (sama efekt, vähem tokeneid)
good_instructions = """
Corsen AI hääleassistent. Prantsuse keel, lühidalt, professionaalselt.
Kasuta tööriistu kohtumiste ja broneeringute jaoks.
Küsi vajadusel täpsustust.
"""
Võrgulatenzuse vähendamine
Edasi-tagasi reisi mõõtmine
Paiguta oma WebSocket-relee oma kasutajatele nii lähedale kui võimalik ja mõõda teed, selle asemel et seda eeldada. Lihtne sündmus, nagu sisendpuhvri tühjendamine, piisab edasi-tagasi reisi ajastamiseks:
import time
async def measure_roundtrip(ws):
"""Mõõdab võrgulatenzust Realtime API-ni."""
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 # ignoreeri teisi vahepeal saabuvaid sündmusi
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Võrgulatenz: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Püsiühendus ja uuesti ühendamine
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Tugev ühendus automaatse uuesti ühendamisega."""
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 iga 20 s järel
ping_timeout=10, # Pingu aegumine 10 s
close_timeout=5 # Sulgemise aegumine 5 s
) as ws:
retry_count = 0 # Lähtesta eduka ühenduse korral
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Uuesti ühendamine {wait}s pärast...")
await asyncio.sleep(wait)
Uuesti ühendamine avab uue seansi: eelmine vestlus on kadunud ja seanss kestab niigi maksimaalselt 60 minutit. Seega pea oma vahetuste kirja (transkriptsioonid, tööriistade tulemused) ja süsti oluline uuesti sisse käsuga conversation.item.create pärast uuesti ühendumist.
WebRTC-seansi loomise kiirendamine: WARP
Brauseri või nativrakenduse poolel dokumenteerib OpenAI WARP-i (WebRTC Abridged Roundtrip Protocol), mis vähendab WebRTC-seansi loomise aega, kombineerides kolme transpordi optimeerimist: DTLS 1.3, SPED ja SNAP. Need on IETF-i eelnõud, mida toetavad libwebrtc-i värsked versioonid; saad lubada need, mida sinu klient toetab, ükshaaval. WebRTC koos WARP-iga juhend kirjeldab konfiguratsiooni üksikasjalikult.
Funktsioonikutsete optimeerimine
Funktsioonikutsumine lisab latentsust. Optimeeri nende täitmist:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Täidab funktsioonikutseid paralleelselt."""
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
# Vahemälu sagedastele funktsioonidele
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Salvestab sagedaste päringute tulemused vahemällu."""
# Andmebaasi või API päring
return {"data": "..."}
Latentsuse jälgimine
Integreeri mõõtesüsteem kitsaskohtade tuvastamiseks:
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)
Peamised punktid
- Kogulatenz liidab kokku VAD-i, võrgu, mudeli ja tööriistad: mõõda iga sammu, OpenAI ei avalda tüüpilisi kestusi
silence_duration_mskontrollib otseselt ooteaega enne vastust;semantic_vadja selleeagernesson teine hoob- Lühikesed süsteemijuhised vähendavad mudeli töötlemisaega
- Funktsioonikutsete paralleeltäitmine ja vahemällu salvestamine vähendavad rakenduse latentsust
- TTFA-ga (Time-to-First-Audio) jälgimissüsteem on pidevaks optimeerimiseks hädavajalik