BentoML

BentoML के लिए एक आधुनिक, ओपन-सोर्स फ्रेमवर्क है AI अनुप्रयोगों के निर्माण, डिप्लॉयमेंट और स्केलिंग के लिए. यह ML प्रयोग और प्रोडक्शन डिप्लॉयमेंट के बीच की खाई को पाटता है, जिससे आप किसी भी फ्रेमवर्क के किसी भी मॉडल को कुछ ही मिनटों में प्रोडक्शन-रेडी API सेवा में पैकेज कर सकते हैं। लागत-कुशल AI एप्लिकेशन होस्टिंग के लिए Clore.ai के GPU क्लाउड पर BentoML चलाएँ।

---

BentoML क्या है?

BentoML एक प्रशिक्षित मॉडल को लेकर उसे स्केलेबल API सेवा में बदलना आसान बनाता है:

• फ्रेमवर्क-अज्ञेय: PyTorch, TensorFlow, JAX, scikit-learn, HuggingFace, XGBoost, LightGBM, और अधिक

• Bento: एक स्व-निहित, पुनरुत्पादनीय आर्टिफैक्ट (मॉडल + कोड + निर्भरताएँ)

• रनर: स्वचालित बैचिंग के साथ स्केलेबल मॉडल इनफ़रेंस इकाई

• सेवा: FastAPI-जैसी HTTP/gRPC सेवा परिभाषा

• BentoCloud: वैकल्पिक प्रबंधित डिप्लॉयमेंट प्लेटफ़ॉर्म

• Docker-प्रथम: हर Bento को एक कमांड से कंटेनराइज़ किया जा सकता है

मुख्य विशेषताएँ:

• थ्रूपुट अनुकूलन के लिए अनुकूली माइक्रो-बैचिंग

• Pydantic के साथ अंतर्निर्मित इनपुट/आउटपुट सत्यापन

• OpenAPI स्पेक स्वतः जनरेट होता है

• अंतर्निर्मित Prometheus मेट्रिक्स

• स्ट्रीमिंग प्रतिक्रिया समर्थन (LLMs)

---

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

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

---

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

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

2. क्लिक करें मार्केटप्लेस और ≥ 16 GB VRAM वाला GPU इंस्टेंस चुनें।

3. Docker इमेज सेट करें: हम कस्टम बिल्ड का उपयोग करेंगे (चरण 2 देखें)।

4. ओपन पोर्ट सेट करें: 22 (SSH) और 3000 (BentoML सेवा).

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

---

चरण 2 — Dockerfile

BentoML का कोई आधिकारिक GPU Docker इमेज नहीं है, इसलिए हम एक बनाते हैं:

FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \\
    git wget curl \\
    openssh-server \\
    libgl1 libglib2.0-0 \\
    && 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

# BentoML और सामान्य ML लाइब्स इंस्टॉल करें
RUN pip install --upgrade pip && \\
    pip install \\
        bentoml \\
        transformers \\
        accelerate \\
        diffusers \\
        Pillow \\
        numpy \\
        scipy \\
        tritonclient[all]

WORKDIR /workspace

EXPOSE 22 3000

CMD service ssh start && tail -f /dev/null

बिल्ड और पुश करें

इमेज बनाएं और इसे अपने Docker Hub खाते में पुश करें (बदलें YOUR_DOCKERHUB_USERNAME अपने वास्तविक उपयोगकर्ता नाम से):

docker build -t YOUR_DOCKERHUB_USERNAME/bentoml-gpu:latest .
docker push YOUR_DOCKERHUB_USERNAME/bentoml-gpu:latest

BentoML Docker Hub पर कोई आधिकारिक GPU Docker इमेज प्रदान नहीं करता। bentoml/bento-server Docker Hub पर इमेजें प्री-पैकेज्ड Bentos को सर्व करने के लिए हैं और इनमें CUDA समर्थन शामिल नहीं है। Clore.ai पर GPU-सक्षम डिप्लॉयमेंट के लिए ऊपर दिए गए Dockerfile से इमेज बनाएं।

---

