BentoML

BentoML est un framework moderne et open-source pour construire, déployer et faire évoluer des applications d'IA. Il comble le fossé entre l'expérimentation en ML et le déploiement en production, vous permettant d'emballer n'importe quel modèle issu de n'importe quel framework en un service API prêt pour la production en quelques minutes. Exécutez BentoML sur le cloud GPU de Clore.ai pour un hébergement d'applications IA rentable.

---

Qu'est-ce que BentoML ?

BentoML facilite la transformation d'un modèle entraîné en un service API évolutif :

• Agnostique au framework : PyTorch, TensorFlow, JAX, scikit-learn, HuggingFace, XGBoost, LightGBM, et plus encore

• Bento : Un artefact autosuffisant et reproductible (modèle + code + dépendances)

• Runner : Unité d'inférence de modèle évolutive avec mise en lot automatique

• Service : Définition de service HTTP/gRPC de type FastAPI

• BentoCloud : Plateforme de déploiement gérée optionnelle

• Docker en priorité : Chaque Bento peut être containerisé avec une seule commande

Principales fonctionnalités :

• Micro-batching adaptatif pour l'optimisation du débit

• Validation entrée/sortie intégrée avec Pydantic

• Spécification OpenAPI générée automatiquement

• Métriques Prometheus intégrées

• Prise en charge des réponses en streaming (LLMs)

---

Prérequis

Exigence	Minimum	Recommandé
VRAM GPU	8 Go	16–24 Go
GPU	N'importe quel NVIDIA	RTX 4090 / A100
RAM	8 Go	16 Go
Stockage	20 Go	40 Go
Python	3.9+	3.11+

---

Étape 1 — Louez un GPU sur Clore.ai

1. Connectez-vous à clore.ai.

2. Cliquez Place de marché et choisissez une instance GPU avec ≥ 16 Go de VRAM.

3. Définir l'image Docker : nous utiliserons une build personnalisée (voir l'étape 2).

4. Définir les ports ouverts : 22 (SSH) et 3000 (service BentoML).

5. Cliquez Louez.

---

Étape 2 — Dockerfile

BentoML n'a pas d'image Docker GPU officielle, donc nous en construisons une :

