Ein praktischer Leitfaden zur Bereitstellung von Modellen für maschinelles Lernen

Als Datenwissenschaftler wissen Sie wahrscheinlich, wie man Modelle für maschinelles Lernen erstellt. Aber erst wenn Sie das Modell bereitstellen, erhalten Sie eine nützliche Lösung für maschinelles Lernen. Und wenn Sie mehr über die Bereitstellung von Modellen für maschinelles Lernen erfahren möchten, ist dieser Leitfaden genau das Richtige für Sie.

Die Schritte zum Erstellen und Bereitstellen von ML-Modellen lassen sich normalerweise wie folgt zusammenfassen: Erstellen des Modells, Erstellen einer API zur Bereitstellung von Modellvorhersagen, Containerisieren der API und Bereitstellen in der Cloud.

Dieser Leitfaden konzentriert sich auf Folgendes:

  • Erstellen eines Modells für maschinelles Lernen mit Scikit-learn
  • Erstellen einer REST-API, um mithilfe von FastAPI Vorhersagen aus dem Modell bereitzustellen
  • Containerisieren der API mit Docker

Wir werden ein einfaches Regressionsmodell auf der Grundlage des kalifornischen Immobiliendatensatzes erstellen, um die Immobilienpreise vorherzusagen. Am Ende verfügen Sie über eine Containeranwendung, die Immobilienpreisvorhersagen basierend auf ausgewählten Eingabefunktionen liefert.

Einrichten der Projektumgebung

Bevor Sie beginnen, stellen Sie sicher, dass Folgendes installiert ist:

  • Eine aktuelle Version von Python (vorzugsweise Python 3.11 oder höher)
  • Docker für Containerisierung; Holen Sie sich Docker für Ihr Betriebssystem

⚙️ Um problemlos mitmachen zu können, ist es hilfreich, ein grundlegendes Verständnis für die Erstellung von Modellen für maschinelles Lernen und die Arbeit mit APIs zu haben.

Erste Schritte

Hier ist die (empfohlene) Struktur für das Projektverzeichnis:

project-dir/
│
├── app/
│   ├── __init__.py       	# Empty file
│   └── main.py           	# FastAPI code for prediction API
│
├── model/
│   └── linear_regression_model.pkl  # Saved trained model (after running model_training.py)
│
├── model_training.py      	# Script to train and save the model
├── requirements.txt       	# Dependencies for the project
└── Dockerfile             	# Docker configuration

Wir benötigen ein paar Python-Bibliotheken, um loszulegen. Als nächstes installieren wir sie alle.

Erstellen und aktivieren Sie in Ihrer Projektumgebung eine virtuelle Umgebung:

$ python3 -m venv v1
$ source v1/bin/activate

Für das Projekt, an dem wir arbeiten werden, benötigen wir Pandas und Scikit-Learn, um das Modell für maschinelles Lernen zu erstellen. Und FastAPI und Uvicorn bauen die API auf, um die Vorhersagen des Modells zu unterstützen.

Lassen Sie uns also diese erforderlichen Pakete mit pip installieren:

$ pip3 install pandas scikit-learn fastapi uvicorn

Den gesamten Code für dieses Tutorial finden Sie auf GitHub.

Erstellen eines Modells für maschinelles Lernen

Jetzt trainieren wir ein lineares Regressionsmodell mithilfe des California Housing-Datensatzes, der in scikit-learn integriert ist. Dieses Modell wird die Immobilienpreise basierend auf den ausgewählten Merkmalen vorhersagen. Erstellen Sie im Projektverzeichnis eine Datei mit dem Namen model_training.py:

# model_training.py
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
import pickle
import os

# Load the dataset
data = fetch_california_housing(as_frame=True)
df = data['data']
target = data['target']

# Select a few features
selected_features = ['MedInc', 'AveRooms', 'AveOccup']
X = df[selected_features]
y = target

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Train the Linear Regression model
model = LinearRegression()
model.fit(X_train, y_train)

