BentoML

BentoML est un framework moderne et open source pour créer, 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'empaqueter n'importe quel modèle de n'importe quel framework dans un service d'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 d'IA économique.

Qu'est-ce que BentoML ?

BentoML facilite la prise d’un modèle entraîné et sa transformation en service d’API évolutif :

Indépendant du framework : PyTorch, TensorFlow, JAX, scikit-learn, Hugging Face, XGBoost, LightGBM, et plus encore
Bento : Un artefact autonome et reproductible (modèle + code + dépendances)
Runner : Unité d'inférence de modèle évolutive avec micro-lots automatiques
Service : Définition de service HTTP/gRPC de type FastAPI
BentoCloud : Plateforme de déploiement gérée optionnelle
Priorité à Docker : Chaque Bento peut être conteneurisé en une seule commande

Fonctionnalités clés :

Micro-batching adaptatif pour optimiser le débit
Validation intégrée des entrées/sorties 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

Toute carte NVIDIA

RTX 4090 / A100

RAM

8 Go

16 Go

Stockage

20 Go

40 Go

Python

3.9+

3.11+

Étape 1 — Louer un GPU sur Clore.ai

Connectez-vous à clore.ai.
Cliquez sur Place de marché et sélectionnez une instance GPU avec ≥ 16 Go de VRAM.
Définissez l'image Docker : nous utiliserons une build personnalisée (voir l'étape 2).
Définissez les ports ouverts : 22 (SSH) et 3000 (service BentoML).
Cliquez sur Louer.

Étape 2 — Dockerfile

BentoML ne dispose pas d'une image Docker GPU officielle, nous en construisons donc une :

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/*

# 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 propre compte Docker Hub (remplacez YOUR_DOCKERHUB_USERNAME par votre nom d'utilisateur réel) :

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

BentoML ne fournit pas d'image Docker GPU officielle sur Docker Hub. Les bentoml/bento-server images sur Docker Hub sont destinées au service de Bentos préemballés et n'incluent pas la prise en charge de CUDA. Construisez l'image à partir du Dockerfile ci-dessus pour des déploiements avec GPU sur Clore.ai.

Étape 3 — Connectez-vous 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:
    """Classifie 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 L'indicateur permet le rechargement à chaud pendant le développement. Supprimez-le en production pour plus de stabilité.

Étape 5 — Accéder au service

Ouvrez l'interface Swagger UI 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 de 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:
    """Classifie 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

Testez 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 de streaming LLM

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"Modèle enregistré : {saved_model.tag}")

python /workspace/build_bento.py

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

# Construire un Bento (nécessite 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

# Conteneuriser
bentoml containerize image_classifier_service:latest \
    --image-tag YOUR_DOCKERHUB_USERNAME/my-bento:latest

Surveillance et métriques

BentoML expose les 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 l'envoi
)

Dépannage

Le service ne démarre pas

ERREUR - Échec de l'initialisation du Runner

Solutions :

Vérifiez la disponibilité de CUDA : python -c "import torch; print(torch.cuda.is_available())"
Vérifiez la VRAM du GPU : nvidia-smi
Vérifiez que le téléchargement du modèle est terminé (cherchez la progression du téléchargement dans les journaux)

Port 3000 inaccessible

# Assurez-vous que le service se lie à 0.0.0.0 (et non à localhost)
bentoml serve service:svc --host 0.0.0.0 --port 3000

Latence élevée lors de 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 à un point de terminaison de warm-up après le démarrage :

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

Erreurs d'importation

ModuleNotFoundError: Aucun module nommé 'transformers'

Solution :

pip install transformers accelerate

Recommandations GPU Clore.ai

BentoML est un framework de service — 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 du LLM (7B Q4)

Diffusion (SDXL)

Vision (ResNet50)

RTX 3090

24 Go

0,07–0,21 $/h

~80 tok/s

~4 img/min

~400 req/s

RTX 4090

24 Go

0,14–0,42 $/h

~140 tok/s

~8 img/min

~700 req/s

A100 40 Go

40 Go

bare metal

~110 tok/s

~6 img/min

~1200 req/s

A100 80 Go

80 Go

bare metal

~130 tok/s

~7 img/min

~1400 req/s

Conseils d'utilisation :

Service d'API LLM (7B–13B) : RTX 3090 (0,07–0,21 $/h) — rapport qualité-prix optimal
API de génération d'images : RTX 3090 ou RTX 4090 selon les besoins en débit
Grands modèles (34B–70B Q4) : A100 40 Go (bare metal) — tient largement
Service multi-modèles en production : A100 80 Go pour une marge mémoire

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

Ressources utiles

PrécédentServeur d'inférence Triton

SuivantClearML

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?