BentoML

BentoML es un marco moderno de código abierto para crear, desplegar y escalar aplicaciones de IA. Une la brecha entre la experimentación con ML y el despliegue en producción, permitiéndote empaquetar cualquier modelo de cualquier framework en un servicio API listo para producción en minutos. Ejecuta BentoML en la nube de GPU de Clore.ai para un alojamiento rentable de aplicaciones de IA.

---

¿Qué es BentoML?

BentoML facilita tomar un modelo entrenado y convertirlo en un servicio API escalable:

• Independiente del framework: PyTorch, TensorFlow, JAX, scikit-learn, HuggingFace, XGBoost, LightGBM y más

• Bento: Un artefacto autónomo y reproducible (modelo + código + dependencias)

• Runner: Unidad de inferencia de modelo escalable con procesamiento por lotes automático

• Servicio: Definición de servicio HTTP/gRPC similar a FastAPI

• BentoCloud: Plataforma de despliegue gestionada opcional

• Primero Docker: Cada Bento puede convertirse en contenedor con un solo comando

Características principales:

• Micro-lotes adaptativos para optimización del rendimiento

• Validación integrada de entrada/salida con Pydantic

• Especificación OpenAPI generada automáticamente

• Métricas de Prometheus integradas

• Compatibilidad con respuestas en streaming (LLMs)

---

Requisitos previos

Requisito	Mínimo	Recomendado
VRAM de GPU	8 GB	16–24 GB
GPU	Cualquier NVIDIA	RTX 4090 / A100
RAM	8 GB	16 GB
Almacenamiento	20 GB	40 GB
Python	3.9+	3.11+

---

Paso 1 — Alquila una GPU en Clore.ai

1. Inicia sesión en clore.ai.

2. Haz clic en Marketplace y selecciona una instancia de GPU con ≥ 16 GB de VRAM.

3. Establece la imagen Docker: usaremos una compilación personalizada (ver Paso 2).

4. Establece los puertos abiertos: 22 (SSH) y 3000 (servicio BentoML).

5. Haz clic en Alquilar.

---

Paso 2 — Dockerfile

BentoML no tiene una imagen Docker oficial para GPU, así que construimos una:

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

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

# Instalar BentoML y bibliotecas comunes de 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

Construir y subir

Construye la imagen y súbela a tu propia cuenta de Docker Hub (reemplaza YOUR_DOCKERHUB_USERNAME con tu nombre de usuario real):

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

BentoML no proporciona una imagen Docker oficial de GPU en Docker Hub. Las bentoml/bento-server imágenes en Docker Hub son para servir Bentos preempaquetados y no incluyen compatibilidad con CUDA. Construye la imagen a partir del Dockerfile anterior para despliegues con GPU en Clore.ai.

---

Paso 3 — Conéctate por SSH

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

Verifica BentoML:

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

---

Paso 4 — Tu primer servicio BentoML

Clasificador de texto simple

Crea un archivo de servicio:

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

