FastAPI Machine Studying-Bereitstellung: Eine Schritt-für-Schritt-Anleitung

Die Mehrheit der Menschen erstellt Modelle für maschinelles Lernen in einer experimentellen oder Forschungsumgebung, die für die Erkundung geeignet ist. Erst wenn Sie mit der Bereitstellung in realen Anwendungen beginnen, werden Sie den tatsächlichen Wert erkennen, z. B. wenn eine Webanwendung Vorhersagen von Ihrem Modell anfordert oder eine Backend-Anwendung Echtzeitentscheidungen auf der Grundlage Ihres trainierten Modells treffen muss. Sie möchten eine einfache und zuverlässige Möglichkeit, Ihr trainiertes maschinelles Lernmodell als Webdienst, additionally als API, verfügbar zu machen.

Die FastAPI ist für diese Aufgabe die perfekte Wahl.

Was ist FastAPI?

FastAPI ist ein Python-Webframework, das Entwicklern beim Erstellen von RESTful-APIs helfen soll. Es ist schnell, einfach und verfügt standardmäßig über viele Funktionen, wie z. B. die automatische Generierung der API-Dokumentation. FastAPI funktioniert auch intestine mit den vorhandenen Python-Bibliotheken für die Datenverarbeitung und ist daher eine ideale Choice für maschinelle Lernprojekte.

Die wichtigsten Vorteile der Nutzung FastAPI Sind:

1. Schnelle Leistung: FastAPI ist eines der schnellsten verfügbaren Net-Frameworks für Python Programmiersprache, da sie auf zwei beliebten Bibliotheken aufbaute: Starlette und Pydantic.
2. Einfache Entwicklung und Wartung: Das Schreiben sauberer APIs mit FastAPI erfordert dank der automatisierten Funktionen von FastAPI, zu denen automatische Validierung, Serialisierung und Eingabeprüfungen gehören, nur minimalen Code.
3. Integrierte API-Dokumentation: Alle mit FastAPI erstellten APIs enthalten automatisch eine integrierte Swagger-Schnittstelle am URL-Endpunkt /docs. Damit können Benutzer ihre API-Endpunkte direkt über ihren Webbrowser testen.
4. Superb für Modelle des maschinellen Lernens: Durch die Verwendung von FastAPI können Benutzer ihr Eingabeschema für ihre Modelle für maschinelles Lernen definieren, den Endpunkt des Modells für eine Vorhersage verfügbar machen und einfach den Speicherort der gespeicherten Datei des Modells freigeben, damit diese beim Begin der Anwendung in den Speicher geladen werden kann. Die gesamte Backend-Arbeit wird von FastAPI übernommen. Daher erfreut sich FastAPI bei Entwicklern, die Modelle für maschinelles Lernen einsetzen, großer Beliebtheit.

Diese Abbildung zeigt den Fluss einer Vorhersageanfrage durch das System: Daten werden von einem Benutzer an die FastAPI-Anwendung gesendet, die das trainierte Modell für maschinelles Lernen lädt und die Inferenz ausführt. Das Modell erstellt eine Vorhersage und dieses Ergebnis wird von der API im JSON-Format zurückgegeben.

Bereitstellen eines ML-Modells mit FastAPI – praktisches Tutorial

Nachfolgend finden Sie eine vollständig praxisorientierte Anleitung zum Erstellen von Net-APIs für Modelle für maschinelles Lernen. Aber vorher schauen wir uns die Ordnerstruktur an.

Ordnerstruktur

Die Ordnerstruktur hilft dabei, die Projektdateien in einer einfachen Struktur zu organisieren; Dies erleichtert die Identifizierung, wo jeder Teil der Anwendung hingehört.

Sehen wir uns nun an, was die einzelnen Teile bewirken

• primary.py
  Führt FastAPI aus, lädt das trainierte Modell und macht den Vorhersageendpunkt verfügbar.
• train_model.py
  Erstellt und speichert das maschinelle Lernmodell, das FastAPI lädt.
• Modelle/
  Speichert trainierte Modellartefakte. Dieser Ordner wird erstellt, sofern er noch nicht vorhanden ist.
• Anforderungen.txt
  Nicht erforderlich, aber empfohlen, damit andere alles mit einem Befehl installieren können.
• .venv/
  Enthält Ihre virtuelle Umgebung, um Abhängigkeiten isoliert zu halten.

