Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Išmatuokite ir analizuokite delsą

Paskaita 1 iš 20 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Kodėl delsa yra jūsų svarbiausias rodiklis
  2. Delsos komponentai
  3. Kliūčių diagnostika
  4. Svarbiausi punktai

Kodėl delsa yra jūsų svarbiausias rodiklis

Kai diegiate LLM varoma programą į gamybinę aplinką, vartotojų jaučiama delsa tiesiogiai lemia jos priimtinumą. Atsakymas, kuris atsiranda po 8 sekundžių, atbaido 70 % vartotojų: jie uždaro kortelę, kartoją užklausą arba daro išvadą, kad įrankis neveikia. Joks kokybės pagerinimas negali kompensuoti šio nuostolio, nes tai įvyksta dar prieš tai, kai vartotojas perskaito atsakymą.

Gamybinėje aplinkoje problema ta, kad „tai lėta“ nėra diagnozė. Tos pačios aštuonių sekundžių trukmės priežastis gali būti per didelis sistemos prompt’as, pernelyg ambicingas samprotavimo nustatymas, netinkamai išdėstytas programos serveris arba potvarkis, kuris laukia viso atsakymo prieš parodydamas ką nors. Kiekviena priežastis reikalauja skirtingo sprendimo, o netinkamos šalinimas nieko nekeičia. Ši pamoka išmokys tave išmatuoti, suskaidyti ir diagnozuoti galutinę delsą, kad galėtum paversti skundą veiksmingu skaičiumi.

Delsos komponentai

Bendra API užklausos delsa suskirstoma į keturias dalis, kurias turi atskirti. Tinklo delsa yra kelionės laikas tarp tavo serverio ir OpenAI API; ji nematoma tavo programos žurnaluose, tačiau gali viršyti 100 milisekundžių, jei tavo serveris yra toli nuo galinio taško. Laikas iki pirmojo tokeno (TTFT) matuoja vėlavimą prieš sugeneruojant pirmąjį tokeną: tai yra segmentas, kurį vartotojai jaučia kaip „laukimą“, nes ekranas lieka tuščias, kol jis baigiasi. Laikas vienam išvesties tokenui (TPOT) tada apibūdina kiekvieno paskesnio tokeno generavimo greitį; padauginus jį iš atsakymo ilgio, gaunamas teksto slinkimo trukmė. Galiausiai, programos delsa apima viską, ką tavo paties serveris daro prieš ir po užklausos: dokumentų gavimą, prompt’o surinkimą, išvesties JSON validavimą ir rašymą į duomenų bazę.

Šis skaidymas nėra akademinis. Komanda, kuri atranda, kad jos TTFT yra gera, bet programos delsa priduria dvi sekundes, nekeis modelių: ji nagrinės savo konteksto gavimo SQL užklausą.

Matavimas naudojant Python

Štai kaip instrumentuoti užklausą Responses API, norint užfiksuoti kiekvieną 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}")

Svarbiausia šio kodo išvada yra stream=True naudojimas. Be srautinio perdavimo, negali izoliuoti TTFT: API grąžina duomenis tik po viso atsakymo, todėl matuoji tik bendrą laiką. Laikmatis paleidžiamas prieš užklausą, sustabdomas ties pirmuoju teksto delta, o likusi trukmė, padalinta iš likusių tokenų skaičiaus, duoda TPOT. Paleisk tą patį prompt’ą dviem modeliams arba dviem samprotavimo nustatymams ir per kelias minutes gausi kiekybinį palyginimą, kuris pakeis tavo komandos spėliojimus.

Kliūčių diagnostika

Didelis TTFT, viršijantis dvi sekundes, rodo tris priežastis. Dažniausia – per ilgas sistemos prompt’as, kuris nėra kaupiamas talpykloje: modelis turi suvartoti kelis tūkstančius tokenų prieš pradėdamas rašyti, kiekvieno užklausos metu. Kita – aukštas samprotavimo nustatymas – high, xhigh arba max GPT-5.6 atveju – kuris tyčia priverčia modelį galvoti prieš kuriant bet kokį matomą išvestį; tai nėra klaida, tai numatyta elgsena, tačiau tai turi būti sąmoningas pasirinkimas, o ne iš prototipo paveldėtas nustatymas. Galiausiai, gali būti OpenAI pusės apkrovos šuolis, kurio negali kontroliuoti: būtent todėl tau reikia nuolatinio matavimo, o ne vienkartinio patikrinimo, kad atskirtum tai nuo kitų dviejų.

Didelis TPOT, viršijantis 50 ms vienam tokenui, reiškia ką kita. Labai didelis max_output_tokens verčia modelį kurti ilgas sekvenijas, ir bendra trukmė mechaniškai didėja, net jei kiekvienas tokenas atkeliauja normaliu greičiu. Sudėtingų funkcijų kvietimų naudojimas su daugeliu deklaruotų įrankių taip pat apsunkina generavimą. Konkrečiai, komanda, kuri paliko penkiolika įrankių savo schemoje, kai pusė jų nebenaudojami, mokės tą pridėtinę kainą kiekvieno užklausos metu.

Stebėsenos įrankiai

Vienkartinio matavimo nepakanka: turi sekti pasiskirstymą laike, nes pasiskirstymo uodega generuoja palaikymo bilietus. Nuolatiniam gamybiniam stebėjimui integruok šiuos rodiklius į savo stebėsenos sistemą:

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

Tūkstančio matavimų slankusis langas neleidžia neribotam atminties augimui, išlaikant reprezentatyvią naujausio srauto imtį. Svarbiausia, kad ši klasė atskleidžia du percentilius, o ne vidurkį: 700 ms p50 su 6 sekundžių p99 apibūdina tarnybą, kurią dauguma vartotojų laiko greita, o mažuma – nenaudojama. Vidurkis būtų užmaskavęs abu realybės aspektus. Prijunk report() prie savo metrikų įrankio ir nustatyk įspėjimo slenkstį p99 reikšmei prieš liečiant likusią sistemos dalį.

Svarbiausi punktai

  • Delsa suskaidoma į TTFT + generavimą (TPOT × tokenai) + tinklą
  • Visada matuok naudodamas srautinį perdavimą, kad gautum tikrąjį TTFT
  • Stebėk p50 ir p99 percentilius, o ne tik vidurkį
  • Modelio pasirinkimas ir samprotavimo nustatymai tiesiogiai veikia delsą: GPT-5.6 Terra su žemu samprotavimu atsako greičiau nei GPT-5.6 Sol su aukštu samprotavimu