A késleltetés mérése és elemzése
Ezen az oldalon
Miért a késleltetés a legfontosabb metrikád
Amikor LLM-mel működő alkalmazást élesítesz, a felhasználók által észlelt késleltetés közvetlenül meghatározza az elfogadottságot. Egy 8 másodpercig tartó válasz a felhasználók 70%-át elűzi: bezárják a lapot, újra próbálják a kérést, vagy arra a következtetésre jutnak, hogy az eszköz nem működik. Ezt a veszteséget semmilyen minőségjavítás nem kompenzálhatja, mivel ez még azelőtt megtörténik, hogy a felhasználó elolvasná a választ.
A kihívás az éles környezetben az, hogy a „lassú“ önmagában nem diagnózis. Ugyanaz a nyolc másodperces időtartam származhat túl hosszú rendszerüzenetből, túlzottan ambiciózus gondolkodási beállításból, rosszul elhelyezett alkalmazásszerverből, vagy olyan utófeldolgozásból, amely a teljes válasz megvárása után jelenít meg bármit is. Minden ok más megoldást igényel, és a hibás elem javítása semmit sem változtat. Ez a lecke megtanít a végpontok közötti késleltetés mérésére, összetevőkre bontására és diagnosztizálására, hogy a panaszokat cselekvőképes számmá alakíthasd.
A késleltetés összetevői
A teljes API-hívás késleltetése négy szegmensre bomlik, amelyeket el kell különítened. A hálózati késleltetés a szervered és az OpenAI API közötti utazási idő; ez láthatatlan az alkalmazásnaplóidban, de meghaladhatja a 100 milliszekundumot, ha a szervered távol van a végponttól. Az első tokenig eltelt idő (TTFT) azt a késést méri, amíg az első token generálódik: ezt a szakaszt érzékelik a felhasználók „várakozásként“, mivel a képernyő addig üres marad. Az egy kimeneti tokenre jutó idő (TPOT) ezután az egyes következő tokenek generálási sebességét írja le; a válasz hosszával szorozva megadja a szöveg görgetésének időtartamát. Végül az alkalmazás-késleltetés lefedi mindazt, amit a saját szervered a hívás előtt és után tesz: dokumentumok lekérése, a prompt összeállítása, a kimeneti JSON validálása és az adatbázisba írás.
Ez a felbontás nem elméleti gyakorlat. Egy csapat, amely rájön, hogy a TTFT-je rendben van, de az alkalmazás-késleltetés két másodpercet ad hozzá, nem modellt vált: hanem megvizsgálja a kontextus-lekérő SQL-queryjét.
Mérés Pythonnal
Így instrumentálhatsz egy hívást a Responses API-hoz, hogy rögzítsd az egyes szegmenseket:
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}")
Ennek a kódnak a legfontosabb tanulsága a stream=True használata. Streaming nélkül nem izolálhatod a TTFT-t: az API csak a teljes válasz után tér vissza, így csak a teljes időt mérheted. Az időzítő a hívás előtt indul, az első szöveg-deltánál áll meg, a fennmaradó időtartamot pedig a megmaradó tokenek számával elosztva megkapod a TPOT-ot. Futtasd le ugyanazt a promptot két modellen vagy két gondolkodási beállítással, és perceken belül meglesz a mennyiségi összehasonlítás, amely kiváltja a csapatod találgatásait.
Szűk keresztmetszetek diagnosztizálása
A két másodperc feletti magas TTFT három okra utal. A leggyakoribb egy túl hosszú, nem gyorsítótárazott rendszerüzenet: a modellnek minden hívásnál több ezer tokent kell feldolgoznia, mielőtt elkezdene írni. A következő ok egy magas gondolkodási beállítás – magas, xhigh vagy max a GPT-5.6 esetén –, amely szándékosan arra készteti a modellt, hogy gondolkodjon, mielőtt látható kimenetet produkálna; ez nem hiba, hanem várt viselkedés, de tudatos döntésnek kell lennie, nem egy prototípusból örökölt beállításnak. Végül lehet szó az OpenAI oldalán fellépő terhelési csúcsról, amit nem tudsz kontrollálni: éppen ezért van szükséged folyamatos mérésre egy egyszeri ellenőrzés helyett, hogy megkülönböztesd ezt a másik két októl.
A tokenenként 50 ms feletti magas TPOT másképp olvasandó. Egy nagyon magas max_output_tokens arra kényszeríti a modellt, hogy hosszú szekvenciákat állítson elő, és a teljes időtartam mechanikusan nő, még akkor is, ha minden token normál sebességgel érkezik. A sok deklarált eszközzel végzett összetett függvényhívás szintén terheli a generálást. Konkrétan: egy csapat, amely tizenöt eszközt hagyott a sémájában, miközben a felük már nem használatos, minden hívásnál megfizeti ezt a többletterhet.
Monitorozó eszközök
Egyszeri mérés nem elég: nyomon kell követned az eloszlást az időben, mert az eloszlás farokvége generálja az ügyfélszolgálati jegyeket. A folyamatos éles monitorozáshoz integráld ezeket a metrikákat a megfigyelési stackedbe:
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)}"
)
Az ezer mérésből álló csúszó ablak megakadályozza a memória korlátlan növekedését, miközben reprezentatív mintát tart fenn a legutóbbi forgalomból. Döntő fontosságú, hogy ez az osztály két percentilist tesz közzé, nem átlagot: egy 700 ms-os p50 és egy 6 másodperces p99 olyan szolgáltatást ír le, amelyet a felhasználók többsége gyorsnak, egy kisebbség pedig használhatatlannak talál. Egy átlag elfedte volna mindkét valóságot. Kösd össze a report() függvényt a metrikaeszközzel, és állíts be riasztási küszöbértéket a p99-re, mielőtt hozzányúlnál a rendszer többi részéhez.
Főbb megállapítások
- A késleltetés felbontható TTFT + generálás (TPOT × tokenek) + hálózat összetevőkre
- Mindig streaminggel mérj a valós TTFT érdekében
- Kövesd nyomon a p50 és p99 percentiliseket, ne csak az átlagot
- A modellválasztás és a gondolkodási beállítások közvetlenül befolyásolják a késleltetést: a GPT-5.6 Terra alacsony gondolkodási szinttel gyorsabban válaszol, mint a GPT-5.6 Sol magas gondolkodási szinttel