Schritt 1: Projekteinrichtung

1.1 Erstellen Sie Ihr Projektverzeichnis

Erstellen Sie das Projektverzeichnis, in dem sich Ihr gesamter Code, alle Dateien und Ressourcen für dieses Projekt befinden.

1.2 Erstellen Sie eine virtuelle Umgebung

Eine virtuelle Umgebung isoliert Ihre Abhängigkeiten für Ihr Projekt von anderen Projekten auf Ihrem Pc.

python -m venv .venv

Aktivieren Sie es:

Home windows

.venvScriptsactivate

macOS/Linux

supply .venv/bin/activate

Wenn Ihre Umgebung betriebsbereit ist, sollte vor dem Terminal „(.venv)“ angezeigt werden.

1.3 Erforderliche Abhängigkeiten installieren

Nachfolgend finden Sie eine Liste der Python-Bibliotheken, die wir in unserem FastAPI-Webserver verwenden werden:

• FastAPI (das Hauptframework zum Erstellen von Net-APIs)
• Uvicorn (der ASGI-Webserver zum Hosten von FastAPI-Anwendungen)
• Scikit-Study (zur Verwendung als Modelltrainer)
• Pydantic (zur automatischen Eingabevalidierung)
• Joblib (um das Speichern/Laden von ML-Modellen fortzusetzen)

Installieren Sie sie:

pip set up fastapi uvicorn scikit-learn pydantic joblib 

Schritt 2: Trainieren und speichern Sie ein einfaches ML-Modell

Für diese Demonstration wird unser Klassifikator anhand des klassischen Iris-Datensatzes trainiert und das Modell auf der Festplatte gespeichert. Das gespeicherte Modell wird dann in unsere FastAPI-Webanwendung geladen.

Um unser Modell zu trainieren und zu speichern, erstellen wir eine Datei namens train_model.py:

# train_model.py
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import joblib
from pathlib import Path

MODEL_PATH = Path("fashions")
MODEL_PATH.mkdir(exist_ok=True)
MODEL_FILE = MODEL_PATH / "iris_model.joblib"

def train_and_save_model():
iris = load_iris()
X = iris.knowledge
y = iris.goal

    X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

    clf = RandomForestClassifier(
        n_estimators=100,
        random_state=42
)
    clf.match(X_train, y_train)

accuracy = clf.rating(X_test, y_test)
print(f"Take a look at accuracy: {accuracy:.3f}")

    joblib.dump(
    {
        "mannequin": clf,
        "target_names": iris.target_names,
        "feature_names": iris.feature_names,
    },
    MODEL_FILE,
)
print(f"Saved mannequin to {MODEL_FILE.resolve()}")

if __name__ == "__main__":
    train_and_save_model()

Installieren Sie bei Bedarf joblib:

pip set up joblib

Führen Sie das Skript aus:

Sobald das Modell erfolgreich trainiert wurde, sollte die Genauigkeit auf dem Terminal angezeigt werden. Außerdem wird eine neue Modelldatei erstellt, die zum Laden in FastAPI verwendet wird.

Schritt 3: Erstellen Sie ein FastAPI-Programm, das die Vorhersagen Ihres Modells liefert

In diesem Schritt erstellen wir eine API, die das kann

• Laden Sie das trainierte Machine Studying-Modell beim Begin
• Erstellen Sie ein Eingabeschema, das zur Validierung der an die API gesendeten Daten verwendet werden kann
• Rufen Sie den im vorherigen Schritt definierten Endpunkt /predict auf, um eine Ausgabe basierend auf den Vorhersagen des Modells zu erstellen.

Erstellen primary.py:

# primary.py
from fastapi import FastAPI
from pydantic import BaseModel, Discipline
from typing import Checklist
import joblib
from pathlib import Path

MODEL_FILE = Path("fashions/iris_model.joblib")

class IrisFeatures(BaseModel):
    sepal_length: float = Discipline(..., instance=5.1)
    sepal_width: float = Discipline(..., instance=3.5)
    petal_length: float = Discipline(..., instance=1.4)
    petal_width: float = Discipline(..., instance=0.2)

class PredictionResult(BaseModel):
    predicted_class: str
    predicted_class_index: int
chances: Checklist(float)

app = FastAPI(
title="Iris Classifier API",
description="A easy FastAPI service that serves an Iris classification mannequin.",
model="1.0.0",
)

