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 documentation

Schritt 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 pydantic

Und speichern Sie Ihre Umgebung:

pip freeze > necessities.txt

Schritt 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.py

Schritt 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 --reload

Besuchen: 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.

Das Bereitstellen eines maschinellen Lernmodells ist einer der kritischsten Schritte bei der Einrichtung eines KI -Projekts. Unabhängig davon, ob es sich um einen Prototyp handelt oder Sie ihn für die Produktion skalieren, stellt die Modellbereitstellung in ML sicher, dass die Modelle zugänglich sind und in praktischen Umgebungen verwendet werden können. In diesem Artikel werden wir die besten Plattformen für die Bereitstellung maschineller Lernmodelle untersuchen, insbesondere diejenigen, mit denen wir ML -Modelle kostenlos mit minimalem Setup hosten können.

Was sind Modelle für maschinelles Lernen?

Modelle für maschinelles Lernen sind Programme, die die versteckten Muster in Daten verstehen, um Vorhersagen zu treffen oder ähnliche Datenpunkte zu kombinieren. Sie sind die mathematischen Funktionen, die nach historischen Daten geschult werden. Sobald das Coaching abgeschlossen ist, kann die gespeicherte Modellgewichtsdatei einfach Muster identifizieren, Informationen klassifizieren, Anomalien erkennen oder in bestimmten Fällen sogar Inhalte erzeugen. Daher verwenden Datenwissenschaftler unterschiedliche Algorithmen für maschinelles Lernen als Grundlage für Modelle. Da Daten in einen bestimmten Algorithmus eingeführt werden, wird sie so geändert, dass sie eine bestimmte Aufgabe erledigt maschinelles Lernen Modelle.

Beispielsweise ist ein Entscheidungsbaum ein gemeinsamer Algorithmus für die Klassifizierungs- und Vorhersagemodellierung. Ein Datenwissenschaftler, der versucht, ein maschinelles Lernmodell zu entwickeln, das verschiedene Tierarten identifiziert, kann einen Entscheidungsbaumalgorithmus mit verschiedenen Tierbildern ausbilden. Im Laufe der Zeit würde der Algorithmus durch die Daten modifiziert und immer besser darin, Tierbilder zu klassifizieren. Dies würde wiederum schließlich zu einem maschinellen Lernmodell werden.

Warum maschinelle Lernmodelle auswirken?

Sobald Sie Ihr maschinelles Lernmodell trainiert und an den Beispieldaten getestet haben, die Sie als Testdaten haben, ist es jetzt an der Zeit, es auf einer geeigneten Plattform zu hosten, die den Bedürfnissen des Projekts erfüllt, um es in Echtzeitszenarien verwendbar zu machen. Ob das endgültige Ziel des Modells, Vorhersagen über APIs zu machen oder die Modelle in Webanwendungen einzubetten. Das Internet hosting des Modells stellt sicher, dass unser Modell für andere zugänglich und operativ ist.

Was macht das Internet hosting des Modells wesentlich:

• Zugänglichkeit und Interaktivität: Mit Internet hosting -Modellen können Benutzer oder andere Anwendungen auf der Grundlage des gehosteten Modells über APIs von überall mit dem Modell interagieren.
• Skalierbarkeit: Außerdem bieten die meisten Internet hosting -Plattformen häufig die Skalierung, mit der das Modell gleichzeitig mehrere Benutzeranforderungen bearbeitet und sicherstellt, dass seine Leistung nicht abfällt.
• Zusammenarbeit: Außerdem können die gehosteten Modelle problemlos mit Groups oder mit der breiteren Group für Suggestions und zuverlässigere Integration geteilt werden.
• Überwachung und Wartung: Durch das Internet hosting des Modells kann man die Protokollierungs-, Variations- und Überwachungswerkzeuge problemlos überwachen, um die Modellleistung auf dem neuesten Stand zu halten.
• Integration: Das gehostete Modell kann leicht in Datenbanken, Entrance-Finish-Anwendungen oder andere APIs für die nahtlose Pipeline-Verwaltung integriert werden.

High -Plattformen für maschinelle Lernmodelle zur Host -Modelle

Das Aufbau eines maschinellen Lernmodells ist wirklich nur die Hälfte der Zeit erforderlich. Die andere Hälfte liegt darin, es zugänglich zu machen, damit andere das ausprobieren können, was Sie aufgebaut haben. Internet hosting -Modelle in Cloud -Diensten löst das Drawback, das Sie nicht auf Ihrem lokalen Pc ausführen müssen. In diesem Abschnitt werden wir additionally die führenden kostenlosen Plattformen zum Internet hosting von maschinellem Lernmodellen untersuchen und deren Funktionen und Vorteile beschrieben.

1. Gesichtsräume umarmen

Die umarmenden Gesichtsräume oder kurzer HF-Bereiche sind eine Group-zentrierte Plattform, mit der Benutzer ihre Modelle für maschinelles Lernen mit beliebten Bibliotheken bereitstellen können. Die Räume ermöglichen es, das Modell mit einigen Codezeilen zu hosten, und die öffentliche Nutzung ist mit Zugriff auf eine gemeinsam genutzte CPU- und GPU -Umgebung völlig kostenlos.

