# 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 ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।