PricingLoginStart free
AI Engineering Academy · Lektion

Måling af LLM-latenstid: TTFT og TPOT

Definér tid til første token og tid pr. outputtoken som de to vigtigste latenstidsmål, instrumentér Deres applikation til at måle begge, og fastsæt SLA-mål for hvert endpoint.

Lektion 1 af 413 trin

Måling af LLM-latenstid: TTFT og TPOT er en gratis AI Engineering Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i AI Engineering Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

Hvorfor LLM-latenstid har to komponenter

Det er misvisende at måle LLM-latenstid som ét tal. Der er faktisk to forskellige faser: tiden, indtil den første token ankommer (den oplevede reaktionsevne), og tiden, det tager at generere efterfølgende tokens (outputhastigheden). En model kan have god TTFT, men langsom TPOT, så lange svar føles træge, selv om det første svar virkede øjeblikkeligt.

TTFT: Tid til første token

Time to First Token (TTFT) er varigheden fra afsendelse af API-forespørgslen til modtagelse af den allerførste token i svaret. Den omfatter netværkslatenstid, køtid på inferensserveren og prefill-tid (behandling af inputtokens). TTFT har afgørende betydning for den oplevede reaktionsevne — brugere bemærker, når der ikke vises noget i mere end 1-2 sekunder, uanset hvor hurtigt tokens derefter strømmer.

import time
from openai import OpenAI

client = OpenAI()

def measure_ttft(prompt: str) -> float:
    start = time.perf_counter()
    first_token_time = None
    stream = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}],
        stream=True
    )
    for chunk in stream:
        if chunk.choices[0].delta.content:
            first_token_time = time.perf_counter()
            break  # stop after first token
    return first_token_time - start

TPOT: Tid pr. outputtoken

Time Per Output Token (TPOT) er den gennemsnitlige tid mellem efterfølgende tokens, når genereringen er startet. Den beregnes som den samlede genereringstid divideret med det samlede antal outputtokens. TPOT bestemmer læsehastigheden — mennesker læser omtrent 250 ord i minuttet, så en TPOT på over 100 ms pr. token (10 tokens i sekundet) vil føles mærkbart langsom ved lange svar.

import time
from openai import OpenAI

client = OpenAI()

def measure_tpot(prompt: str) -> dict:
    start = time.perf_counter()
    first_token_time = None
    token_count = 0
    stream = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}],
        stream=True
    )
    for chunk in stream:
        delta = chunk.choices[0].delta.content or ''
        if delta:
            if first_token_time is None:
                first_token_time = time.perf_counter()
            token_count += 1
    end = time.perf_counter()
    ttft = first_token_time - start
    generation_time = end - first_token_time
    tpot = generation_time / max(token_count, 1)
    return {'ttft_ms': ttft * 1000, 'tpot_ms': tpot * 1000, 'tokens': token_count}

Samlet latenstid kontra TTFT og TPOT

Forholdet mellem disse metrikker er: total_latency = TTFT + (output_tokens × TPOT). For et svar på 500 tokens ved 50 ms TPOT tager genereringen 25 sekunder. For streamingapplikationer skal du først optimere TTFT — brugere accepterer langsom streaming bedre end en tom skærm. Ved batchbehandling uden streaming er den samlede latenstid det vigtige, så optimer TPOT ved at vælge modeller med hurtigere inferens.

# Latency breakdown for a 200-token response
ttft_ms = 450       # half a second to first token
tpot_ms = 25        # 25ms per token = 40 tokens/sec
output_tokens = 200

total_latency = ttft_ms + (tpot_ms * output_tokens)
print(f'TTFT:  {ttft_ms}ms')
print(f'Generation: {tpot_ms * output_tokens}ms')
print(f'Total: {total_latency}ms ({total_latency/1000:.1f}s)')
# Output:
# TTFT:  450ms
# Generation: 5000ms
# Total: 5450ms (5.5s)

Faktorer, der påvirker TTFT

