ONNX रनटाइम GPU

क्रॉस-प्लेटफ़ॉर्म, हार्डवेयर-त्वरित ML इन्फ़रेंस — किसी भी फ्रेमवर्क के किसी भी मॉडल को तैनात करें

ONNX Runtime (ORT) माइक्रोसॉफ्ट का ओपन-सोर्स इनफ़रेंस इंजन है जो ONNX (Open Neural Network Exchange) मॉडलों के लिए है। यह एक एकीकृत API के माध्यम से CPU, GPU, और विशेष एसेलेरेटर पर हार्डवेयर-त्वरित इनफ़रेंस प्रदान करता है। चाहे आपका मॉडल PyTorch, TensorFlow, Scikit-learn, या XGBoost में प्रशिक्षित किया गया हो — यदि आप इसे ONNX फॉर्मेट में एक्सपोर्ट कर सकते हैं, तो ORT इसे तेज़ी से चला सकता है।

GitHub: microsoft/onnxruntime — 14K+ ⭐

---

क्यों ONNX Runtime?

फ़ीचर	TensorRT-LLM	TorchScript	TensorFlow Serving
फ्रेमवर्क-अज्ञेय	✅	❌ केवल PyTorch	❌ केवल TF
GPU त्वरण	✅ CUDA/TensorRT	✅	✅
INT8/FP16 क्वांटाइज़ेशन	✅	आंशिक	आंशिक
मोबाइल/एज पर तैनाती	✅	सीमित	सीमित
ऑपरेटर फ़्यूज़न	✅	आंशिक	✅
आसान एकीकरण	✅ Python/C++/Java	Python	Python/gRPC

मुख्य लाभ: CUDA execution provider के साथ ONNX Runtime सामान्यतः प्रदान करता है 1.5–3x गति वृद्धि कम्प्यूटर विज़न और NLP मॉडलों के लिए नेटिव PyTorch इनफ़रेंस की तुलना में।

---

समर्थित Execution Providers

ONNX Runtime कई हार्डवेयर बैकएंड्स (Execution Providers) का समर्थन करता है:

प्रोवाइडर	हार्डवेयर	उपयोग केस
CUDAExecutionProvider	NVIDIA GPUs	सामान्य GPU इनफ़रेंस
TensorrtExecutionProvider	NVIDIA GPUs	अधिकतम थ्रूपुट
CPUExecutionProvider	CPU	फॉलबैक / एज
ROCMExecutionProvider	AMD GPUs	AMD हार्डवेयर
CoreMLExecutionProvider	Apple Silicon	macOS/iOS
OpenVINOExecutionProvider	Intel	Intel CPUs/GPUs

---

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

• GPU किराए के साथ Clore.ai खाता

• बुनियादी Python ज्ञान

• एक प्रशिक्षित मॉडल (PyTorch, TensorFlow, या पहले से एक्सपोर्ट किया गया ONNX)

---

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

1. जाएँ clore.ai → मार्केटप्लेस

2. कोई भी NVIDIA GPU काम करेगा — छोटे मॉडलों के लिए RTX 3070 से लेकर बड़े ट्रांसफ़ॉर्मर्स के लिए A100 तक

3. ट्रांसफ़ॉर्मर मॉडलों के लिए: RTX 4090 या A100 की सिफारिश की जाती है

4. कम्प्यूटर विज़न के लिए: RTX 3090 या RTX 4090 पर्याप्त है

---

चरण 2 — अपना कंटेनर तैनात करें

ONNX Runtime का कोई आधिकारिक pre-built कंटेनर नहीं है, लेकिन NVIDIA CUDA बेस आदर्श है:

Docker इमेज:

nvcr.io/nvidia/cuda:12.2.0-cudnn8-devel-ubuntu22.04

पोर्ट्स:

22

पर्यावरण चर:

NVIDIA_VISIBLE_DEVICES=all
NVIDIA_DRIVER_CAPABILITIES=compute,utility

वैकल्पिक रूप से, उपयोग करें pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime जिसमें CUDA और ORT इंस्टॉलेशन के लिए तैयार Python एनवायरनमेंट शामिल है।

---

चरण 3 — GPU समर्थन के साथ ONNX Runtime इंस्टॉल करें

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

# पैकेज अपडेट करें
apt-get update && apt-get install -y \
    python3-pip \
    python3-dev \
    wget \
    git \
    libgomp1

# CUDA समर्थन के साथ ONNX Runtime इंस्टॉल करें
pip install onnxruntime-gpu

# सहायक पैकेज इंस्टॉल करें
pip install \
    onnx \
    numpy \
    Pillow \
    transformers \
    torch \
    torchvision \
    fastapi \
    uvicorn

