Technical Tutorials

L'exécution locale des grands modèles de langage (LLM) a traditionnellement impliqué un compromis entre la taille du modèle et la vitesse d'inférence. Bien que les modèles quantifiés sur CPU soient accessibles, ils souffrent souvent d'une latence élevée, les rendant inadaptés aux applications en temps réel. Entrez dans le monde de TensorRT-LLM, une bibliothèque d'inférence haute performance de NVIDIA qui optimise l'exécution des LLM sur les GPU modernes. En exploitant la fusion de noyaux, la quantification et le parallélisme multi-GPU, TensorRT-LLM peut atteindre des vitesses d'inférence souvent 5 à 10 fois supérieures à celles des implémentations PyTorch standard.

Pourquoi TensorRT-LLM ?

L'inférence PyTorch standard est interprétée et générique. TensorRT-LLM, en revanche, compile les modèles en graphes d'exécution optimisés. Les avantages clés incluent :

Fusion de noyaux : Combine plusieurs opérations en un seul noyau pour réduire l'utilisation de la bande passante mémoire.
Prise en charge de la quantification : Prise en charge native de la quantification FP8, INT4-AWQ et INT8-Weight-Only, réduisant considérablement l'utilisation de la VRAM.
Attention paginée : Gestion efficace de la mémoire pour l'inférence par lots, permettant un débit élevé sans erreurs de mémoire insuffisante (OOM).

Installation et prérequis

TensorRT-LLM est principalement développé pour les GPU NVIDIA avec une capacité de calcul 8.0 ou supérieure (Ampere et plus récents). Assurez-vous d'avoir installé les éléments suivants :

Python 3.8+
NVIDIA CUDA Toolkit 11.4 ou 12.x
NVIDIA TensorRT 8.6+

Vous pouvez installer la bibliothèque via pip, bien que la compilation depuis le code source soit recommandée pour les fonctionnalités les plus récentes :

pip install tensorrt-llm
# Ou pour une version stable
pip install nvidia-tensorrt-llm

Construction d'un moteur d'inférence

Le cœur de TensorRT-LLM est le « Moteur ». Vous construisez d'abord le moteur à partir d'un point de contrôle de modèle Hugging Face, ce qui compile le modèle pour votre matériel spécifique. Cette étape peut prendre quelques minutes selon la taille du modèle.

Voici un exemple simplifié de construction d'un moteur pour un petit modèle basé sur Llama :

from tensorrt_llm.builder import Builder
from tensorrt_llm import LlmArgs, PluginConfig

# Initialiser le constructeur
builder = Builder()

# Définir la configuration du modèle
# Note : En pratique, vous spécifiez le chemin du point de contrôle HF et les paramètres de quantification
args = LlmArgs(
    name="llama-7b",
    hf_checkpoint="/path/to/llama-7b",
    gpus_per_engine=1,
    use_tensorrt_runtime=True
)

# Construire le moteur
engine = builder.build(args)

# Enregistrer le moteur sur le disque pour une utilisation future
engine.save("/path/to/output_engine")

Exécution de l'inférence

Une fois le moteur construit, vous pouvez le charger et générer du texte. L'API est conçue pour être asynchrone afin de gérer les scénarios à haut débit, mais les appels synchrones sont disponibles pour les cas d'utilisation plus simples.

from tensorrt_llm.runtime import GenerateExecutor

# Charger le moteur précédemment construit
executor = GenerateExecutor(engine_path="/path/to/output_engine")

# Préparer l'entrée
prompt = "Tell me a joke about programming."

# Générer du texte
# max_tokens contrôle la longueur de la sortie
output = executor.generate(prompt, max_tokens=100)

print(output)

Astuce de performance

Utiliser FP8 : Si vous disposez d'un GPU Ada Lovelace (série RTX 40) ou Hopper (H100), la quantification FP8 offre le meilleur rapport vitesse-qualité.
Taille du lot : TensorRT-LLM excelle avec le traitement par lots. Essayez de traiter plusieurs invites en un seul lot pour maximiser l'utilisation du GPU.
Gestion de la mémoire : Définissez max_batch_size et max_input_len de manière appropriée lors de la construction du moteur pour éviter la fragmentation de la mémoire.

Conclusion

TensorRT-LLM est actuellement la référence en matière d'inférence locale haute performance des LLM sur le matériel NVIDIA. Bien que la courbe d'apprentissage soit plus raide que l'utilisation directe de Hugging Face Transformers, les gains de performance sont significatifs. Pour les développeurs créant des applications IA locales, des chatbots ou des assistants en temps réel, TensorRT-LLM fournit la vitesse et l'efficacité nécessaires pour que ces expériences semblent véritablement instantanées. Commencez par de petits modèles pour comprendre le processus de construction, puis passez à des modèles de plus de 70 milliards de paramètres selon la VRAM disponible.