TTFT domineres af prefill-omkostningen, som skalerer med antallet af inputtokens. En systemprompt på 10.000 tokens vil have 10 gange højere TTFT end en prompt på 1.000 tokens, alt andet lige. Andre faktorer omfatter belastningen på serveren (køtid), netværkets tur-retur-tid til API-endepunktet og om prompt-caching reducerer det effektive prefill-arbejde. Minimer længden på systemprompten for at reducere TTFT.

# TTFT scales approximately linearly with input tokens
# Measured typical values for gpt-4o (2026):
# 500 input tokens:   ~400ms TTFT
# 2000 input tokens:  ~600ms TTFT
# 10000 input tokens: ~1500ms TTFT
# 32000 input tokens: ~4000ms TTFT

# Use prompt caching to avoid paying for repeated long prefixes:
# Cached tokens: ~200ms saved per 1000 cached tokens

Faktorer, der påvirker TPOT

TPOT bestemmes primært af modellens størrelse og hardwaren. Mindre modeller (GPT-4o-mini) afkoder meget hurtigere end store modeller (GPT-4o). På selvhostede modeller er gruppestørrelse og GPU-hukommelsesbåndbredde de vigtigste faktorer. For OpenAI-hostede modeller varierer TPOT med serverbelastningen, men er typisk 15-40 ms pr. token. Du kan ikke styre TPOT direkte på hostede API'er — modelvalget er dit vigtigste håndtag.

# Typical TPOT benchmarks (approximate, 2026):
# gpt-4o-mini:   15-20ms per token (50-65 tokens/sec)
# gpt-4o:        25-40ms per token (25-40 tokens/sec)
# claude-3.5-haiku: 20-25ms per token
# claude-3.5-sonnet: 30-50ms per token
# local llama-3.1-8B on A100: 8-12ms per token
# local llama-3.1-70B on 4xA100: 25-35ms per token

Fastlæggelse af SLA-mål pr. endepunkt

Ikke alle endepunkter har brug for samme mål for latenstid. Et chatendepunkt har en stram TTFT-SLA (brugerne forventer <500 ms), mens et endepunkt til batchopsummering kan tolerere latenstid på flere sekunder. Definér eksplicitte SLA-mål pr. endepunkt, og instrumentér hvert endepunkt separat. Almindelige mål er: interaktiv chat = p95-TTFT <600 ms, dokumentudtræk = samlet p95 <10 sek., batch = ingen realtids-SLA.

SLA_TARGETS = {
    'chat':       {'ttft_p95_ms': 600,  'total_p95_ms': 8000},
    'extraction': {'ttft_p95_ms': 1500, 'total_p95_ms': 10000},
    'summary':    {'ttft_p95_ms': 2000, 'total_p95_ms': 30000},
    'batch':      {'ttft_p95_ms': None, 'total_p95_ms': None},
}

Logning af latenstidsmålinger

Log TTFT og TPOT for hver produktionsanmodning med struktureret logning. Medtag modelnavnet, endepunktet, antallet af prompttokens, antallet af outputtokens og oplysninger om, hvorvidt der blev ramt en cache. Det giver dig data til at beregne percentilfordelinger (p50, p95, p99), opdage forringelser efter modelopdateringer og sammenholde latenstidsspidser med kødybde eller hændelser hos udbyderen.

import structlog

log = structlog.get_logger()

def log_latency(endpoint: str, model: str, metrics: dict):
    log.info(
        'llm_latency',
        endpoint=endpoint,
        model=model,
        ttft_ms=round(metrics['ttft_ms'], 1),
        tpot_ms=round(metrics['tpot_ms'], 1),
        output_tokens=metrics['tokens'],
        total_ms=round(metrics['ttft_ms'] + metrics['tpot_ms'] * metrics['tokens'], 1)
    )

Beregning af percentiler ud fra stikprøver

Rå gennemsnit er misvisende for latenstid – nogle få langsomme afvigere øger gennemsnittet uden at påvirke de fleste brugere. Rapportér altid percentilerne p50, p95 og p99. P95 er den mest almindelige SLA-måling: Det betyder, at 95 % af anmodningerne blev gennemført inden for den angivne tid. Brug NumPy eller modulet statistics til at beregne percentiler ud fra dine loggede latenstidsmålinger.