# स्थापना सत्यापित करें
python3 << 'EOF'
import onnxruntime as ort
print(f"ORT Version: {ort.__version__}")
print(f"Available providers: {ort.get_available_providers()}")
# इसमें शामिल होना चाहिए: CUDAExecutionProvider, TensorrtExecutionProvider, CPUExecutionProvider
EOF

---

चरण 4 — अपना मॉडल ONNX में एक्सपोर्ट करें

PyTorch मॉडल एक्सपोर्ट

import torch
import torch.nn as nn
import onnx

# उदाहरण: ResNet50 एक्सपोर्ट करें
model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True)
model.eval()

# डमी इनपुट बनाएं (batch=1, RGB इमेज 224x224)
dummy_input = torch.randn(1, 3, 224, 224)

# ONNX में एक्सपोर्ट करें
torch.onnx.export(
    model,
    dummy_input,
    "resnet50.onnx",
    export_params=True,
    opset_version=17,              # नवीनतम स्थिर opset का उपयोग करें
    do_constant_folding=True,      # स्थिर मानों का अनुकूलन करें
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={
        "input": {0: "batch_size"},    # डायनैमिक बैच
        "output": {0: "batch_size"}
    }
)
print("Model exported successfully!")

# एक्सपोर्ट किए गए मॉडल को सत्यापित करें
onnx_model = onnx.load("resnet50.onnx")
onnx.checker.check_model(onnx_model)
print("ONNX model is valid!")

HuggingFace Transformers एक्सपोर्ट

# HuggingFace ONNX एक्सपोर्ट के लिए optimum इंस्टॉल करें
pip install optimum[exporters]

# टेक्स्ट क्लासिफिकेशन के लिए BERT एक्सपोर्ट करें
optimum-cli export onnx \
    --model bert-base-uncased \
    --task text-classification \
    ./bert_onnx/

# अनुकूलन के साथ एक्सपोर्ट करें
optimum-cli export onnx \
    --model microsoft/phi-2 \
    --task text-generation \
    --optimize O2 \
    ./phi2_onnx/

ORT अनुकूलन के साथ एक्सपोर्ट करें

from optimum.onnxruntime import ORTModelForSequenceClassification
from optimum.onnxruntime.configuration import OptimizationConfig, ORTConfig
from optimum.onnxruntime import ORTOptimizer

# लोड और अनुकूलित करें
model = ORTModelForSequenceClassification.from_pretrained(
    "distilbert-base-uncased-finetuned-sst-2-english",
    export=True
)

optimizer = ORTOptimizer.from_pretrained(model)
optimization_config = OptimizationConfig(
    optimization_level=2,
    optimize_for_gpu=True,
    fp16=True
)

optimizer.optimize(
    save_dir="./distilbert_optimized",
    optimization_config=optimization_config
)

---

चरण 5 — ONNX Runtime के साथ इनफ़रेंस चलाएँ

बुनियादी GPU इनफ़रेंस

import onnxruntime as ort
import numpy as np
from PIL import Image
import torchvision.transforms as transforms

# GPU execution providers के साथ सेशन कॉन्फ़िगर करें
# प्रोवाइडर्स को क्रम में आजमाया जाता है — पहले CUDA, फिर CPU फॉलबैक
providers = [
    ("CUDAExecutionProvider", {
        "device_id": 0,
        "arena_extend_strategy": "kNextPowerOfTwo",
        "gpu_mem_limit": 4 * 1024 * 1024 * 1024,  # 4GB सीमा
        "cudnn_conv_algo_search": "EXHAUSTIVE",
        "do_copy_in_default_stream": True,
    }),
    "CPUExecutionProvider"
]

# प्रदर्शन के लिए सेशन विकल्प
opts = ort.SessionOptions()
opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
opts.intra_op_num_threads = 8
opts.execution_mode = ort.ExecutionMode.ORT_PARALLEL

# मॉडल लोड करें
session = ort.InferenceSession(
    "resnet50.onnx",
    sess_options=opts,
    providers=providers
)

print(f"Running on: {session.get_providers()}")

# इनपुट तैयार करें
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

img = Image.open("test_image.jpg").convert("RGB")
img_tensor = transform(img).unsqueeze(0).numpy()

# इन्फरेंस चलाएँ
outputs = session.run(None, {"input": img_tensor})
probabilities = outputs[0][0]
top5_idx = probabilities.argsort()[-5:][::-1]
print("Top 5 predictions:", top5_idx, probabilities[top5_idx])

थ्रूपुट के लिए बैच इनफ़रेंस

import onnxruntime as ort
import numpy as np
import time

session = ort.InferenceSession(
    "resnet50.onnx",
    providers=["CUDAExecutionProvider"]
)

# GPU वार्म अप करें
dummy = np.random.randn(1, 3, 224, 224).astype(np.float32)
for _ in range(10):
    session.run(None, {"input": dummy})

