TensorRT-LLM

Débit maximal d'inférence LLM avec optimisation NVIDIA TensorRT — déployé via Triton Inference Server

TensorRT-LLM est la bibliothèque open-source de NVIDIA pour optimiser l'inférence des grands modèles de langage sur les GPU NVIDIA. Elle offre des performances de pointe grâce à la fusion de noyaux, la quantification (INT4, INT8, FP8), le batching en vol et la mise en cache KV paginée. Combinée avec Triton Inference Server, vous obtenez une infrastructure de service prête pour la production.

GitHub : NVIDIA/TensorRT-LLM — 10K+ ⭐

---

Pourquoi TensorRT-LLM ?

Fonctionnalité	vLLM	TensorRT-LLM
Débit	Excellente	Meilleur de sa catégorie
Latence	Bonne	Excellente
Quantification INT4/INT8	Partiel	Support natif
Prise en charge FP8	Limité	Complet
Parallélisme tensoriel multi-GPU	Oui	Oui
Complexité de configuration	Faible	Moyenne-Élevée

TensorRT-LLM offre généralement un débit 2 à 4x supérieur par rapport à l'inférence standard des transformers HuggingFace, et un débit 30 à 50 % meilleur que vLLM pour les scénarios de service par lots.

---

Prérequis

• Compte Clore.ai avec location de GPU

• GPU NVIDIA avec architecture Ampere ou plus récente (RTX 3090, A100, RTX 4090, H100)

• Connaissances de base en Linux et Docker

• VRAM suffisante pour le modèle choisi

---

Exigences de VRAM par modèle

Modèle	FP16	INT8	INT4
Llama-3.1 8B	16GB	8 Go	4 Go
Llama-3.1 70B	140 Go	70GB	35 Go
Mistral 7B	14 Go	7 Go	4 Go
Mixtral 8x7B	90 Go	45 Go	24GB
Qwen2.5 72B	144 Go	72GB	36 Go

---

Étape 1 — Choisissez votre GPU sur Clore.ai

1. Connectez-vous à clore.ai → Place de marché

2. Pour le service sur GPU unique (modèles 7B–13B) : RTX 4090 24GB ou RTX 3090 24GB

3. Pour les gros modèles (70B+) : Plusieurs A100 80GB ou H100

Stratégie multi-GPU :

• 2x A100 80GB → Llama 3.1 70B en FP16 ou Qwen2.5 72B

• 4x A100 80GB → Llama 3.1 405B en INT8

• Sélectionnez des serveurs avec plusieurs GPU listés sur la marketplace Clore.ai

---

Étape 2 — Déployez Triton Inference Server avec le backend TRT-LLM

Image Docker :

nvcr.io/nvidia/tritonserver:24.01-trtllm-python-py3

Utilisez le -trtllm-python-py3 variante — cela inclut le backend TensorRT-LLM préinstallé. Le tag correspond à la version du conteneur NVIDIA (24.01 = janvier 2024). Consultez NGC pour le tag le plus récent.

Ports exposés :

22
8000

Variables d’environnement :

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility
TRANSFORMERS_CACHE=/workspace/hf_cache
HF_HOME=/workspace/hf_cache

Volume/Disque : 100 Go minimum recommandé

---

Étape 3 — Connectez-vous et vérifiez l'installation

ssh root@<server-ip> -p <ssh-port>

# Vérifier le GPU
nvidia-smi

# Vérifier la version de TensorRT
python3 -c "import tensorrt_llm; print(tensorrt_llm.__version__)"

# Vérifier que Triton est disponible
tritonserver --version

---

Étape 4 — Télécharger et préparer le modèle

Nous utiliserons Llama 3.1 8B comme exemple. Ajustez les chemins pour le modèle choisi.

Installer HuggingFace CLI

pip install huggingface_hub
huggingface-cli login
# Entrez votre token HuggingFace lorsqu'on vous le demande

Télécharger les poids du modèle

mkdir -p /workspace/models/llama-3.1-8b
huggingface-cli download \
    meta-llama/Llama-3.1-8B-Instruct \
    --local-dir /workspace/models/llama-3.1-8b \
    --local-dir-use-symlinks False

# Ou utilisez snapshot_download
python3 << 'EOF'
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id="meta-llama/Llama-3.1-8B-Instruct",
    local_dir="/workspace/models/llama-3.1-8b",
    local_dir_use_symlinks=False
)
EOF

---

Étape 5 — Construire le moteur TensorRT

C'est l'étape clé — compiler le modèle en un moteur TensorRT optimisé.

Moteur FP16 (Meilleure qualité)

cd /workspace

# Convertir les poids HuggingFace au format TRT-LLM
python3 /usr/local/lib/python3.10/dist-packages/tensorrt_llm/examples/llama/convert_checkpoint.py \
    --model_dir /workspace/models/llama-3.1-8b \
    --output_dir /workspace/trt_checkpoints/llama-3.1-8b-fp16 \
    --dtype float16 \
    --tp_size 1

# Construire le moteur TensorRT
trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-fp16 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-fp16 \
    --gemm_plugin float16 \
    --max_batch_size 32 \
    --max_input_len 4096 \
    --max_seq_len 8192 \
    --max_num_tokens 16384 \
    --use_paged_context_fmha enable