चरण 3 — SSH के माध्यम से कनेक्ट करें

ssh root@<clore-host> -p <assigned-ssh-port>

BentoML सत्यापित करें:

bentoml --version
# अपेक्षित: bentoml, version 1.x.x

---

चरण 4 — आपकी पहली BentoML सेवा

सरल टेक्स्ट क्लासिफ़ायर

एक सेवा फ़ाइल बनाएं:

mkdir -p /workspace/my-service
cat > /workspace/my-service/service.py << 'EOF'
import bentoml
from bentoml.io import JSON, Text
import numpy as np

# एक Runner (मॉडल इकाई) परिभाषित करें
class TextClassifierRunnable(bentoml.Runnable):
    SUPPORTED_RESOURCES = ("gpu", "cpu")
    SUPPORTS_CPU_MULTI_THREADING = True
    
    def __init__(self):
        import torch
        from transformers import pipeline
        
        self.classifier = pipeline(
            "text-classification",
            model="distilbert-base-uncased-finetuned-sst-2-english",
            device=0 if torch.cuda.is_available() else -1,
        )
    
    @bentoml.Runnable.method(batchable=True, batch_dim=0)
    def classify(self, texts: list[str]) -> list[dict]:
        results = self.classifier(texts)
        return results

# Runner बनाएं
classifier_runner = bentoml.Runner(
    TextClassifierRunnable,
    name="text_classifier",
    max_batch_size=32,
    max_latency_ms=100,
)

# सेवा परिभाषित करें
svc = bentoml.Service(
    name="text_classifier_service",
    runners=[classifier_runner],
)

@svc.api(input=Text(), output=JSON())
async def classify(text: str) -> dict:
    """इनपुट पाठ की भावना वर्गीकृत करें।"""
    results = await classifier_runner.classify.async_run([text])
    return results[0]
EOF

सेवा शुरू करें

cd /workspace/my-service

bentoml serve service:svc \\
    --host 0.0.0.0 \\
    --port 3000 \\
    --reload

यह --reload फ्लैग विकास के दौरान हॉट-रीलोड सक्षम करता है। स्थिरता के लिए इसे प्रोडक्शन में हटा दें।

---

चरण 5 — सेवा तक पहुँचें

स्वतः जनरेटेड Swagger UI खोलें:

http://<clore-host>:<public-port-3000>

या इसके माध्यम से परीक्षण करें curl:

curl -X POST http://<clore-host>:<public-port-3000>/classify \\
    -H "Content-Type: text/plain" \\
    -d "This GPU cloud service is amazing!"

अपेक्षित प्रतिक्रिया:

{"label": "POSITIVE", "score": 0.9986}

---

चरण 6 — इमेज वर्गीकरण सेवा

विज़न मॉडल सेवा

# /workspace/vision-service/service.py
import bentoml
from bentoml.io import Image, JSON
from PIL import Image as PILImage
import numpy as np

class ImageClassifierRunnable(bentoml.Runnable):
    SUPPORTED_RESOURCES = ("gpu",)
    SUPPORTS_CPU_MULTI_THREADING = False
    
    def __init__(self):
        import torch
        import torchvision.transforms as transforms
        from torchvision.models import resnet50, ResNet50_Weights
        
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        weights = ResNet50_Weights.DEFAULT
        self.model = resnet50(weights=weights).to(self.device)
        self.model.eval()
        self.preprocess = weights.transforms()
        self.categories = weights.meta["categories"]
    
    @bentoml.Runnable.method(batchable=True, batch_dim=0)
    def predict(self, images: list) -> list[dict]:
        import torch
        
        batch = torch.stack([self.preprocess(img) for img in images]).to(self.device)
        
        with torch.no_grad():
            predictions = self.model(batch).softmax(dim=1)
        
        results = []
        for pred in predictions:
            top5 = pred.topk(5)
            results.append({
                "predictions": [
                    {"label": self.categories[idx], "score": round(score.item(), 4)}
                    for score, idx in zip(top5.values, top5.indices)
                ]
            })
        return results


