Delply-Modell für maschinelles Lernen mit Heroku und FastAPI

Dieser Artikel wurde im Rahmen der Data Science Blogathon

Einführung

Ich begleite Sie durch den Prozess der Implementieren Sie ein Modell für maschinelles Lernen als API mit FastAPI und Heroku. In diesem Artikel behandelte Dinge:

1. Eine kurze Einführung in den Datensatz und das Modell
2. FastAPI-Grundlagen
3. So strukturieren Sie Ihren Code, um das ML-Modell zu verwenden
4. So testen und wiederherstellen Sie diese API?
5. Implementierung in Heroku
6. Bono: Erstellung von Dokumenten

Der Datensatz und das Modell

Die Problemstellung, die ich für diese Artikelserie gewählt habe, ist die Klassifizierung von Musikgenres. Der Datensatz wurde zusammengestellt von einer Forschungsgruppe namens The Echo Nest. Enthält verschiedene technische Details zur Musik. Diese beinhalten Akustik, Tanzbarkeit, Energie, Instrumentalität, Lebhaftigkeit, spricht, Tempo und Valencia. Die objektive Variable dieser Daten ist, ob der Song zum Rock- oder Hip-Hop-Genre gehört.. Dann, einige Details zum Datensatz werden angezeigt:

Die Trackidentifikation war für unsere Analyse nicht hilfreich und, Daher, es wurde gelöscht. Genre_top ist unsere Zielvariable und enthält “Felsen” Ö “HipHop”. Ich habe einen Entscheidungsbaum-Klassifikator für diesen Datensatz trainiert und einen guten Präzisionswert erhalten. (Andere Ensemblemodelle wie Random Forest habe ich nicht ausprobiert, aber du kannst es versuchen).

Sobald Sie das Modell angepasst und mit Zufallsdaten getestet haben, Es ist Zeit, das Modell auszuwählen. Stripping ist der Prozess der Konvertierung eines Python-Objekts in einen Bytestream. Speichern Sie das Modell als Datei, damit darauf zugegriffen werden kann / später laden. Hier ist der Code für dasselbe, wenn Sie nicht vertraut sind:

pkl_filename="model.pkl"
mit offen(pkl_filename, 'wb') als f:
    pickle.dump(Modell, F)

Einführung in FastAPI

Es ist ein Web-Framework, das die Backend-Entwicklung einer Website mit Python beschleunigt. Dieser Rahmen ist neu, anpassungsfähig und leicht zu erlernen. Ermöglicht Benutzern die schnelle Konfiguration der API, generiert automatische Dokumente für alle Endpunkte, bietet Authentifizierung, Datenvalidierung, ermöglicht asynchronen Code und vieles mehr. Es basiert auf Starlette, was ist ein rahmen / leichtes ASGI-Toolkit und bietet produktionsfertigen Code.

Zweitens, Flask ist älter als FastAPI, wird aber immer noch für viele Projekte verwendet. Sein minimalistischer Ansatz ist vielversprechend und die Erstellung von Kolben-APIs ist auch nicht so schwierig. Beide Frameworks haben ihre Vor- und Nachteile.

In diesem Artikel finden Sie einen detaillierten FastAPI-Vergleich: Ist der richtige Ersatz für Flaschen?

Um unser Machine-Learning-Modell zu implementieren, wir werden den FastAPI-Ansatz verwenden. Bevor Sie in den Code eintauchen, um die Modell-API zu erstellen, Lassen Sie uns einige Grundlagen von FastAPI verstehen, die Ihnen helfen, die Codebasis besser zu verstehen.

FastAPI-Grundlagen

Die Struktur des FastAPI-Codes ist der Struktur der Flask-Anwendung sehr ähnlich. Sie müssen Endpunkte erstellen, an denen unser Kundenservice Anfragen stellen und die erforderlichen Daten abrufen kann. Siehe die grundlegende Code-Implementierung unten:

uvicorn importieren

aus fastapi importieren FastAPI

app = FastAPI()

@app.get('/')

