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

{% hint style="success" %}
**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.
{% 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 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](https://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

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

***

## É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é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

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

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

C'est l'étape clé — compiler le 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

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

```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 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.
{% 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 = "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

```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 la santé du serveur
curl -s http://localhost:8000/v2/health/ready
```

***

## Étape 8 — Interroger l'API

### Client compatible 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("Expliquer 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 — Ajouter un wrapper d'API compatible OpenAI

Pour une intégration plus facile, 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 construction 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
```

### Triton Server ne démarre pas

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

```bash
# 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](https://github.com/NVIDIA/TensorRT-LLM)
* [Triton Inference Server](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 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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec 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:

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

The question should be specific, self-contained, and written in natural language.
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.