Mõõda ja analüüsi latentsust
Sellel lehel
Miks on latentsus sinu tähtsaim näitaja
Kui viid LLM-il põhineva rakenduse tootmiskeskkonda, määrab kasutajate tajutav latentsus otseselt selle leviku. Vastus, mille ilmumine võtab 8 sekundit, peletab eemale 70% kasutajatest: nad sulgevad vahekaardi, proovivad päringut uuesti või järeldavad, et tööriist ei tööta. Ükski kvaliteediparandus ei suuda seda kadu kompenseerida, sest see juhtub enne, kui kasutaja jõuab vastust lugeda.
Probleem tootmiskeskkonnas on see, et „see on aeglane“ ei ole diagnoos. Sama kaheksasekundiline viivitus võib tuleneda liiga mahukast süsteemikäsust, liiga ambitsioonikast arutlusseadistusest, valesti paigutatud rakendusserverist või järeltöötlusest, mis ootab kogu vastuse valmimist enne midagi kuvamist. Iga põhjus nõuab erinevat lahendust ja vale probleemi lahendamine ei muuda midagi. See õppetund õpetab sind mõõtma, lahutama ja diagnoosima otsast-otsani latentsust, et saaksid muuta kaebuse tegevusväärseks numbriks.
Latentsuse komponendid
API kõne kogulatentsus jaguneb neljaks segmendiks, mille pead eristama. Võrgu latentsus on ülekandeaeg sinu serveri ja OpenAI API vahel; see on sinu rakenduse logides nähtamatu, kuid võib ületada 100 millisekundit, kui sinu server asub lõpp-punktist kaugel. Aeg esimese tokenini (TTFT) mõõdab viivitust enne esimese tokeni genereerimist: see on segment, mida kasutajad tunnevad kui „ootamist“, kuna ekraan püsib tühjaks, kuni see lõpeb. Aeg väljundtokeni kohta (TPOT) kirjeldab seejärel iga järgneva tokeni genereerimise kiirust; korrutatuna vastuse pikkusega annab see teksti kerimise kestuse. Lõpuks hõlmab rakenduse latentsus kõike, mida sinu enda server teeb enne ja pärast kõnet: dokumentide toomine, käsu kokkupanek, väljundi JSON-i valideerimine ja andmebaasi kirjutamine.
See lahutamine ei ole akadeemiline harjutus. Meeskond, kes avastab, et tema TTFT on korras, kuid rakenduse latentsus lisab kaks sekundit, ei vaheta mudeleid: ta uurib oma konteksti toomise SQL-päringut.
Mõõtmine Pythoniga
Siin on näide, kuidas instrumenteerida kõnet Responses API-le, et tabada iga segment:
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}")
Selle koodi põhimõte seisneb stream=True kasutamises. Ilma voogedastuseta ei saa TTFT-i eraldada: API tagastab tulemuse alles pärast kogu vastuse valmimist, nii et mõõdad vaid koguaega. Taimer käivitub enne kõnet, peatub esimese teksti delta juures ja ülejäänud kestus jagatuna ülejäänud tokenite arvuga annab TPOT-i. Käivita sama käsk kahe mudeli või kahe arutlusseadistuse vastu ja mõne minuti jooksul on sul kvantitatiivne võrdlus, mis asendab sinu meeskonna arvamused.
Pudelikaelade diagnoosimine
Kõrge TTFT, üle kahe sekundi, viitab kolmele põhjusele. Kõige levinum on liiga pikk süsteemikäsk, mida ei vahemällu salvestata: mudel peab enne kirjutamise alustamist iga kõne korral tarbima mitu tuhat tokenit. Järgmine on kõrge arutlusseadistus – high, xhigh või max mudelil GPT-5.6 –, mis paneb mudeli tahtlikult mõtlema enne nähtava väljundi loomist; see ei ole viga, vaid oodatav käitumine, kuid see peaks olema teadlik valik, mitte prototüübist päritud seadistus. Lõpuks võib tegemist olla OpenAI-poolse koormuse tipuga, mida sa kontrollida ei saa: just seetõttu vajad pidevat mõõtmist, mitte üksikjuhtumi kontrolli, et seda kahest esimesest eristada.
Kõrge TPOT, üle 50 ms tokeni kohta, annab märku millestki muust. Väga kõrge max_output_tokens sunnib mudelit looma pikki jadasid ja kogukestus suureneb mehaaniliselt, isegi kui iga token saabub normaalse kiirusega. Ka keerukate funktsioonikutsete kasutamine paljude deklareeritud tööriistadega koormab genereerimist. Konkreetsemalt: meeskond, mis jättis oma skeemi viisteist tööriista, millest pooled pole enam kasutusel, maksab selle ülekoormuse eest iga kõne korral.
Seiretööriistad
Ühekordne mõõtmine ei piisa: pead jälgima jaotust ajas, sest jaotuse saba tekitab tugipäringuid. Pidevaks tootmisseireks integreeri need mõõdikud oma vaadeldavuse stacki:
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)}"
)
Tuhande mõõtmise liuguv aken hoiab ära mälu piiramatu kasvu, säilitades samal ajal esindusliku proovi hiljutisest liiklusest. Oluline on, et see klass avaldab kaks protsentiili, mitte keskmist: p50 väärtusega 700 ms ja p99 väärtusega 6 sekundit kirjeldab teenust, mida enamik kasutajaid peab kiireks ja vähemus kasutuskõlbmatuks. Keskmine oleks mõlemad reaalsused varjanud. Ühenda report() oma mõõdikute tööriistaga ja sea hoiatuse lävi p99-le enne süsteemi ülejäänud osade puudutamist.
Peamised punktid
- Latentsus laguneb osadeks: TTFT + genereerimine (TPOT × tokenid) + võrk
- Mõõda alati voogedastusega, et saada tegelik TTFT
- Jälgi p50 ja p99 protsentiile, mitte ainult keskmist
- Mudeli valik ja arutlusseadistused mõjutavad latentsust otseselt: GPT-5.6 Terra madala arutlusega vastab kiiremini kui GPT-5.6 Sol kõrge arutlusega