# बैच साइज़ का बेंचमार्क करें
for batch_size in [1, 4, 8, 16, 32, 64]:
    inputs = np.random.randn(batch_size, 3, 224, 224).astype(np.float32)
    
    start = time.time()
    n_iter = 100
    for _ in range(n_iter):
        session.run(None, {"input": inputs})
    elapsed = time.time() - start
    
    throughput = (batch_size * n_iter) / elapsed
    latency = (elapsed / n_iter) * 1000  # ms
    
    print(f"Batch {batch_size:3d}: {throughput:7.1f} img/sec, {latency:.1f}ms/batch")

---

चरण 6 — TensorRT Execution Provider (अधिकतम प्रदर्शन)

NVIDIA GPUs के लिए, TensorRT EP और भी बेहतर प्रदर्शन प्रदान करता है:

import onnxruntime as ort
import numpy as np

# TensorRT execution provider कॉन्फ़िगरेशन
tensorrt_provider_options = {
    "trt_max_workspace_size": 4 * 1024 * 1024 * 1024,  # 4GB
    "trt_fp16_enable": True,          # तेज़ इनफ़रेंस के लिए FP16 सक्षम करें
    "trt_int8_enable": False,
    "trt_engine_cache_enable": True,   # संकलित इंजनों को कैश करें
    "trt_engine_cache_path": "/tmp/trt_cache",
    "trt_max_partition_iterations": 1000,
    "trt_min_subgraph_size": 1,
    "trt_timing_cache_enable": True,
}

providers = [
    ("TensorrtExecutionProvider", tensorrt_provider_options),
    ("CUDAExecutionProvider", {"device_id": 0}),
    "CPUExecutionProvider"
]

session = ort.InferenceSession("resnet50.onnx", providers=providers)
print("Active provider:", session.get_providers()[0])

# पहली रन TensorRT इंजन को संकलित करती है (1-3 मिनट लग सकते हैं)
# बाद की रन कैश किए गए इंजन का उपयोग करती हैं और बहुत तेज़ होती हैं

TensorRT इंजन का संकलन पहली इनफ़रेंस पर होता है और 1–5 मिनट तक लग सकता है। कैशिंग सक्षम करें (trt_engine_cache_enable: True) ताकि संकलित इंजन को सेशंस के बीच पुन: उपयोग किया जा सके।

---

चरण 7 — अधिकतम गति के लिए INT8 क्वांटाइज़ेशन

from onnxruntime.quantization import quantize_dynamic, quantize_static, QuantType
import onnxruntime as ort
import numpy as np

# डायनामिक INT8 क्वांटाइज़ेशन (कैलिब्रेशन डाटा की आवश्यकता नहीं)
quantize_dynamic(
    model_input="resnet50.onnx",
    model_output="resnet50_int8_dynamic.onnx",
    weight_type=QuantType.QInt8
)

# स्टेटिक INT8 क्वांटाइज़ेशन (कैलिब्रेशन डाटा आवश्यक है)
from onnxruntime.quantization import CalibrationDataReader

class ImageCalibrationReader(CalibrationDataReader):
    def __init__(self, data_dir, input_name="input"):
        self.data_dir = data_dir
        self.input_name = input_name
        self.images = self._load_images()
        self.idx = 0
    
    def _load_images(self):
        # 100 कैलिब्रेशन इमेज लोड करें
        import glob, torchvision.transforms as T
        from PIL import Image
        transform = T.Compose([T.Resize(256), T.CenterCrop(224), T.ToTensor()])
        images = []
        for path in glob.glob(f"{self.data_dir}/*.jpg")[:100]:
            img = Image.open(path).convert("RGB")
            images.append(transform(img).numpy())
        return images
    
    def get_next(self):
        if self.idx >= len(self.images):
            return None
        data = {self.input_name: self.images[self.idx:self.idx+1]}
        self.idx += 1
        return data

from onnxruntime.quantization import quantize_static, QuantFormat
quantize_static(
    model_input="resnet50.onnx",
    model_output="resnet50_int8_static.onnx",
    calibration_data_reader=ImageCalibrationReader("/data/calibration_images"),
    quant_format=QuantFormat.QDQ,
    weight_type=QuantType.QInt8
)

---

चरण 8 — एक Inference API बनाएं

cat > /workspace/onnx_api.py << 'EOF'
from fastapi import FastAPI, File, UploadFile
from fastapi.responses import JSONResponse
import onnxruntime as ort
import numpy as np
from PIL import Image
import io
import torchvision.transforms as transforms
import json

app = FastAPI(title="ONNX Runtime Inference API")

# स्टार्टअप पर मॉडल लोड करें
session = ort.InferenceSession(
    "resnet50.onnx",
    providers=["CUDAExecutionProvider", "CPUExecutionProvider"]
)

