Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Mittaa ja analysoi latenssia

Oppitunti 1 / 20 Päivitetty 28. heinäkuuta 2026 Edistynyt
Tällä sivulla
  1. Miksi latenssi on tärkein mittarisi
  2. Latenssin osatekijät
  3. Pullonkaulojen diagnosointi
  4. Keskeiset asiat

Miksi latenssi on tärkein mittarisi

Kun otat LLM-pohjaisen sovelluksen käyttöön tuotannossa, käyttäjien kokema latenssi määrittää suoraan käyttöönoton onnistumisen. Vastaus, jonka ilmestyminen kestää 8 sekuntia, karkottaa 70 % käyttäjistä: he sulkevat välilehden, yrittävät pyyntöä uudelleen tai päättelevät työkalun olevan rikki. Mikään laadun parannus ei korvaa tätä menetystä, sillä se tapahtuu ennen kuin käyttäjä ehtii edes lukea vastausta.

Haaste tuotannossa on se, että “se on hidas” ei ole diagnoosi. Sama kahdeksan sekunnin kesto voi johtua liian laajasta järjestelmäkehotteesta, liian kunnianhimoisesta päättelyasetuksesta, huonosti sijoitetusta sovelluspalvelimesta tai jälkikäsittelystä, joka odottaa koko vastausta ennen kuin näyttää mitään. Jokainen syy vaatii erilaisen korjauksen, ja väärän kohdan korjaaminen ei muuta mitään. Tämä oppitunti opettaa sinulle mittaamaan, erittelemään ja diagnosoimaan end-to-end-latenssin, jotta voit muuttaa valituksen toimintakelpoiseksi numeroksi.

Latenssin osatekijät

API-kutsun kokonaislatenssi jakautuu neljään osaan, jotka sinun on erotettava toisistaan. Verkkolatenssi on siirtymäaika palvelimesi ja OpenAI API:n välillä; se on näkymätön sovelluslokeissasi, mutta voi ylittää 100 millisekuntia, jos palvelimesi on kaukana päätepisteestä. Aika ensimmäiseen tokeniin (TTFT) mittaa viivettä ennen ensimmäisen tokenin generointia: tämä on se jakso, jonka käyttäjät kokevat “odotuksena”, sillä näyttö pysyy tyhjänä sen valmistumiseen saakka. Aika ulostulotokenia kohden (TPOT) kuvaa taas generointinopeutta jokaiselle seuraavalle tokenille; kerrottuna vastauksen pituudella se antaa tekstin vierityksen keston. Lopuksi sovelluslatenssi kattaa kaiken, mitä oma palvelimesi tekee ennen kutsua ja sen jälkeen: asiakirjojen hakeminen, kehotteen kokoaminen, ulostulon JSON-validointi ja tietokantaan kirjoittaminen.

Tämä erittely ei ole akateemista. Tiimi, joka huomaa TTFT:n olevan kunnossa, mutta sovelluslatenssin lisäävän kaksi sekuntia, ei vaihda malleja: se tutkii kontekstin hakemiseen käytettyä SQL-kyselyään.

Mittaaminen Pythonilla

Näin instrumentoit kutsun Responses API:hun siepataksesi jokaisen osion:

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

Tämän koodin tärkein oivallus on stream=True-parametrin käyttö. Ilman suoratoistoa et voi eristää TTFT:tä: API palauttaa vastauksen vasta koko tekstin valmistuttua, jolloin mittaat vain kokonaiskeston. Ajastin käynnistyy ennen kutsua, pysähtyy ensimmäiseen tekstideltaan, ja jäljellä oleva kesto jaettuna jäljellä olevien tokenien määrällä antaa TPOT:n. Suorita sama kehote kahdella eri mallilla tai kahdella eri päättelyasetuksella, niin muutaman minuutin kuluessa sinulla on kvantitatiivinen vertailu, joka korvaa tiimisi arvailut.

Pullonkaulojen diagnosointi

Korkea TTFT, yli kaksi sekuntia, viittaa kolmeen syyhyn. Yleisin on liian pitkä järjestelmäkehote, jota ei ole välimuistitettu: mallin on nieltävä useita tuhansia tokeneita ennen kirjoittamisen aloittamista jokaisella kutsulla. Seuraava syy on korkea päättelyasetus – high, xhigh tai max mallissa GPT-5.6 – joka saa mallin tarkoituksellisesti miettimään ennen näkyvän tulosteen tuottamista; tämä ei ole bugi, vaan odotettu käyttäytyminen, mutta sen tulisi olla tietoinen valinta, ei prototyypistä periytyvä asetus. Lopuksi syynä voi olla OpenAI:n puoleinen kuormituspiikki, jota et voi hallita: juuri siksi tarvitset jatkuvaa mittaamista kertaluonteisen tarkistuksen sijaan, jotta voit erottaa sen kahdesta muusta syystä.

Korkea TPOT, yli 50 ms tokenia kohden, kertoo eri tarinaa. Erittäin korkea max_output_tokens pakottaa mallin tuottamaan pitkiä jonoja, jolloin kokonaiskesto kasvaa mekaanisesti, vaikka jokainen token saapuisi normaalilla nopeudella. Monimutkaisten funktiokutsujen käyttö monien määriteltyjen työkalujen kanssa kuormittaa myös generointia. Konkreettisesti tiimi, joka on jättänyt skeemaansa viisitoista työkalua, joista puolta ei enää käytetä, maksaa tämän ylimääräisen kuorman jokaisesta kutsusta.

Seurantatyökalut

Kertamittaaminen ei riitä: sinun on seurattava jakaumaa ajan myötä, koska jakauman häntäpää aiheuttaa tukipyynnöt. Integroi nämä mittarit havainnointipinoosi jatkuvaa tuotantoseurantaa varten:

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

Tuhannen mittauksen liukuva ikkuna estää muistin rajattoman kasvun säilyttäen samalla edustavan otoksen viimeaikaisesta liikenteestä. Ratkaisevan tärkeää on, että tämä luokka paljastaa kaksi persentiiliä, ei keskiarvoa: 700 ms:n p50 ja 6 sekunnin p99 kuvaavat palvelua, jota useimmat käyttäjät pitävät nopeana ja vähemmistö käyttökelvottomana. Keskiarvo olisi peittänyt molemmat realiteetit. Kytke report()-metodi mittarityökaluusi ja aseta hälytyskynnys p99:lle ennen kuin kosket järjestelmän muihin osiin.

Keskeiset asiat

  • Latenssi jakautuu osiin: TTFT + generointi (TPOT × tokenit) + verkko
  • Mittaa aina suoratoistolla saadaksesi todellisen TTFT:n
  • Seuraa p50- ja p99-persentiilejä, älä pelkkää keskiarvoa
  • Mallin valinta ja päättelyasetukset vaikuttavat suoraan latenssiin: GPT-5.6 Terra alhaisella päättelyllä vastaa nopeammin kuin GPT-5.6 Sol korkealla päättelyllä