Mesurer la latence des LLM : TTFT et TPOT
Définissez le délai avant le premier jeton et le délai par jeton de sortie comme les deux principales mesures de latence, instrumentez votre application pour mesurer les deux et établissez des objectifs SLA pour chaque point d’accès.
Mesurer la latence des LLM : TTFT et TPOT est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.
Pourquoi la latence des LLM comporte deux composantes
Mesurer la latence d’un LLM par un seul nombre est trompeur. Il existe en réalité deux phases distinctes : le temps nécessaire à l’arrivée du premier jeton (réactivité perçue) et le temps nécessaire à la génération des jetons suivants (vitesse de sortie). Un modèle peut avoir un excellent TTFT mais un TPOT lent, ce qui rend les longues réponses laborieuses, même si la réponse initiale semblait instantanée.
TTFT : temps avant le premier jeton
Le temps avant le premier jeton (TTFT) est la durée entre l’envoi de la requête à l’API et la réception du tout premier jeton de la réponse. Il comprend la latence réseau, le temps d’attente dans la file du serveur d’inférence et le temps de préremplissage (traitement des jetons d’entrée). Le TTFT détermine principalement la réactivité perçue : les utilisateurs remarquent qu’aucun contenu n’apparaît pendant plus d’une ou deux secondes, quelle que soit ensuite la vitesse de diffusion des jetons.
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 - startTPOT : temps par jeton de sortie
Le temps par jeton de sortie (TPOT) est le temps moyen entre deux jetons successifs une fois la génération commencée. Il se calcule en divisant la durée totale de génération par le nombre total de jetons de sortie. Le TPOT détermine la vitesse de lecture : les humains lisent environ 250 mots par minute, donc un TPOT supérieur à 100 ms par jeton (10 jetons par seconde) semblera sensiblement lent pour les longues réponses.
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}Latence totale, TTFT et TPOT
La relation entre ces métriques est la suivante : total_latency = TTFT + (output_tokens × TPOT). Pour une réponse de 500 jetons avec un TPOT de 50 ms, la génération prend 25 secondes. Pour les applications avec diffusion en continu, optimisez d’abord le TTFT : les utilisateurs tolèrent mieux une diffusion lente qu’un écran vide. Pour le traitement par lots sans diffusion en continu, c’est la latence totale qui compte ; optimisez donc le TPOT en choisissant des modèles dont l’inférence est plus rapide.
# 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)Facteurs qui influencent le TTFT
Le TTFT dépend principalement du coût de préremplissage, qui augmente avec le nombre de jetons d’entrée. Toutes choses égales par ailleurs, une invite système de 10 000 jetons aura un TTFT 10 fois supérieur à celui d’une invite de 1 000 jetons. Parmi les autres facteurs figurent la charge du serveur (temps d’attente dans la file), le temps aller-retour sur le réseau jusqu’au point d’accès de l’API et la réduction éventuelle du travail de préremplissage effectif grâce à la mise en cache des invites. Réduisez la longueur de l’invite système pour diminuer le 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 tokensFacteurs qui influencent le TPOT
Le TPOT est principalement déterminé par la taille du modèle et le matériel. Les modèles plus petits (GPT-4o-mini) décodent beaucoup plus rapidement que les grands modèles (GPT-4o). Pour les modèles hébergés vous-même, la taille des lots et la bande passante de la mémoire GPU sont les principaux facteurs. Pour les modèles hébergés par OpenAI, le TPOT varie selon la charge du serveur, mais se situe généralement entre 15 et 40 ms par jeton. Vous ne pouvez pas contrôler directement le TPOT des API hébergées : le choix du modèle est votre principal levier.
# 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 tokenDéfinir des objectifs de SLA pour chaque point d’accès
Tous les points de terminaison n’ont pas besoin du même objectif de latence. Un point de terminaison de conversation possède un SLA TTFT strict (les utilisateurs s’attendent à un délai <500ms), tandis qu’un point de terminaison de résumé par lots peut tolérer une latence de plusieurs secondes. Définissez des objectifs de SLA pour chaque point de terminaison et instrumentez-les séparément. Objectifs courants : conversation interactive = TTFT p95 <600ms, extraction de documents = durée totale p95 <10s, traitement par lots = aucun SLA en temps réel.
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},
}Consigner les métriques de latence
Consignez le TTFT et le TPOT pour chaque requête en production à l’aide d’une journalisation structurée. Incluez le nom du modèle, le point de terminaison, le nombre de jetons de l’invite, le nombre de jetons de sortie et indiquez si la requête a utilisé une réponse mise en cache. Vous disposerez ainsi des données nécessaires pour calculer les distributions par percentile (p50, p95, p99), repérer les régressions après les mises à jour du modèle et corréler les pics de latence avec la profondeur de la file d’attente ou les incidents affectant les fournisseurs.
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)
)Calculer les percentiles à partir d’échantillons
Les moyennes brutes sont trompeuses pour la latence : quelques valeurs aberrantes très lentes augmentent la moyenne sans affecter la plupart des utilisateurs. Présentez toujours les percentiles p50, p95 et p99. Le p95 est la métrique de SLA la plus courante : cela signifie que 95 % des requêtes se sont terminées dans ce délai. Utilisez NumPy ou le module statistics pour calculer les percentiles à partir de vos échantillons de latence consignés.
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 statsRéduire la latence avec max_tokens
Définir une limite max_tokens appropriée réduit la latence totale maximale en empêchant les réponses excessivement longues. Si votre cas d’utilisation nécessite au plus 200 jetons par réponse, définissez max_tokens=250. Cela limite également le coût. Combinez cette limite avec la génération en continu afin que les utilisateurs voient immédiatement la sortie pendant que la réponse complète est encore générée. Ne laissez jamais max_tokens sans limite sur les points de terminaison de production.
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+Priorités pour optimiser la latence
Lorsque la latence est trop élevée, traitez les goulots d’étranglement par ordre de priorité. Premièrement, activez la génération en continu afin que les utilisateurs voient immédiatement la sortie, même si la latence totale reste élevée. Deuxièmement, raccourcissez l’invite système pour réduire le TTFT. Troisièmement, ajoutez la mise en cache du préfixe de l’invite afin d’amortir le coût du préremplissage entre les requêtes répétées. Quatrièmement, passez à un modèle plus petit si la qualité le permet. Enfin, envisagez une inférence hébergée par vos soins pour contrôler au maximum le TTFT et le 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)Vérification rapide
Vérifiez votre compréhension du TTFT et du TPOT en tant que métriques de latence des LLM.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que le TTFT (Time to First Token) mesure la réactivité perçue et augmente avec le nombre de jetons d’entrée, que le TPOT (Time Per Output Token) détermine la vitesse de génération et dépend principalement de la taille du modèle, et que les objectifs de SLA par point de terminaison associés à des métriques par percentile constituent la bonne méthode pour surveiller la latence en production. Nous allons maintenant mettre en œuvre l’équilibrage de charge entre plusieurs clés d’API.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Mesurer la latence des LLM : TTFT et TPOT » est-elle gratuite ?
Oui — le texte complet de « Mesurer la latence des LLM : TTFT et TPOT » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Mesurer la latence des LLM : TTFT et TPOT » ?
Définissez le délai avant le premier jeton et le délai par jeton de sortie comme les deux principales mesures de latence, instrumentez votre application pour mesurer les deux et établissez des object… Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?
Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Mesurer la latence des LLM : TTFT et TPOT » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?
Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Mesurer la latence des LLM : TTFT et TPOT
- Équilibrage de charge et stratégies multi-clés
- Fournisseurs de secours et disjoncteurs
- Budgets de délai et dégradation progressive