> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/devops-gpu/tensorrt-llm.md).

# 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](https://github.com/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         |

{% hint style="success" %}
**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.
{% endhint %}

***

## 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](https://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

{% hint style="info" %}
**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
  {% endhint %}

***

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

**Image Docker :**

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

{% hint style="warning" %}
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](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver/tags) pour le tag le plus récent.
{% endhint %}

**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

```bash
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

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

### Télécharger les poids du modèle

```bash
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é)

```bash
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é)

```bash
# 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)

```bash
# 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
```

{% hint style="info" %}
**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.
{% endhint %}

***

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

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

```bash
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

```bash
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

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

### Démarrer le serveur Triton

```bash
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

```python
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

```bash
# 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 :

```bash
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

```bash
# 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

```bash
# 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

```bash
# 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](https://github.com/NVIDIA/TensorRT-LLM)
* [Serveur d'inférence Triton](https://github.com/triton-inference-server/server)
* [Registre de conteneurs NGC](https://catalog.ngc.nvidia.com/)
* [Documentation TRT-LLM](https://nvidia.github.io/TensorRT-LLM/)
* [Quantification AWQ](https://github.com/mit-han-lab/llm-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

{% hint style="warning" %}
**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](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement.
{% endhint %}

| 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](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/devops-gpu/tensorrt-llm.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.