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

Измерване и анализ на латентност

Урок 1 от 20 Обновен 28 юли 2026 г. Напреднало
На тази страница
  1. Защо латентността е Вашата метрика номер едно
  2. Компоненти на латентността
  3. Диагностициране на тесни места
  4. Ключови изводи

Защо латентността е Вашата метрика номер едно

Когато внедрите приложение, задвижвано от голям езиков модел (LLM), в продукционна среда, латентността, която потребителите възприемат, директно определя нивото на адаптация. Отговор, който се появява след 8 секунди, прогонва 70% от потребителите: те затварят раздела, повтарят заявката или заключават, че инструментът не работи. Никакво подобряване на качеството не може да компенсира тази загуба, защото тя настъпва, преди потребителят дори да прочете отговора.

Предизвикателството в продукционната среда е, че „бавно е“ не е диагноза. Същата продължителност от осем секунди може да произтича от прекалено обемен системен промпт, твърде амбициозна настройка за разсъждение, лошо разположен приложение сървър или пост-обработка, която чака целия отговор, преди да покаже каквото и да е. Всяка причина изисква различно решение, а поправянето на грешната не променя нищо. Този урок Ви учи как да измервате, декомпозирате и диагностицирате латентността от край до край, за да превърнете една оплакване в действие число.

Компоненти на латентността

Общата латентност на API повикването се разпада на четири сегмента, които трябва да разделите. Мрежова латентност е времето за транзит между Вашия сървър и API на OpenAI; тя е невидима в логовете на Вашето приложение, но може да надхвърли 100 милисекунди, ако сървърът Ви е далеч от крайната точка. Време до първия токен (TTFT) измерва забавянето преди генерирането на първия токен: това е сегментът, който потребителите усещат като „чакане“, тъй като екранът остава празен, докато не приключи. Време на изходен токен (TPOT) след това описва скоростта на генериране за всеки следващ токен; умножено по дължината на отговора, то дава продължителността на превъртането на текста. Накрая, латентност на приложението обхваща всичко, което Вашият собствен сървър прави преди и след повикването: извличане на документи, сглобяване на промпта, валидиране на изходния JSON и запис в базата данни.

Тази декомпозиция не е академична упражнение. Екип, който открива, че неговият TTFT е добър, но латентността на приложението добавя две секунди, няма да смени моделите: той ще разгледа своята SQL заявка за извличане на контекст.

Измерване с Python

Ето как да инструментирате повикване към Responses API, за да уловите всеки сегмент:

import time
import openai

client = openai.OpenAI()

def measure_latency(prompt: str, model: str = "gpt-5.6-terra") -> dict:
    """Measure decomposed latency of an API call."""
    metrics = {}

    start_total = time.perf_counter()

    # Stream the call to measure TTFT
    stream = client.responses.create(
        model=model,
        input=prompt,
        stream=True,
    )

    first_token = True
    output_tokens = 0

    for event in stream:
        if event.type == "response.output_text.delta":
            if first_token:
                metrics["ttft"] = time.perf_counter() - start_total
                start_generation = time.perf_counter()
                first_token = False
            output_tokens += 1

    metrics["total_duration"] = time.perf_counter() - start_total
    metrics["output_tokens"] = output_tokens
    if output_tokens > 1:
        metrics["tpot"] = (
            (metrics["total_duration"] - metrics["ttft"]) / (output_tokens - 1)
        )

    return metrics

result = measure_latency("Explain Bayes' theorem in 3 sentences.")
for key, value in result.items():
    print(f"{key}: {value:.4f}" if isinstance(value, float) else f"{key}: {value}")

Ключовото извод от този код е използването на stream=True. Без стрийминг не можете да изолирате TTFT: API връща отговор едва след пълния отговор, така че измервате само общото време. Таймерът стартира преди повикването, спира при първата текстова делта, а останалата продължителност, разделена на броя на останалите токени, дава TPOT. Стартирайте същия промпт срещу два модела или две настройки за разсъждение и в рамките на минути ще имате количественото сравнение, което замества предположенията на Вашия екип.

Диагностициране на тесни места

Висок TTFT, над две секунди, сочи към три причини. Най-честата е прекалено дълъг системен промпт, който не е кеширан: моделът трябва да погълне няколко хиляди токена, преди да започне да пише, при всяко повикване. Следващата е висока настройка за разсъждение – high, xhigh или max на GPT-5.6 – която умишлено кара модела да мисли, преди да произведе видим изход; това не е бъг, а очаквано поведение, но трябва да бъде съзнателен избор, а не настройка, наследена от прототип. Накрая, може да има пик в натоварването от страна на OpenAI, който не можете да контролирате: точно затова се нуждаете от непрекъснато измерване, а не от еднократна проверка, за да го разграничите от другите две.

Висок TPOT, над 50 ms на токен, се чете различно. Много високо max_output_tokens кара модела да произвежда дълги последователности и общата продължителност механично се увеличава, дори ако всеки токен пристига с нормална скорост. Използването на сложно извикване на функции с много декларирани инструменти също натоварва генерирането. Конкретно, екип, който е оставил петнадесет инструмента в своята схема, когато половината вече не се използват, ще плаща тази надбавка при всяко повикване.

Инструменти за мониторинг

Еднократното измерване не е достатъчно: трябва да проследявате разпределението във времето, защото опашката на разпределението генерира тикети за поддръжка. За непрекъснат мониторинг в продукционна среда интегрирайте тези метрики във Вашия стек за наблюдаемост:

import logging
from dataclasses import dataclass, field

@dataclass
class LatencyMetrics:
    """Aggregates latency metrics over a sliding window."""
    measurements: list[dict] = field(default_factory=list)

    def add(self, measurement: dict) -> None:
        self.measurements.append(measurement)
        if len(self.measurements) > 1000:
            self.measurements = self.measurements[-1000:]

    @property
    def ttft_p50(self) -> float:
        values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
        if not values:
            return 0.0
        return values[len(values) // 2]

    @property
    def ttft_p99(self) -> float:
        values = sorted(m["ttft"] for m in self.measurements if "ttft" in m)
        if not values:
            return 0.0
        idx = int(len(values) * 0.99)
        return values[min(idx, len(values) - 1)]

    def report(self) -> str:
        return (
            f"TTFT p50={self.ttft_p50:.3f}s p99={self.ttft_p99:.3f}s | "
            f"Samples: {len(self.measurements)}"
        )

Плъзгащият прозорец от хиляда измервания предотвратява неограничен растеж на паметта, като същевременно запазва представителна извадка от скорошния трафик. От съществено значение е, че този клас излага два перцентила, а не средна стойност: p50 от 700 ms с p99 от 6 секунди описва услуга, която повечето потребители намират за бърза, а малцинството – за неизползваема. Средната стойност би маскирала и двете реалности. Свържете report() към Вашия инструмент за метрики и задайте праг за предупреждение за p99, преди да пипнете останалата част от системата.

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

  • Латентността се декомпозира на TTFT + генериране (TPOT × токени) + мрежа
  • Винаги измервайте със стрийминг, за да получите реален TTFT
  • Проследявайте перцентилите p50 и p99, а не само средната стойност
  • Изборът на модел и настройките за разсъждение директно влияят на латентността: GPT-5.6 Terra с ниско разсъждение отговаря по-бързо от GPT-5.6 Sol с високо разсъждение