Bild von Autor | Leinwand
Wenn Sie gerne maschinelle Lernmodelle erstellen und mit neuen Sachen experimentieren, ist das wirklich cool – aber um ehrlich zu sein, wird es für andere nur nützlich, sobald Sie es ihnen zur Verfügung stellen. Dafür müssen Sie es bedienen – sie über eine Net -API aussetzen, damit andere Programme (oder Menschen) Daten senden und Vorhersagen zurückerhalten können. Dort kommen REST -APIs ins Spiel.
In diesem Artikel erfahren Sie, wie wir in knapp 10 Minuten von einem einfachen Modell für maschinelles Lernen zu einer produktionsbereiteten API mit Fastapi, einem der schnellsten und entwicklerfreundlichsten Webrahmen von Python, übergehen werden. Und wir werden nicht einfach bei einer Demo „Make It Run“ anhalten, sondern wir werden Dinge hinzufügen wie:
- Validierung eingehender Daten
- Jede Anfrage protokollieren
- Hinzufügen von Hintergrundaufgaben, um Verlangsamungen zu vermeiden
- Anmutig mit Fehlern umgehen
Lassen Sie mich Ihnen additionally schnell zeigen, wie unsere Projektstruktur aussehen wird, bevor wir zum Code -Teil wechseln:
ml-api/
│
├── mannequin/
│ └── train_model.py # Script to coach and save the mannequin
│ └── iris_model.pkl # Skilled mannequin file
│
├── app/
│ └── predominant.py # FastAPI app
│ └── schema.py # Enter information schema utilizing Pydantic
│
├── necessities.txt # All dependencies
└── README.md # Optionally available documentationSchritt 1: Installieren Sie das, was Sie brauchen
Für dieses Projekt benötigen wir ein paar Python-Pakete: Fastapi für die API, Scikit-Be taught für das Modell und ein paar Helfer wie JoBlib und Pydantic. Sie können sie mit PIP installieren:
pip set up fastapi uvicorn scikit-learn joblib pydanticUnd speichern Sie Ihre Umgebung:
pip freeze > necessities.txtSchritt 2: trainieren und ein einfaches Modell speichern
Lassen Sie uns den Teil des maschinellen Lernens einfach halten, damit wir uns auf das Servieren des Modells konzentrieren können. Wir werden den Berühmten benutzen Iris -Datensatz und prepare a Zufälliger Waldklassifizierer die Artwork der Irisblume vorherzusagen, basierend auf seinen Blüten- und Sepal -Messungen.
Hier ist das Trainingsskript. Erstellen Sie eine Datei aufgerufen train_model.py in a Modell/ Verzeichnis:
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import joblib, os
X, y = load_iris(return_X_y=True)
clf = RandomForestClassifier()
clf.match(*train_test_split(X, y, test_size=0.2, random_state=42)(:2))
os.makedirs("mannequin", exist_ok=True)
joblib.dump(clf, "mannequin/iris_model.pkl")
print("✅ Mannequin saved to mannequin/iris_model.pkl")Dieses Skript lädt die Daten, spaltet es, trainiert das Modell und speichert es mit JoBlib. Führen Sie es einmal aus, um die Modelldatei zu generieren:
python mannequin/train_model.pySchritt 3: Definieren Sie, welche Eingabe Ihre API erwarten sollte
Jetzt müssen wir definieren, wie Benutzer mit Ihrer API interagieren. Was sollten sie senden und in welchem Format?
Wir werden Pydantic, einen integrierten Teil von Fastapi, verwenden, um ein Schema zu erstellen, das eingehende Daten beschreibt und validiert. Insbesondere stellen wir sicher, dass Benutzer vier optimistic Float -Werte bereitstellen – für die Sepallänge/-breite und Blütenblätterlänge/-breite.
In einer neuen Datei App/Schema.pyhinzufügen:
from pydantic import BaseModel, Discipline
class IrisInput(BaseModel):
sepal_length: float = Discipline(..., gt=0, lt=10)
sepal_width: float = Discipline(..., gt=0, lt=10)
petal_length: float = Discipline(..., gt=0, lt=10)
petal_width: float = Discipline(..., gt=0, lt=10)Hier haben wir Wertschöpfungsbeschränkungen (mehr als 0 und weniger als 10) zusätzliche Wertschöpfungsbeschränkungen, um unsere Eingaben sauber und realistisch zu halten.
Schritt 4: Erstellen Sie die API
Jetzt ist es Zeit, die eigentliche API zu erstellen. Wir werden Fastapi verwenden, um:
- Laden Sie das Modell
- Akzeptieren Sie JSON -Eingaben
- Vorhersage der Klasse und den Wahrscheinlichkeiten
- Melden Sie die Anforderung im Hintergrund an
- Eine saubere JSON -Antwort zurückgeben
Schreiben wir den Haupt -API -Code darin App/predominant.py:
from fastapi import FastAPI, HTTPException, BackgroundTasks
from fastapi.responses import JSONResponse
from app.schema import IrisInput
import numpy as np, joblib, logging
# Load the mannequin
mannequin = joblib.load("mannequin/iris_model.pkl")
# Arrange logging
logging.basicConfig(filename="api.log", degree=logging.INFO,
format="%(asctime)s - %(message)s")
# Create the FastAPI app
app = FastAPI()
@app.submit("/predict")
def predict(input_data: IrisInput, background_tasks: BackgroundTasks):
attempt:
# Format the enter as a NumPy array
information = np.array(((input_data.sepal_length,
input_data.sepal_width,
input_data.petal_length,
input_data.petal_width)))
# Run prediction
pred = mannequin.predict(information)(0)
proba = mannequin.predict_proba(information)(0)
species = ("setosa", "versicolor", "virginica")(pred)
# Log within the background so it doesn’t block response
background_tasks.add_task(log_request, input_data, species)
# Return prediction and chances
return {
"prediction": species,
"class_index": int(pred),
"chances": {
"setosa": float(proba(0)),
"versicolor": float(proba(1)),
"virginica": float(proba(2))
}
}
besides Exception as e:
logging.exception("Prediction failed")
elevate HTTPException(status_code=500, element="Inner error")
# Background logging job
def log_request(information: IrisInput, prediction: str):
logging.information(f"Enter: {information.dict()} | Prediction: {prediction}")Lassen Sie uns innehalten und verstehen, was hier passiert.
Wir laden das Modell einmal, wenn die App startet. Wenn ein Benutzer die trifft /vorhersagen Endpunkt mit gültigen JSON -Eingaben konvertieren wir dies in ein Numpy -Array, bestehen es durch das Modell und geben die vorhergesagte Klasse und Wahrscheinlichkeiten zurück. Wenn etwas schief geht, protokollieren wir es und geben einen freundlichen Fehler zurück.
Beachten Sie die Hintergrundbeschwerden Teil – Dies ist eine ordentliche Fastapi -Funktion, mit der wir nach dem Senden der Antwort arbeiten können (z. B. Speichern von Protokollen). Das hält die API an und vermeidet Verzögerungen.
Schritt 5: Führen Sie Ihre API aus
Verwenden Sie uvicorn so wie folgt, um den Server zu starten:
uvicorn app.predominant:app --reloadBesuchen: http://127.0.0.1:8000/docs
Sie werden eine interaktive Swagger -Benutzeroberfläche sehen, in der Sie die API testen können.
Probieren Sie diese Beispieleingabe aus:
{
"sepal_length": 6.1,
"sepal_width": 2.8,
"petal_length": 4.7,
"petal_width": 1.2
}Oder Sie können Curl verwenden, um die Anfrage wie folgt zu stellen:
curl -X POST "http://127.0.0.1:8000/predict" -H "Content material-Kind: utility/json" -d
'{
"sepal_length": 6.1,
"sepal_width": 2.8,
"petal_length": 4.7,
"petal_width": 1.2
}'Beide erzeugen die gleiche Antwort, die Folgendes ist:
{"prediction":"versicolor",
"class_index":1,
"chances": {
"setosa":0.0,
"versicolor":1.0,
"virginica":0.0 }
}Optionaler Schritt: Stellen Sie Ihre API bereit
Sie können die Fastapi -App auf:
- Render.com (Null -Konfigurationsbereitstellung)
- Eisenbahn.App (für kontinuierliche Integration)
- Heroku (über Docker)
Sie können dies auch in einen produktionsbereiten Service ausdehnen, indem Sie Authentifizierung (z. B. API-Schlüssel oder OAuth) hinzufügen, um Ihre Endpunkte zu schützen, Anforderungen mit Prometheus und Grafana zu überwachen und Redis oder Sellerie für Hintergrundjob-Warteschlangen zu verwenden. Sie können sich auch auf meinen Artikel beziehen: Schritt-für-Schritt-Anleitung zum Bereitstellen von Modellen für maschinelles Lernen mit Docker.
Einpacken
Das struggle’s – und es ist schon besser als die meisten Demos. Was wir gebaut haben, ist mehr als nur ein Spielzeugbeispiel. Allerdings: es:
- Validiert automatisch Eingabedaten
- Gibt aussagekräftige Antworten mit Vorhersagevertrauen zurück
- Melden Sie sich jede Anforderung an eine Datei an (api.log)
- Verwendet Hintergrundaufgaben, sodass die API schnell und reaktionsschnell bleibt
- Verarbeitet Misserfolge anmutig
Und alles in weniger als 100 Codezeilen.
Kanwal Mehreen Kanwal ist ein Ingenieur für maschinelles Lernen und technischer Schriftsteller mit einer tiefgreifenden Leidenschaft für die Datenwissenschaft und die Schnittstelle von KI mit Medizin. Sie hat das eBook „Produktivität mit Chatgpt maximieren“. Als Google -Era -Gelehrte 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie wird auch als Teradata -Vielfalt in Tech Scholar, MITACS Globalink Analysis Scholar und Harvard Wecode Scholar anerkannt. Kanwal ist ein leidenschaftlicher Verfechter der Veränderung, nachdem er Femcodes gegründet hat, um Frauen in STEM -Bereichen zu stärken.