Mērīt un analizēt latentumu
Šajā lapā
Kāpēc latentums ir tavs galvenais rādītājs
Kad izvieto LLM darbinātu lietotni ražošanas vidē, lietotāju uztvertais latentums tieši nosaka tās pieņemšanu. Atbilde, kas parādās pēc 8 sekundēm, atbaida 70% lietotāju: viņi aizver cilni, atkārto pieprasījumu vai secina, ka rīks nedarbojas. Nekāds kvalitātes uzlabojums nevar kompensēt šos zaudējumus, jo tie notiek vēl pirms lietotājs paspēj izlasīt atbildi.
Problēma ražošanas vidē ir tā, ka frāze “tas ir lēns” nav diagnoze. Tie paši astoņas sekundes var rasties no pārmērīgi gara sistēmas uzvedņa, pārlieku ambicioziem spriešanas iestatījumiem, slikti izvietota lietotnes servera vai pēcapstrādes, kas gaida pilnu atbildi, pirms kaut ko parāda ekrānā. Katram cēlonim ir nepieciešams atšķirīgs risinājums, un nepareizā labošana neko nemainīs. Šī nodarbība iemācīs tev mērīt, sadalīt komponentēs un diagnosticēt kopējo (end-to-end) latentumu, lai pārvērstu sūdzību konkrētā, risināmā skaitlī.
Latentuma komponentes
Kopējais API izsaukuma latentums sadalās četrās segmentos, kas tev ir jānošķir. Tīkla latentums ir pārvades laiks starp tavu serveri un OpenAI API; tas nav redzams tavos lietotnes žurnālos, bet var pārsniegt 100 milisekundes, ja tavs serveris atrodas tālu no galapunkta. Laiks līdz pirmajam tokenam (TTFT) mēra kavēšanos pirms tiek ģenerēts pirmais tokens: tas ir segments, ko lietotāji uztver kā “gaidīšanu”, jo ekrāns paliek tukšs, līdz tas ir pabeigts. Laiks uz izejas tokena (TPOT) pēc tam apraksta ģenerēšanas ātrumu katram nākamajam tokenam; reizinot to ar atbildes garumu, iegūst teksta ritināšanas ilgumu. Visbeidzot, lietotnes latentums aptver visu, ko tavs serveris dara pirms un pēc izsaukuma: dokumentu iegūšanu, uzvedņa sastādīšanu, izejas JSON validēšanu un rakstīšanu datubāzē.
Šī sadalīšana nav tikai teorija. Komanda, kas atklāj, ka tās TTFT ir kārtībā, bet lietotnes latentums pieskaita divas sekundes, nemainīs modeļus: tā pārbaudīs savu konteksta iegūšanas SQL vaicājumu.
Mērīšana ar Python
Lūk, kā instrumentēt izsaukumu uz Responses API, lai fiksētu katru 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}")
Galvenā atziņa no šī koda ir stream=True izmantošana. Bez straumēšanas tu nevari izolēt TTFT: API atgriež datus tikai pēc pilnas atbildes saņemšanas, tāpēc tu mēri tikai kopējo laiku. Taimeris startē pirms izsaukuma, apstājas pie pirmā teksta delta, un atlikušais ilgums, dalīts ar atlikušo tokena skaitu, dod TPOT. Palaid to pašu uzvedni pret diviem modeļiem vai diviem spriešanas iestatījumiem, un dažu minūšu laikā tev būs kvantitatīvs salīdzinājums, kas aizstās tavas komandas minējumus.
Sastrēgumu diagnosticēšana
Augsts TTFT, virs divām sekundēm, norāda uz trim cēloņiem. Visbiežākais ir pārmērīgi garš sistēmas uzvednis, kas netiek kešots: modelim katrā izsaukumā ir jāievada vairāki tūkstoši tokena, pirms tas sāk rakstīt. Nākamais ir augsts spriešanas iestatījums—high, xhigh vai max priekš GPT-5.6—kas apzināti liek modelim domāt, pirms tas rada jebkuru redzamu izeju; tas nav kļūda, tā ir paredzēta uzvedība, taču tai ir jābūt apzinātai izvēlei, nevis iestatījumam, kas mantots no prototipa. Visbeidzot, tas varētu būt OpenAI puses slodzes pieaugums, ko tu nevari kontrolēt: tieši tāpēc ir nepieciešami nepārtraukti mērījumi, nevis vienreizēja pārbaude, lai to atšķirtu no abiem pārējiem cēloņiem.
Augsts TPOT, virs 50 ms uz tokena, liecina par ko citu. Ļoti augsts max_output_tokens spiež modeli ģenerēt garas secības, un kopējais ilgums mehāniski pieaug, pat ja katrs tokens ierodas ar normālu ātrumu. Arī sarežģītu funkciju izsaukumu izmantošana ar daudziem deklarētiem rīkiem apgrūtina ģenerēšanu. Konkrēti, komanda, kas savā shēmā atstājusi piecpadsmit rīkus, lai gan puse no tiem vairs netiek izmantoti, maksās par šo pārslodzi katrā izsaukumā.
Uzraudzības rīki
Vienreizēja mērīšana nav pietiekama: tev ir jāizseko sadalījums laika gaitā, jo sadalījuma astes daļa rada atbalsta biļetes. Nepārtrauktai ražošanas uzraudzībai integrē šos rādītājus savā novērojamības (observability) stackā:
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)}"
)
Slīdošais logs ar tūkstoš mērījumiem novērš neierobežotu atmiņas pieaugumu, vienlaikus saglabājot reprezentatīvu paraugu no nesenās satiksmes. Būtiski, ka šī klase eksponē divus percentiļus, nevis vidējo vērtību: p50 700 ms apmērā ar p99 6 sekunžu apmērā apraksta servisu, ko vairums lietotāju uzskata par ātru, bet minoritāte—par nelietojamu. Vidējā vērtība būtu noslēpusi abas šīs realitātes. Pievieno report() savam metrikas rīkam un iestati brīdinājuma slieksni pie p99, pirms ķeries klāt pārējai sistēmai.
Galvenās atziņas
- Latentums sadalās komponentēs: TTFT + ģenerēšana (TPOT × tokeni) + tīkls
- Vienmēr mēri, izmantojot straumēšanu, lai iegūtu patieso TTFT
- Izseko p50 un p99 percentiļus, ne tikai vidējo vērtību
- Modeļa izvēle un spriešanas iestatījumi tieši ietekmē latentumu: GPT-5.6 Terra ar zemu spriešanas līmeni atbild ātrāk nekā GPT-5.6 Sol ar augstu spriešanas līmeni