Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Kejjel u analizza l-latency

Lezzjoni 1 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Għaliex il-latency hija l-metrika numru wieħed tiegħek
  2. Komponenti tal-latency
  3. Dijanjożi tal-bottlenecks
  4. Punti Ewlenin

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