Moteur INT8 SmoothQuant (Débit supérieur)

# Convertir avec la quantification SmoothQuant
python3 /usr/local/lib/python3.10/dist-packages/tensorrt_llm/examples/llama/convert_checkpoint.py \
    --model_dir /workspace/models/llama-3.1-8b \
    --output_dir /workspace/trt_checkpoints/llama-3.1-8b-int8 \
    --dtype float16 \
    --smoothquant 0.5 \
    --per_channel \
    --per_token

trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-int8 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-int8 \
    --gemm_plugin float16 \
    --smoothquant_plugin float16 \
    --max_batch_size 64 \
    --max_input_len 4096 \
    --max_seq_len 8192

Moteur INT4 AWQ (Débit maximal / Mémoire minimale)

# Installer auto-gptq pour la quantification
pip install autoawq

# Quantifier en INT4 AWQ
python3 << 'EOF'
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer

model_path = "/workspace/models/llama-3.1-8b"
quant_path = "/workspace/models/llama-3.1-8b-awq-int4"

model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM"
}
model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)
EOF

# Convertir AWQ en TRT-LLM
python3 /usr/local/lib/python3.10/dist-packages/tensorrt_llm/examples/llama/convert_checkpoint.py \
    --model_dir /workspace/models/llama-3.1-8b-awq-int4 \
    --output_dir /workspace/trt_checkpoints/llama-3.1-8b-int4 \
    --dtype float16 \
    --quant_ckpt_path /workspace/models/llama-3.1-8b-awq-int4 \
    --use_weight_only \
    --weight_only_precision int4_awq \
    --per_group

trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-int4 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-int4 \
    --gemm_plugin float16 \
    --max_batch_size 128 \
    --max_input_len 4096 \
    --max_seq_len 8192

Temps de construction du moteur : 10–30 minutes selon le GPU et la taille du modèle. Il s'agit d'une opération unique — une fois construit, le moteur se charge en quelques secondes.

---

Étape 6 — Test rapide avec l'API Python TRT-LLM

Avant de configurer Triton, vérifiez que le moteur fonctionne :

python3 << 'EOF'
import tensorrt_llm
from tensorrt_llm.runtime import ModelRunner
from transformers import AutoTokenizer

engine_dir = "/workspace/trt_engines/llama-3.1-8b-fp16"
tokenizer_dir = "/workspace/models/llama-3.1-8b"

tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir)
runner = ModelRunner.from_dir(
    engine_dir=engine_dir,
    rank=0
)

prompt = "Quelle est la capitale de la France ?"
input_ids = tokenizer.encode(prompt, return_tensors="pt")

output = runner.generate(
    batch_input_ids=[input_ids[0].tolist()],
    max_new_tokens=200,
    temperature=0.7,
    top_p=0.9
)

output_ids = output[0][0][len(input_ids[0]):]
response = tokenizer.decode(output_ids, skip_special_tokens=True)
print(f"Response: {response}")
EOF

---

Étape 7 — Configurer Triton Inference Server

Créer la structure du dépôt de modèles

mkdir -p /workspace/triton_model_repo/llama/1

# Créer la configuration du modèle
cat > /workspace/triton_model_repo/llama/config.pbtxt << 'EOF'
backend: "tensorrtllm"
name: "llama"
max_batch_size: 64
model_transaction_policy {
  decoupled: true
}

dynamic_batching {
  preferred_batch_size: [1, 2, 4, 8, 16, 32, 64]
  max_queue_delay_microseconds: 1000
}

input [
  {
    name: "input_ids"
    data_type: TYPE_INT32
    dims: [-1]
  },
  {
    name: "input_lengths"
    data_type: TYPE_INT32
    dims: [1]
    reshape: { shape: [] }
  },
  {
    name: "request_output_len"
    data_type: TYPE_INT32
    dims: [1]
    reshape: { shape: [] }
  },
  {
    name: "temperature"
    data_type: TYPE_FP32
    dims: [1]
    reshape: { shape: [] }
    optional: true
  }
]

output [
  {
    name: "output_ids"
    data_type: TYPE_INT32
    dims: [-1, -1]
  },
  {
    name: "sequence_length"
    data_type: TYPE_INT32
    dims: [1]
  }
]

instance_group [
  {
    count: 1
    kind: KIND_GPU
    gpus: [0]
  }
]

parameters: {
  key: "gpt_model_type"
  value: { string_value: "inflight_fused_batching" }
}

parameters: {
  key: "gpt_model_path"
  value: { string_value: "/workspace/trt_engines/llama-3.1-8b-fp16" }
}

parameters: {
  key: "max_tokens_in_paged_kv_cache"
  value: { string_value: "8192" }
}

parameters: {
  key: "batch_scheduler_policy"
  value: { string_value: "guaranteed_no_evict" }
}
EOF

Créer un lien symbolique vers le moteur

ln -s /workspace/trt_engines/llama-3.1-8b-fp16 \
    /workspace/triton_model_repo/llama/1/

Démarrer le serveur Triton

