Get Started

Just replace the line saving the model with a call to mlem.api.save:

from mlem.api import save
...

# instead of joblib.dump(rf, "models/rf")
save(rf, "models/rf", sample_data=df)

The sample_data argument will prove useful later when serving the model. MLEM uses it to infer the data schema of the payload automatically!

You can use mlem.api.import_object() to "import" the object from Python code, which would create the the rf.mlem metadata file:

from mlem.api import import_object

model = import_object(path="models/rf", target="models/rf.mlem", type_="pickle")

or just use mlem import from your terminal for the same effect:

$ mlem import models/rf models/rf.mlem --type pickle

Learn more about importing models in the importing guide.

Let's load the model we saved earlier using mlem.api.load() and predict some probabilities.

Try creating and running this simple predict.py script:

from mlem.api import load

model = load("models/rf")  # RandomForestClassifier
features = [
    "sepal length (cm)",
    "sepal width (cm)",
    "petal length (cm)",
    "petal width (cm)",
]
df = pd.DataFrame([[0, 1, 2, 3]], columns=features)
y_pred = model.predict_proba(df)

print(y_pred)

The loaded object is fully functioning, and as expected, we get:

$ python predict.py
[[0.47 0.24 0.29]]

Use MLEM CLI to apply any local dataset against any model for prediction or batch scoring.

Let's create an example dataset file, we'll go with a csv format:

$ cat <<EOF > new_data.csv
sepal length (cm),sepal width (cm),petal length (cm),petal width (cm)
0,1,2,3
4,5,6,7
EOF

Next, simply run mlem apply to apply this dataset against our model's predict_proba method:

$ mlem apply models/rf new_data.csv \
    --method predict_proba \
    --import \
    --import-type "pandas[csv]"

And we get our expected probabilities as output:

⏳️ Importing object from new_data.csv
⏳️ Loading model from models/rf.mlem
🍏 Applying `predict_proba` method...
[[0.47, 0.24, 0.29], [0.03, 0.1, 0.87]]

Python requirements

pip install mlem[docker]

Deploying a Docker container

With one simple command, you can package your model+server into a Docker image, and run it in a container:

$ mlem deployment run docker_container docker_app.mlem \
    --model models/rf \
    --image_name mlem-rf-server \
    --server fastapi

The container is now running your model server, and you can open https://localhost:8080/docs in a browser, or query the model with curl / mlem apply-remote.

The above command will create a mlem-rf-server:latest Docker image, which can now be pushed to any container registry for publishing and distribution.

Removing the deployment

To remove the deployment, simply run:

mlem deployment remove docker_app.mlem

Python requirements

pip install mlem[heroku]

Deploying a Heroku app

To create applications on the Heroku platform you need a Heroku API key.

To allow MLEM to push the Docker image built to the Heroku Docker Registry, you'll also need to execute heroku container:login.

After getting authorized with Heroku, we can run the deployment command:

$ mlem deployment run heroku heroku_app.mlem \
  --model models/rf \
  --app_name {your-name}-mlem-get-started-app

Making requests

Your application is now live on Heroku! You can browse to this deployed example and see the same OpenAPI docs UI as you would see in your local or docker deployments. To learn how to easily send requests to your model with MLEM, refer to the deployment guide.

Removing the deployment

To remove the deployment, simply run:

mlem deployment remove heroku_app.mlem

Python requirements

pip install mlem[kubernetes]

Deploying on a Kubernetes cluster

If you have a K8s cluster available and properly configured (see prerequisites), MLEM will deploy your model to the cluster with a single command. This includes the following key steps:

• building a Docker image
• pushing it to the configured docker registry (this example uses dockerhub)
• creating the appropriate K8s resources to spin up your server on the cluster using the pushed image

Before running the MLEM command to deploy, we'll first have to docker login to the container registry to allow pushing the image there:

$ docker login docker.io/{username}
Username: ******
Password: ******
Login Succeeded

Great, we're ready to deploy the app:

$ mlem deployment run kubernetes k8s_app.mlem \
  --model models/rf \
  --registry remote \
  --registry.host=docker.io/{username} \
  --image_name mlem-rf-server \
  --namespace mlem

That's it! We're already up and running, check it out:

$ kubectl -n mlem get all
NAME                                  READY   STATUS    RESTARTS   AGE
pod/mlem-rf-server-6c9945bcdf-rh9fc   1/1     Running   0          71s

NAME                     TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/mlem-rf-server   NodePort   10.104.251.44   <none>        8080:32701/TCP   71s

NAME                             READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/mlem-rf-server   1/1     1            1           71s

NAME                                        DESIRED   CURRENT   READY   AGE
replicaset.apps/mlem-rf-server-6c9945bcdf   1         1         1       71s

To expose your model server for external requests, MLEM creates a NodePort service by default. You can use other service types using the --service_type option.

If you're running a local K8s cluster (e.g. Docker Desktop) for example, you'd be able to access the cluster network from your localhost interface, and your app would be available on http://localhost:31103, as seen in the service/mlem-rf-server resource above.

Removing the deployment

To remove the deployment, simply run:

mlem deployment remove k8s_app.mlem