TensorRT-LLM

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

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

GitHub: NVIDIA/TensorRT-LLM — 10K+ ⭐

---

TensorRT-LLM क्यों?

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

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

---

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

• 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 → मार्केटप्लेस

2. सिंगल GPU सर्विंग के लिए (7B–13B मॉडल): RTX 4090 24GB या RTX 3090 24GB

3. बड़े मॉडल्स (70B+): कई A100 80GB या H100

मल्टी-GPU रणनीति:

• 2x A100 80GB → Llama 3.1 70B FP16 या Qwen2.5 72B में

• 4x A100 80GB → Llama 3.1 405B INT8 में

• Clore.ai मार्केटप्लेस में उन सर्वरों का चयन करें जिनमें कई GPUs सूचीबद्ध हों

---

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

Docker इमेज:

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

उपयोग करें -trtllm-python-py3 वेरिएंट — इसमें पहले से TensorRT-LLM बैकएंड इंस्टॉल किया गया है। टैग NVIDIA कंटेनर रिलीज से मेल खाता है (24.01 = जनवरी 2024)। जाँचें NGC नवीनतम टैग के लिए।

खुले पोर्ट:

22
8000

पर्यावरण चर:

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

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

---

चरण 3 — कनेक्ट करें और स्थापना सत्यापित करें

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 इंस्टॉल करें

pip install huggingface_hub
huggingface-cli login
# संकेत मिलने पर अपना HuggingFace टोकन दर्ज करें

मॉडल वेट्स डाउनलोड करें

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 इंजन (बेहतर गुणवत्ता)

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 इंजन (उच्च थ्रूपुट)

# 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 इंजन (अधिकतम थ्रूपुट / न्यूनतम मेमोरी)

# क्वांटाइज़ेशन के लिए 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

इंजन निर्माण समय: GPU और मॉडल आकार पर निर्भर करते हुए 10–30 मिनट। यह एक बार किया जाने वाला ऑपरेशन है — एक बार बन जाने पर, इंजन सेकंडों में लोड हो जाता है।

---

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

Triton सेटअप करने से पहले सत्यापित करें कि इंजन काम करता है:

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 सेटअप करें

मॉडल रिपोजिटरी संरचना बनाएं

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

इंजन के लिए सिमलिंक बनाएं

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

Triton सर्वर शुरू करें

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-अनुकूल क्लाइंट

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

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

# 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 रैपर जोड़ें:

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

# 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 सर्वर शुरू नहीं हो रहा

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

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

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

कम थ्रूपुट

# इन-फ्लाइट बैचिंग सक्षम करें और समव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

• MLflow

• NGC कंटेनर रजिस्ट्री

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