Измерване и анализ на латентност
На тази страница
Защо латентността е Вашата метрика номер едно
Когато внедрите приложение, задвижвано от голям езиков модел (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 с високо разсъждение