# Define un Runner (la unidad del modelo)
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(
            "clasificación de texto",
            "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

# Crear Runner
classifier_runner = bentoml.Runner(
    TextClassifierRunnable,
    name="text_classifier",
    max_batch_size=32,
    max_latency_ms=100,
)

# Definir el servicio
svc = bentoml.Service(
    name="text_classifier_service",
    runners=[classifier_runner],
)

@svc.api(input=Text(), output=JSON())
async def classify(text: str) -> dict:
    """Clasifica el sentimiento del texto de entrada."""
    results = await classifier_runner.classify.async_run([text])
    return results[0]
EOF

Inicia el servicio

cd /workspace/my-service

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

El --reload El indicador habilita la recarga en caliente durante el desarrollo. Elimínalo en producción para mayor estabilidad.

---

Paso 5 — Accede al servicio

Abre la UI Swagger generada automáticamente:

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

O prueba mediante curl:

curl -X POST http://<clore-host>:<public-port-3000>/classify \
    -H "Content-Type: text/plain" \
    -d "¡Este servicio de nube GPU es increíble!"

Respuesta esperada:

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

---

Paso 6 — Servicio de clasificación de imágenes

Servicio de modelo de visión

# /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({
                "predicciones": [
                    {"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:
    """Clasifica una imagen con ResNet50."""
    results = await image_runner.predict.async_run([image])
    return results[0]

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

Prueba con una imagen:

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

---

Paso 7 — Servicio de streaming de LLM

Para modelos de lenguaje con respuestas 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)

---

Paso 8 — Guarda y construye un Bento

Un Bento es un artefacto empaquetado y reproducible:

# /workspace/build_bento.py
import bentoml

# Guarda el modelo en el almacén de modelos de 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

# Lista los modelos guardados
bentoml models list

# Construye un Bento (requiere 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

# Lista los bentos construidos
bentoml list

# Convierte en contenedor
bentoml containerize image_classifier_service:latest \
    --image-tag YOUR_DOCKERHUB_USERNAME/my-bento:latest

---

Monitorización y métricas

BentoML expone métricas de Prometheus en /metrics:

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

Métricas clave:

# Tasa de solicitudes
bentoml_service_request_total{endpoint="classify", http_status_code="200"}
# Latencia
bentoml_service_request_duration_seconds{endpoint="classify"}
# Rendimiento del Runner  
bentoml_runner_request_total{runner_name="image_classifier"}

---

Configuración de agrupación adaptativa

# Ajusta el comportamiento de la agrupación
image_runner = bentoml.Runner(
    ImageClassifierRunnable,
    name="image_classifier",
    max_batch_size=64,          # Máx. solicitudes por lote
    max_latency_ms=50,          # Máx. espera antes del envío
)

---

Solución de problemas

El servicio no inicia

ERROR - No se pudo inicializar el runner

Soluciones:

• Comprueba la disponibilidad de CUDA: python -c "import torch; print(torch.cuda.is_available())"

• Verifica la VRAM de la GPU: nvidia-smi

• Comprueba que la descarga del modelo se completó (busca el progreso de descarga en los registros)

Puerto 3000 no accesible

# Asegúrate de que el servicio se enlace a 0.0.0.0 (no localhost)
bentoml serve service:svc --host 0.0.0.0 --port 3000

Alta latencia en la primera solicitud

Esto es normal: la primera solicitud activa la carga del modelo (calentamiento). Todas las solicitudes posteriores serán rápidas. Añade una llamada al endpoint de calentamiento después del inicio:

# Calentar tras iniciar
sleep 10 && curl -s -o /dev/null http://localhost:3000/healthz

Errores de importación

ModuleNotFoundError: No module named 'transformers'

Solución:

pip install transformers accelerate

---

Recomendaciones de GPU para Clore.ai

BentoML es un framework de servicio; los requisitos de GPU dependen totalmente del modelo que despliegues. Esto es lo que puedes esperar para cargas de trabajo comunes:

GPU	VRAM	Precio de Clore.ai	Rendimiento de LLM (7B Q4)	Difusión (SDXL)	Visión (ResNet50)
RTX 3090	24 GB	$0.07–0.21/h	~80 tok/s	~4 img/min	~400 req/s
RTX 4090	24 GB	$0.14–0.42/h	~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

Guía de casos de uso:

• Servicio de API LLM (7B–13B): RTX 3090 ($0.07–0.21/h) — relación precio-rendimiento óptima

• APIs de generación de imágenes: RTX 3090 o RTX 4090 según las necesidades de rendimiento

• Modelos grandes (34B–70B Q4): A100 40GB (bare metal) — cabe cómodamente

• Servicio multmodelo en producción: A100 80GB para margen de memoria

La microagrupación adaptativa de BentoML es especialmente eficaz en A100: el programador de hardware maneja las agrupaciones eficientemente, extrayendo más rendimiento por dólar que un servicio ingenuo de una sola solicitud. Para APIs con mucho tráfico, A100 40GB a menudo ofrece mejor ROI que dos RTX 4090.

---

Recursos útiles

• Documentación oficial de BentoML

• GitHub de BentoML

• Ejemplos de BentoML

• Comunidad Discord de BentoML

• Galería de BentoML

• Inicio rápido: Servir LLMs