def-Index():

    Rückkehr {'Botschaft': "Dies ist die Homepage dieser API. Gehe zu /apiv1/ oder /apiv2/?name="}

@app.get('/apiv1 /{Name}')

def api1(Name: str):

    Rückkehr {'Botschaft': f'Hallo! @{Name}'}

@app.get('/apiv2 /')

def api2(Name: str):

    Rückkehr {'Botschaft': f'Hallo! @{Name}'}

if __name__ == '__main__':

    uvicorn.run(App, Gastgeber="127.0.0.1", port=4000, debug=Wahr)

1. Die ersten beiden Zeilen importieren FastAPI und uvicorn. Das Uvicorn wird verwendet, um den Server zu implementieren und alle Aufrufe in Python abzuwickeln.
2. Dann, eine Instanz der FastAPI-Anwendung wird erstellt.
3. Routen hinzufügen / Endpunkte zu dieser Anwendungsinstanz, eine Funktion wird erstellt und ein Routen-Dekorator wird hinzugefügt. Dieser Dekorator registriert die Funktion für die definierte Route, sodass diese bestimmte Route angefordert wird, die Funktion wird aufgerufen und ihr Ergebnis wird an den Client zurückgegeben. Allgemein, Wir geben ein JSON-Objekt zurück, damit es in jeder Sprache geparst werden kann.
4. Das Beste an FastAPI ist, dass Sie diese Routen direkt für HTTP-Methoden definieren können. In der Flasche, Sie müssen sie manuell zu einer Methodenliste hinzufügen (aktualisiert auf der Flasche 2.0).
5. Um Kundeneingaben zu erhalten, Sie können Pfadparameter verwenden, Abfrageparameter oder Anforderungstexte. Der Pfad “/apiv1 / {Name}”Implementiert einen routenbasierten Ansatz, bei dem Parameter als Routen übergeben werden. Die Strecke “/ apiv2 /” implementiert einen abfragebasierten Ansatz, bei dem die Parameter übergeben werden, indem die “?” am Ende der URL und mit “&” mehrere Parameter hinzufügen.

Sehen Sie diese Routen in Aktion:

Körperfokus anfordern

Mit diesem Ansatz, Kundendaten können an unsere API weitergegeben werden. Und FastAPI, um die Dinge zu vereinfachen, wir verwenden pydantische Modelle, um die Datenstruktur für die empfangenden Daten zu definieren. Pydantic führt alle Typprüfungen der Parameter durch und gibt erklärbare Fehler zurück, wenn der falsche Parametertyp empfangen wird. Fügen wir unserem vorhandenen Code eine Datenklasse hinzu und erstellen Sie einen Pfad für den Anforderungstext:

.

.

# Nach anderen Importen
von pydantic importieren BaseModel
Klasse Details(Basismodell):
    f_name: str
    l_name: str
    Telefonnummer: int
app = FastAPI()

.
.
.

# Nach alten Routen
@app.post('/apiv3 /')
def api3(Daten: Einzelheiten):
    Rückkehr {'Botschaft': Daten}

Die Pfadfunktion deklariert einen Parameter “Daten” vom Typ “Einzelheiten” oben definiert. Dieses Modell von “Einzelheiten” erbt vom Basismodell von Pydantic und bietet Datenvalidierung. Um diese Route zu testen, Ich verwende die Thunder-Client-VS-Codeerweiterung, um eine Post-Anfrage an unseren API-Pfad zu senden “/ apiv3 /”:

Einwickeln des Modells

Nachdem wir die Konzepte von FastAPI entfernt haben, Es ist an der Zeit, das Modell in die FastAPI-Codestruktur zu integrieren, um Vorhersageanfragen zu stellen. Wir erstellen eine Route “/ Vorhersage” die die vom Body der Client-Anfrage gesendeten Daten entgegennimmt und unsere API die Antwort als JSON-Objekt mit dem Ergebnis zurückgibt. Schauen wir uns zuerst den Code an und dann erkläre ich die Mechanik:

uvicorn importieren

Essiggurke importieren

aus fastapi importieren FastAPI

von pydantic importieren BaseModel

