Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Viive ja reaaliaikainen optimointi

Oppitunti 17 / 18 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Viive ja reaaliaikainen optimointi
  2. Viiveen anatomia
  3. VAD-tunnistuksen optimointi
  4. Järjestelmäohjeiden optimointi
  5. Verkkoviiveen vähentäminen
  6. Funktiokutsujen optimointi
  7. Viiveen seuranta
  8. Keskeiset asiat

Päivitetty 2. marraskuuta 2026 — Äänimallit. Useat tämän kurssin malleista on poistettu käytöstä: tts-1, tts-1-hd ja gpt-4o-mini-tts lakkaavat 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-realtime ja vanhat äänimallit 20. tammikuuta 2027 (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe ja /v1/audio/translations 26. 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:

VAD
Odottaa vuoron päättävää hiljaisuutta (`silence_duration_ms`)
Verkko
Käyttäjän, palvelimesi ja API:n väliset edestakaiset kierrokset
Malli
Kontekstin käsittely, sitten ensimmäinen äänipala

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_ms ohjaa suoraan odotusaikaa ennen vastetta; semantic_vad ja sen eagerness ovat 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