Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Meranie a analýza latencie

Lekcia 1 z 20 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Prečo je latencia tvoja najdôležitejšia metrika
  2. Zložky latencie
  3. Diagnostika úzkych hrdiel
  4. Kľúčové poznatky

Prečo je latencia tvoja najdôležitejšia metrika

Keď nasadíš aplikáciu poháňanú LLM do produkcie, latencia, ktorú vnímajú používatelia, priamo určuje mieru jej adopcie. Odpoveď, ktorej zobrazenie trvá 8 sekúnd, odradí 70 % používateľov: zatvoria kartu, zopakujú požiadavku alebo dospieju k záveru, že nástroj nefunguje. Žiadne zlepšenie kvality túto stratu nenahradí, pretože k nej dôjde skôr, než si používateľ vôbec prečíta odpoveď.

Výzvou v produkcii je, že „je to pomalé“ nie je diagnóza. Rovnakých osem sekúnd môže spôsobovať príliš dlhý systémový prompt, príliš ambiciózne nastavenie logického uvažovania, zle umiestnený aplikačný server alebo post-spracovanie, ktoré čaká na celú odpoveď, než zobrazí čokoľvek. Každá príčina si vyžaduje inú opravu a oprava tej nesprávnej nič nezmení. Táto lekcia ťa naučí merať, rozkladať a diagnostikovať latenciu od začiatku do konca, aby si dokázal premeniť sťažnosť na konkrétne číslo, s ktorým sa dá pracovať.

Zložky latencie

Celková latencia volania API sa rozkladá na štyri segmenty, ktoré musíš oddeliť. Sieťová latencia je čas prenosu medzi tvojim serverom a API OpenAI; v logoch tvojej aplikácie je neviditeľná, ale ak je tvoj server ďaleko od koncového bodu, môže presiahnuť 100 milisekúnd. Čas do prvého tokenu (TTFT) meria oneskorenie pred vygenerovaním prvého tokenu: toto je segment, ktorý používatelia vnímajú ako „čakanie“, pretože obrazovka zostáva prázdna, kým sa neskončí. Čas na výstupný token (TPOT) následne opisuje rýchlosť generovania pre každý ďalší token; po vynásobení dĺžkou odpovede získavaš trvanie rolovania textu. Nakoniec, aplikačná latencia pokrýva všetko, čo robí tvoj vlastný server pred volaním a po ňom: načítavanie dokumentov, zostavovanie promptu, validácia výstupného JSON a zápis do databázy.

Toto rozloženie nie je len teoretické. Tím, ktorý zistí, že jeho TTFT je v poriadku, ale aplikačná latencia pridáva dve sekundy, nebude meniť model: preskúma svoj SQL dopyt na získavanie kontextu.

Meranie pomocou Pythonu

Tu je návod, ako inštrumentovať volanie Responses API na zachytenie 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}")

Kľúčovým poznatkom z tohto kódu je použitie stream=True. Bez streamovania nedokážeš izolovať TTFT: API vráti odpoveď až po dokončení celej odpovede, takže zmeriaš len celkový čas. Časovač sa spustí pred volaním, zastaví sa pri prvom prírastku textu a zvyšné trvanie vydelené počtom zostávajúcich tokenov dáva TPOT. Spusť ten istý prompt proti dvom modelom alebo dvom nastaveniam logického uvažovania a do niekoľkých minút budeš mať kvantitatívne porovnanie, ktoré nahradí dohady tvojho tímu.

Diagnostika úzkych hrdiel

Vysoké TTFT, nad dve sekundy, poukazuje na tri príčiny. Tou najčastejšou je príliš dlhý systémový prompt, ktorý nie je uložený v cache: model musí pri každom volaní načítať niekoľko tisíc tokenov, než začne písať. Ďalšou príčinou je vysoké nastavenie logického uvažovania – high, xhigh alebo max na GPT-5.6 – ktoré zámerne núti model premýšľať pred vytvorením akéhokoľvek viditeľného výstupu; nie je to chyba, je to očakávané správanie, ale malo by ísť o vedomé rozhodnutie, nie o nastavenie zdedené z prototypu. Nakoniec tu môže byť špička zaťaženia na strane OpenAI, ktorú nemôžeš ovplyvniť: presne preto potrebuješ nepretržité meranie namiesto jednorazovej kontroly, aby si ju odlíšil od ostatných dvoch príčin.

Vysoké TPOT, nad 50 ms na token, sa interpretuje inak. Veľmi vysoká hodnota max_output_tokens núti model produkovať dlhé sekvencie a celkové trvanie sa mechanicky zvyšuje, aj keď každý token prichádza normálnou rýchlosťou. Používanie komplexného volania funkcií s mnohými deklarovanými nástrojmi tiež zaťažuje generovanie. Konkrétne, tím, ktorý nechal v schéme pätnásť nástrojov, hoci polovica sa už nepoužíva, bude platiť túto réžiu pri každom volaní.

Nástroje na monitorovanie

Jednorazové meranie nestačí: musíš sledovať distribúciu v čase, pretože chvost distribúcie generuje tikety podpory. Pre nepretržité monitorovanie produkcie integruj tieto metriky do svojho stacku observability:

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ícky meraní zabraňuje neobmedzenému rastu pamäte pri zachovaní reprezentatívnej vzorky nedávnej prevádzky. Kľúčové je, že táto trieda expose dva percentily, nie priemer: p50 na úrovni 700 ms s p99 na úrovni 6 sekúnd opisuje službu, ktorú väčšina používateľov považuje za rýchlu a menšina za nepoužiteľnú. Priemer by obe reality zamaskoval. Napoj report() na svoj nástroj pre metriky a nastav prahovú hodnotu alertu pre p99 skôr, než sa dotkneš zvyšku systému.

Kľúčové poznatky

  • Latencia sa rozkladá na TTFT + generovanie (TPOT × tokeny) + sieť
  • Vždy meraj so streamovaním, aby si získal skutočné TTFT
  • Sleduj percentily p50 a p99, nielen priemer
  • Výber modelu a nastavenia logického uvažovania priamo ovplyvňujú latenciu: GPT-5.6 Terra s nízkym logickým uvažovaním odpovedá rýchlejšie ako GPT-5.6 Sol s vysokým logickým uvažovaním