Przejdź do głównej treści
Polski— Wybierz język
Menu

Optymalizacja opóźnień i działania w czasie rzeczywistym

Lekcja 17 z 18 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Optymalizacja opóźnień i działania w czasie rzeczywistym
  2. Anatomia opóźnienia
  3. Optymalizacja wykrywania VAD
  4. Optymalizacja instrukcji systemowych
  5. Redukcja opóźnień sieciowych
  6. Optymalizacja wywoływania funkcji
  7. Monitorowanie opóźnień
  8. Kluczowe wnioski

Zaktualizowano 2 listopada 2026 — Modele audio. Kilka modeli w tym kursie jest przestarzałych: tts-1, tts-1-hd oraz gpt-4o-mini-tts przestaną działać 6 stycznia 2027 r. (następca: gpt-realtime-2.1-mini, który zgodnie z przewodnikiem OpenAI TTS nie jest obsługiwany przez /v1/audio/speech: migracja syntezy głosu przechodzi do Realtime API); gpt-realtime, gpt-4o-realtime oraz starsze modele audio 20 stycznia 2027 r. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe oraz /v1/audio/translations 26 lutego 2027 r. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). W przypadku głosu pełnodupleksowego GPT-Live 1 jest dostępny w API od 10 września 2026 r.

Skorygowano 3 listopada 2026 r. Czasy przypisane do każdego etapu („VAD 300–700 ms“, „sieć 20–100 ms“, „model 200–800 ms“) oraz progi percepcji („powyżej 500 ms“) nie miały źródeł: OpenAI nie publikuje takich danych, dlatego lekcja uczy teraz, jak je mierzyć. Usunięto zalecenie umieszczania serwera „w tym samym regionie co serwery OpenAI (US East)“ z powodu braku potwierdzenia. Dodano udokumentowane elementy: semantic_vad, WARP przyspieszający nawiązywanie sesji WebRTC. Źródła: Wykrywanie aktywności głosowej · WebRTC z WARP · Optymalizacja kosztów.

Optymalizacja opóźnień i działania w czasie rzeczywistym

Opóźnienie to główny wróg agenta głosowego: cisza następująca po zakończeniu pytania jest natychmiast zauważalna w rozmowie telefonicznej lub w aplikacji. W tej lekcji szczegółowo omówimy źródła opóźnień, metody ich pomiaru oraz techniki ich redukcji.

Anatomia opóźnienia

Całkowite opóźnienie agenta głosowego to suma kilku składników:

VAD
Oczekiwanie na ciszę kończącą turę (`silence_duration_ms`)
Sieć
Cykle wymiany danych między użytkownikiem, Twoim serwerem a API
Model
Przetwarzanie kontekstu, a następnie pierwszy fragment audio

W zależności od Twojej architektury dodaj czasy wywoływania narzędzi przez agenta oraz czas inicjalizacji sesji. Żaden z tych czasów nie jest stały: zależą one od Twoich ustawień, długości rozmowy i ścieżki sieciowej. Jedynym sposobem, aby dowiedzieć się, gdzie ucieka czas, jest mierzenie każdego kroku, tak jak robi to przedstawiony poniżej monitor.

Optymalizacja wykrywania VAD

Przy użyciu server_vad odpowiedź nie może rozpocząć się przed upływem ciszy zdefiniowanej przez silence_duration_ms: jest to więc bezpośrednie ustawienie wpływające na postrzegane opóźnienie, które należy zrównoważyć z ryzykiem przerwania użytkownikowi. Poniższe wartości to punkty wyjścia do testów, a nie rekomendacje OpenAI:

# Konfiguracja agresywna (szybka odpowiedź, ryzyko ucięcia wypowiedzi użytkownika)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # Wyższy próg = mniej fałszywych wykryć
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Szybka reakcja
}

# Konfiguracja cierpliwa (mniej przerwań, większe opóźnienie)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Alternatywa: semantic VAD, który ocenia koniec zdania na podstawie słów;
# eagerness "high" odpowiada natychmiast, "low" pozwala użytkownikowi dokończyć
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Konfiguracja adaptacyjna w zależności od kontekstu
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
    }

Optymalizacja instrukcji systemowych