Schlüsselmerkmale von umarmenden Gesichtsräumen

• Kostenlos zu verwenden mit integrierter Unterstützung für Python.
• Es bietet auch Flexibilität bei der Auswahl von Computerressourcen basierend auf den Modellanforderungen.
• Bietet eine Plattform für Mitarbeiter und ein großartiges Engagement der Group.

Streamlit bietet eine kostenlose Cloud -Plattform, mit der Entwickler Streamlit -Anwendungen direkt aus Github -Repositories bereitstellen können. Es bietet kostenlose Internet hosting mit grundlegenden Ressourcen, sodass es best für die Herstellung von Dashboards und ML -Inferenz -Apps ist. Es wurde für den schnellen und einfachen Austausch von Datenanwendungen entwickelt.

Schlüsselmerkmale der streamliten Group Cloud

• Bietet eine einfache Bereitstellung mit Github -Repositories.
• Es ist kein Server -Setup erforderlich, daher reduziert es den Ressourcenaufwand.
• Es vereinfacht außerdem den Bereitstellungsprozess und macht es für Nicht-Experten in Modellbereitstellungen zugänglich.

3.. Gradio

Gradio ist sowohl eine Python -Bibliothek als auch eine Internet hosting -Plattform, mit der Sie schnell Internet -UI -Anwendungen für maschinelles Lernen erstellen können. Dies macht die Anwendungen für Benutzer ohne Fachwissen in der Webentwicklung zugänglich. Es wird zum Erstellen von gemeinsam genutzbaren Demos mit interaktiven Dashboards und Datenanwendungen verwendet.

Schlüsselmerkmale von Gradio

• Es bietet Zugriff auf maschinelle Lernmodelle, indem benutzerfreundliche Schnittstellen bereitgestellt werden.
• Es unterstützt auch eine nahtlose Integration mit umarmenden Gesichtsräumen zum Internet hosting.
• Ermöglicht Entwicklern, Modelle zu teilen, ohne benutzerdefinierte Webanwendungen zu erstellen.

4. Pythonanywhere

Pythonanywhere ist eine Cloud-basierte Plattform zum Internet hosting und Entwickeln von Python-Anwendungen. Es ermöglicht Entwicklern, Python -Skripte auszuführen. Entwickler, die ihren Code bereitstellen und ausführen möchten, ohne ihre lokalen Server zu verwenden, um Webanwendungen mit Flask und Django einzurichten.

Schlüsselmerkmale von Pythonanywhere

• Pythonanywhere bietet eine einfache Integration in Datenbanken wie MySQL, sodass es best für das Internet hosting von Anwendungen mit Backend -Datenbanken.
• Es ist best, um die Prototypanwendungen zu präsentieren, da es keine lokale Python -Umgebung einrichten muss. Dies macht es perfekt für Anfänger oder für diejenigen, die einen schnellen Prototyp zeigen möchten.
• Diese Plattform unterstützt die integrierte Unterstützung für die Planung von Python-Skripten der Aufgaben, die zu bestimmten Zeiten ausgeführt werden sollen.

5. Mlflow

MLFlow ist eine Open-Supply-Plattform, die den vollständigen Lebenszyklus eines maschinellen Lernprojekts verwaltet, beginnend von Experimentieren bis zur Bereitstellung. Während es nicht die direkte Internet hosting-Infrastruktur bereitstellt, können MLFlow-Modelle auf Cloud-Plattformen mit den integrierten Servern von MLFlow bereitgestellt werden.

Schlüsselmerkmale von MLFlow

• MLFlow hilft dabei, die Leistung, Modellregistrierung und Versionskontrolle des Modells zu verfolgen.
• Ermöglicht Entwicklern, die Teamzusammenarbeit in Unternehmensumgebungen durch die Aufrechterhaltung von Protokollen und den Vergleich mit mehreren Läufen ihrer ML -Modelle zu haben.
• Integriert sich einfach in Bibliotheken für maschinelles Lernen und andere Help -Instruments.

6. Dagshub

Dagshub ist eine Collaboration -Plattform, die speziell für Projekte für maschinelles Lernen erstellt wurde. Es kombiniert GIT (für die Versionskontrolle), DVC (für Daten- und Modellüberprüfung) und MLFlow (für die Experimentverfolgung). Wir können Datensätze, Notizbücher und Modelle verwalten und Ihren ML -Lebenszyklus an einem Ort verfolgen.

Schlüsselmerkmale von Dagshub

