Skip to main content
Join the official 2020 Python Developers SurveyStart the survey!

An open-source platform for machine learning model serving.

Project description

pypi status python versions Downloads build status Documentation Status join BentoML Slack

BentoML

BentoML is an open-source platform for high-performance ML model serving.

What does BentoML do?

  • Turn your ML model into production API endpoint with just a few lines of code
  • Support all major machine learning training frameworks
  • End-to-end model serving solution with DevOps best practices baked in
  • Model server with Adaptive micro-batching support, bringing the advantage of batch processing to online serving
  • Model management for teams, providing CLI access and Web UI dashboard
  • Flexible model deployment orchestration with support for Docker, Kubernetes, KFserving, AWS Lambda, SageMaker, Azure and more

👉 Join BentoML Slack community to hear about the latest development updates.


Why BentoML

Getting Machine Learning models into production is hard. Data Scientists are not experts in building production services and DevOps best practices. The trained models produced by a Data Science team are hard to test and hard to deploy. This often leads us to a time consuming and error-prone workflow, where a pickled model or weights file is handed over to a software engineering team.

BentoML is an end-to-end solution for model serving, making it possible for Data Science teams to build production-ready model serving endpoints, with common DevOps best practices and performance optimizations baked in.

👉 Check out Frequently Asked Questions

Getting Started

Installing BentoML with pip:

pip install bentoml

A minimal prediction service in BentoML looks something like this:

from bentoml import env, artifacts, api, BentoService
from bentoml.handlers import DataframeHandler
from bentoml.artifact import SklearnModelArtifact

@env(auto_pip_dependencies=True)
@artifacts([SklearnModelArtifact('model')])
class IrisClassifier(BentoService):

    @api(DataframeHandler)
    def predict(self, df):
        return self.artifacts.model.predict(df)

This code defines a prediction service that requires a scikit-learn model, and asks BentoML to figure out the required PyPI pip packages automatically. It also defined an API, which is the entry point for accessing this prediction service. And the API is expecting a pandas.DataFrame object as its input data.

Now you are ready to train a model and serve the model with the IrisClassifier service defined above. Save the above code to a new file iris_classifier.py and run the following code:

from sklearn import svm
from sklearn import datasets

from iris_classifier import IrisClassifier

if __name__ == "__main__":
    # Load training data
    iris = datasets.load_iris()
    X, y = iris.data, iris.target

    # Model Training
    clf = svm.SVC(gamma='scale')
    clf.fit(X, y)

    # Create a iris classifier service instance
    iris_classifier_service = IrisClassifier()

    # Pack the newly trained model artifact
    iris_classifier_service.pack('model', clf)

    # Save the prediction service to disk for model serving
    saved_path = iris_classifier_service.save()

You've just created a BentoService SavedBundle, it's a versioned file archive that is ready for production deployment. It contains the BentoService class you defined, all its python code dependencies and PyPI dependencies, and the trained scikit-learn model. By default, BentoML saves those files and related metadata under ~/bentoml directory, but this is easily customizable to a different directory or cloud storage like Amazon S3.

You can now start a REST API server by specifying the BentoService's name and version, or provide the file path to the saved bundle:

bentoml serve IrisClassifier:latest

Alternatively, in bash command line, you can get the absolute path to the saved BentoService from the JSON output of bentoml get command:

saved_path=$(bentoml get IrisClassifier:latest -q | jq -r ".uri.uri")
bentoml serve $saved_path

The REST API server provides web UI for testing and debugging the server. If you are running this command on your local machine, visit http://127.0.0.1:5000 in your browser and try out sending API request to the server. You can also send prediction request with curl from command line:

curl -i \
  --header "Content-Type: application/json" \
  --request POST \
  --data '[[5.1, 3.5, 1.4, 0.2]]' \
  http://localhost:5000/predict

The BentoService SavedBundle directory is structured to work as a docker build context, that can be used to build a API server docker container image:

docker build -t my-org/iris-classifier:v1 $saved_path

docker run -p 5000:5000 -e BENTOML_ENABLE_MICROBATCH=True my-org/iris-classifier:v1

You can also deploy your BentoService directly to cloud services such as AWS Lambda with bentoml CLI's deployment management commands:

> bentoml get IrisClassifier
BENTO_SERVICE                         CREATED_AT        APIS                       ARTIFACTS
IrisClassifier:20200121114004_360ECB  2020-01-21 19:40  predict<DataframeHandler>  model<SklearnModelArtifact>
IrisClassifier:20200120082658_4169CF  2020-01-20 16:27  predict<DataframeHandler>  clf<PickleArtifact>
...

> bentoml lambda deploy test-deploy -b IrisClassifier:20200121114004_360ECB
...

> bentoml deployment list
NAME           NAMESPACE    PLATFORM    BENTO_SERVICE                         STATUS    AGE
test-deploy    dev          aws-lambda  IrisClassifier:20200121114004_360ECB  running   2 days and 11 hours
...

Documentation

BentoML full documentation can be found here: https://docs.bentoml.org/

Examples

Visit bentoml/gallery repository for more examples and tutorials.

FastAI

Scikit-Learn

PyTorch

Tensorflow Keras

Tensorflow 2.0

XGBoost

LightGBM

H2O

Deployment guides:

Contributing

Have questions or feedback? Post a new github issue or discuss in our Slack channel: join BentoML Slack

Want to help build BentoML? Check out our contributing guide and the development guide.

Releases

BentoML is under active development and is evolving rapidly. Currently it is a Beta release, we may change APIs in future releases.

Read more about the latest features and changes in BentoML from the releases page.

Usage Tracking

BentoML by default collects anonymous usage data using Amplitude. It only collects BentoML library's own actions and parameters, no user or model data will be collected. Here is the code that does it.

This helps BentoML team to understand how the community is using this tool and what to build next. You can easily opt-out of usage tracking by running the following command:

# From terminal:
bentoml config set usage_tracking=false
# From python:
import bentoml
bentoml.config().set('core', 'usage_tracking', 'False')

License

Apache License 2.0

FOSSA Status

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for BentoML, version 0.7.4
Filename, size File type Python version Upload date Hashes
Filename, size BentoML-0.7.4-py3-none-any.whl (3.0 MB) File type Wheel Python version py3 Upload date Hashes View
Filename, size BentoML-0.7.4.tar.gz (2.6 MB) File type Source Python version None Upload date Hashes View

Supported by

Pingdom Pingdom Monitoring Google Google Object Storage and Download Analytics Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page