image_runner = bentoml.Runner(
    ImageClassifierRunnable,
    name="image_classifier",
    max_batch_size=16,
)

svc = bentoml.Service(
    name="image_classifier_service",
    runners=[image_runner],
)

@svc.api(input=Image(), output=JSON())
async def classify(image: PILImage.Image) -> dict:
    """ResNet50 के साथ एक छवि वर्गीकृत करें।"""
    results = await image_runner.predict.async_run([image])
    return results[0]

bentoml serve service:svc --host 0.0.0.0 --port 3000

एक छवि के साथ परीक्षण करें:

curl -X POST http://<clore-host>:<public-port-3000>/classify \\
    -H "Content-Type: image/jpeg" \\
    --data-binary @/path/to/image.jpg

---

चरण 7 — LLM स्ट्रीमिंग सेवा

स्ट्रीमिंग प्रतिक्रियाओं वाले भाषा मॉडलों के लिए:

# /workspace/llm-service/service.py
import bentoml
from bentoml.io import JSON, Text
from typing import AsyncGenerator

class LLMRunnable(bentoml.Runnable):
    SUPPORTED_RESOURCES = ("gpu",)
    SUPPORTS_CPU_MULTI_THREADING = False
    
    def __init__(self):
        from transformers import AutoModelForCausalLM, AutoTokenizer
        import torch
        
        model_name = "microsoft/phi-2"
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForCausalLM.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="auto"
        )
    
    @bentoml.Runnable.method(batchable=False)
    def generate(self, prompt: str, max_tokens: int = 200) -> str:
        import torch
        
        inputs = self.tokenizer(prompt, return_tensors="pt").to("cuda")
        
        with torch.no_grad():
            outputs = self.model.generate(
                **inputs,
                max_new_tokens=max_tokens,
                do_sample=True,
                temperature=0.7,
                pad_token_id=self.tokenizer.eos_token_id,
            )
        
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)


llm_runner = bentoml.Runner(LLMRunnable, name="llm")

svc = bentoml.Service("llm_service", runners=[llm_runner])

@svc.api(input=JSON(), output=Text())
async def generate(body: dict) -> str:
    prompt = body.get("prompt", "")
    max_tokens = body.get("max_tokens", 200)
    return await llm_runner.generate.async_run(prompt, max_tokens)

---

चरण 8 — एक Bento सहेजें और बनाएं

एक Bento एक पैकेज्ड, पुनरुत्पादनीय आर्टिफैक्ट है:

# /workspace/build_bento.py
import bentoml

# मॉडल को BentoML मॉडल स्टोर में सहेजें
import torch
from torchvision.models import resnet50, ResNet50_Weights

model = resnet50(weights=ResNet50_Weights.DEFAULT)
model.eval()

saved_model = bentoml.pytorch.save_model(
    name="resnet50",
    model=model,
    labels={"framework": "pytorch", "task": "image-classification"},
    metadata={"accuracy": 0.80, "dataset": "ImageNet"}
)
print(f"Model saved: {saved_model.tag}")

python /workspace/build_bento.py

# सहेजे गए मॉडल सूचीबद्ध करें
bentoml models list

# एक Bento बनाएं (bentofile.yaml आवश्यक है)
bentoml build

bentofile.yaml

service: "service:svc"
labels:
  owner: "ml-team"
  stage: "production"
include:
  - "*.py"
python:
  packages:
    - torch
    - torchvision
    - transformers
    - Pillow
    - numpy
docker:
  python_version: "3.11"
  cuda_version: "12.1"
  system_packages:
    - libgl1

bentoml build

# बने हुए Bentos सूचीबद्ध करें
bentoml list

# कंटेनराइज़ करें
bentoml containerize image_classifier_service:latest \\
    --image-tag YOUR_DOCKERHUB_USERNAME/my-bento:latest

---

निगरानी और मेट्रिक्स

BentoML Prometheus मेट्रिक्स यहाँ उपलब्ध कराता है /metrics:

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

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

