Mierzenie i analiza opóźnień
Na tej stronie
Dlaczego opóźnienie jest Twoją najważniejszą metryką
Gdy wdrażasz aplikację opartą na dużych modelach językowych (LLM) w środowisku produkcyjnym, opóźnienie odczuwane przez użytkowników bezpośrednio decyduje o adopcji produktu. Odpowiedź, która pojawia się po 8 sekundach, odstrasza 70% użytkowników: zamykają oni kartę, ponawiają żądanie lub wnioskują, że narzędzie nie działa. Żadna poprawa jakości nie zrekompensuje tej straty, ponieważ następuje ona zanim użytkownik zdąży przeczytać odpowiedź.
Wyzwaniem w środowisku produkcyjnym jest fakt, że stwierdzenie „to działa wolno“ nie jest diagnozą. Te same osiem sekund może wynikać ze zbyt długiego promptu systemowego, nadmiernie ambitnego ustawienia rozumowania, źle umiejscowionego serwera aplikacji lub przetwarzania końcowego, które czeka na pełną odpowiedź przed wyświetleniem czegokolwiek. Każda przyczyna wymaga innego rozwiązania, a naprawienie niewłaściwej nic nie zmieni. Ta lekcja nauczy Cię mierzyć, dekomponować i diagnozować opóźnienie end-to-end, abyś mógł przekształcić skargę w konkretną liczbę, na podstawie której można działać.
Składowe opóźnienia
Całkowite opóźnienie wywołania API dzieli się na cztery segmenty, które musisz rozróżnić. Opóźnienie sieciowe to czas przesyłu między Twoim serwerem a API OpenAI; jest ono niewidoczne w logach aplikacji, ale może przekroczyć 100 milisekund, jeśli Twój serwer znajduje się daleko od punktu końcowego. Czas do pierwszego tokenu (TTFT) mierzy opóźnienie przed wygenerowaniem pierwszego tokenu: to segment, który użytkownicy odczuwają jako „oczekiwanie“, ponieważ ekran pozostaje pusty aż do jego zakończenia. Czas na token wyjściowy (TPOT) opisuje następnie szybkość generowania każdego kolejnego tokenu; pomnożony przez długość odpowiedzi daje czas przewijania tekstu. Na koniec, opóźnienie aplikacji obejmuje wszystko, co Twój własny serwer wykonuje przed i po wywołaniu: pobieranie dokumentów, składanie promptu, walidację wyjściowego JSON-a i zapis do bazy danych.
Ta dekompozycja nie jest ćwiczeniem akademickim. Zespół, który odkryje, że jego TTFT jest w porządku, ale opóźnienie aplikacji dodaje dwie sekundy, nie będzie zmieniał modeli: przeanalizuje swoje zapytanie SQL pobierające kontekst.
Pomiary w Pythonie
Oto sposób instrumentacji wywołania API Responses w celu przechwycenia każdego segmentu:
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}")
Kluczowym wnioskiem z tego kodu jest użycie stream=True. Bez strumieniowania nie możesz wyizolować TTFT: API zwraca wynik dopiero po uzyskaniu pełnej odpowiedzi, więc mierzysz tylko czas całkowity. Timer uruchamia się przed wywołaniem, zatrzymuje przy pierwszym delta tekstu, a pozostały czas podzielony przez liczbę pozostałych tokenów daje TPOT. Uruchom ten sam prompt przeciwko dwóm modelom lub dwóm ustawieniom rozumowania, a w ciągu kilku minut uzyskasz ilościowe porównanie, które zastąpi domysły Twojego zespołu.
Diagnozowanie wąskich gardeł
Wysokie TTFT, powyżej dwóch sekund, wskazuje na trzy przyczyny. Najczęstszą jest zbyt długi prompt systemowy, który nie jest buforowany w pamięci podręcznej: model musi przetworzyć kilka tysięcy tokenów przed rozpoczęciem pisania, przy każdym wywołaniu. Kolejną przyczyną jest wysokie ustawienie rozumowania – high, xhigh lub max w GPT-5.6 – które celowo заставляет model „myśleć“ przed wyprodukowaniem jakiegokolwiek widocznego wyniku; nie jest to błąd, lecz oczekiwane zachowanie, powinno jednak być świadomym wyborem, a nie ustawieniem odziedziczonym po prototypie. Wreszcie, może wystąpić skok obciążenia po stronie OpenAI, na który nie masz wpływu: właśnie dlatego potrzebujesz ciągłego pomiaru, a nie jednorazowej проверки, aby odróżnić tę przyczynę od dwóch pozostałych.
Wysokie TPOT, powyżej 50 ms na token, oznacza coś innego. Bardzo wysokie max_output_tokens zmusza model do generowania długich sekwencji, co mechanicznie zwiększa całkowity czas trwania, nawet jeśli każdy token pojawia się z normalną prędkością. Używanie złożonych wywołań funkcji z wieloma zadeklarowanymi narzędziami również obciąża generowanie. Konkretnie, zespół, który pozostawił piętnaście narzędzi w swoim schemacie, gdy połowa z nich nie jest już używana, będzie ponosić ten narzut przy każdym wywołaniu.
Narzędzia monitorujące
Jednorazowy pomiar nie wystarczy: musisz śledzić rozkład w czasie, ponieważ ogon rozkładu generuje zgłoszenia do wsparcia technicznego. Do ciągłego monitorowania produkcji zintegruj te metryki ze swoim stackiem obserwowalności:
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)}"
)
Przesuwne okno tysiąca pomiarów zapobiega nieograniczonemu wzrostowi zużycia pamięci, zachowując jednocześnie reprezentatywną próbkę niedawnego ruchu. Co kluczowe, klasa ta udostępnia dwa percentyle, a nie średnią: p50 wynoszące 700 ms przy p99 równym 6 sekundom opisuje usługę, którą większość użytkowników uważa za szybką, a mniejszość za nieużyteczną. Średnia zamaskowałaby obie te rzeczywistości. Podłącz metodę report() do swojego narzędzia metryk i ustaw próg alertu dla p99, zanim dotkniesz reszty systemu.
Kluczowe wnioski
- Opóźnienie dekomponuje się na TTFT + generowanie (TPOT × tokeny) + sieć
- Zawsze mierz ze strumieniowaniem, aby uzyskać rzeczywiste TTFT
- Śledź percentyle p50 i p99, a nie tylko średnią
- Wybór modelu i ustawienia rozumowania bezpośrednio wpływają na opóźnienie: GPT-5.6 Terra z niskim poziomem rozumowania odpowiada szybciej niż GPT-5.6 Sol z wysokim poziomem rozumowania