Vitesse de génération (TPS / TTFT / Latence)

1. Vue d'ensemble du concept et problème systémique

Dans les discussions d'ingénierie, la performance des modèles est souvent réduite à des définitions floues telles que « rapide » ou « lente ». Cette approche amateur conduit inévitablement à l'échec des systèmes temps réel : l'interface d'un bot vocal se fige pendant plusieurs secondes avant de répondre, l'autocomplétion de code dans un IDE irrite par la latence d'affichage des caractères, et les boucles agentiques en arrière-plan restent bloquées dans des files d'attente s'étalant sur des heures.

L'inférence réelle des grands modèles de langage (LLM) obéit aux lois physiques des semi-conducteurs et se divise en deux phases matérielles radicalement distinctes :

1. Phase de Prefill (Context Phase) : traitement parallèle du prompt d'entrée.
2. Phase de Decode (Generation Phase) : génération séquentielle des symboles de sortie, token par token.

Les métriques TTFT (Time to First Token) et TPS (Tokens Per Second) constituent la boussole systémique de l'ingénieur, déterminant l'architecture des files d'attente, le choix du matériel et l'expérience utilisateur des applications interactives.

2. Taxonomie architecturale et modèle mental

Les métriques de latence et de débit sont classifiées selon les étapes du cycle de vie de la requête :

┌─────────────────────────────────────────────────────────────┐
│                 TAXONOMIE DE LA LATENCE D'INFÉRENCE         │
├─────────────────────────────────────────────────────────────┤
│ 1. Temps d'attente (File d'attente pour les ressources GPU) │
├─────────────────────────────────────────────────────────────┤
│ 2. Phase de Prefill ➔ TTFT (Time to First Token)            │
│    • Limité par le calcul (TFLOPS des Tensor Cores)          │
│    • Calcul direct du cache KV pour l'intégralité du texte   │
│      d'entrée                                               │
├─────────────────────────────────────────────────────────────┤
│ 3. Phase de Decode ➔ TPS / ITL (Inter-Token Latency)        │
│    • Limité par la bande passante mémoire (GB/s du bus VRAM)│
│    • Lecture séquentielle des poids pour chaque token       │
├─────────────────────────────────────────────────────────────┤
│ 4. Latence E2E totale = TTFT + (N_tokens_générés * ITL)     │
└─────────────────────────────────────────────────────────────┘

1. TTFT (Time to First Token — temps jusqu'au premier token) :
   • Nombre de millisecondes entre l'envoi de la requête HTTP par le client et la réception du premier octet de la réponse streaming. Il comprend la latence réseau, l'attente dans la file d'attente et le temps de calcul du prefill.
2. TPS (Tokens Per Second — vitesse de génération) :
   • Nombre de tokens émis par le système en une seconde. Pour un flux unique, cela correspond à $1 / \text{ITL}$. Pour l'ensemble du serveur (Aggregate Throughput), il s'agit du nombre total de tokens générés simultanément par tous les clients.
3. ITL (Inter-Token Latency — latence inter-token) :
   • Temps écoulé entre l'apparition de deux tokens consécutifs lors du streaming. Pour l'œil humain, un seuil confortable est inférieur à 30 ms par token (correspondant à >33 TPS).
4. Speculative Decoding :
   • Astuce algorithmique qui transforme une partie des opérations de la phase Decode en vérification parallèle, augmentant le TPS net de 2 à 3 fois sans perte de précision.

3. Pipeline technique et mécanique interne

Le cycle de vie de l'inférence sous le microscope des timings :

1. Réception de la requête et batching : Une requête contenant 4000 tokens de code arrive dans le moteur d'inférence (par exemple, vLLM).
2. Prefill (Phase de pré-remplissage) : Le GPU charge les matrices de poids et multiplie parallèlement les 4000 tokens sur les Tensor Cores. Les vecteurs Q, K, V sont calculés et la mémoire du KV-cache est initialisée.
3. Émission du premier token (Fixation du TTFT) : Le premier token est envoyé au client via Server-Sent Events. Si le prompt est mis en cache (Prompt Caching), cette étape prend 50 ms ; sinon, elle varie de 500 ms à 3 secondes.
4. Boucle séquentielle de décodage (Decode Loop) :
   • Pour générer un seul token, la carte graphique doit lire tous les 70 milliards de paramètres du modèle depuis la VRAM vers le cache du cristal.
   • Sur une mémoire avec un débit de 1000 Go/s (RTX 4090), la lecture d'un modèle quantifié de 35 Go prend : $$35 \text{ Go} / 1000 \text{ Go/s} = 35 \text{ ms par token} \approx 28 \text{ TPS}$$
5. Clôture de la requête : La génération s'arrête lorsque le token <|im_end|> est atteint ou que la limite de longueur est dépassée, libérant ainsi les ressources du KV-cache pour d'autres requêtes.

4. Scénarios d'ingénierie pratiques en production

01. Développement d'un assistant vocal à réaction humaine (Human-Like Latency)

Un humain perçoit une pause dans une conversation si la réponse tarde plus de 500 ms :

• Les ingénieurs optent pour Gemini 2.0 Flash ou Mistral NeMo avec un hébergement local.
• Grâce à l'optimisation de la stack, le TTFT est réduit à 180 ms, et la synthèse vocale (TTS) ajoute 120 ms. Un temps de réaction total de 300 ms crée l'illusion d'un dialogue vivant.

02. Autocomplétion ultra-rapide dans un IDE (Ghost Text)

Un développeur tape du code dans Cursor à une vitesse de 5 caractères par seconde :

• Toute latence supérieure à 150 ms fait apparaître la suggestion après que le développeur a déjà tapé un nouveau caractère.
• Pour ces tâches, on utilise des modèles légers spécifiques (3B–7B paramètres) ou des moteurs spéculatifs capables d'émettre les premiers caractères en 40–80 ms.

03. Traitement par lots de grands volumes de documents dans le backend

Traitement nocturne de 100 000 fichiers PDF utilisateurs :

• Le TTFT individuel pour chaque fichier n'a pas d'importance.
• Le serveur est optimisé pour l'Aggregate Throughput : grâce au Continuous Batching dans vLLM, le cluster sert parallèlement 256 flux, atteignant une vitesse cumulée de 4 000 tokens par seconde.

5. Pièges courants, erreurs typiques et sécurité

• Chute du TPS lors de l'épuisement du KV-cache : Lorsque la mémoire vidéo est remplie à 95 %, le moteur commence à décharger le cache vers le SSD ou le CPU. La vitesse de génération chute instantanément de plusieurs ordres de grandeur, paralysant le système.
• Course aveugle au TPS sans contrôle qualité : Un modèle très rapide (200 tokens/s) qui produit du code non fonctionnel avec des erreurs de syntaxe ne fait qu'augmenter le temps de développement dû aux corrections manuelles.
• Illusion de rapidité due à la mise en tampon réseau : Si un proxy (Nginx ou Cloudflare) met la réponse en buffer au lieu de la streamer (absence de l'en-tête X-Accel-Buffering: no), le client ne verra aucun token tant que le modèle n'aura pas généré l'intégralité du texte.
• Impact de la longueur du contexte sur le TTFT : En augmentant le prompt d'entrée de 2 000 à 100 000 tokens, le temps de prefill croît de manière disproportionnée sans cache activé, transformant un modèle « rapide » en un modèle lent.