FROM pytorch/pytorch:2.1.2-cuda12.1-cudnn8-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/*

# Configurer SSH
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# Installer BentoML et les bibliothèques ML courantes
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

Construire et pousser

Construisez l'image et poussez-la vers votre compte Docker Hub (remplacez VOTRE_NOM_UTILISATEUR_DOCKERHUB par votre nom d'utilisateur réel) :

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

BentoML ne fournit pas d'image Docker GPU officielle sur Docker Hub. Les bentoml/bento-server images sur Docker Hub servent à déployer des Bentos pré-packagés et n'incluent pas le support CUDA. Construisez l'image à partir du Dockerfile ci‑dessus pour des déploiements compatibles GPU sur Clore.ai.

---

Étape 3 — Connexion via SSH

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

Vérifier BentoML :

bentoml --version
# Attendu : bentoml, version 1.x.x

---

Étape 4 — Votre premier service BentoML

Classificateur de texte simple

Créez un fichier de service :

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

# Définir un Runner (l'unité de modèle)
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

# Créer le Runner
classifier_runner = bentoml.Runner(
    TextClassifierRunnable,
    name="text_classifier",
    max_batch_size=32,
    max_latency_ms=100,
)

# Définir le Service
svc = bentoml.Service(
    name="text_classifier_service",
    runners=[classifier_runner],
)

@svc.api(input=Text(), output=JSON())
async def classify(text: str) -> dict:
    """Classer le sentiment du texte d'entrée."""
    results = await classifier_runner.classify.async_run([text])
    return results[0]
EOF

Démarrer le service

cd /workspace/my-service

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

Le --reload le drapeau active le rechargement à chaud pendant le développement. Supprimez-le en production pour la stabilité.

---

Étape 5 — Accéder au service

Ouvrez l'interface Swagger générée automatiquement :

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

Ou testez via curl:

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

Réponse attendue :

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

---

Étape 6 — Service de classification d'images

Service de modèle vision

# /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:
    """Classer une image avec ResNet50."""
    results = await image_runner.predict.async_run([image])
    return results[0]

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

Tester avec une image :

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

---

Étape 7 — Service LLM en streaming

Pour les modèles de langage avec réponses en streaming :

# /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)

---

Étape 8 — Enregistrer et construire un Bento

Un Bento est un artefact empaqueté et reproductible :

# /workspace/build_bento.py
import bentoml

# Enregistrer le modèle dans le magasin de modèles 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

# Lister les modèles sauvegardés
bentoml models list

# Construire un Bento (requiert 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

# Lister les bentos construits
bentoml list

# Containeriser
bentoml containerize image_classifier_service:latest \
    --image-tag VOTRE_NOM_UTILISATEUR_DOCKERHUB/my-bento:latest

---

Surveillance et métriques

BentoML expose des métriques Prometheus à /metrics:

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

Métriques clés :

# Taux de requêtes
bentoml_service_request_total{endpoint="classify", http_status_code="200"}
# Latence
bentoml_service_request_duration_seconds{endpoint="classify"}
# Débit du Runner  
bentoml_runner_request_total{runner_name="image_classifier"}

---

Configuration du batching adaptatif

# Ajuster finement le comportement du batching
image_runner = bentoml.Runner(
    ImageClassifierRunnable,
    name="image_classifier",
    max_batch_size=64,          # Nombre max de requêtes par lot
    max_latency_ms=50,          # Temps d'attente max avant envoi
)

---

Dépannage

Le service ne démarre pas

ERROR - Échec de l'initialisation du runner

Solutions :

• Vérifier la disponibilité de CUDA : python -c "import torch; print(torch.cuda.is_available())"

• Vérifier la VRAM GPU : nvidia-smi

• Vérifier que le téléchargement du modèle est terminé (recherchez la progression du téléchargement dans les logs)

Le port 3000 n'est pas accessible

# Assurez-vous que le service écoute sur 0.0.0.0 (et non localhost)
bentoml serve service:svc --host 0.0.0.0 --port 3000

Latence élevée sur la première requête

C'est normal — la première requête déclenche le chargement du modèle (warm-up). Toutes les requêtes suivantes seront rapides. Ajoutez un appel d'endpoint de warm‑up après le démarrage :

# Échauffer après le démarrage
sleep 10 && curl -s -o /dev/null http://localhost:3000/healthz

Erreurs d'importation

ModuleNotFoundError: No module named 'transformers'

Solution :

pip install transformers accelerate

---

Recommandations GPU Clore.ai

BentoML est un framework de serving — les exigences GPU dépendent entièrement du modèle que vous déployez. Voici à quoi vous attendre pour les charges de travail courantes :

GPU	VRAM	Prix Clore.ai	Débit LLM (7B Q4)	Diffusion (SDXL)	Vision (ResNet50)
RTX 3090	24 Go	~0,12 $/h	~80 tok/s	~4 img/min	~400 req/s
RTX 4090	24 Go	~0,70 $/h	~140 tok/s	~8 img/min	~700 req/s
A100 40GB	40 Go	~1,20 $/h	~110 tok/s	~6 img/min	~1200 req/s
A100 80GB	80 Go	~2,00 $/h	~130 tok/s	~7 img/min	~1400 req/s

Conseils d'utilisation :

• Service API LLM (7B–13B) : RTX 3090 (~0,12 $/h) — rapport prix‑performance optimal

• API de génération d'images : RTX 3090 ou RTX 4090 selon les besoins de débit

• Grands modèles (34B–70B Q4) : A100 40GB (~1,20 $/h) — convient confortablement

• Service multi‑modèles en production : A100 80GB pour marge mémoire

Le micro-batching adaptatif de BentoML est particulièrement efficace sur les A100 — le planificateur matériel gère le batching efficacement, extrayant plus de débit par dollar qu'un service naïf par requête unique. Pour des API à fort trafic, l'A100 40GB offre souvent un meilleur ROI que deux RTX 4090.

---

Ressources utiles

• Documentation officielle de BentoML

• BentoML GitHub

• Exemples BentoML

• Communauté BentoML sur Discord

• Galerie BentoML

• Démarrage rapide : servir des LLMs