# Create a 'model' folder to save the trained model
os.makedirs('model', exist_ok=True)

# Save the trained model using pickle
with open('model/linear_regression_model.pkl', 'wb') as f:
	pickle.dump(model, f)

print("Model trained and saved successfully.")

Dieses Skript lädt den kalifornischen Wohnungsdatensatz, wählt drei Funktionen aus (MedInc, AveRooms, AveOccup), trainiert ein lineares Regressionsmodell und speichert es im Ordner model/ als linear_regression_model.pkl.

Hinweis: Der Einfachheit halber haben wir nur einen kleinen Teil der Funktionen verwendet. Sie können jedoch versuchen, weitere hinzuzufügen.

Führen Sie das Skript aus, um das Modell zu trainieren und zu speichern:

$ python3 model_training.py

Sie erhalten die folgende Meldung und sollten die .pkl-Datei im Verzeichnis model/ finden können:

Model trained and saved successfully.

Erstellen der FastAPI-App

Wir erstellen jetzt eine API, die Vorhersagen mithilfe von FastAPI bereitstellt.

Erstellen Sie im Ordner app/ zwei Dateien: __init__.py (leer) und main.py. Wir tun dies, weil wir als Nächstes die FastAPI-App mithilfe von Docker containerisieren möchten.

Schreiben Sie in main.py den folgenden Code:

# app/main.py
from fastapi import FastAPI
from pydantic import BaseModel
import pickle
import os

# Define the input data schema using Pydantic
class InputData(BaseModel):
    MedInc: float
    AveRooms: float
    AveOccup: float

# Initialize FastAPI app
app = FastAPI(title="House Price Prediction API")

# Load the model during startup
model_path = os.path.join("model", "linear_regression_model.pkl")
with open(model_path, 'rb') as f:
    model = pickle.load(f)

@app.post("/predict")
def predict(data: InputData):
    # Prepare the data for prediction
    input_features = [[data.MedInc, data.AveRooms, data.AveOccup]]
    
    # Make prediction using the loaded model
    prediction = model.predict(input_features)
    
    # Return the prediction result
    return {"predicted_house_price": prediction[0]}

Diese FastAPI-Anwendung stellt einen /predict-Endpunkt bereit, der drei Funktionen benötigt (MedInc, AveRooms, AveOccup). Es verwendet das trainierte Modell, um Immobilienpreise vorherzusagen, und gibt den vorhergesagten Preis zurück.

Containerisierung der App mit Docker

Lassen Sie uns nun unsere FastAPI-Anwendung in einen Container umwandeln. Erstellen Sie im Stammverzeichnis des Projekts eine Dockerfile- und eine requirements.txt-Datei.

Erstellen der Docker-Datei

Lassen Sie uns eine Docker-Datei erstellen:

# Use Python 3.11 as the base image
FROM python:3.11-slim

# Set the working directory inside the container
WORKDIR /code

# Copy the requirements file
COPY ./requirements.txt /code/requirements.txt

# Install the Python dependencies
RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt

# Copy the app folder into the container
COPY ./app /code/app

# Copy the model directory (with the saved model file) into the container
COPY ./model /code/model

# Expose port 80 for FastAPI
EXPOSE 80

# Command to run the FastAPI app with Uvicorn
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]

Dadurch wird ein leichter Container für eine FastAPI-Anwendung erstellt, der Python 3.11 (Slim-Version) als Basis-Image verwendet. Es legt das Arbeitsverzeichnis auf /code fest, kopiert die Datei requirements.txt in den Container und installiert die erforderlichen Python-Abhängigkeiten ohne Zwischenspeicherung.

Anschließend werden die FastAPI-App und die Modelldateien in den Container kopiert. Port 80 ist für die Anwendung verfügbar und Uvicorn wird zum Ausführen der FastAPI-App verwendet. Dadurch wird die API über Port 80 zugänglich. Dieses Setup ist effizient für die Bereitstellung einer FastAPI-App in einer Containerumgebung.

