Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Merjenje in analiza zakasnitve

Lekcija 1 od 20 Posodobljeno 28. julij 2026 Napredni
Na tej strani
  1. Zakaj je zakasnitev tvoja najpomembnejša metrika
  2. Komponente zakasnitve
  3. Diagnosticiranje ozkih grl
  4. Ključne ugotovitve

Zakaj je zakasnitev tvoja najpomembnejša metrika

Ko aplikacijo, ki poganja LLM, uvedeš v proizvodno okolje, zakasnitev, ki jo zaznajo uporabniki, neposredno določa sprejetost. Odziv, ki se prikaže šele po 8 sekundah, odžene 70 % uporabnikov: zaprejo zavihek, ponovno pošljejo zahtevo ali sklepajo, da orodje ne deluje. Nobena izboljšava kakovosti ne more nadomestiti te izgube, saj do nje pride, preden uporabnik sploh prebere odgovor.

Izziv v proizvodnem okolju je v tem, da „počasno je” ni diagnoza. Istih osem sekund lahko izvira iz prevelikega sistemskega poziva, pretirano ambiciozne nastavitve razmišljanja, slabo postavljene aplikacijske strežniške infrastrukture ali obdelave po klicu, ki čaka na celoten odgovor, preden prikaže karkoli. Vsak vzrok zahteva drugačen popravek, in če popraviš napačnega, se ne spremeni nič. Ta lekcija te nauči meriti, razčleniti in diagnosticirati celotno zakasnitev od konca do konca, da boš lahko pritožbo spremenil v ukrepljivo številko.

Komponente zakasnitve

Skupna zakasnitev klica API se razčleni na štiri segmente, ki jih moraš ločiti. Omrežna zakasnitev je čas potovanja med tvojim strežnikom in API-jem OpenAI; v dnevnikih tvoje aplikacije je nevidna, lahko pa preseže 100 milisekund, če je tvoj strežnik daleč od končne točke. Čas do prvega žetona (TTFT) meri zamik pred generiranjem prvega žetona: to je segment, ki ga uporabniki občutijo kot „čakanje”, saj zaslon ostane prazen, dokler se ta del ne konča. Čas na izhodni žeton (TPOT) nato opisuje hitrost generiranja za vsak naslednji žeton; pomnožen z dolžino odgovora da trajanje drsenja besedila. Nazadnje aplikacijska zakasnitev zajema vse, kar tvoj strežnik naredi pred klicem in po njem: pridobivanje dokumentov, sestavljanje poziva, validacija izhodnega JSON-a in zapis v bazo podatkov.

Ta razčlenitev ni zgolj akademska. Ekipa, ki ugotovi, da je njen TTFT v redu, aplikacijska zakasnitev pa dodaja dve sekundi, ne bo menjala modelov: preučila bo svoj SQL-poizvedbi za pridobivanje konteksta.

Merjenje s Pythonom

Tukaj je prikazano, kako instrumentirati klic API-ja Responses za zajem vsakega segmenta:

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}")

Ključni sklep te kode je uporaba stream=True. Brez pretoka ne moreš izolirati TTFT: API vrne odgovor šele po koncu celotnega odziva, zato izmeriš le skupni čas. Časomer se zažene pred klicem, ustavi se ob prvem delu besedila, preostalo trajanje, deljeno s številom preostalih žetonov, pa da TPOT. Zaženi isti poziv proti dvema modeloma ali dvema nastavitvama razmišljanja in v nekaj minutah boš dobil količinsko primerjavo, ki nadomesti ugibanja tvoje ekipe.

Diagnosticiranje ozkih grl

Visok TTFT, nad dvema sekundama, kaže na tri vzroke. Najpogostejši je predolg sistemski poziv, ki ni predpomnjen: model mora pred vsakim klicem zaužiti več tisoč žetonov, preden začne pisati. Naslednji vzrok je visoka nastavitev razmišljanja – high, xhigh ali max na GPT-5.6 – ki namerno prisili model k razmišljanju, preden proizvede kakršen koli vidni izhod; to ni napaka, temveč pričakovano vedenje, vendar mora biti zavestna izbira, ne nastavitev, podedovana iz prototipa. Nazadnje lahko pride do skoka obremenitve na strani OpenAI, na katerega ne moreš vplivati: prav zato potrebuješ neprekinjeno merjenje namesto enkratnega preverjanja, da ga ločiš od drugih dveh vzrokov.

Visok TPOT, nad 50 ms na žeton, beremo drugače. Zelo visok max_output_tokens prisili model k ustvarjanju dolgih zaporedij, skupno trajanje pa se mehansko poveča, tudi če vsak žeton prispe z normalno hitrostjo. Uporaba kompleksnega klicanja funkcij z mnogimi deklariranimi orodji prav tako obremenjuje generiranje. Konkretneje: ekipa, ki je v svoji shemi pustila petnajst orodij, čeprav jih polovica ni več v uporabi, bo to stroške plačevala pri vsakem klicu.

Orodja za nadzor

Enkratno merjenje ni dovolj: spremljati moraš porazdelitev skozi čas, saj rep porazdelitev ustvarja podporne zahtevke. Za neprekinjen nadzor v proizvodnem okolju integriraj te metrike v svoj observabilnostni sklad:

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)}"
        )

Drsno okno tisoč meritev preprečuje neomejeno rast pomnilnika, hkrati pa ohranja reprezentativen vzorec nedavnega prometa. Ključno je, da ta razred izpostavlja dva percentila, ne povprečja: p50 700 ms s p99 6 sekund opisuje storitev, ki jo večina uporabnikov šteje za hitro, manjšina pa za neuporabno. Povprečje bi obe realnosti zamaskiralo. Poveži report() s svojim orodjem za metrike in nastavi prag opozorila na p99, preden se dotakneš preostanka sistema.

Ključne ugotovitve

  • Zakasnitev se razčleni na TTFT + generiranje (TPOT × žetoni) + omrežje
  • Vedno meri s pretokom, da dobiš pravi TTFT
  • Sledi percentiloma p50 in p99, ne le povprečju
  • Izbira modela in nastavitve razmišljanja neposredno vplivajo na zakasnitev: GPT-5.6 Terra z nizkim razmišljanjem odgovori hitreje kot GPT-5.6 Sol z visokim razmišljanjem