# ImageNet क्लास लेबल लोड करें
with open("imagenet_classes.json") as f:
    classes = json.load(f)

transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

@app.get("/health")
async def health():
    return {"status": "ok", "providers": session.get_providers()}

@app.post("/predict")
async def predict(file: UploadFile = File(...), topk: int = 5):
    image_data = await file.read()
    img = Image.open(io.BytesIO(image_data)).convert("RGB")
    tensor = transform(img).unsqueeze(0).numpy()
    
    outputs = session.run(None, {"input": tensor})[0][0]
    top_indices = outputs.argsort()[-topk:][::-1]
    
    results = [
        {"label": classes[str(i)], "score": float(outputs[i])}
        for i in top_indices
    ]
    return JSONResponse({"predictions": results})

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)
EOF

python3 /workspace/onnx_api.py &

# API का परीक्षण करें
curl -X POST "http://localhost:8080/predict" \
    -H "accept: application/json" \
    -F "file=@test_image.jpg"

---

चरण 9 — GPU उपयोग की निगरानी करें

# इनफ़रेंस के दौरान रियल-टाइम GPU मॉनिटरिंग
watch -n 0.5 nvidia-smi

# या बेहतर UI के लिए nvitop का उपयोग करें
pip install nvitop
nvitop

---

प्रदर्शन बेंचमार्क्स

मॉडल	GPU	प्रोवाइडर	थ्रूपुट (inf/sec)
ResNet50	RTX 4090	CUDA	~4,200
ResNet50	RTX 4090	TensorRT FP16	~8,500
BERT बेस	RTX 4090	CUDA	~380
BERT बेस	RTX 4090	TensorRT FP16	~720
YOLOv8n	RTX 3090	CUDA	~1,800
YOLOv8x	A100	TensorRT FP16	~920

---

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

CUDA प्रोवाइडर उपलब्ध नहीं है

# जांचें कि CUDA ORT इंस्टॉल है (केवल CPU वर्ज़न नहीं)
pip uninstall onnxruntime
pip install onnxruntime-gpu

python3 -c "import onnxruntime as ort; print(ort.get_available_providers())"

TensorRT संकलन त्रुटियाँ

# TensorRT संस्करण संगतता जांचें
python3 -c "import tensorrt; print(tensorrt.__version__)"

# इसके बजाय CUDA EP का उपयोग करें
providers = ["CUDAExecutionProvider"]  # TensorRT EP छोड़ें

आकार मेल न होने की त्रुटियाँ

# मॉडल इनपुट/आउटपुट आकार जांचें
for input in session.get_inputs():
    print(f"Input: {input.name}, shape: {input.shape}, type: {input.type}")

for output in session.get_outputs():
    print(f"Output: {output.name}, shape: {output.shape}, type: {output.type}")

---

उन्नत: मल्टी-मॉडल पाइपलाइन

import onnxruntime as ort
import numpy as np

class MultiModelPipeline:
    def __init__(self):
        providers = ["CUDAExecutionProvider"]
        self.detector = ort.InferenceSession("detector.onnx", providers=providers)
        self.classifier = ort.InferenceSession("classifier.onnx", providers=providers)
    
    def run(self, image: np.ndarray) -> list:
        # स्टेज 1: ऑब्जेक्ट डिटेक्शन
        boxes = self.detector.run(None, {"image": image})[0]
        
        results = []
        for box in boxes:
            # पहचानित क्षेत्र को क्रॉप करें
            crop = self._crop(image, box)
            
            # स्टेज 2: प्रत्येक क्षेत्र को क्लासिफाई करें
            label = self.classifier.run(None, {"input": crop})[0]
            results.append({"box": box.tolist(), "label": int(label.argmax())})
        
        return results
    
    def _crop(self, image, box):
        x1, y1, x2, y2 = box.astype(int)
        return image[:, :, y1:y2, x1:x2]

pipeline = MultiModelPipeline()

---

अतिरिक्त संसाधन

• ONNX Runtime GitHub

• ONNX Runtime प्रलेखन

• Hugging Face Optimum

• ONNX Model Zoo — पहले से एक्सपोर्ट किए गए मॉडल

• Netron — ONNX मॉडल विज़ुअलाइज़र

• ONNX Runtime Python API

---

Clore.ai पर ONNX Runtime उत्पादन इनफ़रेंस सेवाओं के लिए आदर्श विकल्प है जिन्हें अधिकतम GPU दक्षता के साथ विभिन्न फ्रेमवर्क्स के मॉडल सर्व करने की आवश्यकता होती है।

---

Clore.ai GPU सिफारिशें

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
उत्पादन इन्फरेंस	RTX 4090 (24GB)	~$0.70/gpu/hr
बड़े पैमाने पर तैनाती	A100 80GB	~$1.20/gpu/hr

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