mannequin = None
target_names = None
feature_names = None

@app.on_event("startup")
def load_model():
world mannequin, target_names, feature_names

if not MODEL_FILE.exists():
    increase RuntimeError(
            f"Mannequin file not discovered at {MODEL_FILE}. "
            f"Run train_model.py first."
    )

artifact = joblib.load(MODEL_FILE)
mannequin = artifact("mannequin")
    target_names = artifact("target_names")
    feature_names = artifact("feature_names")
    print("Mannequin loaded efficiently.")

@app.get("/")
def root():
return {
    "message": "Welcome to the Iris ML API",
    "predict_endpoint": "/predict",
    "docs": "/docs",
}

@app.submit("/predict", response_model=PredictionResult)
def predict(options: IrisFeatures):
if mannequin is None:
    increase RuntimeError("Mannequin is just not loaded.")

X = ((
        options.sepal_length,
        options.sepal_width,
        options.petal_length,
        options.petal_width,
))

    proba = mannequin.predict_proba(X)(0)
    class_index = int(proba.argmax())
    class_name = str(target_names(class_index))

return PredictionResult(
        predicted_class=class_name,
        predicted_class_index=class_index,
    chances=proba.tolist(),
)

Diese Datei enthält den gesamten Code, der dies ermöglicht Maschinelles Lernen Modell, das als Net-App funktioniert.

Schritt 4: Lokales Ausführen und Testen der API

4.1 Starten Sie den Server

Laufen:

uvicorn primary:app –reload 

Die App startet unter: http://127.0.0.1:8000/

4.2 Testen der API mithilfe der interaktiven Dokumentation von FastAPI

FastAPI bietet integrierte Swagger-Dokumentation unter: http://127.0.0.1:8000/docs

Dort finden Sie:

• Ein GET-Endpunkt /
• Ein POST-Endpunkt /predict 

Probieren Sie es aus /predict Endpunkt durch Klicken Probieren Sie es aus und Eingabe:

{
  "sepal_length": 5.1,
  "sepal_width": 3.5,
  "petal_length": 1.4,
  "petal_width": 0.2
}

Sie erhalten eine Vorhersage wie:

{ 
  "predicted_class": "setosa", 
  "predicted_class_index": 0, 
  "chances": (1, 0, 0) 
} 

Ihr ML-Modell ist jetzt vollständig als API bereitgestellt.

In der Cloud bereitstellen

Sobald Ihre FastAPI-Anwendung auf Ihrem lokalen Pc ausgeführt wird, können Sie sie in der Cloud bereitstellen, sodass sie von überall aus zugänglich ist. Sie müssen sich hierfür nicht um die Einrichtung eines Containers kümmern. Ein paar Dienste machen es ziemlich einfach.

Beim Rendern bereitstellen

Rendern ist eine der schnellsten Möglichkeiten, eine FastAPI-App on-line zu stellen.

1. Schieben Sie Ihr Projekt auf GitHub.
2. Erstellen Sie beim Rendern einen neuen Webdienst.
3. Legen Sie den Construct-Befehl fest:

pip set up -r necessities.txt

4. Legen Sie den Startbefehl fest:

uvicorn primary:app --host 0.0.0.0 --port 10000

Render installiert Ihre Pakete, startet Ihre App und stellt Ihnen einen öffentlichen Hyperlink zur Verfügung. Jeder kann jetzt Anfragen an Ihr Modell senden.

Bereitstellung in GitHub-Codespaces

Wenn Sie nur eine einfache On-line-Umgebung ohne zusätzliche Einrichtung wünschen, kann Codespaces Ihre FastAPI-App ausführen.

1. Öffnen Sie Ihr Repository in Codespaces.
2. Installieren Sie Ihre Abhängigkeiten.
3. Starten Sie die Anwendung:

uvicorn primary:app --host 0.0.0.0 --port 8000

Codespaces stellt den Port bereit, sodass Sie den Hyperlink direkt in Ihrem Browser öffnen können. Dies ist intestine zum Testen oder zum Teilen einer kurzen Demo.

Bereitstellung auf AWS EC2

Sie können eine EC2-Instanz verwenden, wenn Sie die Kontrolle über Ihren eigenen Server haben möchten.

