Introduction : pourquoi construire TensorRT-LLM pendant votre week-end en vaut la peine
Si vous avez déjà vu un GPU tourner à 60 % d’utilisation pendant que votre LLM avance à pas de tortue, vous savez qu’il y a des performances gratuites à exploiter. TensorRT-LLM transforme cet espace libre en débit : noyaux fusionnés, attention paginée, quantification et optimisations au niveau du graphe qui réduisent la latence et augmentent le nombre de jetons par seconde. Dans ce guide pratique, nous aborderons l’ensemble du processus, de l’installation à la création du moteur en passant par la diffusion, afin que vous puissiez déployer en toute confiance une inférence plus rapide et moins coûteuse sur les GPU NVIDIA.
Ce tutoriel est écrit dans un style pratique et axé sur les solutions. Nous utiliserons une structure axée sur les questions avec des commandes copiables, des pièges courants et des points de décision pour FP16 par rapport à INT8, le traitement par lots et les stratégies de cache KV. Nous ferons également référence aux ressources officielles pour des explorations plus approfondies, , , .
Ce que vous apprendrez
- Comment configurer l’environnement pour TensorRT-LLM
- Comment préparer un modèle (à partir de Hugging Face ou de points de contrôle) pour la création du moteur
- Comment créer des moteurs FP16/INT8 et optimiser les performances
- Comment exécuter l’inférence via Python/C++ et la diffusion HTTP
- Comment évaluer les performances, traiter par lots et déboguer
À qui s’adresse ce guide
- Ingénieurs ML déployant des LLM sur des GPU NVIDIA
- Professionnels optimisant les coûts/la latence en production
- Constructeurs passant des Transformers PyTorch à une inférence hautement optimisée
- Qu’est-ce que TensorRT-LLM et quand devez-vous l’utiliser ?
TensorRT-LLM est une pile d’inférence qui compile les modèles Transformer en « moteurs » GPU hautement optimisés. Comparé à PyTorch brut ou aux runtimes génériques, vous obtenez généralement :
- Une latence plus faible par jeton
- Un débit plus élevé avec des tailles de lots importantes
- Une meilleure efficacité de la mémoire grâce au cache KV paginé et à la quantification
Utilisez-le lorsque vous exécutez des GPU NVIDIA et que vous vous souciez des performances de qualité production. Il est particulièrement intéressant pour les LLM à décodeur uniquement (par exemple, Llama, Mistral, Phi, BLOOM) et les scénarios tels que les chatbots, RAG et les services API à QPS élevé.
- Prérequis et configuration de l’environnement
Exigences de base
- GPU NVIDIA avec une capacité de calcul récente (par exemple, Ampere, Ada, Hopper)
- Versions CUDA et TensorRT correspondantes, ainsi que les pilotes appropriés
- Python 3.8+ et outils de construction si vous compilez à partir de la source
Remarque sur le contrôle de version : vérifiez toujours la matrice de prise en charge et les notes de version TensorRT officielles pour connaître les versions et les fonctionnalités CUDA/TensorRT compatibles avant l’installation, , , .
Options de démarrage rapide
- Conteneurisé : utilisez les conteneurs de NVIDIA avec CUDA/TensorRT préinstallé : le moyen le plus rapide d’éviter les incompatibilités de version.
- Installation native : suivez le démarrage rapide officiel pour TensorRT de base, puis superposez TensorRT-LLM par-dessus, .
- Préparation de votre modèle (Hugging Face → TensorRT-LLM)
Sources courantes
- Hugging Face : variantes Llama/Mistral/BLOOM
- Points de contrôle locaux : réglages fins personnalisés
Liste de contrôle de préparation
- Confirmez que l’architecture du modèle est prise en charge par TensorRT-LLM.
- Téléchargez les poids du modèle et le tokenizer.
- Si nécessaire, convertissez les safetensors aux formats attendus ou exportez-les vers ONNX via les scripts du projet.
Conseil : le démarrage rapide officiel comprend souvent des scripts pour récupérer les modèles et les convertir au format intermédiaire approprié. Pour une présentation de style tutoriel avec un exemple BLOOM, consultez le guide de Dell sur la conversion des LLM Hugging Face vers TensorRT-LLM.
- Création d’un moteur TensorRT-LLM (le cœur du flux de travail)
Concepts que vous devez connaître
- Moteur : l’artefact compilé et optimisé pour le matériel que vous chargez pour l’inférence.
- Précision : FP16/BF16 pour une base de référence solide ; INT8 ou FP8 pour un débit plus élevé si la précision est maintenue.
- Cache KV : le cache KV paginé réduit la fragmentation de la mémoire et améliore les performances du contexte long.
Étapes de haut niveau
- Définissez la configuration de la construction : lot maximal, longueurs de séquence, précision, quantification et architecture GPU.
- Pointez vers vos points de contrôle de modèle et votre tokenizer.
- Compilez le moteur pour votre ou vos GPU cibles.
Référence : création de moteurs avec la documentation et les configurations officielles. Si vous prévoyez de diffuser via Hugging Face Text Generation Inference (TGI), consultez les notes du backend TRT-LLM sur la précompilation des moteurs par architecture et configuration GPU.
Arbre de décision de démarrage
- Première construction : FP16, longueur de séquence maximale moyenne (par exemple, 4 K–8 K), lot modéré (par exemple, 4–8). Validez l’exactitude.
- Mise à l’échelle : activez le cache KV paginé. Augmentez les tailles maximales de lot/faisceau. Expérimentez avec FP8 ou INT8.
- Production : épinglez les configurations qui répondent aux SLO de latence/QPS ; créez des moteurs distincts par scénario (invites courtes par rapport au contexte long).
- Exécution de l’inférence : Python, C++ et HTTP
Vous avez trois chemins courants :
- Python : prototypage rapide, idéal pour les pipelines et les blocs-notes.
- C++ : performances maximales, intégration dans les services natifs.
- Diffusion HTTP : utilisez TGI avec le backend TRT-LLM ou les exemples de diffusion du runtime pour un déploiement évolutif.
Backend Hugging Face TGI
- Précompilez les moteurs pour votre configuration GPU/précision exacte.
- Démarrez TGI avec le backend TRT-LLM et pointez-le vers le répertoire du moteur.
- Envoyez des requêtes via /generate ou des itinéraires compatibles avec openai et mettez à l’échelle avec des réplicas.
- Optimisation des performances qui fait réellement bouger les choses
Où commencer
- Précision : FP16 est votre base de référence fiable. INT8/FP8 peut réduire davantage la latence, mais validez la qualité.
- Traitement par lots : le traitement par lots dynamique et la fusion des requêtes augmentent considérablement le débit ; mesurez la latence de la queue.
- Cache KV paginé : essentiel pour les invites longues et la diffusion ; réduit la pression sur la mémoire.
- Longueurs maximales : des longueurs de séquence maximales plus importantes augmentent la taille du moteur et peuvent réduire l’horloge ; créez des moteurs adaptés à l’usage.
Conseils pratiques
- Évaluez les performances avec des invites réalistes : mesurez séparément les phases de préremplissage et de décodage.
- Le débit du tokenizer est important : effectuez-le sur le GPU si votre framework le prend en charge.
- Gardez un œil sur les graphes CUDA/noyaux fusionnés : ils réduisent la surcharge du CPU et la latence de lancement du noyau.
- Pour plusieurs GPU : préférez le parallélisme tenseur ou le parallélisme de pipeline en fonction de la taille de votre modèle et de vos exigences de latence.
- Évaluation des performances : prouvez la victoire
Liste de contrôle
- Jetons/seconde (débit) aux tailles de lots cibles
- Temps avant le premier jeton (TTFT) et latence de bout en bout par requête
- Utilisation du GPU et marge de mémoire sous QPS maximal
- Précision : BLEU/perplexité ou évaluations spécifiques à la tâche si vous quantifiez
Utilisez des amorces et des ensembles d’invites cohérents sur les bases de référence (PyTorch par rapport à TensorRT-LLM) pour valider l’exactitude et les deltas.
- Débogage et pièges courants
- Versions incompatibles : alignez les versions de CUDA, des pilotes et de TensorRT conformément à la matrice de prise en charge officielle.
- Moteur non valide pour l’appareil : reconstruisez les moteurs spécifiquement pour votre architecture GPU.
- OOM pendant la construction : réduisez la longueur ou le lot maximal de la séquence ; activez le KV paginé ; envisagez la quantification.
- Baisse de précision avec INT8 : étalonnez sur des données représentatives du domaine ; essayez la quantification par tenseur et vérifiez la sensibilité couche par couche.
- TTFT lent malgré un débit élevé : optimisez le cache KV paginé, activez les graphes CUDA et vérifiez les goulots d’étranglement du tokenizer.
- Exemple de flux de travail : du modèle Hugging Face à la production
Scénario : vous souhaitez un modèle de chat à faible latence sur un A100.
- Choisissez un modèle : variante Llama/Mistral 7B–13B.
- Préparez : téléchargez les poids et le tokenizer ; vérifiez que l’architecture est prise en charge.
- Premier moteur : FP16, entrée maximale 4 K, sortie maximale 1 K, lot 4 ; KV paginé activé.
- Validez : comparez les sorties avec votre base de référence PyTorch.
- Optimisez : essayez INT8 ou FP8 ; mesurez le TTFT et le débit. Augmentez le lot pour le mode serveur.
- Diffusez : utilisez le backend TGI TRT-LLM ; mettez à l’échelle les réplicas derrière un équilibreur de charge ; ajoutez la diffusion.
- Planification des coûts et de la capacité
- Débit par GPU : mesurez les jetons/seconde dans votre contexte cible. Utilisez cette valeur pour calculer la capacité QPS.
- Prix par 1 million de jetons : avec un décodage plus rapide et une utilisation des lots plus élevée, TRT-LLM réduit généralement le coût par jeton.
- Moteurs de taille appropriée : créez des moteurs distincts pour les formes courtes et les formes longues afin de minimiser le gaspillage de marge.
- FAQ à l’intérieur du guide
Q : Dois-je reconstruire les moteurs pour chaque type de GPU ?
R : Oui. Les moteurs sont spécifiques au matériel. Créez-les pour chaque architecture GPU sur laquelle vous effectuerez le déploiement.
Q : Dans quelle mesure INT8 affecte-t-il la qualité ?
R : Cela dépend du modèle et de la tâche. Avec de bonnes données d’étalonnage, de nombreux modèles conservent une qualité proche de FP16 tout en offrant des accélérations substantielles.
Q : Puis-je exécuter des contextes longs (par exemple, 32 K) ?
R : Oui, mais planifiez soigneusement la mémoire. Utilisez le cache KV paginé et optimisez les tailles de bloc ; notez que les contextes plus longs augmentent l’empreinte du moteur et le coût de décodage.
Q : TGI est-il requis ?
R : Non. Vous pouvez exécuter Python/C++ directement. TGI est pratique pour les API HTTP de qualité production avec mise à l’échelle automatique et journalisation.
À noter pour l’accélération du flux de travail
Si vous itérez fréquemment sur les invites, comparez les sorties entre les moteurs ou documentez les expériences, un assistant IA côte à côte qui prend en charge les nouvelles tentatives rapides, l’exécution de blocs de code et les extraits Web peut accélérer votre boucle. Au fait, Sider.AI offre une expérience de bureau adaptée aux ingénieurs, pratique pour capturer des benchmarks, tester des invites et organiser vos notes pendant que vous optimisez votre pipeline TensorRT-LLM. Liste de contrôle des prochaines étapes
- Lisez le démarrage rapide officiel pour valider votre environnement.
- Confirmez la compatibilité CUDA/TensorRT dans la matrice de prise en charge.
- Suivez le guide de création du moteur et choisissez d’abord FP16.
- Si vous diffusez via TGI, précompilez les moteurs et configurez le backend TRT-LLM.
- Vous pouvez également consulter une présentation de style tutoriel pour les modèles Hugging Face comme BLOOM.
Principaux points à retenir
- TensorRT-LLM compile votre Transformer dans un moteur natif GPU pour un débit maximal et une latence plus faible.
- Commencez par FP16, activez le cache KV paginé et mesurez. Ensuite, explorez INT8/FP8 pour plus de vitesse.
- Les moteurs sont spécifiques au GPU et à la configuration ; créez-les par cible de déploiement.
- Pour la production, associez les moteurs à une couche de diffusion robuste (par exemple, TGI) et surveillez le TTFT, le débit et la qualité.
FAQ
Q1 :Comment installer et configurer TensorRT-LLM correctement ?
Utilisez un conteneur avec CUDA/TensorRT correspondant ou suivez le démarrage rapide officiel et la matrice de prise en charge pour éviter la dérive de version. Vérifiez les pilotes GPU et les outils de construction avant de compiler les moteurs.
Q2 :Comment utiliser TensorRT-LLM avec les modèles Hugging Face ?
Téléchargez le modèle et le tokenizer, confirmez la prise en charge et convertissez-les si nécessaire avant de créer le moteur. Si vous diffusez avec TGI, compilez les moteurs pour votre GPU et pointez le backend vers le répertoire du moteur.
Q3 :Dois-je choisir FP16, FP8 ou INT8 pour TensorRT-LLM ?
Commencez par FP16 pour la stabilité, puis essayez FP8/INT8 pour augmenter le débit. Validez toujours la précision de la tâche après la quantification.
Q4 :Puis-je diffuser TensorRT-LLM via HTTP ?
Oui. Vous pouvez utiliser Python/C++ directement ou diffuser via le backend TRT-LLM de Hugging Face TGI pour des API évolutives, prêtes pour la production avec la diffusion.
Q5 :Quels sont les goulots d’étranglement courants en matière de performances lors de l’utilisation de TensorRT-LLM ?
La surcharge du tokenizer, le traitement par lots sous-optimal et le manque de cache KV paginé sont des problèmes courants. Optimisez les tailles de lots, activez les graphes CUDA et surveillez le TTFT par rapport au nombre total de jetons par seconde.
