Salt la conținutul principal
Română— Alege o limbă
Meniu

Măsurarea și analiza latenței

Lecția 1 din 20 Actualizată 28 iulie 2026 Avansat
Pe această pagină
  1. De ce latența este metrica dumneavoastră numărul unu
  2. Componentele latenței
  3. Diagnosticarea gâtuirilor
  4. Puncte cheie

De ce latența este metrica dumneavoastră numărul unu

Când implementați o aplicație bazată pe LLM în producție, latența percepută de utilizatori determină direct rata de adopție. Un răspuns care apare după 8 secunde alungă 70% dintre utilizatori: aceștia închid fila, reîncearcă cererea sau concluzionează că instrumentul nu funcționează. Nicio îmbunătățire a calității nu poate compensa această pierdere, deoarece ea survine înainte ca utilizatorul să citească măcar răspunsul.

Provocarea în producție este că afirmația „este lent“ nu constituie un diagnostic. Aceeași durată de opt secunde poate proveni dintr-un prompt de sistem supradimensionat, o setare de raționament prea ambițioasă, un server de aplicații plasat necorespunzător sau o post-procesare care așteaptă răspunsul complet înainte de a afișa orice. Fiecare cauză necesită o remediere diferită, iar repararea elementului greșit nu schimbă nimic. Această lecție vă învață să măsurați, să descompuneți și să diagnosticați latența end-to-end, astfel încât să transformați o plângere într-o valoare acționabilă.

Componentele latenței

Latența totală a unui apel API se descompune în patru segmente pe care trebuie să le separați. Latența de rețea reprezintă timpul de tranzit între serverul dumneavoastră și API-ul OpenAI; aceasta este invizibilă în jurnalele aplicației, dar poate depăși 100 de milisecunde dacă serverul este departe de punctul final. Timpul până la primul token (TTFT) măsoară întârzierea înainte de generarea primului token: acesta este segmentul pe care utilizatorii îl simt ca „timp de așteptare“, deoarece ecranul rămâne gol până la finalizarea sa. Timpul per token de ieșire (TPOT) descrie apoi viteza de generare pentru fiecare token subsequent; înmulțit cu lungimea răspunsului, acesta oferă durata de derulare a textului. În final, latența aplicației acoperă tot ceea ce face serverul dumneavoastră înainte și după apel: preluarea documentelor, asamblarea promptului, validarea JSON-ului de ieșire și scrierea în baza de date.

Această descompunere nu este doar academică. O echipă care descoperă că TTFT-ul său este acceptabil, dar latența aplicației adaugă două secunde, nu va schimba modelul: va examina interogarea SQL de preluare a contextului.

Măsurarea cu Python

Iată cum să instrumentați un apel către API-ul Responses pentru a captura fiecare 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}")

Concluzia principală a acestui cod este utilizarea stream=True. Fără streaming, nu puteți izola TTFT: API-ul returnează date doar după răspunsul complet, astfel încât măsurați doar un total. Cronometrul pornește înainte de apel, se oprește la primul delta de text, iar durata rămasă împărțită la numărul de tokeni rămași oferă TPOT. Rulați același prompt pe două modele sau cu două setări de raționament și, în câteva minute, veți obține comparația cantitativă care înlocuiește presupunerile echipei dumneavoastră.

Diagnosticarea gâtuirilor

Un TTFT ridicat, peste două secunde, indică trei cauze. Cea mai frecventă este un prompt de sistem excesiv de lung care nu este stocat în cache: modelul trebuie să ingereze câteva mii de tokeni înainte de a începe scrierea, la fiecare apel. Urmează o setare de raționament ridicată—high, xhigh sau max pe GPT-5.6—care face ca modelul să „gândească“ deliberat înainte de a produce orice ieșire vizibilă; acesta nu este un bug, ci un comportament așteptat, dar ar trebui să fie o alegere conștientă, nu o setare moștenită de la un prototip. În final, ar putea exista un vârf de încărcare din partea OpenAI, pe care nu îl puteți controla: tocmai de aceea aveți nevoie de măsurători continue, nu de o verificare unică, pentru a-l distinge de celelalte două.

Un TPOT ridicat, peste 50 ms per token, se citește diferit. Un max_output_tokens foarte mare împinge modelul să producă secvențe lungi, iar durata totală crește mecanic, chiar dacă fiecare token sosește la viteza normală. Utilizarea apelurilor de funcții complexe cu multe instrumente declarate îngreunează, de asemenea, generarea. Concret, o echipă care a lăsat cincisprezece instrumente în schema sa, când jumătate nu mai sunt folosite, va plăti acea suprasolicitare la fiecare apel.

Instrumente de monitorizare

Măsurarea o singură dată nu este suficient: trebuie să urmăriți distribuția în timp, deoarece coada distribuției generează tichete de suport. Pentru monitorizarea continuă în producție, integrați aceste metrici în stiva dumneavoastră de observabilitate:

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

Fereastra glisantă de o mie de măsurători previne creșterea necontrolată a memoriei, menținând în același timp un eșantion reprezentativ al traficului recent. Esențial este că această clasă expune două percentile, nu o medie: un p50 de 700 ms cu un p99 de 6 secunde descrie un serviciu pe care majoritatea utilizatorilor îl găsesc rapid, dar pe care o minoritate îl consideră inutilizabil. O medie ar fi mascat ambele realități. Conectați report() la instrumentul dumneavoastră de metrici și setați un prag de alertă pentru p99 înainte de a atinge restul sistemului.

Puncte cheie

  • Latența se descompune în TTFT + generare (TPOT × tokeni) + rețea
  • Măsurați întotdeauna cu streaming pentru a obține TTFT real
  • Urmăriți percentilele p50 și p99, nu doar media
  • Alegerea modelului și setările de raționament impactează direct latența: GPT-5.6 Terra cu raționament scăzut răspunde mai rapid decât GPT-5.6 Sol cu raționament ridicat