# setup.cfg

[metadata]
name = app  # What name will we import our package under?
version = 0.1.0

[options]
package_dir =  # Where is the source code for the "app" package?
    app = app
install_requires =  # What dependencies do we need?
    anyio==3.6.2
    attrs==22.2.0
    ... # omitted

[options.package_data]
app = models/*  # Include non-Python files in app/models.

# pyproject.toml

[build-system]
requires = ["setuptools"]

>>> import requests
>>> response = requests.post(
...     "http://localhost:8000/predict",
...     json={
...         "sepal_width": 1,
...         "sepal_length": 1,
...         "petal_length": 1,
...         "petal_width": 1,
...     },
... )
>>> response.status_code
200
>>> response.json()
{'flower_type': 0}

# app/main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")  # Listen for GET method requests at "/" route
def status():
    """Check that the API is working."""
    return "the API is up and running!"  # Return this as response

$ uvicorn app.main:app --host 0.0.0.0 --port 8000

$ curl -X GET http://localhost:8000

>>> import httpx
>>> response = httpx.get("http://localhost:8000")

>>> response
<Response [200 OK]>

>>> response.json()
'the API is up and running!'

# tests/test_addition.py

def test_addition_of_2_and_2():
    result = 2 + 2
    assert result == 4

# tests/conftest.py

import pytest
from fastapi.testclient import TestClient

from app.main import app


@pytest.fixture
def client() -> TestClient:
    return TestClient(app)

# tests/test_app.py

from fastapi.testclient import TestClient


def test_status_endpoint(client: TestClient):
    response = client.get("/")
    # 200 is the standard code for "success"
    assert response.status_code == 200

    # response.json() turns the response into Python objects
    payload = response.json()
    assert payload == "the API is up and running!"

@app.get("/")  # Listen for GET method requests at "/" route
def status():
    """Check that the API is working."""
    return "the API is up and running!"  # Return this as response

def predict(observation):
    """Return a prediction for the given observation."""
    prediction = mymodel.predict(observation)
    return prediction

from pydantic import BaseModel

class Observation(BaseModel):
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

from pydantic import BaseModel

class Observation(BaseModel):
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

>>> obs = Observation(sepal_length=1.4, sepal_width=2, petal_length=3.3, petal_width=4)

>>> obs

Observation(sepal_length=1.4, sepal_width=2.0, petal_length=3.3, petal_width=4.0)

>>> obs = Observation(sepal_length=1.4, sepal_width=2, petal_length=3.3, petal_width="abc")

ValidationError: 1 validation error for Observation
petal_width
  value is not a valid float (type=type_error.float)

from typing import Literal

class Prediction(BaseModel):
    flower_type: Literal["setosa", "versicolor", "virginica"]

# app/pydantic_models.py

from typing import Literal
from pydantic import BaseModel

class Observation(BaseModel):
    """An observation of a flower's measurements."""
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

class Prediction(BaseModel):
    """A prediction of the species of a flower."""
    flower_type: Literal["setosa", "versicolor", "virginica"]

# app/main.py

from .pydantic_models import Observation, Prediction

@app.post("/predict", status_code=201)
def predict(obs: Observation) -> Prediction:
    """For now, just return a dummy prediction."""
    return Prediction(flower_type="setosa")

# tests/test_app.py

def test_predict(client: TestClient):
    response = client.post(
        "/predict",
        # We pass observation data as a dictionary.
        json={
            "sepal_length": 5.1,
            "sepal_width": 3.5,
            "petal_length": 1.4,
            "petal_width": 0.2,
        },
    )
    assert response.status_code == 201
    payload = response.json()
    # For now, our fake endpoint always predicts "setosa".
    assert payload["flower_type"] == "setosa"

# app/main.py
...

import importlib
import pickle
from sklearn.linear_model import LogisticRegression

def load_model(model_name: str) -> LogisticRegression:
    with importlib.resources.open_binary("app.models", model_name) as f:
        model = pickle.load(f)
    return model

@app.get("/")
def status():
    """Check that the API is working."""
    return "the API is up and running!"

# app/main.py
...

import importlib
import pickle
from sklearn.linear_model import LogisticRegression

def load_model(model_name: str) -> LogisticRegression:
    with importlib.resources.open_binary("app.models", model_name) as f:
        model = pickle.load(f)
    return model

MODEL_NAME = "iris_regression.pickle"
model = load_model(MODEL_NAME)
app = FastAPI()

@app.get("/")
def status():
    """Check that the API is working."""
    return "the API is up and running!"

>>> model = load_model("iris_regression.pickle")
>>> model
LogisticRegression(max_iter=1000)

>>> import pandas as pd
>>> observation = pd.Series({
...     "sepal length (cm)": 1,
...     "sepal width (cm)": 2,
...     "petal length (cm)": 3,
...     "petal width (cm)": 4,
... })
>>> observation
sepal length (cm)    1
sepal width (cm)     2
petal length (cm)    3
petal width (cm)     4
dtype: int64

>>> observation
sepal length (cm)    1
sepal width (cm)     2
petal length (cm)    3
petal width (cm)     4
dtype: int64
>>> model.predict(observation)
/Users/eswan18/Develop/sklearn-api-deploy/.venv/lib/python3.10/site-packages/sklearn/base.py:439: UserWarning: X does not have valid feature names, but LogisticRegression was fitted with feature names
  warnings.warn(
Traceback (most recent call last):
  <...omitted...>
  ValueError: Expected 2D array, got 1D array instead:
array=[1 2 3 4].
Reshape your data either using array.reshape(-1, 1) if your data has a single feature or array.reshape(1, -1) if it contains a single sample.

>>> obs_df = pd.DataFrame([observation])
>>> obs_df
   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
0                  1                 2                  3                 4
>>> predictions = model.predict(obs_df)
>>> predictions
array([2])

>>> predictions
array([2])
>>> obs_prediction = predictions[0] 
>>> obs_prediction
2

@app.post("/predict", status_code=201)
def predict(obs: Observation) -> Prediction:
    """For now, just return a dummy prediction."""
    return Prediction(flower_type="setosa")

CLASS_FLOWER_MAPPING = {
    0: 'setosa',
    1: 'versicolor',
    2: 'virginica',
}

@app.post("/predict", status_code=201)
def predict(obs: Observation) -> Prediction:
    """For now, just return a dummy prediction."""
    # .predict() gives us an array, but it has only one element
    prediction = model.predict(obs.as_dataframe())[0]
    flower_type = CLASS_FLOWER_MAPPING[prediction]
    pred = Prediction(flower_type=flower_type)
    return pred

import pandas as pd

class Observation(BaseModel):
    """An observation of a flower's measurements."""
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float

    def as_dataframe(self) -> pd.DataFrame:
        """Convert this record to a DataFrame with one row."""
        return pd.DataFrame([self.as_row()])

    def as_row(self) -> pd.Series:
        row = pd.Series({
            "sepal length (cm)": self.sepal_length,
            "sepal width (cm)": self.sepal_width,
            "petal length (cm)": self.petal_length,
            "petal width (cm)": self.petal_width,
        })
        return row

$ curl -X POST localhost:8000/predict \
    -d '{"sepal_length": 1, "sepal_width": 2, "petal_length": 3, "petal_width": 4}' \
    -H "Content-Type: application/json"

def test_predict(client: TestClient):
    # Test an obs that should come back as setosa
    response = client.post(
        "/predict",
        json={
            "sepal_length": 5.1,
            "sepal_width": 3.5,
            "petal_length": 1.4,
            "petal_width": 0.2,
        },
    )
    assert response.status_code == 201
    payload = response.json()
    assert payload["flower_type"] == "setosa"

    # Test an obs that should come back as versicolor
    response = client.post(
        "/predict",
        json={
            "sepal_length": 7.1,
            "sepal_width": 3.5,
            "petal_length": 3.0,
            "petal_width": 0.8,
        },
    )
    assert response.status_code == 201
    payload = response.json()
    assert payload["flower_type"] == "versicolor"

Deploying a Model Prediction Server¶

Welcome!¶

Today's goal¶

First: say hi to your neighbors!¶

About me¶

Day job¶

Outside teaching and consulting¶

Find me online¶

Agenda¶

About this tutorial¶

Resources¶

Slides¶

Application Code¶

Incremental Diffs¶

Setting up your project workspace¶

Goals¶

Getting started¶

Project layout¶

Project layout¶

Downloading GitHub files¶

setup.cfg¶

pyproject.toml¶

Readmes¶

Readmes¶

Iris Prediction API¶

Fetching Predictions¶

Virtual environments¶

Creating virtual environments¶

Trying it out¶

❗ To-Do List ❗¶

A "hello world" FastAPI app¶

Goals¶

Web APIs¶

HTTP¶

Web API complications¶

FastAPI¶

A simple FastAPI app¶

Running the app¶

Testing our app¶

Pytest¶

Pytest Fixtures¶

Pytest Fixtures¶

Testing our status endpoint¶

Running tests¶

❗ To-Do List ❗¶

Pydantic models and payloads¶

Goals¶

An endpoint with inputs¶

An endpoint with inputs¶

Pydantic models¶

Observation model¶

Pydantic and type annotations¶

Valid Pydantic types¶

Prediction model¶

A predict endpoint¶

Updating our tests¶

❗ To-Do List ❗¶

Connecting our model to the API¶

Goals¶

Loading our model¶

Loading our model¶

Loading in global scope¶

Predictions¶

Adding this to our /predict code.¶

Updating our test¶

❗ To-Do List ❗¶

Stretch goal: batch prediction¶

Questions¶

Other topics¶

Managing application and dependencies¶

Model storage formats¶

Alternatives to API-based deployment¶

Thorough testing¶

Authentication¶

Deploying an API¶

`setup.cfg`¶

`pyproject.toml`¶

`Observation` model¶

`Prediction` model¶

A `predict` endpoint¶

Adding this to our `/predict` code.¶