Triton Inference Server

NVIDIA Triton इनफ़रेंस सर्वर एक प्रोडक्शन-ग्रेड, ओपन-सोर्स इनफ़रेंस सर्विंग प्लेटफ़ॉर्म है जो लगभग हर प्रमुख ML फ्रेमवर्क को सपोर्ट करता है। उच्च-थ्रूपुट, कम-लेटेंसी सर्विंग के लिए डिज़ाइन किया गया Triton, PyTorch, TensorFlow, ONNX, TensorRT, OpenVINO, और अन्य को — सब कुछ एक ही सर्वर प्रोसेस से — संभालता है। इसे स्केलेबल, लागत-कुशल इनफ़रेंस इंफ़्रास्ट्रक्चर के लिए Clore.ai के GPU क्लाउड पर डिप्लॉय करें।

---

Triton Inference Server क्या है?

Triton, बड़े पैमाने पर ML मॉडल सर्व करने की चुनौती के लिए NVIDIA का समाधान है:

• मल्टी-फ़्रेमवर्क: PyTorch, TensorFlow, TensorRT, ONNX, OpenVINO, Python कस्टम बैकएंड

• समवर्ती निष्पादन: कई मॉडल, प्रति GPU कई इंस्टेंस

• डायनेमिक बैचिंग: उच्च थ्रूपुट के लिए अनुरोधों को स्वतः बैच करें

• gRPC + HTTP: आउट-ऑफ़-द-बॉक्स उद्योग-मानक प्रोटोकॉल

• मेट्रिक्स: Prometheus-संगत मेट्रिक्स एंडपॉइंट

• मॉडल रिपॉज़िटरी: फ़ाइल-सिस्टम-आधारित मॉडल प्रबंधन

उपयोग किए गए पोर्ट:

पोर्ट	प्रोटोकॉल	उद्देश्य
8000	HTTP	REST इनफ़रेंस API
8001	gRPC	gRPC इनफ़रेंस API
8002	HTTP	Prometheus मेट्रिक्स

---

पूर्वापेक्षाएँ

आवश्यकता	न्यूनतम	अनुशंसित
GPU VRAM	8 GB	16–24 GB
GPU	CUDA 11+ वाला कोई भी NVIDIA GPU	RTX 4090 / A100
RAM	16 GB	32 GB
स्टोरेज	20 GB	50 GB

Triton, गैर-CUDA वर्कलोड के लिए CPU-only इनफ़रेंस भी सपोर्ट करता है। cpu-only ऐसे बैच जॉब्स पर लागत बचत के लिए Docker इमेज के वैरिएंट का उपयोग करें जिन्हें GPU की आवश्यकता नहीं है।

---

चरण 1 — Clore.ai पर GPU किराए पर लें

1. में लॉग इन करें clore.ai.

2. क्लिक करें मार्केटप्लेस और VRAM ≥ 16 GB के अनुसार फ़िल्टर करें।

3. एक सर्वर चुनें और Configure.

4. Docker इमेज सेट करें: nvcr.io/nvidia/tritonserver:24.01-py3

   • (इसे बदलें 24.01 नवीनतम संस्करण के साथ — देखें NGC catalog)

5. ओपन पोर्ट सेट करें: 22 (SSH), 8000 (HTTP), 8001 (gRPC), 8002 (मेट्रिक्स).

6. क्लिक करें किराए पर लें.

Triton Docker इमेज बड़ी होती हैं (~15–20 GB)। पहली बार लॉन्च पर शुरुआती pull के लिए 3–5 मिनट दें। उसके बाद स्टार्ट तेज़ होते हैं।

---

चरण 2 — कस्टम Dockerfile (SSH के साथ)

आधिकारिक Triton इमेज में SSH सर्वर शामिल नहीं है। इस Dockerfile का उपयोग करें:

FROM nvcr.io/nvidia/tritonserver:24.01-py3

