A minimalist framework for online deployment of sklearn-like models
pip install modelib
The modelib package provides a simple interface to deploy and serve models online. The package is designed to be used with the fastapi package, and supports serving models that are compatible with the sklearn package.
First, you will need to create a model that is compatible with the sklearn package. For example, let's create a simple RandomForestClassifier model with a StandardScaler preprocessor:
MODEL = Pipeline(
[
("scaler", StandardScaler()),
("clf", RandomForestClassifier(random_state=42)),
]
).set_output(transform="pandas")
Let's assume that you have a dataset with the following columns:
request_model = [
{"name": "sepal length (cm)", "dtype": "float64"},
{"name": "sepal width (cm)", "dtype": "float64"},
{"name": "petal length (cm)", "dtype": "float64"},
{"name": "petal width (cm)", "dtype": "float64"},
]
Alternatively, you can use a pydantic model to define the request model, where the alias field is used to match the variable names with the column names in the training dataset:
class InputData(pydantic.BaseModel):
sepal_length: float = pydantic.Field(alias="sepal length (cm)")
sepal_width: float = pydantic.Field(alias="sepal width (cm)")
petal_length: float = pydantic.Field(alias="petal length (cm)")
petal_width: float = pydantic.Field(alias="petal width (cm)")
request_model = InputData
After the model is created and trained, you can create a modelib runner for this model as follows:
import modelib as ml
simple_runner = ml.SklearnRunner(
name="my simple model",
predictor=MODEL,
method_name="predict",
request_model=request_model,
)
Another option is to use the SklearnPipelineRunner
class which allows you to get all the outputs of the pipeline:
pipeline_runner = ml.SklearnPipelineRunner(
"Pipeline Model",
predictor=MODEL,
method_names=["transform", "predict"],
request_model=request_model,
)
Now you can create a FastAPI app with the runners:
app = ml.init_app(runners=[simple_runner, pipeline_runner])
You can also pass an existing FastAPI app to the init_app
function:
import fastapi
app = fastapi.FastAPI()
app = ml.init_app(app=app, runners=[simple_runner, pipeline_runner])
The init_app
function will add the necessary routes to the FastAPI app to serve the models. You can now start the app with:
uvicorn <replace-with-the-script-filename>:app --reload
After the app is running you can check the created routes in the Swagger UI at the /docs
endpoint.
The created routes expect a JSON payload with the features as keys and the values as the input to the model. For example, to make a prediction with the simple model runner you can send a POST request to the /my-simple-model
endpoint with the following payload:
{
"sepal length (cm)": 5.1,
"sepal width (cm)": 3.5,
"petal length (cm)": 1.4,
"petal width (cm)": 0.2
}
The response will be a JSON with the prediction:
{
"result": 0
}
If you want to contribute to the project, please read the CONTRIBUTING.md file for more information.