Zwięzłe instrukcje redukują kontekst do przetworzenia. Pamiętaj też, że Realtime API automatycznie stosuje buforowanie promptów: stabilne instrukcje i narzędzia, umieszczone na początku i niemodyfikowane podczas sesji, są wykorzystywane z tury na turę.

# Rozgadane instrukcje (więcej tokenów do przetworzenia)
bad_instructions = """
Jesteś inteligentnym i kompetentnym asystentem głosowym pracującym
dla Corsen AI, francuskiej firmy specjalizującej się w
sztucznej inteligencji. Musisz odpowiadać na pytania użytkownika
profesjonalnie, zwięźle i w języku francuskim.
Masz dostęp do różnych narzędzi do sprawdzania spotkań,
dostępności i dokonywania rezerwacji.
Nie wahaj się prosić o wyjaśnienia, jeśli żądanie jest niejasne.
"""

# Zoptymalizowane instrukcje (ten sam efekt, mniej tokenów)
good_instructions = """
Asystent głosowy Corsen AI. Francuski, zwięzły, profesjonalny.
Używaj narzędzi do spotkań i rezerwacji.
W razie potrzeby pytaj o wyjaśnienia.
"""

Redukcja opóźnień sieciowych

Pomiar czasu round-trip

Umieść swoje przekaźniki WebSocket jak najbliżej użytkowników i mierz ścieżkę, zamiast zakładać jej parametry. Proste zdarzenie, takie jak wyczyszczenie bufora wejściowego, wystarczy do zmierzenia czasu round-trip:

import time

async def measure_roundtrip(ws):
    """Mierzy opóźnienie sieciowe do 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  # ignoruj inne zdarzenia przychodzące w międzyczasie
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Opóźnienie sieciowe: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Keepalive i ponowne łączenie

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Solidne połączenie z automatycznym ponownym łączeniem."""
    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 co 20 s
                ping_timeout=10,       # Limit czasu pingu 10 s
                close_timeout=5        # Limit czasu zamknięcia 5 s
            ) as ws:
                retry_count = 0  # Reset przy udanym połączeniu
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Ponowne łączenie za {wait}s...")
            await asyncio.sleep(wait)

Ponowne połączenie otwiera nową sesję: poprzednia rozmowa znika, a sesja i tak trwa maksymalnie 60 minut. Dlatego prowadź własny rejestr wymiany danych (transkrypcje, wyniki narzędzi) i po ponownym połączeniu wstrzyknij niezbędne elementy za pomocą conversation.item.create.

Przyspieszanie konfiguracji WebRTC: WARP

Po stronie przeglądarki lub aplikacji natywnej OpenAI dokumentuje WARP (WebRTC Abridged Roundtrip Protocol), który skraca czas nawiązywania sesji WebRTC dzięki połączeniu trzech optymalizacji transportu: DTLS 1.3, SPED i SNAP. Są to projekty IETF, obsługiwane przez najnowsze wersje libwebrtc; możesz włączyć te, które obsługuje Twój klient, pojedynczo. Przewodnik WebRTC with WARP szczegółowo opisuje konfigurację.

Optymalizacja wywoływania funkcji

Wywołania funkcji dodają opóźnienia. Zoptymalizuj ich wykonywanie:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Wykonuje wywołania funkcji równolegle."""
    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

# Bufor dla częstych funkcji
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Buforuje wyniki częstych żądań."""
    # Zapytanie do bazy danych lub API
    return {"data": "..."}

Monitorowanie opóźnień

Zintegruj system pomiarowy, aby identyfikować wąskie gardła:

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)

Kluczowe wnioski

  • Całkowite opóźnienie to suma VAD, sieci, modelu i narzędzi: mierz każdy krok, OpenAI nie publikuje typowych czasów
  • silence_duration_ms bezpośrednio kontroluje czas oczekiwania przed odpowiedzią; semantic_vad i jego eagerness to druga dźwignia
  • Zwięzłe instrukcje systemowe redukują czas przetwarzania przez model
  • Równoległe wykonywanie wywołań funkcji i buforowanie redukują opóźnienia aplikacji
  • System monitorowania z TTFA (Time-to-First-Audio) jest niezbędny do ciągłej optymalizacji