Kejjel u analizza l-latency
F'din il-paġna
Għaliex il-latency hija l-metrika numru wieħed tiegħek
Meta tiddispjega applikazzjoni mħaddma minn LLM fil-produzzjoni, il-latency li jħossu l-utenti tiegħek tiddetermina direttament l-adozzjoni. Risposta li tieħu 8 sekondi biex tidher tkeċċi 70% tal-utenti: jagħlqu t-tab, jippruvaw jerġgħu jagħmlu t-talba, jew jikkonkludu li l-għodda ma taħdimx. L-ebda titjib fil-kwalità ma jista’ jikkumpensa għal din it-telfa, għax iseħħ qabel ma l-utent anki jaqra t-tweġiba.
L-isfida fil-produzzjoni hija li “hija bil-mod” mhijiex dijanjożi. L-istess tul ta’ tmien sekondi jista’ jirriżulta minn prompt tas-sistema kbir wisq, setting tar-raġunar ambizzjuż wisq, server tal-applikazzjoni mqiegħed ħażin, jew post-ipproċessar li jistenna r-risposta sħiħa qabel ma juri xejn. Kull kawża teħtieġ fix differenti, u li tiffissa dik ħażina ma tbiddel xejn. Din il-lezzjoni tgħallmek kif tkejjel, tifred u tiddijanjożika l-latency end-to-end biex tkun tista’ tbiddel ilment f’numru li tista’ taġixxi fuqu.
Komponenti tal-latency
Il-latency totali tas-sejħa tal-API tinħall f’erba’ segmenti li trid tifred. In-network latency hija l-ħin tat-transitu bejn is-server tiegħek u l-API ta’ OpenAI; hija inviżibbli fil-logs tal-applikazzjoni tiegħek iżda tista’ taqbeż il-100 millisekonda jekk is-server tiegħek ikun ‘il bogħod mill-endpoint. Time to First Token (TTFT) ikejjel id-dewmien qabel ma jiġi ġġenerat l-ewwel token: dan huwa s-segment li l-utenti jħossu bħala “stennija”, peress li l-iskrin jibqa’ vojt sakemm jintemm. Time Per Output Token (TPOT) imbagħad jiddeskrivi l-veloċità tal-ġenerazzjoni għal kull token sussegwenti; immultiplikat bit-tul tar-risposta, jagħtik id-durata tal-iskrolljar tat-test. Fl-aħħar nett, l-application latency tkopri kull ma jagħmel is-server tiegħek stess qabel u wara s-sejħa: it-tniġġis tad-dokumenti, l-assemblaġġ tal-prompt, il-validazzjoni tal-JSON tal-output, u l-kitba fid-database.
Din id-dekompożizzjoni mhix akkademika. Tim li jiskopri li t-TTFT tiegħu huwa tajjeb iżda l-application latency tiegħu żżid żewġ sekondi mhux se jbiddel il-mudelli: se jeżamina l-query SQL tal-ġbir tal-kuntest tiegħu.
Il-kejl bl-użu ta’ Python
Hekk kif tistrumenta sejħa lejn ir-Responses API biex taqbad kull 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}")
Il-punt ewlieni ta’ dan il-kodiċi huwa l-użu ta’ stream=True. Mingħajr streaming, ma tistax tiżola t-TTFT: l-API tirritorna biss wara r-risposta sħiħa, allura tkejjel biss total. It-tajmer jibda qabel is-sejħa, jieqaf fl-ewwel delta tat-test, u d-durata li fadal diviża bin-numru ta’ tokens li fadal tagħtik it-TPOT. Iddi l-istess prompt kontra żewġ mudelli jew żewġ settings tar-raġunar u, fi żmien minuti, ikollok il-konfront kwantitattiv li jieħu post is-suppożizzjonijiet tat-tim tiegħek.
Dijanjożi tal-bottlenecks
TTFT għoli, ‘il fuq minn żewġ sekondi, jindika tliet kawżi. L-aktar waħda komuni hija prompt tas-sistema twil wisq li mhuwiex cached: il-mudell irid jassorbi diversi eluf ta’ tokens qabel ma jibda jikteb, fuq kull sejħa. Li jmiss huwa setting għoli tar-raġunar—għoli, xhigh, jew max fuq GPT-5.6—li deliberatament jagħmel il-mudell jaħseb qabel ma jipproduċi kwalunkwe output viżibbli; dan mhuwiex bug, huwa mġiba mistennija, iżda għandu jkun għażla konxja, mhux setting wirtut minn prototip. Fl-aħħar nett, jista’ jkun hemm pik fit-tagħbija min-naħa ta’ OpenAI, li ma tistax tikkontrolla: eżattament għalhekk għandek bżonn kejl kontinwu minflok verifika waħda, biex tifredha miż-żewġ oħrajn.
TPOT għoli, ‘il fuq minn 50 ms kull token, jinqara b’mod differenti. max_output_tokens għoli wisq iġiegħel il-mudell jipproduċi sekwenzi twal, u d-durata totali tiżdied mekkanikament anki jekk kull token jasla b’veloċità normali. L-użu ta’ sejħa ta’ funzjoni kumplessa b’ħafna għodod iddikjarati jtaqqal ukoll il-ġenerazzjoni. Konkretament, tim li ħalla ħmistax-il għodda fl-iskema tiegħu meta nofshom ma għadhomx jintużaw se jħallas dak l-overhead fuq kull sejħa.
Għodod ta’ monitoraġġ
Il-kejl darba waħda mhuwiex biżżejjed: trid traċċa d-distribuzzjoni maż-żmien, għax id-denb tad-distribuzzjoni jiġġenera tikketts tas-support. Għal monitoraġġ kontinwu tal-produzzjoni, integra dawn il-metriċi fl-istack tal-osservabbiltà tiegħek:
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)}"
)
It-tieqa li tiżżerżaq ta’ elf kejl tipprevjeni t-tkabbir illimitat tal-memorja filwaqt li żżomm kampjun rappreżentattiv tat-traffiku reċenti. Kritikalment, din il-klassi tesponi żewġ perċentili, mhux medja: p50 ta’ 700 ms b’p99 ta’ 6 sekondi jiddeskrivi servizz li l-biċċa l-kbira tal-utenti jsibu veloċi u minoranza ssibu mhux użabbli. Medja kienet tgħatti ż-żewġ realtajiet. Agħmel hook ta’ report() mal-għodda tal-metriċi tiegħek u stabbilixxi limitu ta’ allarm fuq il-p99 qabel ma tmiss il-bqija tas-sistema.
Punti Ewlenin
- Il-latency tinħall f’TTFT + ġenerazzjoni (TPOT × tokens) + network
- Dejjem kejjel bis-streaming biex tikseb TTFT reali
- Traċċa l-perċentili p50 u p99, mhux biss il-medja
- L-għażla tal-mudell u s-settings tar-raġunar jaffettwaw direttament il-latency: GPT-5.6 Terra b’raġunar baxx jirrispondi aktar malajr minn GPT-5.6 Sol b’raġunar għoli