# अनुरोध दर
bentoml_service_request_total{endpoint="classify", http_status_code="200"}
# विलंबता
bentoml_service_request_duration_seconds{endpoint="classify"}
# Runner थ्रूपुट  
bentoml_runner_request_total{runner_name="image_classifier"}

---

अनुकूली बैचिंग कॉन्फ़िगरेशन

# बैचिंग व्यवहार को सूक्ष्म रूप से समायोजित करें
image_runner = bentoml.Runner(
    ImageClassifierRunnable,
    name="image_classifier",
    max_batch_size=64,          # प्रति बैच अधिकतम अनुरोध
    max_latency_ms=50,          # डिस्पैच से पहले अधिकतम प्रतीक्षा
)

---

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

सेवा शुरू नहीं होगी

त्रुटि - Runner को प्रारंभ करने में विफल

समाधान:

• CUDA उपलब्धता जांचें: python -c "import torch; print(torch.cuda.is_available())"

• GPU VRAM सत्यापित करें: nvidia-smi

• जांचें कि मॉडल डाउनलोड पूरा हुआ या नहीं (लॉग्स में डाउनलोड प्रगति देखें)

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

# सुनिश्चित करें कि सेवा 0.0.0.0 से बाइंड हो (localhost से नहीं)
bentoml serve service:svc --host 0.0.0.0 --port 3000

पहले अनुरोध पर अधिक विलंबता

यह सामान्य है — पहला अनुरोध मॉडल लोडिंग (वार्म-अप) को ट्रिगर करता है। उसके बाद के सभी अनुरोध तेज़ होंगे। शुरू होने के बाद एक वार्म-अप एंडपॉइंट कॉल जोड़ें:

# शुरू होने के बाद वार्म अप करें
sleep 10 && curl -s -o /dev/null http://localhost:3000/healthz

इंपोर्ट त्रुटियाँ

ModuleNotFoundError: No module named 'transformers'

समाधान:

pip install transformers accelerate

---

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

BentoML एक सर्विंग फ्रेमवर्क है — GPU आवश्यकताएँ पूरी तरह उस मॉडल पर निर्भर करती हैं जिसे आप डिप्लॉय करते हैं। सामान्य वर्कलोड के लिए यह अपेक्षित है:

GPU	VRAM	Clore.ai मूल्य	LLM (7B Q4) थ्रूपुट	डिफ्यूज़न (SDXL)	विज़न (ResNet50)
RTX 3090	24 GB	$0.07–0.21/hr	~80 tok/s	~4 img/min	~400 req/s
RTX 4090	24 GB	$0.14–0.42/hr	~140 tok/s	~8 img/min	~700 req/s
A100 40GB	40 GB	bare metal	~110 tok/s	~6 img/min	~1200 req/s
A100 80GB	80 GB	bare metal	~130 tok/s	~7 img/min	~1400 req/s

उपयोग-प्रकरण मार्गदर्शन:

• LLM API सर्विंग (7B–13B): RTX 3090 ($0.07–0.21/hr) — कीमत-प्रदर्शन के लिए सर्वोत्तम

• छवि जनरेशन API: थ्रूपुट आवश्यकताओं के अनुसार RTX 3090 या RTX 4090

• बड़े मॉडल (34B–70B Q4): A100 40GB (bare metal) — आराम से फिट हो जाता है

• प्रोडक्शन मल्टी-मॉडल सर्विंग: मेमोरी हेडरूम के लिए A100 80GB

BentoML की अनुकूली माइक्रो-बैचिंग A100s पर विशेष रूप से प्रभावी है — हार्डवेयर शेड्यूलर बैचिंग को कुशलता से संभालता है, और साधारण एकल-अनुरोध सर्विंग की तुलना में प्रति डॉलर अधिक थ्रूपुट निकालता है। उच्च-ट्रैफ़िक API के लिए, A100 40GB अक्सर दो RTX 4090s से बेहतर ROI देता है।

---

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

• BentoML आधिकारिक दस्तावेज़

• BentoML GitHub

• BentoML उदाहरण

• BentoML Discord समुदाय

• BentoML गैलरी

• क्विकस्टार्ट: LLMs सर्व करना