RUN apt-get update && apt-get install -y \\
    openssh-server \\
    wget curl \\
    && rm -rf /var/lib/apt/lists/*

# SSH कॉन्फ़िगर करें
RUN mkdir /var/run/sshd && \\
    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Python क्लाइंट लाइब्रेरी इंस्टॉल करें
RUN pip install tritonclient[all] numpy Pillow

RUN mkdir -p /models

EXPOSE 22 8000 8001 8002

CMD service ssh start && \\
    tritonserver \\
        --model-repository=/models \\
        --log-verbose=0 \\
        --http-port=8000 \\
        --grpc-port=8001 \\
        --metrics-port=8002

---

चरण 3 — मॉडल रिपॉज़िटरी को समझें

Triton मॉडल्स को मॉडल रिपॉज़िटरी से लोड करता है — एक विशेष संरचना वाली डायरेक्टरी:

/models/
├── model_name_1/
│   ├── config.pbtxt          # मॉडल कॉन्फ़िगरेशन
│   ├── 1/                    # वर्शन 1
│   │   └── model.pt          # मॉडल फ़ाइल
│   └── 2/                    # वर्शन 2 (वैकल्पिक)
│       └── model.pt
├── model_name_2/
│   ├── config.pbtxt
│   └── 1/
│       └── model.onnx

हर मॉडल के लिए चाहिए:

1. मॉडल नाम वाली एक डायरेक्टरी

2. एक config.pbtxt कॉन्फ़िगरेशन फ़ाइल

3. कम से कम एक वर्शन सबडायरेक्टरी (जैसे, 1/) जिसमें मॉडल फ़ाइल हो

---

चरण 4 — PyTorch मॉडल डिप्लॉय करें

मॉडल को TorchScript में निर्यात करें

import torch
import torchvision

# एक pretrained ResNet50 लोड करें
model = torchvision.models.resnet50(pretrained=True)
model.eval()

# TorchScript में निर्यात करें
example_input = torch.randn(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)

# सहेजें
traced_model.save("/tmp/resnet50.pt")
print("मॉडल सफलतापूर्वक निर्यात किया गया")

मॉडल रिपॉज़िटरी सेट अप करें

# अपनी Clore.ai इंस्टेंस में SSH करें
ssh root@<clore-host> -p <port>

# डायरेक्टरी संरचना बनाएं
mkdir -p /models/resnet50/1

# मॉडल अपलोड करें
# (अपनी स्थानीय मशीन से)
scp -P <port> /tmp/resnet50.pt root@<clore-host>:/models/resnet50/1/model.pt

config.pbtxt बनाएं

cat > /models/resnet50/config.pbtxt << 'EOF'
name: "resnet50"
platform: "pytorch_libtorch"
max_batch_size: 32

input [
  {
    name: "input__0"
    data_type: TYPE_FP32
    dims: [3, 224, 224]
  }
]

output [
  {
    name: "output__0"
    data_type: TYPE_FP32
    dims: [1000]
  }
]

dynamic_batching {
  preferred_batch_size: [8, 16, 32]
  max_queue_delay_microseconds: 100
}

instance_group [
  {
    count: 2
    kind: KIND_GPU
    gpus: [0]
  }
]
EOF

---

चरण 5 — ONNX मॉडल डिप्लॉय करें

ONNX में निर्यात करें

import torch
import torchvision
import torch.onnx

model = torchvision.models.resnet50(pretrained=True)
model.eval()

dummy_input = torch.randn(1, 3, 224, 224)

torch.onnx.export(
    model,
    dummy_input,
    "/tmp/resnet50.onnx",
    opset_version=13,
    input_names=["images"],
    output_names=["logits"],
    dynamic_axes={
        "images": {0: "batch_size"},
        "logits": {0: "batch_size"}
    }
)

ONNX कॉन्फ़िग

mkdir -p /models/resnet50_onnx/1
scp -P <port> /tmp/resnet50.onnx root@<clore-host>:/models/resnet50_onnx/1/model.onnx

cat > /models/resnet50_onnx/config.pbtxt << 'EOF'
name: "resnet50_onnx"
platform: "onnxruntime_onnx"
max_batch_size: 32

input [
  {
    name: "images"
    data_type: TYPE_FP32
    dims: [3, 224, 224]
  }
]

output [
  {
    name: "logits"
    data_type: TYPE_FP32
    dims: [1000]
  }
]

dynamic_batching {
  preferred_batch_size: [8, 16, 32]
  max_queue_delay_microseconds: 100
}
EOF

---

चरण 6 — Python कस्टम बैकएंड डिप्लॉय करें

ऐसे मॉडल्स के लिए जो मानक बैकएंड में फिट नहीं होते (कस्टम प्रीप्रोसेसिंग, एंसेंबल लॉजिक):

mkdir -p /models/custom_model/1

cat > /models/custom_model/1/model.py << 'EOF'
import triton_python_backend_utils as pb_utils
import numpy as np
import torch

class TritonPythonModel:
    def initialize(self, args):
        self.model = torch.nn.Linear(10, 5).cuda()
        self.model.eval()
    
    def execute(self, requests):
        responses = []
        for request in requests:
            input_tensor = pb_utils.get_input_tensor_by_name(request, "INPUT")
            input_np = input_tensor.as_numpy()
            
            with torch.no_grad():
                inp = torch.from_numpy(input_np).float().cuda()
                out = self.model(inp).cpu().numpy()
            
            output_tensor = pb_utils.Tensor("OUTPUT", out.astype(np.float32))
            responses.append(pb_utils.InferenceResponse(output_tensors=[output_tensor]))
        
        return responses
    
    def finalize(self):
        pass
EOF

cat > /models/custom_model/config.pbtxt << 'EOF'
name: "custom_model"
backend: "python"
max_batch_size: 64

input [
  {
    name: "INPUT"
    data_type: TYPE_FP32
    dims: [10]
  }
]

output [
  {
    name: "OUTPUT"
    data_type: TYPE_FP32
    dims: [5]
  }
]
EOF

---

चरण 7 — Triton शुरू करें और परीक्षण करें

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

# शुरू करें (यदि Dockerfile CMD का उपयोग कर रहे हैं, तो यह अपने-आप शुरू हो जाता है)
tritonserver \\
    --model-repository=/models \\
    --http-port=8000 \\
    --grpc-port=8001 \\
    --metrics-port=8002 \\
    --log-verbose=0 &

# सर्वर के तैयार होने की प्रतीक्षा करें
sleep 5
curl -s http://localhost:8000/v2/health/ready
# अपेक्षित: {"live": true}

उपलब्ध मॉडल जाँचें

curl http://<clore-host>:<public-8000>/v2/models

HTTP के माध्यम से इनफ़रेंस चलाएँ

import tritonclient.http as httpclient
import numpy as np

client = httpclient.InferenceServerClient(
    url="<clore-host>:<public-port-8000>",
    ssl=False
)

# सर्वर हेल्थ जाँचें
print("Server ready:", client.is_server_ready())
print("Model ready:", client.is_model_ready("resnet50_onnx"))

# इनपुट बनाएं
image = np.random.rand(1, 3, 224, 224).astype(np.float32)
input_tensor = httpclient.InferInput("images", image.shape, "FP32")
input_tensor.set_data_from_numpy(image)

# इन्फ़रेंस चलाएँ
outputs = [httpclient.InferRequestedOutput("logits")]
response = client.infer("resnet50_onnx", [input_tensor], outputs=outputs)

logits = response.as_numpy("logits")
predicted_class = np.argmax(logits[0])
print(f"अनुमानित वर्ग: {predicted_class}")

gRPC के माध्यम से इनफ़रेंस चलाएँ

import tritonclient.grpc as grpcclient
import numpy as np

client = grpcclient.InferenceServerClient(
    url="<clore-host>:<public-port-8001>"
)

image = np.random.rand(1, 3, 224, 224).astype(np.float32)
input_tensor = grpcclient.InferInput("images", image.shape, "FP32")
input_tensor.set_data_from_numpy(image)

outputs = [grpcclient.InferRequestedOutput("logits")]
response = client.infer("resnet50_onnx", [input_tensor], outputs=outputs)

logits = response.as_numpy("logits")
print(f"आउटपुट आकार: {logits.shape}")

---

Prometheus के साथ मॉनिटरिंग

Triton पोर्ट 8002 पर मेट्रिक्स एक्सपोज़ करता है:

curl http://<clore-host>:<public-port-8002>/metrics

मुख्य मेट्रिक्स:

# इनफ़रेंस थ्रूपुट
nv_inference_request_success{model="resnet50_onnx", version="1"}
# औसत इनफ़रेंस समय
nv_inference_compute_infer_duration_us{model="resnet50_onnx", version="1"}
# GPU उपयोग
nv_gpu_utilization{gpu_uuid="..."}
# GPU मेमोरी
nv_gpu_memory_used_bytes{gpu_uuid="..."}

---

डायनेमिक बैचिंग कॉन्फ़िगरेशन

dynamic_batching {
  preferred_batch_size: [4, 8, 16, 32]
  max_queue_delay_microseconds: 5000
  preserve_ordering: true
  
  priority_levels: 3
  default_priority_level: 2
  default_queue_policy {
    timeout_action: REJECT
    default_timeout_microseconds: 10000
    allow_timeout_override: true
    max_queue_size: 100
  }
}

---

समस्या निवारण

मॉडल लोड विफलता

मॉडल लोड करने में विफल: मॉडल फ़ाइल नहीं मिल सकी

समाधान: डायरेक्टरी संरचना और अनुमतियाँ जाँचें:

ls -la /models/resnet50/1/
# इसमें model.pt (PyTorch) या model.onnx (ONNX) होना चाहिए
chmod -R 755 /models/

CUDA असंगतता

समाधान: Triton इमेज संस्करण को अपने CUDA ड्राइवर से मिलाएँ:

nvidia-smi  # CUDA संस्करण नोट करें
# मेल खाने वाला tritonserver टैग उपयोग करें, जैसे CUDA 12.2 के लिए 23.10

पोर्ट उपलब्ध नहीं

समाधान: सत्यापित करें कि तीनों पोर्ट (8000, 8001, 8002) Clore.ai में फ़ॉरवर्ड किए गए हैं। प्रत्येक को परीक्षण करें:

curl http://<host>:<port>/v2/health/live

मॉडल लोडिंग के दौरान OOM

समाधान: इंस्टेंस काउंट कम करें या कुछ मॉडल्स के लिए CPU इंस्टेंस का उपयोग करें:

instance_group [
  {
    count: 1       # डिफ़ॉल्ट से कम करें
    kind: KIND_GPU
  }
]

---

लागत अनुमान

GPU	VRAM	अनुमानित कीमत	थ्रूपुट (ResNet50)
RTX 3080	10 GB	$0.05–0.19/घंटा	~500 अनुरोध/सेकंड
RTX 4090	24 GB	$0.14–0.42/hr	~1500 अनुरोध/सेकंड
A100 40GB	40 GB	bare metal	~3000 अनुरोध/सेकंड
H100	80 GB	~$1.04/घंटा	~8000 अनुरोध/सेकंड

---

उपयोगी संसाधन

• Triton GitHub

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

• Triton क्लाइंट लाइब्रेरीज़

• Triton मॉडल कॉन्फ़िगरेशन संदर्भ

• Triton Python बैकएंड

• Triton प्रदर्शन विश्लेषक

---

Clore.ai GPU अनुशंसाएँ

उपयोग-प्रकरण	अनुशंसित GPU	Clore.ai पर अनुमानित लागत
विकास/परीक्षण	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
प्रोडक्शन इनफ़रेंस	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
बड़े मॉडल (70B+)	A100 80GB	bare metal

💡 इस गाइड के सभी उदाहरण Clore.ai GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.