1. Starten Sie eine kleine EC2-Maschine.
2. Installieren Sie Python und pip.
3. Klonen Sie Ihr Projekt.
4. Installieren Sie die Anforderungen:

pip set up -r necessities.txt

5. Starten Sie die API:

uvicorn primary:app --host 0.0.0.0 --port 8000

Stellen Sie sicher, dass Port 8000 in Ihren EC2-Sicherheitseinstellungen geöffnet ist. Ihre API ist unter der öffentlichen IP-Adresse der Maschine verfügbar.

Häufige Fehler und Korrekturen

Hier sind einige Probleme, die beim Erstellen oder Ausführen des Projekts auftreten können, sowie einfache Möglichkeiten, diese zu beheben.

Modelldatei nicht gefunden

Dies bedeutet normalerweise, dass das Trainingsskript nie ausgeführt wurde. Laufen:

python train_model.py

Überprüfen Sie, ob die Modelldatei im Modellordner angezeigt wird.

Fehlende Bibliotheken

Wenn Sie Meldungen über fehlende Module sehen, stellen Sie sicher, dass Ihre virtuelle Umgebung aktiv ist:

supply .venv/bin/activate

Installieren Sie dann die erforderlichen Bibliotheken neu:

pip set up fastapi uvicorn scikit-learn pydantic joblib

Drawback beim Nachladen von Uvicorn

Einige On-line-Befehle verwenden den falschen Bindestrichtyp.
Wenn dies fehlschlägt:

uvicorn primary:app –reload

Verwenden Sie stattdessen Folgendes:

uvicorn primary:app --reload

Der Browser kann die API nicht aufrufen

Wenn Sie CORS-Fehler sehen, wenn ein Frontend die API aufruft, fügen Sie diesen Block zu Ihrer FastAPI-App hinzu:

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=("*"),
    allow_methods=("*"),
    allow_headers=("*"),
)

5. Eingabeformfehler

Scikit-learn erwartet die Eingabe als Liste von Pay attention. Stellen Sie sicher, dass Ihre Daten das folgende Format haben:

X = ((
    options.sepal_length,
    options.sepal_width,
    options.petal_length,
    options.petal_width,
))

Dadurch werden die meisten formbedingten Fehler vermieden.

Abschluss

Die Bereitstellung von Modellen für maschinelles Lernen muss einfach sein. Mit FastAPI sollten Sie jedoch in der Lage sein, mit nur wenigen Codezeilen problemlos eine API zu erstellen, die leicht zu lesen und zu verstehen ist. FastAPI übernimmt für Sie die gesamte Einrichtung, Validierung und Dokumentation, sodass Sie sich ganz auf Ihr Modell konzentrieren können. Diese Methode hilft Menschen beim Übergang vom Testen und Entwickeln zur vollständigen Implementierung in der realen Welt. Unabhängig davon, ob Sie Prototypen, Demos oder Produktionsdienstleistungen erstellen, können Sie mit FastAPI jetzt Ihre Modelle teilen und sie schnell und einfach für die Produktion bereitstellen.

Häufig gestellte Fragen

Q1. Warum eignet sich FastAPI intestine für die Bereitstellung von Modellen für maschinelles Lernen?

A. Es lädt Ihr Modell beim Begin, validiert Eingaben automatisch, stellt saubere Vorhersageendpunkte bereit und stellt Ihnen integrierte interaktive Dokumente zur Verfügung. Dadurch bleibt Ihr Bereitstellungscode einfach, während das Framework den Großteil der Set up übernimmt.

Q2. Warum muss ich das Trainingsskript ausführen, bevor ich die API starte?

A. Die API lädt beim Begin eine gespeicherte Modelldatei.

Q3. Wie kann ich den Vorhersageendpunkt testen, ohne Clientcode zu schreiben?

A. FastAPI wird mit Swagger-Dokumenten unter /docs ausgeliefert. Sie können es in einem Browser öffnen, Beispieleingaben für /predict eingeben und eine Anfrage senden, um echte Ausgaben Ihres Modells anzuzeigen.




Hallo, ich bin Janvi, ein leidenschaftlicher Knowledge-Science-Fanatic, der derzeit bei Analytics Vidhya arbeitet. Meine Reise in die Welt der Daten begann mit einer tiefen Neugier, wie wir aus komplexen Datensätzen aussagekräftige Erkenntnisse gewinnen können.