• Es ermöglicht eine nahtlose und einfache Zusammenarbeit zum Austausch von Datensätzen, Modellen und Experimenten, was es Entwicklern erleichtert, zusammenzuarbeiten und Arbeitsumgebungen zu organisieren.
• Es bietet auch integrierte Visualisierungstools zur Überwachung der Modellleistung und zum Vergleich von Metriken über verschiedene Experimente hinweg.
• DagShub unterstützt Open-Supply-Komponenten, wodurch es für weitere Anpassungen flexibel ist und auch bei der Erweiterung seiner Funktionalität, insbesondere für die Bedürfnisse der Benutzer, erweitert wird.

7. Kubeflow

Kubeflow ist eine Open-Supply-Plattform, die speziell zur Vereinfachung der Bereitstellung, Überwachung und Verwaltung von Modellen oder Workflows für maschinelle Lernen auf Kubernetes entwickelt wurde. Ziel ist es, Finish-to-Finish-Unterstützung für den gesamten Lebenszyklus für maschinelles Lernen zu unterstützen, von der Datenvorbereitung über das Modellieren von Schulungen bis hin zur Bereitstellung und Überwachung in der Produktion. Kubeflow ermöglicht skalierbare, verteilte und tragbare ML -Workflows.

Schlüsselmerkmale von Kubeflow

• Erleichtert eine einfache Einsatz von maschinellen Lernmodellen in die Produktion, da sie eine einfache und nahtlose Integration in Kubernetes für automatisierte Skalierung und Verwaltung ermöglicht.
• Es unterstützt auch beliebte Rahmenbedingungen für maschinelles Lernen wie Tensorflow, Pytorch, MXNet und andere, damit Entwickler mit ihren bevorzugten Instruments arbeiten können.
• Mit Kubeflow können Sie maschinelle Lernpipelines als Code mit Python definieren. Dies ermöglicht einfache Versionen, Testen und Teilen von Workflows.

8. Rendern

Render ist eine Cloud -Plattform, die eine einheitliche Lösung für die Bereitstellung und Verwaltung von Webanwendungen, APIs und statischen Web sites bietet. Es vereinfacht den Prozess des Internet hosting von Anwendungen mit Vollstapel. Dies bietet automatische Skalierung, kontinuierliche Bereitstellung und einfache Integration in beliebte Datenbanken. Render ist so konzipiert, dass sie eine einfache und Entwickler-freundliche Various für herkömmliche Cloud-Anbieter bieten, die einen Schwerpunkt auf Benutzerfreundlichkeit, Geschwindigkeit und Effizienz für kleine und unternehmerische Anwendungen konzentrieren.

Schlüsselmerkmale von Render

• Render bietet eine einfache Integration in Github und GitLab, die es automatische Bereitstellungen ermöglicht, wenn Änderungen an Repositories gedrückt werden und die kontinuierliche Bereitstellung mit minimalem Setup gewährleistet.
• Es skaliert die Anwendungen automatisch nach dem Verkehr nach oben und unten und stellt sicher, dass die Leistung ohne manuelle Eingriff optimiert wird.
• Render bietet auch Echtzeit-Protokolle, Leistungsüberwachung und Warnungen, um die Leistung der Anwendung zu verfolgen. Außerdem kann es in GitHub -Aktionen für maßgeschneiderte Bereitstellungspipelines und Workflows integriert werden.

Vergleich zwischen den Plattformen

Abschluss

Der Lebenszyklus des maschinellen Lernens ist noch nicht vorbei, bis die Modelle in der realen Welt verwendet werden. Die Auswahl der richtigen Plattform, um Ihr maschinelles Lernmodell zu hosten, ist je nach Größe und technischer Anforderungen des Projekts ein sehr wichtiger Schritt dieses Lebenszyklus. Wenn Sie additionally nach schnellen Demos mit minimalem Setup suchen, Plattformen wie Huggingface -Räume, Streamlit und Gradio sind einige der besten Ausgangspunkte. Für fortschrittlichere Workflows für die Bereitstellung von Produktionsumgebungen bieten Render, Kubeflow und MLFlow Skalierbarkeit und Versionskontrolle gemäß Ihren Anforderungen. Darüber hinaus sind Plattformen wie Pythonanywhere und Dagshub best für kleine Projekte und Teamkollaborationen.

Egal, ob Sie ein Pupil, ein Information Science -Fanatic oder ein berufstätiger Fachmann sind, diese Plattformen unterstützen Ihre ML -Reise vom Prototyp zur Produktion Ihres Modells.

Hallo! Ich bin Vipin, ein leidenschaftlicher Information Science und maschinelles Lernen, der eine starke Grundlage für die Datenanalyse, Algorithmen und Programmierung maschinelles Lernens und Programmierung hat. Ich habe praktische Erfahrungen beim Aufbau von Modellen, beim Verwalten unordentlicher Daten und die Lösung realer Probleme. Mein Ziel ist es, datengesteuerte Erkenntnisse anzuwenden, um praktische Lösungen zu erstellen, die Ergebnisse erzielen. Ich bin bestrebt, meine Fähigkeiten in einer kollaborativen Umgebung beizutragen und gleichzeitig in den Bereichen Datenwissenschaft, maschinelles Lernen und NLP zu lernen und zu wachsen.