Klasse Musik(Basismodell):

    Akustik: schweben

    Tanzbarkeit: schweben

    Energie: schweben

    Instrumentalität: schweben

    Lebendigkeit: schweben

    Redegewandtheit: schweben

    Tempo: schweben

    Wertigkeit: schweben

app = FastAPI()




mit offen("./FastAPI-Dateien/model.pkl", "rb") als f:

    model = pickle.load(F)

@app.get('/')

def-Index():

    Rückkehr {'Botschaft': 'Dies ist die Homepage der API'}

@app.post('/Vorhersage')

def get_music_category(Daten: Musik):

    empfangen = data.dict()

    Akustik = empfangen['Akustik']

    Tanzbarkeit = erhalten['Tanzfähigkeit']

    Energie = empfangen['Energie']

    Instrumentalität = empfangen['Instrumentalität']

    Lebendigkeit = erhalten['Lebendigkeit']

    Redlichkeit = empfangen['Sprechbarkeit']

    Tempo = empfangen['Wetter']

    Wertigkeit = erhalten['Wertigkeit']

    pred_name = model.predict([[Akustik, Tanzbarkeit, Energie,

                                Instrumentalität, Lebendigkeit, Redegewandtheit, Wetter, Wertigkeit]]).auflisten()[0]

    Rückkehr {'Vorhersage': pred_name}

if __name__ == '__main__':

    uvicorn.run(App, Gastgeber="127.0.0.1", port=4000, debug=Wahr)

1. Wir haben eine Musikmodellklasse erstellt, die alle Parameter unseres ML-Modells definiert. Alle Werte sind vom Typ float.
2. Dann, Wir laden das Modell, indem wir es trennen und das Modell speichern unter “Modell”. Dieses Modellobjekt wird verwendet, um die Vorhersagen zu erhalten.
3. Die Pfadfunktion “/ Vorhersage” einen Parameter namens . deklarieren “Daten” des Modelltyps “Lied”. Auf diesen Parameter kann als Wörterbuch zugegriffen werden. Das Dictionary-Objekt ermöglicht es uns, auf die Parameterwerte als Schlüssel-Wert-Paare zuzugreifen.
4. Jetzt, Wir speichern alle vom Kunden gesendeten Parameterwerte. Diese Werte werden nun in die Vorhersagefunktion des Modells eingespeist und wir haben unsere Vorhersage für die bereitgestellten Daten.

Alle in diesem Artikel besprochenen Codes sind verfügbar unter mein GitHub-Repository.

Modell-API-Test

Jetzt ist es an der Zeit, die API zu testen. Sie können die API mit zwei Methoden testen:

Thunder-Client / Briefträger

Wir verwenden den Thunder-Client, um eine Post-Anfrage an den Pfad zu senden “/ Vorhersage” mit einem Anfragetext. Der Anfragetext enthält die Schlüssel-Wert-Paare der Parameter und wir sollten eine JSON-Antwort mit dem klassifizierten Musikgenre erwarten.

Stellen Sie eine Anfrage mit dem Anfragemodul

Wenn Sie die VSCode-Erweiterungen oder eine API-Testsoftware nicht verwenden möchten, Sie können einfach ein separates Python-Programm erstellen, um diese API aufzurufen. Das Python-Anforderungsmodul ermöglicht das Aufrufen von APIs.

Importanfragen
json importieren

URL = "<lokale-host-URL>/Vorhersage"

Nutzlast = json.dumps({
  "Akustik": 0.344719513,
  "Tanzbarkeit": 0.758067547,
  "Energie": 0.323318405,
  "Instrumentalität": 0.0166768347,
  "Lebendigkeit": 0.0856723112,
  "Redegewandtheit": 0.0306624283,
  "Wetter": 101.993,
  "Wertigkeit": 0.443876228
})

Überschriften = {
  'Inhaltstyp': 'anwendung/json'
}

Antwort = Anfragen.Anfrage("POST", URL, headers=header, Daten=Nutzlast)

drucken(antwort.text)

Ersetzen “lokale-host-URL” mit Ihrer URL, die Sie nach dem Ausführen der API-Datei des FastAPI-Modells erhalten. Die Ausgabe dafür ist:

