Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Mål og analysér ventetid

Lektion 1 af 20 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Hvorfor ventetid er din vigtigste metrik
  2. Ventetidens komponenter
  3. Diagnosticering af flaskehalse
  4. Vigtige pointer

Hvorfor ventetid er din vigtigste metrik

Når du sætter en LLM-drevet applikation i produktion, bestemmer den ventetid, dine brugere oplever, direkte adoptionen. Et svar, der tager 8 sekunder om at dukke op, skræmmer 70 % af brugerne væk: de lukker fanen, prøver forespørgslen igen eller konkluderer, at værktøjet ikke virker. Ingen kvalitetsforbedring kan opveje dette tab, fordi det sker, før brugeren overhovedet læser svaret.

Udfordringen i produktion er, at „det er langsomt” ikke er en diagnose. Den samme varighed på otte sekunder kan skyldes en oppustet system-prompt, en alt for ambitiøs ræsonnementsindstilling, en dårligt placeret applikationsserver eller efterbehandling, der venter på hele svaret, før noget vises. Hver årsag kræver en anden løsning, og hvis du fikser den forkerte, ændrer det ingenting. Denne lektion lærer dig at måle, dekomponere og diagnosticere end-to-end-ventetid, så du kan omsætte en klage til et handlingsorienteret tal.

Ventetidens komponenter

Den samlede ventetid for et API-kald opdeles i fire segmenter, du skal adskille. Netværksventetid er rejsetiden mellem din server og OpenAI-API’et; den er usynlig i dine applikationslogs, men kan overstige 100 millisekunder, hvis din server er langt fra endpointet. Time to First Token (TTFT) måler forsinkelsen, før det første token genereres: dette er det segment, brugere oplever som „venten”, da skærmen forbliver blank, indtil det er færdigt. Time Per Output Token (TPOT) beskriver derefter generationshastigheden for hvert efterfølgende token; ganget med svarlængden giver det varigheden for tekstrulningen. Endelig dækker applikationsventetid alt, hvad din egen server gør før og efter kaldet: hentning af dokumenter, sammensætning af prompten, validering af output-JSON og skrivning til databasen.

Denne dekomposition er ikke akademisk. Et team, der opdager, at deres TTFT er fin, men at deres applikationsventetid tilføjer to sekunder, vil ikke skifte model: det vil undersøge deres SQL-forespørgsel til hentning af kontekst.

Måling med Python

Sådan instrumenterer du et kald til Responses API for at fange hvert 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}")

Det vigtigste takeaway fra denne kode er brugen af stream=True. Uden streaming kan du ikke isolere TTFT: API’et returnerer først efter det fulde svar, så du måler kun en samlet værdi. Timeren starter før kaldet, stopper ved det første tekst-delta, og den resterende varighed divideret med antallet af resterende tokens giver TPOT. Kør den samme prompt mod to modeller eller to ræsonnementsindstillinger, og inden for få minutter har du den kvantitative sammenligning, der erstatter dit teams gætterier.

Diagnosticering af flaskehalse

En høj TTFT på over to sekunder peger på tre årsager. Den mest almindelige er en alt for lang system-prompt, der ikke er cachelagret: modellen skal indtage flere tusinde tokens, før den begynder at skrive, ved hvert kald. Dernæst kommer en høj ræsonnementsindstilling – high, xhigh eller max på GPT-5.6 – som bevidst får modellen til at tænke, før den producerer synligt output; dette er ikke en fejl, det er forventet adfærd, men det bør være et bevidst valg, ikke en indstilling arvet fra en prototype. Endelig kan der være en belastningsspike på OpenAI-siden, som du ikke kan kontrollere: det er netop derfor, du har brug for løbende måling frem for et engangstjek, for at skelne det fra de to andre.

En høj TPOT på over 50 ms per token læses anderledes. En meget høj max_output_tokens presser modellen til at producere lange sekvenser, og den samlede varighed stiger mekanisk, selvom hvert token ankommer med normal hastighed. Brug af kompleks funktionskald med mange erklærede værktøjer belaster også generationen. Konkret vil et team, der har efterladt femten værktøjer i sit skema, når halvdelen ikke længere bruges, betale den overhead ved hvert kald.

Overvågningsværktøjer

Det er ikke nok at måle én gang: du skal spore fordelingen over tid, fordi halen af fordelingen genererer support-sager. Til løbende produktionsovervågning skal du integrere disse metrikker i din observabilitets-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)}"
        )

Det glidende vindue på tusind målinger forhindrer ubegrænset vækst af hukommelsesforbrug, mens det beholder en repræsentativ stikprøve af den seneste trafik. Afgørende er, at denne klasse eksponerer to percentiler, ikke et gennemsnit: en p50 på 700 ms med en p99 på 6 sekunder beskriver en tjeneste, som de fleste brugere finder hurtig, og som et mindretal finder ubrugelig. Et gennemsnit ville have sløret begge realiteter. Hook report() ind i dit metrikværktøj, og sæt en alert-tærskel på p99, før du rører resten af systemet.

Vigtige pointer

  • Ventetid dekomponeres til TTFT + generation (TPOT × tokens) + netværk
  • Mål altid med streaming for at få den rigtige TTFT
  • Spor p50- og p99-percentiler, ikke kun gennemsnittet
  • Modelvalg og ræsonnementsindstillinger påvirker ventetiden direkte: GPT-5.6 Terra med lav ræsonnement svarer hurtigere end GPT-5.6 Sol med højt ræsonnement