Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Mät och analysera latens

Lektion 1 av 20 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Varför latens är din viktigaste metrik
  2. Latenskomponenter
  3. Diagnostisera flaskhalsar
  4. Viktiga punkter

Varför latens är din viktigaste metrik

När du driftsätter en LLM-driven applikation i produktion avgör den latens som dina användare upplever direkt adoptionen. Ett svar som tar 8 sekunder att visa skrämmer bort 70 % av användarna: de stänger fliken, försöker igen eller drar slutsatsen att verktyget inte fungerar. Ingen kvalitetsförbättring kan kompensera för denna förlust, eftersom den inträffar innan användaren ens hunnit läsa svaret.

Utmaningen i produktion är att “det går långsamt” inte är en diagnos. Samma varaktighet på åtta sekunder kan bero på en alltför stor systemprompt, en alltför ambitiös inställning för resonemang, en dåligt placerad applikationsserver eller efterbehandling som väntar på hela svaret innan något visas. Varje orsak kräver en annan åtgärd, och att åtgärda fel sak ändrar ingenting. I denna lektion lär du dig att mäta, dela upp och diagnostisera latens från början till slut så att du kan omvandla ett klagomål till ett hanterbart tal.

Latenskomponenter

Den totala latensen för ett API-anrop delas upp i fyra segment som du måste hålla isär. Nätverkslatens är transittiden mellan din server och OpenAI:s API; den är osynlig i dina applikationsloggar men kan överstiga 100 millisekunder om din server befinner sig långt från slutpunkten. Time to First Token (TTFT) mäter fördröjningen innan den första token genereras: detta är den del som användarna upplever som “väntan”, eftersom skärmen är tom tills den är klar. Time Per Output Token (TPOT) beskriver sedan genereringshastigheten för varje efterföljande token; multiplicerat med svarslängden ger det varaktigheten för textscrollningen. Slutligen täcker applikationslatens allt som din egen server gör före och efter anropet: hämta dokument, sätta ihop prompten, validera utdata som JSON och skriva till databasen.

Denna uppdelning är inte bara akademisk. Ett team som upptäcker att dess TTFT är bra men att applikationslatensen lägger till två sekunder kommer inte att byta modell: det kommer att granska sin SQL-fråga för kontexthämtning.

Mätning med Python

Så här instrumenterar du ett anrop till Responses API för att fånga varje 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 viktigaste att ta med sig från denna kod är användningen av stream=True. Utan strömning kan du inte isolera TTFT: API:et returnerar först efter hela svaret, så du mäter bara en totaltid. Timern startar före anropet, stoppas vid första textdelta och den återstående varaktigheten dividerat med antalet återstående token ger TPOT. Kör samma prompt mot två modeller eller två inställningar för resonemang så har du inom några minuter den kvantitativa jämförelse som ersätter ditt teams gissningar.

Diagnostisera flaskhalsar

En hög TTFT, över två sekunder, pekar på tre orsaker. Den vanligaste är en alltför lång systemprompt som inte är cachad: modellen måste bearbeta flera tusen token innan den börjar skriva, vid varje anrop. Nästa orsak är en hög inställning för resonemang – high, xhigh eller max på GPT-5.6 – vilket medvetet får modellen att tänka innan den producerar någon synlig utdata; detta är inget fel, det är förväntat beteende, men det bör vara ett medvetet val, inte en inställning ärvd från en prototyp. Slutligen kan det röra sig om en belastningstopp hos OpenAI som du inte kan styra över: det är precis därför du behöver kontinuerlig mätning snarare än en engångskontroll, för att skilja detta från de andra två.

En hög TPOT, över 50 ms per token, tyder på något annat. Ett mycket högt max_output_tokens tvingar modellen att producera långa sekvenser, och den totala varaktigheten ökar mekaniskt även om varje token anländer med normal hastighet. Att använda komplex funktionsanrop med många deklarerade verktyg belastar också genereringen. Konkret kommer ett team som lämnat femton verktyg i sitt schema när hälften inte längre används att betala den kostnaden vid varje anrop.

Övervakningsverktyg

Att mäta en gång räcker inte: du måste spåra fördelningen över tid, eftersom svansen av fördelningen genererar supportärenden. För kontinuerlig produktionsövervakning integrerar du dessa mätvärden i din observabilitetsstack:

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 glidande fönstret på tusen mätningar förhindrar obegränsad minnestillväxt samtidigt som det behåller ett representativt urval av den senaste trafiken. Avgörande är att denna klass exponerar två percentiler, inte ett medelvärde: ett p50 på 700 ms med ett p99 på 6 sekunder beskriver en tjänst som de flesta användare upplever som snabb och en minoritet som oanvändbar. Ett medelvärde hade maskerat båda verkligheterna. Koppla report() till ditt mätverktyg och ställ in en varningströskel på p99 innan du rör resten av systemet.

Viktiga punkter

  • Latens delas upp i TTFT + generering (TPOT × token) + nätverk
  • Mät alltid med strömning för att få riktig TTFT
  • Spåra p50- och p99-percentiler, inte bara medelvärdet
  • Modellval och inställningar för resonemang påverkar latensen direkt: GPT-5.6 Terra med lågt resonemang svarar snabbare än GPT-5.6 Sol med högt resonemang