Премини към основното съдържание
Български— Изберете език
Меню

Латентност и оптимизация в реално време

Урок 17 от 18 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Латентност и оптимизация в реално време
  2. Анатомия на латентността
  3. Оптимизиране на откриването на VAD
  4. Оптимизиране на системните инструкции
  5. Намаляване на мрежовата латентност
  6. Оптимизиране на извикването на функции
  7. Мониторинг на латентността
  8. Ключови изводи

Обновено на 2 ноември 2026 г. — Аудио модели. Няколко модела в този курс са депрецирали: tts-1, tts-1-hd и gpt-4o-mini-tts ще спрат работа на 6 януари 2027 г. (наследник: gpt-realtime-2.1-mini, който според ръководството на OpenAI за TTS не се поддържа от /v1/audio/speech: миграцията на синтез на глас преминава към Realtime API); gpt-realtime, gpt-4o-realtime и наследените аудио модели на 20 януари 2027 г. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe и /v1/audio/translations на 26 февруари 2027 г. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). За двупосочен гласов режим (full-duplex), GPT-Live 1 е наличен в API от 10 септември 2026 г.

Коригирано на 3 ноември 2026 г. Продължителностите, присвоени на всяка стъпка („VAD 300-700 мс“, „мрежа 20-100 мс“, „модел 200-800 мс“) и праговете на възприятие („над 500 мс“) нямаха източници: OpenAI не публикува такива цифри и урокът сега Ви учи как да ги измервате. Инструктажът за разполагане на сървъра Ви „в същия регион като сървърите на OpenAI (US East)“ беше премахнат поради липса на източници. Документирани добавки: semantic_vad, WARP за ускоряване на установяването на WebRTC сесия. Източници: Откриване на гласова активност · WebRTC с WARP · Оптимизация на разходите.

Латентност и оптимизация в реално време

Латентността е враг номер едно на гласовия агент: тишината след края на въпроса се забелязва веднага по телефона или в приложението. Този урок описва източниците на латентност, как да ги измервате и техники за тяхното намаляване.

Анатомия на латентността

Общата латентност на гласовия агент е сбор от няколко компонента:

VAD
Изчакване на тишината, която завършва репликата (`silence_duration_ms`)
Мрежа
Пътувания туда-назад между потребителя, Вашия сървър и API
Модел
Обработка на контекста, след което първият аудио чънк

В зависимост от Вашата архитектура, добавете инструментите, които агентът извиква, и времето за настройка на сесията. Никоя от тези продължителности не е фиксирана: те зависят от Вашите настройки, дължината на разговора и мрежовия път. Единственият начин да разберете къде отива времето, е да измервате всяка стъпка, както прави мониторът, представен по-долу.

Оптимизиране на откриването на VAD

При server_vad отговорът не може да започне, преди да приключи тишината, дефинирана от silence_duration_ms: това е пряка настройка за възприеманата латентност, която трябва да се балансира срещу риска от прекъсване на потребителя. Стойностите по-долу са отправни точки за тестване, а не препоръки на OpenAI:

# Агресивна конфигурация (бърз отговор, риск от прекъсване на потребителя)
fast_vad = {
    "type": "server_vad",
    "threshold": 0.6,           # По-висок праг = по-малко фалшиви положителни резултати
    "prefix_padding_ms": 200,
    "silence_duration_ms": 400  # Бърза реакция
}

# Търпелива конфигурация (по-малко прекъсвания, повече латентност)
patient_vad = {
    "type": "server_vad",
    "threshold": 0.4,
    "prefix_padding_ms": 400,
    "silence_duration_ms": 800
}

# Алтернатива: семантичен VAD, който преценява края на изречението въз основа на думи;
# eagerness "high" отговаря възможно най-бързо, "low" оставя потребителя да довърши
semantic_vad = {"type": "semantic_vad", "eagerness": "high"}

# Адаптивна конфигурация въз основа на контекста
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
    }

Оптимизиране на системните инструкции

Кратките инструкции намаляват контекста за обработка. Също така имайте предвид, че Realtime API прилага автоматично кеширане на промптове: стабилни инструкции и инструменти, поставени в началото и никога не модифицирани по време на сесия, се преизползват от реплика на реплика.

