BentoML

BentoML является современной open-source платформой для создания, доставки и масштабирования AI-приложений. Она устраняет разрыв между экспериментами в ML и продакшн-развертыванием, позволяя за минуты упаковать любую модель из любого фреймворка в готовый к продакшну API-сервис. Запускайте BentoML в GPU-облаке Clore.ai для экономичного хостинга AI-приложений.

Что такое BentoML?

BentoML упрощает превращение обученной модели в масштабируемый API-сервис:

Независим от фреймворка: PyTorch, TensorFlow, JAX, scikit-learn, HuggingFace, XGBoost, LightGBM и другие
Bento: Самодостаточный, воспроизводимый артефакт (модель + код + зависимости)
Runner: Масштабируемый модуль инференса модели с автоматическим батчингом
Service: HTTP/gRPC-сервис в стиле FastAPI
BentoCloud: Опциональная управляемая платформа развертывания
Сначала Docker: Любой Bento можно контейнеризировать одной командой

Ключевые возможности:

Адаптивный микробатчинг для оптимизации пропускной способности
Встроенная валидация входа/выхода с Pydantic
OpenAPI-спецификация генерируется автоматически
Метрики Prometheus встроены
Поддержка потоковой передачи ответа (LLM)

Предварительные требования

Требование

Минимум

Рекомендуется

VRAM GPU

8 ГБ

16–24 ГБ

GPU

Любой NVIDIA

RTX 4090 / A100

ОЗУ

8 ГБ

16 ГБ

Хранилище

20 ГБ

40 ГБ

Python

3.9+

3.11+

Шаг 1 — Арендуйте GPU на Clore.ai

Войдите в маркетплейсе clore.ai.
Нажмите Маркетплейс и выберите GPU-инстанс с ≥ 16 ГБ VRAM.
Установите Docker-образ: мы будем использовать пользовательскую сборку (см. Шаг 2).
Откройте порты: 22 (SSH) и 3000 (сервис BentoML).
Нажмите Аренда.

Шаг 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 не предоставляет официальный GPU Docker-образ на Docker Hub. Образы bentoml/bento-server на Docker Hub предназначены для обслуживания заранее упакованных Bentos и не включают поддержку CUDA. Соберите образ из файла Dockerfile выше для развертываний с GPU на Clore.ai.

Шаг 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,
)

# Определите Service
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 "Это облачный сервис GPU потрясающий!"

Ожидаемый ответ:

{"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"Модель сохранена: {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())"
Проверьте VRAM GPU: nvidia-smi
Проверьте, что загрузка модели завершена (ищите прогресс загрузки в логах)

Порт 3000 недоступен

# Убедитесь, что сервис привязан к 0.0.0.0 (а не к localhost)
bentoml serve service:svc --host 0.0.0.0 --port 3000

Высокая задержка при первом запросе

Это нормально — первый запрос запускает загрузку модели (прогрев). Все последующие запросы будут быстрыми. Добавьте вызов endpoint для прогрева после запуска:

# Прогрев после запуска
sleep 10 && curl -s -o /dev/null http://localhost:3000/healthz

Ошибки импорта

ModuleNotFoundError: No module named 'transformers'

Решение:

pip install transformers accelerate

Полезные ресурсы

ПредыдущаяTriton Inference Server

СледующаяClearML

Последнее обновление 1 месяц назад

Это было полезно?