> 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-hi/gpu-devops/tensorrt-llm.md).

# TensorRT-LLM

> **NVIDIA TensorRT अनुकूलन के साथ अधिकतम LLM इनफरेंस थ्रूपुट — Triton Inference Server के माध्यम से तैनात**

TensorRT-LLM NVIDIA की ओपन-सोर्स लाइब्रेरी है जो NVIDIA GPUs पर बड़े भाषा मॉडल इनफरेंस का अनुकूलन करती है। यह कर्नेल फ्यूज़न, क्वांटाइज़ेशन (INT4, INT8, FP8), इन-फ्लाइट बैचिंग, और पेज्ड KV-कैशिंग के माध्यम से अत्याधुनिक प्रदर्शन प्रदान करती है। Triton Inference Server के साथ संयोजन में, आपको प्रोडक्शन-ग्रेड सर्विंग इन्फ्रास्ट्रक्चर मिलता है।

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

***

## TensorRT-LLM क्यों?

| फ़ीचर                    | vLLM      | — 2 गाइड्स:          |
| ------------------------ | --------- | -------------------- |
| थ्रूपुट                  | अत्युत्तम | सर्वोत्तम श्रेणी में |
| लेटेंसी                  | अच्छा     | अत्युत्तम            |
| INT4/INT8 क्वांटाइज़ेशन  | आंशिक     | नेटिव                |
| FP8 समर्थन               | सीमित     | पूर्ण                |
| मल्टी-GPU टेENSOR पैरेलल | हाँ       | हाँ                  |
| सेटअप जटिलता             | कम        | मध्यम-उच्च           |

{% hint style="success" %}
**TensorRT-LLM आमतौर पर 2–4x अधिक थ्रूपुट देता है** मानक HuggingFace transformers इनफरेंस की तुलना में, और बैच सर्विंग परिदृश्यों के लिए vLLM की तुलना में 30–50% बेहतर थ्रूपुट।
{% endhint %}

***

## पूर्व-आवश्यकताएँ

* GPU किराये के साथ Clore.ai खाता
* **Ampere आर्किटेक्चर या नया NVIDIA GPU** (RTX 3090, A100, RTX 4090, H100)
* बुनियादी Linux और Docker ज्ञान
* आपके चुने मॉडल के लिए पर्याप्त VRAM

***

## मॉडल के अनुसार VRAM आवश्यकताएँ

| मॉडल          | FP16  | INT8 | INT4 |
| ------------- | ----- | ---- | ---- |
| Llama-3.1 8B  | 16GB  | 8GB  | 4GB  |
| Llama-3.1 70B | 140GB | 70GB | 35GB |
| Mistral 7B    | 14GB  | 7GB  | 4GB  |
| Mixtral 8x7B  | 90GB  | 45GB | 24GB |
| Qwen2.5 72B   | 144GB | 72GB | 36GB |

***

## चरण 1 — Clore.ai पर अपना GPU चुनें

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 में
* Clore.ai मार्केटप्लेस में उन सर्वरों का चयन करें जिनमें कई GPUs सूचीबद्ध हों
  {% endhint %}

***

## चरण 2 — TRT-LLM बैकएंड के साथ Triton Inference Server तैनात करें

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

**वॉल्यूम/डिस्क:** कम से कम 100GB की सिफारिश की जाती है

***

## चरण 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 का उपयोग करेंगे। अपने चुने मॉडल के लिए पथ समायोजित करें।

### HuggingFace CLI इंस्टॉल करें

```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" %}
**इंजन निर्माण समय:** GPU और मॉडल आकार पर निर्भर करते हुए 10–30 मिनट। यह एक बार किया जाने वाला ऑपरेशन है — एक बार बन जाने पर, इंजन सेकंडों में लोड हो जाता है।
{% endhint %}

***

## चरण 6 — TRT-LLM Python API के साथ त्वरित परीक्षण

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 = "फ्रांस की राजधानी क्या है?"
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 सर्वर शुरू करें

```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("क्वांटम कंप्यूटिंग को सरल शब्दों में समझाइए:"))
```

### थ्रुपुट का बेंचमार्क करें

```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 — OpenAI-अनुकूल API रैपर जोड़ें

आसान एकीकरण के लिए, एक 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 सर्वर शुरू नहीं हो रहा

```bash
# लॉग्स जांचें
cat /workspace/triton.log

# सत्यापित करें कि इंजन फाइलें मौजूद हैं
ls -la /workspace/trt_engines/llama-3.1-8b-fp16/

# GPU मेमोरी जांचें
nvidia-smi
```

### कम थ्रूपुट

```bash
# इन-फ्लाइट बैचिंग सक्षम करें और समवConcurrency बढ़ाएँ
# उपलब्ध VRAM के आधार पर max_tokens_in_paged_kv_cache को अनुकूलित करें
```

***

## Clore.ai GPUs पर प्रदर्शन बेंचमार्क

| मॉडल          | 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)
* [MLflow](https://github.com/triton-inference-server/server)
* [NGC कंटेनर रजिस्ट्री](https://catalog.ngc.nvidia.com/)
* [TRT-LLM दस्तावेज़ीकरण](https://nvidia.github.io/TensorRT-LLM/)
* [AWQ क्वांटाइज़ेशन](https://github.com/mit-han-lab/llm-awq)

***

*जहाँ थ्रूपुट और लेटेंसी महत्वपूर्ण हैं, वहाँ प्रोडक्शन LLM सर्विंग के लिए Clore.ai पर TensorRT-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 सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।


---

# 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-hi/gpu-devops/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.