# Подробни инструкции (повече токени за обработка)
bad_instructions = """
Вие сте интелигентен и компетентен гласов асистент, работещ
за Corsen AI, френска компания, специализирана в
изкуствения интелект. Трябва да отговаряте на въпросите на потребителя
професионално, сбито и на френски език.
Имате достъп до различни инструменти за консултиране на срещи,
проверка на наличността и правене на резервации.
Не се колебайте да поискате изясняване, ако заявката е неясна.
"""

# Оптимизирани инструкции (същият ефект, по-малко токени)
good_instructions = """
Гласов асистент на Corsen AI. Френски, сбит, професионален.
Използвайте инструменти за срещи и резервации.
Поискайте изясняване, ако е необходимо.
"""

Намаляване на мрежовата латентност

Измерване на пътуването туда-назад

Разположете Вашето WebSocket реле възможно най-близо до Вашите потребители и измервайте пътя, вместо да го предполагате. Едно просто събитие, като изчистване на входния буфер, е достатъчно за измерване на пътуване туда-назад:

import time

async def measure_roundtrip(ws):
    """Измерва мрежовата латентност към 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  # игнорира други събития, пристигащи междувременно
    roundtrip_ms = (time.monotonic() - start) * 1000
    print(f"Мрежова латентност: {roundtrip_ms:.0f} ms")
    return roundtrip_ms

Поддържане на връзката и повторно свързване

import asyncio
import websockets

async def robust_connection(api_key: str, max_retries: int = 5):
    """Стабилна връзка с автоматично повторно свързване."""
    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 на всеки 20 сек.
                ping_timeout=10,       # Таймаут на ping 10 сек.
                close_timeout=5        # Таймаут на затваряне 5 сек.
            ) as ws:
                retry_count = 0  # Нулиране при успешно свързване
                yield ws

        except websockets.exceptions.ConnectionClosed:
            retry_count += 1
            wait = min(2 ** retry_count, 30)
            print(f"Повторно свързване след {wait} сек...")
            await asyncio.sleep(wait)

Повторното свързване отваря нова сесия: предишният разговор вече го няма, а една сесия трае най-много 60 минути anyway. Затова пазете собствен запис на размените (транскрипции, резултати от инструменти) и инжектирайте отново същественото с conversation.item.create след повторно свързване.

Ускоряване на настройката на WebRTC: WARP

От страната на браузъра или нативното приложение, OpenAI документира WARP (WebRTC Abridged Roundtrip Protocol), което намалява времето за установяване на WebRTC сесия чрез комбиниране на три транспортни оптимизации: DTLS 1.3, SPED и SNAP. Това са чернови на IETF, поддържани от последните версии на libwebrtc; можете да активирате тези, които Вашият клиент поддържа, едно по едно. Ръководството WebRTC с WARP описва конфигурацията в детайли.

Оптимизиране на извикването на функции

Извикванията на функции добавят латентност. Оптимизирайте тяхното изпълнение:

import asyncio

async def execute_functions_parallel(function_calls: list) -> list:
    """Изпълнява извикванията на функции паралелно."""
    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

# Кеш за чести функции
from functools import lru_cache

@lru_cache(maxsize=100)
def get_cached_data(key: str) -> dict:
    """Кешира резултатите от чести заявки."""
    # Заявка към база данни или API
    return {"data": "..."}

Мониторинг на латентността

Интегрирайте система за измерване, за да идентифицирате тесните места:

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)

Ключови изводи

  • Общата латентност събира VAD, мрежа, модел и инструменти: измервайте всяка стъпка, OpenAI не публикува типични продължителности
  • silence_duration_ms директно контролира изчакването преди отговор; semantic_vad и неговият eagerness са другият лост
  • Кратките системни инструкции намаляват времето за обработка на модела
  • Паралелното изпълнение на извиквания на функции и кеширането намаляват латентността на приложението
  • Система за мониторинг с TTFA (Time-to-First-Audio) е от съществено значение за непрекъсната оптимизация