import numpy as np

def compute_percentiles(samples: list, label: str = 'latency_ms'):
    arr = np.array(samples)
    stats = {
        'count': len(arr),
        'p50': np.percentile(arr, 50),
        'p95': np.percentile(arr, 95),
        'p99': np.percentile(arr, 99),
        'mean': np.mean(arr),
        'max': np.max(arr)
    }
    print(f'{label}:')
    for k, v in stats.items():
        print(f'  {k}: {v:.1f}')
    return stats

Reduktion af latenstid med max_tokens

Ved at angive en passende grænse for max_tokens reducerer du den værst tænkelige samlede latenstid ved at forhindre ekstremt lange svar. Hvis din anvendelse højst har brug for svar på 200 tokens, skal du angive max_tokens=250. Det begrænser også omkostningerne. Kombinér det med streaming, så brugerne ser output med det samme, mens hele svaret stadig genereres. Lad aldrig max_tokens være ubegrænset i produktionsendepunkter.

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': question}],
    max_tokens=300,  # cap at 300 tokens
    stream=True
)

# With max_tokens=300 and TPOT=30ms:
# worst-case total generation = 9000ms
# Without limit: could run to 4096+ tokens = 123s+

Prioritering af latenstidsoptimering

Når latenstiden er for høj, skal du afhjælpe flaskehalsene i prioriteret rækkefølge. Først skal du aktivere streaming, så brugerne ser output med det samme, selv hvis den samlede latenstid er høj. Dernæst skal du forkorte systemprompten for at reducere TTFT. Tilføj derefter caching af promptpræfikser for at fordele omkostningen ved prefilling over gentagne anmodninger. Skift til en mindre model, hvis kvaliteten tillader det. Overvej til sidst selvhostet inferens for at få maksimal kontrol over både TTFT og TPOT.

# Latency optimization checklist (in priority order):
# 1. Enable streaming (perceived latency: immediate)
# 2. Shorten system prompt by 50% (TTFT: -20%)
# 3. Enable prompt prefix caching (TTFT: -40% on cache hits)
# 4. Downgrade to gpt-4o-mini for simple queries (TPOT: -40%)
# 5. Self-host llama-3.1-8B for high-volume simple queries
#    (TPOT: 8ms vs 25ms; TTFT: 100ms vs 450ms)

Hurtigt tjek

Test din forståelse af TTFT og TPOT som målinger af latenstid for LLM'er.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion lærte du, at TTFT (Time to First Token) måler den oplevede reaktionsevne og skalerer med antallet af inputtokens, at TPOT (Time Per Output Token) bestemmer genereringshastigheden og primært styres af modellens størrelse, og at SLA-mål pr. endepunkt med percentilmålinger er den rigtige måde at overvåge latenstid i produktion på. I næste afsnit implementerer vi belastningsfordeling på tværs af flere API-nøgler.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
30
Lektioner
120
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Måling af LLM-latenstid: TTFT og TPOT” gratis?

Ja — hele teksten til “Måling af LLM-latenstid: TTFT og TPOT” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af AI Engineering Academy-kurset, skal du opgradere til CoddyKit PRO. AI Engineering Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Måling af LLM-latenstid: TTFT og TPOT”?

Definér tid til første token og tid pr. outputtoken som de to vigtigste latenstidsmål, instrumentér Deres applikation til at måle begge, og fastsæt SLA-mål for hvert endpoint. Du øver dig i AI Engineering Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på AI Engineering Academy?

Der kræves ingen tidligere erfaring. AI Engineering Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Måling af LLM-latenstid: TTFT og TPOT”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne AI Engineering Academy-lektion?

Ja. Alle AI Engineering Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Måling af LLM-latenstid: TTFT og TPOT
  2. Load balancing og strategier med flere nøgler
  3. Fallback-udbydere og circuit breakers
  4. Timeoutbudgetter og kontrolleret forringelse
← Tilbage til AI Engineering Academy