Viva! Sie haben mit FastAPI . erfolgreich eine API für Ihr Machine-Learning-Modell erstellt.

Implementierung in Heroku

Unsere API kann von jeder Art von Programm verwendet werden, das unsere API aufruft. Aber Sie können dieses Programm nicht den ganzen Tag auf Ihrem lokalen System ausführen, das ist praktisch unmöglich. Deswegen, Sie müssen Ihren Service auf einer Cloud-Plattform bereitstellen, die Ihren Code ausführen und Rückgaben zurückgeben kann.

Heroku ist eine dieser Plattformen, die kostenloses Hosting anbietet. Um unsere API in Heroku zu implementieren, Wir müssen diese Dateien erstellen:

1. Anforderungen.txt: Diese Datei sollte alle externen Module auflisten, die Sie in Ihrer Anwendung verwendet haben. Für unseren Fall, war FastAPI, scikit-lernen, uvicorn und einige andere Zusatzmodule.
2. Laufzeit.txt: Diese Datei gibt die Version von Python an, die Heroku auf seinem Endpunkt installiert.
3. Profil: Diese Datei ist die Schnittstellendatei zwischen unserem Python-Code und der Heroku-Plattform. Notiz: die meisten von euch erstellen diese Datei nicht richtig. Es ist keine Textdatei. Diese Datei hat keine Erweiterung. Um solche Dateien zu erstellen, Sie können GitHub verwenden, um Dateien oder Vs-Code oder cmd unter Windows oder Terminal unter Linux hinzuzufügen. Diese Datei würde den folgenden Befehl für FastAPI enthalten:

Netz: Gunicorn -w 4 -k uvicorn.workers.UvicornWorker :App

Hier, Ersetzen Sie file_name durch den Namen der Python-Datei, in der Sie den FastAPI-Code erstellt haben. Danach:

1. Legen Sie alle diese Dateien (Modell, Python-Datei, anforderungen.txt, Profil) in einem GitHub-Repository
2. Melden Sie sich bei Heroku an und erstellen Sie eine neue App. Verbinden Sie Ihr GitHub-Repository
3. Klicken Sie auf Deploy Branch und Ihre API wird betriebsbereit sein, damit jeder mit dem Link verwendet werden kann.

Bono: Erstellung von Dokumenten

FastAPI hat eine besondere Funktion. Dokumente für erstellte API-Endpunkte automatisch generieren. Um auf diese Dokumente zuzugreifen, Besuchen Sie einfach den Endpunkt “/ Dokumente” und Sie erhalten eine attraktive grafische Benutzeroberfläche, die mit Swagger und OpenAI erstellt wurde. Nachdem wir den Service nun implementiert haben, Der Screenshot unten stammt aus der Heroku-Anwendung Deployed. (Verknüpfung: https://kivymlapp.herokuapp.com/)

Fazit

In diesem ausführlichen Artikel, die vorgestellte FastAPI, seine Grundlagen, So erstellen Sie eine API-Datei für ein Modell für maschinelles Lernen, wie man diese API testet und wie man diese API auf der Heroku-Plattform implementiert. Wir haben auch gesehen, wie man auf den Dokumentenendpunkt zugreift, der von FastAPI automatisch generiert wird.

Im nächsten Artikel, Ich werde zeigen, wie Sie die in diesem Artikel erstellte API verwenden, um eine Android-Musikvorhersage-App mit Python zu erstellen, und wir werden diese Datei auch von Python in APK konvertieren.

Notiz: Sie können diesen Link verwenden, Masterlink zu allen meinen Artikeln im Internet, die jedes Mal aktualisiert wird, wenn ich einen neuen Artikel poste, um diesen Artikel zu finden.

Wenn Sie haben irgendwelche Zweifel, Anfrage oder mögliche Gelegenheit, dann kannst du mit mir über kommunizieren

1. Linkedin – In / kaustubh-gupta /

2. Twitter – @ Kaustubh1828

3. GitHub – kaustubhgupta

Verwandt