# TensorRT-LLM

> **Максимальная пропускная способность вывода LLM с оптимизацией NVIDIA TensorRT — развернута через Triton Inference Server**

TensorRT-LLM — это открытая библиотека NVIDIA для оптимизации инференса больших языковых моделей на GPU NVIDIA. Она обеспечивает передовые показатели производительности за счёт объединения ядер, квантизации (INT4, INT8, FP8), пакетирования в полёте и постраничного кеширования KV. В сочетании с Triton Inference Server вы получаете инфраструктуру обслуживания производственного уровня.

**GitHub:** [NVIDIA/TensorRT-LLM](https://github.com/NVIDIA/TensorRT-LLM) — 10K+ ⭐

***

## Почему TensorRT-LLM?

| Функция                                 | vLLM       | TensorRT-LLM    |
| --------------------------------------- | ---------- | --------------- |
| Пропускная способность                  | Отлично    | Лучший в классе |
| Задержка                                | Хорошо     | Отлично         |
| Квантизация INT4/INT8                   | Частично   | Нативная        |
| Поддержка FP8                           | Ограничено | Полная          |
| Тензорный параллелизм на нескольких GPU | Да         | Да              |
| Сложность настройки                     | Низкая     | Средняя‑Высокая |

{% hint style="success" %}
**TensorRT-LLM обычно обеспечивает в 2–4 раза большую пропускную способность** по сравнению со стандартным инференсом HuggingFace transformers и на 30–50% лучшую пропускную способность по сравнению с vLLM в сценариях пакетного обслуживания.
{% endhint %}

***

## Требования

* Учетная запись Clore.ai с арендой GPU
* **GPU NVIDIA с архитектурой Ampere или новее** (RTX 3090, A100, RTX 4090, H100)
* Базовые знания Linux и Docker
* Достаточный объём VRAM для выбранной модели

***

## Требования по VRAM в зависимости от модели

| Модель        | FP16   | INT8  | INT4  |
| ------------- | ------ | ----- | ----- |
| Llama-3.1 8B  | 16GB   | 8 ГБ  | 4 ГБ  |
| Llama-3.1 70B | 140 ГБ | 70GB  | 35 ГБ |
| Mistral 7B    | 14 ГБ  | 7 ГБ  | 4 ГБ  |
| Mixtral 8x7B  | 90 ГБ  | 45 ГБ | 24GB  |
| Qwen2.5 72B   | 144 ГБ | 72GB  | 36 ГБ |

***

## Шаг 1 — Выберите GPU на Clore.ai

1. Войдите в [clore.ai](https://clore.ai) → **Маркетплейс**
2. **Для обслуживания на одном GPU (модели 7B–13B):** RTX 4090 24GB или RTX 3090 24GB
3. **Для больших моделей (70B+):** Несколько A100 80GB или H100

{% hint style="info" %}
**Стратегия для нескольких GPU:**

* 2x A100 80GB → Llama 3.1 70B в FP16 или Qwen2.5 72B
* 4x A100 80GB → Llama 3.1 405B в INT8
* Выберите серверы с несколькими GPU, перечисленными на маркетплейсе Clore.ai
  {% endhint %}

***

## Шаг 2 — Разверните Triton Inference Server с бэкендом TRT-LLM

**Docker-образ:**

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

{% hint style="warning" %}
Используйте вкладку `-trtllm-python-py3` вариант — он включает предустановленный бэкенд TensorRT-LLM. Тег соответствует релизу контейнера NVIDIA (24.01 = январь 2024). Проверьте [NGC](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/tritonserver/tags) для последнего тега.
{% endhint %}

**Открытые порты:**

```
22
8000
```

**Переменные окружения:**

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

**Том/Диск:** Рекомендуется минимум 100 ГБ

***

## Шаг 3 — Подключение и проверка установки

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

# Проверить GPU
nvidia-smi

# Проверить версию TensorRT
python3 -c "import tensorrt_llm; print(tensorrt_llm.__version__)"

# Проверить доступность Triton
tritonserver --version
```

***

## Шаг 4 — Скачать и подготовить модель

В качестве примера используем Llama 3.1 8B. Настройте пути для выбранной модели.

### Установите CLI HuggingFace

```bash
pip install huggingface_hub
huggingface-cli login
# Введите ваш токен HuggingFace при запросе
```

### Скачать веса модели

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

# Или используйте 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
```

***

## Шаг 5 — Построение TensorRT-движка

Это ключевой шаг — компиляция модели в оптимизированный движок TensorRT.

### FP16 движок (лучшее качество)

```bash
cd /workspace

# Конвертировать веса HuggingFace в формат 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

# Построить 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
```

### INT8 движок с SmoothQuant (большая пропускная способность)

```bash
# Конвертировать с квантизацией 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
```

### INT4 AWQ движок (максимальная пропускная способность / минимальная память)

```bash
# Установить auto-gptq для квантизации
pip install autoawq

# Квантизировать в 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

# Конвертировать AWQ в 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" %}
**Время сборки движка:** 10–30 минут в зависимости от GPU и размера модели. Это одноразовая операция — после сборки движок загружается за секунды.
{% endhint %}

***

## Шаг 6 — Быстрый тест с Python API TRT-LLM

Перед настройкой Triton проверьте, что движок работает:

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

***

## Шаг 7 — Настройка Triton Inference Server

### Создать структуру репозитория моделей

```bash
mkdir -p /workspace/triton_model_repo/llama/1

# Создать конфигурацию модели
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
```

### Создать символическую ссылку на движок

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

### Запустить Triton Server

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

# Подождать запуска сервера
sleep 30

# Проверить состояние сервера
curl -s http://localhost:8000/v2/health/ready
```

***

## Шаг 8 — Запрос к API

### Клиент, совместимый с 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", "")

# Тест
print(generate("Explain quantum computing in simple terms:"))
```

### Бенчмарк пропускной способности

```bash
# Установить tritonclient
pip install tritonclient[all]

# Запустить бенчмарк производительности
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
```

***

## Шаг 9 — Добавить обёртку API, совместимую с OpenAI

Для упрощения интеграции добавьте обёртку 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 &
```

***

## Устранение неполадок

### OOM при сборке движка

```bash
# Уменьшите max_batch_size и 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 \        # Уменьшить с 32
    --max_input_len 2048 \      # Уменьшить с 4096
    --max_seq_len 4096          # Уменьшить с 8192
```

### Triton Server не запускается

```bash
# Проверьте логи
cat /workspace/triton.log

# Проверить наличие файлов движка
ls -la /workspace/trt_engines/llama-3.1-8b-fp16/

# Проверить память GPU
nvidia-smi
```

### Низкая пропускная способность

```bash
# Включите пакетирование в полёте и увеличьте конкуренцию
# Настройте max_tokens_in_paged_kv_cache в зависимости от доступного VRAM
```

***

## Бенчмарки производительности на GPU Clore.ai

| Модель        | GPU         | Квантование | Пропускная способность (токенов/с) |
| ------------- | ----------- | ----------- | ---------------------------------- |
| 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                            |

***

## Дополнительные ресурсы

* [TensorRT-LLM на GitHub](https://github.com/NVIDIA/TensorRT-LLM)
* [Triton Inference Server](https://github.com/triton-inference-server/server)
* [NGC Container Registry](https://catalog.ngc.nvidia.com/)
* [Документация по TRT-LLM](https://nvidia.github.io/TensorRT-LLM/)
* [Квантизация AWQ](https://github.com/mit-han-lab/llm-awq)

***

*TensorRT-LLM на Clore.ai — оптимальный выбор для продакшн-обслуживания LLM, где критичны пропускная способность и задержки. Для более простых настроек рассмотрите руководство vLLM.*

***

## Рекомендации Clore.ai по GPU

| Сценарий использования    | Рекомендуемый GPU | Примерная стоимость на Clore.ai |
| ------------------------- | ----------------- | ------------------------------- |
| Разработка/Тестирование   | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Производственный инференс | RTX 4090 (24GB)   | \~$0.70/gpu/hr                  |
| Крупные модели (70B+)     | A100 80GB         | \~$1.20/gpu/hr                  |

> 💡 Все примеры в этом руководстве можно развернуть на [Clore.ai](https://clore.ai/marketplace) GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.


---

# Agent Instructions: 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-ru/gpu-devops/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.