Viive ja reaaliaikainen optimointi
Tällä sivulla
Päivitetty 2. marraskuuta 2026 — Äänimallit. Useat tämän kurssin malleista on poistettu käytöstä:
tts-1,tts-1-hdjagpt-4o-mini-ttslakkaavat toimimasta 6. tammikuuta 2027 (seuraaja:gpt-realtime-2.1-mini, jonka OpenAI:n TTS-opas ilmoittaa ei tukevan/v1/audio/speech: äänisynteesin siirtyminen tapahtuu Realtime API:n kautta);gpt-realtime,gpt-4o-realtimeja vanhat äänimallit 20. tammikuuta 2027 (gpt-realtime-2.1,gpt-realtime-2.1-mini,gpt-audio-1.5);whisper-1,gpt-4o-transcribeja/v1/audio/translations26. helmikuuta 2027 (gpt-transcribe,gpt-live-transcribe,v1/realtime/translations). Täysdupleksista ääntä varten GPT-Live 1 on ollut saatavilla API:ssa 10. syyskuuta 2026 lähtien.
Korjattu 3. marraskuuta 2026. Kullekin vaiheelle määritetyt kestot (“VAD 300–700 ms”, “verkko 20–100 ms”, “malli 200–800 ms”) ja havaintokynnykset (“yli 500 ms”) olivat vailla lähteitä: OpenAI ei julkaise tällaisia lukuja, ja oppitunti opettaa nyt, miten ne mitataan. Ohje sijoittaa palvelimesi “samalle alueelle kuin OpenAI:n palvelimet (US East)” poistettiin lähteiden puutteen vuoksi. Dokumentoidut lisäykset:
semantic_vad, WARP WebRTC-istunnon muodostamisen nopeuttamiseen. Lähteet: Voice activity detection · WebRTC with WARP · Cost optimization.
Viive ja reaaliaikainen optimointi
Viive on puheagentin pahin vihollinen: kysymyksen päättymisen jälkeinen hiljaisuus huomataan välittömästi puhelimessa tai sovelluksessa. Tämä oppitunti käsittelee viiveen lähteitä, niiden mittaamista ja vähentämistekniikoita.
Viiveen anatomia
Puheagentin kokonaisviive on useiden komponenttien summa:
Arkkitehtuuristasi riippuen lisää agentin kutsumat työkalut ja istunnon muodostusaika. Mikään näistä kestosta ei ole kiinteä: ne riippuvat asetuksistasi, keskustelun pituudesta ja verkkoreitistä. Ainoa tapa selvittää, mihin aika kuluu, on mitata jokainen vaihe erikseen, kuten alla esitetty monitori tekee.
VAD-tunnistuksen optimointi
server_vad:lla vaste ei voi alkaa ennen kuin silence_duration_ms:llä määritelty hiljaisuus päättyy: tämä on siis suora asetus koetulle viiveelle, joka on tasapainotettava käyttäjän keskeyttämisen riskin kanssa. Alla olevat arvot ovat testattavia lähtökohtia, eivät OpenAI:n suosituksia:
# Aggressiivinen konfiguraatio (nopea vaste, riski katkaista käyttäjä)
fast_vad = {
"type": "server_vad",
"threshold": 0.6, # Korkeampi kynnys = vähemmän vääriä positiivisia
"prefix_padding_ms": 200,
"silence_duration_ms": 400 # Nopea reaktio
}
# Kärsivällinen konfiguraatio (vähemmän keskeytyksiä, enemmän viivettä)
patient_vad = {
"type": "server_vad",
"threshold": 0.4,
"prefix_padding_ms": 400,
"silence_duration_ms": 800
}
# Vaihtoehto: semanttinen VAD, joka arvioi lauseen lopun sanojen perusteella;
# eagerness "high" vastaa heti, "low" antaa käyttäjän lopettaa
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}
# Kontekstiin perustuva mukautuva konfiguraatio
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
}
Järjestelmäohjeiden optimointi
Tiiviit ohjeet vähentävät käsiteltävää kontekstia. Muista myös, että Realtime API soveltaa kehotevälimuistia (prompt caching) automaattisesti: vakaat ohjeet ja työkalut, jotka on sijoitettu alkuun eikä niitä muokata istunnon aikana, uudelleenkäytetään vuorosta toiseen.
# Laajat ohjeet (enemmän tokeneita käsiteltäväksi)
bad_instructions = """
Olet älykäs ja pätevä puheassistentti, joka työskentelee
Corsen AI:lle, tekoälyyn erikoistuneelle ranskalaiselle yritykselle.
Sinun on vastattava käyttäjien kysymyksiin ammattimaisesti,
tiiviisti ja ranskaksi.
Sinulla on käytössäsi erilaisia työkaluja tapaamisten katseluun,
saatavuuden tarkistamiseen ja varausten tekemiseen.
Älä epäröi pyytää tarkennusta, jos pyyntö on epäselvä.
"""
# Optimoidut ohjeet (sama vaikutus, vähemmän tokeneita)
good_instructions = """
Corsen AI:n puheassistentti. Ranska, tiivis, ammattimainen.
Käytä työkaluja tapaamisiin ja varauksiin.
Pyydä tarkennusta tarvittaessa.
"""
Verkkoviiveen vähentäminen
Edestakaisen kierron mittaaminen
Sijoita WebSocket-välityspalvelimesi mahdollisimman lähelle käyttäjiäsi ja mittaa reitti äläkä oleta sitä. Yksinkertainen tapahtuma, kuten syöttöpuskurin tyhjennys, riittää edestakaisen kierron ajoittamiseen:
import time
async def measure_roundtrip(ws):
"""Mittaa verkkoviiveen Realtime API:hun."""
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 # ohita muut tapahtumat, jotka saapuvat välillä
roundtrip_ms = (time.monotonic() - start) * 1000
print(f"Verkkoviive: {roundtrip_ms:.0f} ms")
return roundtrip_ms
Ylläpito ja uudelleenyhdistäminen
import asyncio
import websockets
async def robust_connection(api_key: str, max_retries: int = 5):
"""Varmayhteys automaattisella uudelleenyhdistämisellä."""
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 joka 20. sekunti
ping_timeout=10, # Ping-aikakatkaisu 10 s
close_timeout=5 # Sulkemisaikakatkaisu 5 s
) as ws:
retry_count = 0 # Nollaa onnistuneen yhteyden jälkeen
yield ws
except websockets.exceptions.ConnectionClosed:
retry_count += 1
wait = min(2 ** retry_count, 30)
print(f"Yhdistetään uudelleen {wait} s kuluttua...")
await asyncio.sleep(wait)
Uudelleenyhdistäminen avaa uuden istunnon: edellistä keskustelua ei enää ole, ja istunto kestää joka tapauksessa enintään 60 minuuttia. Pidä siis oma kirjasi vaihdoista (transkriptiot, työkalujen tulokset) ja injisoi oleelliset tiedot takaisin conversation.item.create:lla uudelleenyhdistämisen jälkeen.
WebRTC-asetuksen nopeuttaminen: WARP
Selaimen tai natiivisovelluksen puolella OpenAI dokumentoi WARP:n (WebRTC Abridged Roundtrip Protocol), joka lyhentää WebRTC-istunnon muodostusaikaa yhdistämällä kolme kuljetusoptimointia: DTLS 1.3, SPED ja SNAP. Nämä ovat IETF-luonnoksia, joita tukevat uusimmat libwebrtc-versiot; voit ottaa käyttöön ne, joita asiakkaasi tukee, yksi kerrallaan. WebRTC with WARP -opas yksityiskohtaa konfiguraation.
Funktiokutsujen optimointi
Funktiokutsut lisäävät viivettä. Optimoi niiden suoritus:
import asyncio
async def execute_functions_parallel(function_calls: list) -> list:
"""Suorittaa funktiokutsut rinnakkain."""
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
# Välimuisti usein käytetyille funktioille
from functools import lru_cache
@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
"""Välimuistaa usein toistuvien pyyntöjen tulokset."""
# Tietokanta- tai API-kysely
return {"data": "..."}
Viiveen seuranta
Integroi mittausjärjestelmä pullonkaulojen tunnistamiseksi:
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)
Keskeiset asiat
- Kokonaisviive muodostuu VAD:n, verkon, mallin ja työkalujen summasta: mittaa jokainen vaihe, OpenAI ei julkaise tyypillisiä kestoaikoja
silence_duration_msohjaa suoraan odotusaikaa ennen vastetta;semantic_vadja seneagernessovat toinen vipu- Tiiviit järjestelmäohjeet vähentävät mallin käsittelyaikaa
- Funktiokutsujen rinnakkainen suoritus ja välimuisti vähentävät sovellusviivettä
- TTFA (Time-to-First-Audio) -mittausjärjestelmä on välttämätön jatkuvaa optimointia varten