Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Měření a analýza latence

Lekce 1 z 20 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Proč je latence tvou nejdůležitější metrikou
  2. Komponenty latence
  3. Diagnostika úzkých hrdel
  4. Klíčové poznatky

Proč je latence tvou nejdůležitější metrikou

Když nasadíš aplikaci poháněnou LLM do produkce, latence, kterou vnímají uživatelé, přímo určuje míru jejího přijetí. Odpověď, jejíž zobrazení trvá 8 sekund, odežene 70 % uživatelů: zavřou kartu, zkusí požadavek znovu nebo dojdou k závěru, že nástroj nefunguje. Žiadne zlepšení kvality tuto ztrátu nenahradí, protože k ní dojde dříve, než si uživatel vůbec přečte odpověď.

Výzvou v produkci je, že „je to pomalé“ není diagnóza. Stejná osmisekundová prodleva může pramenit z příliš dlouhého systémového promptu, příliš ambiciózního nastavení logického uvažování, špatně umístěného aplikačního serveru nebo post-processingu, který čeká na úplnou odpověď, než cokoli zobrazí. Každá příčina vyžaduje jiné řešení a oprava té špatné nic nezmění. Tato lekce tě naučí měřit, rozkládat a diagnostikovat latenci end-to-end, abys dokázal změnit stížnost na konkrétní číslo, s nímž lze pracovat.

Komponenty latence

Celková latence volání API se skládá ze čtyř segmentů, které musíš oddělit. Síťová latence je doba přenosu mezi tvým serverem a API OpenAI; v logech aplikace je neviditelná, ale pokud je tvůj server vzdálený od koncového bodu, může přesáhnout 100 milisekund. Čas do prvního tokenu (TTFT) měří prodlevu před vygenerováním prvního tokenu: toto je úsek, který uživatelé vnímají jako „čekání“, protože obrazovka zůstává prázdná, dokud neskončí. Čas na výstupní token (TPOT) pak popisuje rychlost generování pro každý následující token; po vynásobení délkou odpovědi získáš dobu scrollování textu. Nakonec aplikační latence pokrývá vše, co dělá tvůj vlastní server před voláním a po něm: načítání dokumentů, sestavování promptu, validace výstupního JSON a zápis do databáze.

Toto rozdělení není jen akademické. Tým, který zjistí, že jeho TTFT je v pořádku, ale aplikační latence přidává dvě sekundy, nebude měnit modely: místo toho se podívá na svůj SQL dotaz pro načítání kontextu.

Měření v Pythonu

Zde je návod, jak instrumentovat volání Responses API pro zachycení každého segmentu:

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

Klíčovým poznatkem z tohoto kódu je použití stream=True. Bez streamování nemůžeš izolovat TTFT: API vrátí odpověď až po dokončení celé reakce, takže změříš pouze celkový čas. Časovač spustíš před voláním, zastavíš ho u první textové delty a zbývající dobu vydělíš počtem zbývajících tokenů, čímž získáš TPOT. Spusť stejný prompt proti dvěma modelům nebo dvěma nastavením logického uvažování a během několika minut získáš kvantitativní srovnání, které nahradí dohady tvého týmu.

Diagnostika úzkých hrdel

Vysoké TTFT, nad dvě sekundy, ukazuje na tři příčiny. Tou nejčastější je příliš dlouhý systémový prompt, který není cacheován: model musí při každém volání zpracovat několik tisíc tokenů, než začne psát. Další příčinou je vysoké nastavení logického uvažování – high, xhigh nebo max na GPT-5.6 – které záměrně nutí model přemýšlet před vytvořením jakéhokoli viditelného výstupu; není to chyba, je to očekávané chování, ale mělo by jít o vědomou volbu, nikoli o nastavení zděděné z prototypu. Nakonec může jít o výkyv zátěže na straně OpenAI, který nemůžeš ovlivnit: právě proto potřebuješ průběžné měření místo jednorázové kontroly, abys jej odlišil od ostatních dvou příčin.

Vysoké TPOT, nad 50 ms na token, vypovídá o něčem jiném. Velmi vysoká hodnota max_output_tokens nutí model produkovat dlouhé sekvence a celková doba trvání se mechanicky zvyšuje, i když každý token přichází normální rychlostí. Používání složitého volání funkcí s mnoha deklarovanými nástroji také zatěžuje generování. Konkrétně: tým, který ponechal ve svém schématu patnáct nástrojů, přičemž polovina se již nepoužívá, bude platit tuto režii při každém volání.

Nástroje pro monitorování

Jednorázové měření nestačí: musíš sledovat rozložení v čase, protože dlouhý ocas rozložení generuje supportní tickety. Pro průběžné monitorování produkce integruj tyto metriky do svého observability stacku:

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

Posuvné okno tisíce měření zabraňuje neomezenému růstu paměti a zároveň udržuje reprezentativní vzorek nedávného provozu. Klíčové je, že tato třída exponuje dva percentily, nikoli průměr: p50 na úrovni 700 ms s p99 na 6 sekundách popisuje službu, kterou většina uživatelů považuje za rychlou a menšina za nepoužitelnou. Průměr by obě reality zamaskoval. Napoj report() na svůj nástroj pro metriky a nastav alertní práh na p99 dříve, než začneš zasahovat do zbytku systému.

Klíčové poznatky

  • Latence se rozkládá na TTFT + generování (TPOT × tokeny) + síť
  • Vždy měř se streamováním, abys získal skutečné TTFT
  • Sleduj percentily p50 a p99, nejen průměr
  • Volba modelu a nastavení logického uvažování přímo ovlivňují latenci: GPT-5.6 Terra s nízkým logickým uvažováním odpovídá rychleji než GPT-5.6 Sol s vysokým logickým uvažováním