TensorRT-LLM

Débit d'inférence LLM maximal avec l'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), au batching en vol et au cache KV paginé. Combiné à Triton Inference Server, vous obtenez une infrastructure de service de niveau production.

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

---

Pourquoi TensorRT-LLM ?

Fonctionnalité	vLLM	TensorRT-LLM
Débit	Excellente	Meilleur de sa catégorie
Latence	Bon	Excellente
Quantification INT4/INT8	Partiel	Natif
Prise en charge de 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 à 4 fois supérieur par rapport à l'inférence standard des transformers HuggingFace, et un débit 30 à 50 % supérieur à 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 de Linux et de Docker

• VRAM suffisante pour le modèle choisi

---

Exigences de VRAM par modèle

Modèle	FP16	INT8	INT4
Llama-3.1 8B	16 Go	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 un seul GPU (modèles 7B–13B) : RTX 4090 24 Go ou RTX 3090 24 Go

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

Stratégie multi-GPU :

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

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

• Sélectionnez des serveurs avec plusieurs GPU listés dans la place de marché 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 — ceci 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és

---

É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échargez et préparez le modèle

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

Installer l'interface CLI HuggingFace

pip install huggingface_hub
huggingface-cli login
# Saisissez votre jeton HuggingFace lorsque vous y êtes invité

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 — Compilez le moteur TensorRT

C'est l'étape clé — la compilation du 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

# Compiler 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 plus élevé)

# 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 compilation du moteur : 10 à 30 minutes selon le GPU et la taille du modèle. C'est une opération unique — une fois le moteur compilé, il 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 = "What is the capital of 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 — Configurez 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 l'état du serveur
curl -s http://localhost:8000/v2/health/ready

---

Étape 8 — Interrogez l'API

Client compatible avec 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("Expliquez 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 — Ajoutez un wrapper d'API compatible OpenAI

Pour une intégration plus simple, 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 compilation 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

Le serveur Triton ne démarre pas

# Vérifier les journaux
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

Débit faible

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

---

Tests de performance sur les GPU Clore.ai

Modèle	GPU	Quantification	Débit (jetons/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

• GitHub TensorRT-LLM

• Serveur d'inférence Triton

• Registre de conteneurs NGC

• Documentation TRT-LLM

• Quantification AWQ

---

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

---

Recommandations GPU Clore.ai

Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai. Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez bare metal sur demande. Consultez Tarifs et disponibilité des GPU avant de dimensionner un déploiement.

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Inférence de production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grands modèles (70B+)	A100 80 Go	bare metal

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