tritonserver \
    --model-repository=/workspace/triton_model_repo \
    --http-port=8000 \
    --grpc-port=8001 \
    --metrics-port=8002 \
    --log-verbose=0 &

# Attendre le démarrage du serveur
sleep 30

# Vérifier la santé du serveur
curl -s http://localhost:8000/v2/health/ready

---

Étape 8 — Interroger l'API

Client compatible OpenAI

import requests
import json

def generate(prompt: str, max_tokens: int = 200) -> str:
    url = "http://localhost:8000/v2/models/llama/generate"
    
    payload = {
        "text_input": prompt,
        "parameters": {
            "max_tokens": max_tokens,
            "temperature": 0.7,
            "top_p": 0.9
        }
    }
    
    response = requests.post(url, json=payload)
    result = response.json()
    return result.get("text_output", "")

# Test
print(generate("Expliquer l'informatique quantique en termes simples :"))

Mesurer le débit

# Installer tritonclient
pip install tritonclient[all]

# Lancer le benchmark de performance
perf_analyzer \
    -m llama \
    -u localhost:8001 \
    --protocol grpc \
    --input-data /workspace/sample_inputs.json \
    --concurrency-range 1:32:2 \
    --measurement-interval 10000 \
    --shape input_ids:512 \
    --shape input_lengths:1 \
    --shape request_output_len:1

---

Étape 9 — Ajouter un wrapper d'API compatible OpenAI

Pour une intégration plus facile, ajoutez un wrapper FastAPI :

pip install fastapi uvicorn tritonclient[all]

cat > /workspace/openai_server.py << 'EOF'
from fastapi import FastAPI
from pydantic import BaseModel
import tritonclient.http as httpclient
import numpy as np
from transformers import AutoTokenizer

app = FastAPI()
tokenizer = AutoTokenizer.from_pretrained("/workspace/models/llama-3.1-8b")
client = httpclient.InferenceServerClient("localhost:8000")

class ChatRequest(BaseModel):
    model: str = "llama"
    messages: list
    max_tokens: int = 512
    temperature: float = 0.7

@app.post("/v1/chat/completions")
async def chat(req: ChatRequest):
    prompt = tokenizer.apply_chat_template(
        req.messages,
        tokenize=False,
        add_generation_prompt=True
    )
    
    input_ids = tokenizer.encode(prompt)
    
    inputs = [
        httpclient.InferInput("input_ids", [len(input_ids)], "INT32"),
        httpclient.InferInput("input_lengths", [1], "INT32"),
        httpclient.InferInput("request_output_len", [1], "INT32"),
    ]
    inputs[0].set_data_from_numpy(np.array(input_ids, dtype=np.int32))
    inputs[1].set_data_from_numpy(np.array([len(input_ids)], dtype=np.int32))
    inputs[2].set_data_from_numpy(np.array([req.max_tokens], dtype=np.int32))
    
    result = client.infer("llama", inputs)
    output_ids = result.as_numpy("output_ids")[0][len(input_ids):]
    text = tokenizer.decode(output_ids, skip_special_tokens=True)
    
    return {
        "choices": [{"message": {"role": "assistant", "content": text}}]
    }

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)
EOF

python3 /workspace/openai_server.py &

---

Dépannage

OOM lors de la construction du moteur

# Réduire max_batch_size et max_num_tokens
trtllm-build \
    --checkpoint_dir /workspace/trt_checkpoints/llama-3.1-8b-fp16 \
    --output_dir /workspace/trt_engines/llama-3.1-8b-fp16 \
    --gemm_plugin float16 \
    --max_batch_size 8 \        # Réduire depuis 32
    --max_input_len 2048 \      # Réduire depuis 4096
    --max_seq_len 4096          # Réduire depuis 8192

Triton Server ne démarre pas

# Vérifier les logs
cat /workspace/triton.log

# Vérifier que les fichiers du moteur existent
ls -la /workspace/trt_engines/llama-3.1-8b-fp16/

# Vérifier la mémoire GPU
nvidia-smi

Faible débit

# Activer le batching en vol et augmenter la concurrence
# Ajuster max_tokens_in_paged_kv_cache en fonction de la VRAM disponible

---

Benchmarks de performance sur les GPU Clore.ai

Modèle	GPU	Quantification	Débit (tokens/sec)
Llama 3.1 8B	RTX 4090	FP16	~3,500
Llama 3.1 8B	RTX 4090	INT4 AWQ	~6,200
Llama 3.1 70B	2x A100 80G	FP16	~1,800
Mixtral 8x7B	2x RTX 4090	INT8	~2,400

---

Ressources supplémentaires

• TensorRT-LLM GitHub

• Triton Inference Server

• Registre de conteneurs NGC

• Documentation TRT-LLM

• Quantification AWQ

---

TensorRT-LLM sur Clore.ai est le choix optimal pour le déploiement en production des LLM lorsque le débit et la latence sont critiques. Pour des configurations plus simples, considérez le guide vLLM.

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Inférence en production	RTX 4090 (24GB)	~$0.70/gpu/hr
Grands modèles (70B+)	A100 80GB	~$1.20/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.