TensorRT-LLM et TGI

Alternatives à vLLM

Si vLLM est le moteur recommandé par défaut, deux alternatives méritent votre attention : TensorRT-LLM de NVIDIA pour les performances maximales, et TGI (Text Generation Inference) de Hugging Face pour son écosystème intégré. Cette leçon compare ces deux moteurs et vous guide dans leur configuration.

TensorRT-LLM

Concept

TensorRT-LLM est le framework d’optimisation d’inférence de NVIDIA. Il compile le modèle en un “engine” optimisé spécifiquement pour votre GPU, ce qui offre les meilleures performances possibles sur matériel NVIDIA.

Architecture

Le workflow TensorRT-LLM se décompose en deux étapes :

1. Build — compilation du modèle en engine TensorRT optimisé
2. Serve — déploiement de l’engine via Triton Inference Server

# Étape 1 : Cloner le dépôt TensorRT-LLM
git clone https://github.com/NVIDIA/TensorRT-LLM.git
cd TensorRT-LLM

# Étape 2 : Construire l'engine (exemple Mistral 7B)
# Les modèles Mistral utilisent l'exemple LLaMA du dépôt
python examples/llama/convert_checkpoint.py \
    --model_dir mistralai/Mistral-7B-Instruct-v0.3 \
    --output_dir ./checkpoint \
    --dtype float16

python -m tensorrt_llm.commands.build \
    --checkpoint_dir ./checkpoint \
    --output_dir ./engine \
    --gemm_plugin float16

Avantages de TensorRT-LLM

• Performances maximales sur GPU NVIDIA (30-50% plus rapide que vLLM dans certains cas)
• Optimisations kernel spécifiques à chaque architecture GPU (Ampere, Hopper, Blackwell)
• Quantization avancée (FP8, INT8, INT4) avec calibration automatique
• Inflight batching pour un débit optimal

Inconvénients

• Complexité de build — chaque modèle doit être compilé pour votre GPU spécifique
• Temps de compilation — de 30 minutes à plusieurs heures selon le modèle
• Moins flexible — un changement de modèle nécessite un nouveau build
• Dépendance NVIDIA — ne fonctionne pas sur AMD ou autre matériel

Déploiement avec Triton

# Lancer Triton Inference Server avec l'engine
docker run --rm --gpus all \
    -v ./engine:/models/mistral/1 \
    -p 8000:8000 \
    nvcr.io/nvidia/tritonserver:latest \
    tritonserver --model-repository=/models

TGI (Text Generation Inference)

Concept

TGI est le toolkit d’inférence de Hugging Face. Il offre un bon équilibre entre facilité d’utilisation et performances, avec une intégration native de l’écosystème Hugging Face.

Déploiement Docker

docker run --gpus all --shm-size 1g \
    -p 8080:80 \
    -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
    ghcr.io/huggingface/text-generation-inference:2.0.3 \
    --model-id mistralai/Mistral-7B-Instruct-v0.3

Le serveur est accessible sur le port 8080 une fois le modèle chargé.

Fonctionnalités principales

• Quantization intégrée — GPTQ, AWQ, bitsandbytes
• Tensor parallelism — distribution sur plusieurs GPU
• Streaming — génération token par token
• Batching continu — regroupement automatique des requêtes

Configuration avancée

docker run --gpus all --shm-size 1g \
    -p 8080:80 \
    -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
    ghcr.io/huggingface/text-generation-inference:2.0.3 \
    --model-id mistralai/Mistral-7B-Instruct-v0.3 \
    --max-input-length 4096 \
    --max-total-tokens 8192 \
    --max-batch-prefill-tokens 4096 \
    --quantize awq

Paramètres importants :

• --max-input-length — longueur maximale du prompt
• --max-total-tokens — prompt + génération combinés
• --quantize — activer la quantization (réduit la mémoire GPU)

Appel API

TGI expose une API compatible avec le client Mistral et le client OpenAI :

# Avec le client OpenAI
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[{"role": "user", "content": "Explique le batching continu."}],
    max_tokens=512
)
print(response.choices[0].message.content)

# Avec curl (API native TGI)
curl http://localhost:8080/generate \
    -H "Content-Type: application/json" \
    -d '{
        "inputs": "Explique le batching continu.",
        "parameters": {"max_new_tokens": 512}
    }'

Comparaison des trois moteurs

Quand choisir chaque moteur

vLLM — Le choix par défaut

Choisissez vLLM si :

• Vous voulez démarrer rapidement
• Vous avez besoin d’une API compatible OpenAI
• Vous changez régulièrement de modèle

TensorRT-LLM — La performance maximale

Choisissez TensorRT-LLM si :

• Vous servez un modèle fixe en production à très haut débit
• Vous utilisez exclusivement du matériel NVIDIA
• Vous avez une équipe MLOps pour gérer la complexité

TGI — L’écosystème Hugging Face

Choisissez TGI si :

• Vous utilisez déjà l’écosystème Hugging Face
• Vous avez besoin de quantization intégrée
• Vous voulez une solution Docker simple

Points clés à retenir

• TensorRT-LLM offre les meilleures performances mais nécessite un build spécifique par GPU
• TGI est le toolkit Hugging Face avec quantization, tensor parallelism et batching intégrés
• vLLM reste le meilleur compromis entre performance et simplicité pour la majorité des cas
• Les trois moteurs exposent une API compatible OpenAI (directement ou via Triton)
• Le choix dépend de votre volume, de votre matériel et de votre tolérance à la complexité