Erstellen der Datei „requirements.txt“.

Erstellen Sie eine requirements.txt-Datei, die alle Abhängigkeiten auflistet:

fastapi
uvicorn
scikit-learn
pandas

Erstellen des Docker-Images

Nachdem wir nun die Docker-Datei, die Datei „requirements.txt“ und die FastAPI-App bereit haben, erstellen wir ein Docker-Image und führen den Container aus.

Erstellen Sie das Docker-Image, indem Sie den folgenden Docker-Build-Befehl ausführen:

$ docker build -t house-price-prediction-api .

Führen Sie als Nächstes den Docker-Container aus:

$ docker run -d -p 80:80 house-price-prediction-api

Ihre API sollte jetzt ausgeführt werden und unter http://127.0.0.1:80 zugänglich sein.

Sie können Curl oder Postman verwenden, um den Endpunkt /predict zu testen, indem Sie eine POST-Anfrage senden. Hier ist eine Beispielanfrage:

curl -X 'POST' \
  'http://127.0.0.1:80/predict' \
  -H 'Content-Type: application/json' \
  -d '{
  "MedInc": 3.5,
  "AveRooms": 5.0,
  "AveOccup": 2.0
}'

Dies sollte eine Antwort mit dem prognostizierten Hauspreis zurückgeben, etwa so:

{
  "predicted_house_price": 2.3248705765077062
}

Markieren und Übertragen des Docker-Images an den Docker Hub

Nachdem Sie das Docker-Image erstellt, den Container ausgeführt und getestet haben. Sie können es jetzt an Docker Hub übertragen, um es einfacher zu teilen und auf Cloud-Plattformen bereitzustellen.

Melden Sie sich zunächst bei Docker Hub an:

$ docker login

Sie werden aufgefordert, die Anmeldeinformationen einzugeben.

Markieren Sie das Docker-Image:

$ docker tag house-price-prediction-api your_username/house-price-prediction-api:v1

Ersetzen Sie your_username durch Ihren Docker Hub-Benutzernamen.

Hinweis: Es ist auch sinnvoll, Versionen zu Ihren Modelldateien hinzuzufügen. Wenn Sie das Modell aktualisieren, können Sie das Image mit einem neuen Tag neu erstellen und das aktualisierte Image an Docker Hub übertragen.

Schieben Sie das Bild an Docker Hub:

$ docker push your_username/house-price-prediction-api:v1

Andere Entwickler können das Image jetzt wie folgt abrufen und ausführen:

$ docker pull your_username/house-price-prediction-api:v1
$ docker run -d -p 80:80 your_username/house-price-prediction-api:v1

Jeder mit Zugriff auf Ihr Docker Hub-Repository kann jetzt das Image abrufen und den Container ausführen.

Zusammenfassung und nächste Schritte

Hier ist ein kurzer Rückblick auf das, was wir in diesem Tutorial gemacht haben:

  • Trainieren Sie ein Modell für maschinelles Lernen mit scikit-learn
  • Erstellen Sie eine FastAPI-Anwendung, um Vorhersagen bereitzustellen
  • Containerisieren Sie die Anwendung mit Docker

Wir haben auch darüber nachgedacht, das Docker-Image zur einfacheren Verteilung auf Docker Hub zu übertragen. Der nächste logische Schritt besteht darin, diese Containeranwendung in der Cloud bereitzustellen.

Und dafür können Sie Dienste wie AWS ECS, GCP oder Azure nutzen, um die API in einer Produktionsumgebung bereitzustellen. Teilen Sie uns mit, ob Sie ein Tutorial zum Bereitstellen von Modellen für maschinelles Lernen in der Cloud wünschen.

Viel Spaß beim Bereitstellen!

Referenzen und weiterführende Literatur

  • FastAPI-Tutorial: Erstellen Sie APIs mit Python in wenigen Minuten
  • Containerisieren Sie Python-Apps mit Docker in 5 einfachen Schritten
  • FastAPI in Containern

Verwandte Artikel