Wie setzt man ein Modell für maschinelles Lernen ein?

In den letzten Jahren haben maschinelles Lernen und künstliche Intelligenz erheblich an Popularität gewonnen. Dies ist wahrscheinlich auf die Fortschritte bei der Verarbeitung natürlicher Sprache und bei Empfehlungssystemen zurückzuführen.

Dieser Artikel stellt maschinelles Lernen, seine Anwendungen und Einsatzmöglichkeiten vor und zeigt, wie man ein einfaches maschinelles Lernmodell in Back4app Containern einsetzt.

Was ist maschinelles Lernen?

Maschinelles Lernen ist ein Teilbereich der künstlichen Intelligenz. Im Kern nutzt es statistische Algorithmen, um aus Daten zu lernen und Vorhersagen über neue, ungesehene Daten zu treffen.

Mit anderen Worten, sie gibt Computern die Fähigkeit zu lernen, ohne ausdrücklich programmiert zu werden.

Obwohl maschinelles Lernen und künstliche Intelligenz oft synonym verwendet werden, sind sie nicht dasselbe.

Das maschinelle Lernen konzentriert sich auf Algorithmen und Datenstrukturen, während die künstliche Intelligenz ein allgemeiner Versuch ist, Maschinen zu schaffen, die in der Lage sind, wie Menschen zu denken.

Typische Verfahren des maschinellen Lernens sind die Regression (Vorhersage eines kontinuierlichen Wertes, z. B. eines Hauspreises) und die Klassifizierung (Vorhersage einer Klasse aus einer endlichen Menge von Klassen, z. B. eines Filmgenres).

Im Allgemeinen können wir das maschinelle Lernen in drei Arten unterteilen:

• Überwachtes Lernen – Algorithmen lernen anhand eines markierten Datensatzes. Jedes Beispiel im Datensatz enthält eine Kennzeichnung (oder eine sogenannte Zielvariable). Der Algorithmus verwendet diese, um Kennzeichnungen für ungesehene Beispiele vorherzusagen. Zu den Algorithmen des überwachten Lernens gehören kNN, Decision trees usw.

• Unüberwachtes Lernen – Algorithmen lernen ohne ausdrückliche Anleitung. Es ist Aufgabe des Algorithmus, Muster in den Daten zu finden und darauf basierend Vorhersagen zu treffen. Ein Beispiel für einen Algorithmus ist das k-means Clustering.

• Verstärkungslernen – Algorithmen lernen durch Versuch und Irrtum. Sie sind in der Regel belohnungsbasiert, und das Ziel des Algorithmus ist es, die Belohnung zu maximieren. Beispiel: genetische Algorithmen.

Im praktischen Teil des Artikels werden wir einen typischen Prozess der Modellerstellung durchlaufen. Wir werden eine Klassifizierungsaufgabe mit überwachtem Lernen lösen.

Anwendungen des maschinellen Lernens

Werfen wir einen Blick auf einige reale Anwendungen des maschinellen Lernens!

Empfehlende Systeme

Empfehlungssysteme schlagen vor, welche Artikel (Filme, Produkte usw.) ein Benutzer konsumieren sollte. Diese Systeme können entweder inhaltsbasiert oder kollaborationsbasiert sein.

Heutzutage werden Recommeder-Systeme von fast jedem Unternehmen eingesetzt. Sie ermöglichen es Unternehmen, den Geschäftserfolg zu steigern, zusätzliche Nachfrage zu schaffen, das Engagement der Nutzer zu erhöhen, mehr über Kunden zu erfahren und vieles mehr.

Netflix zum Beispiel nutzt sie, um Filme zu empfehlen, Spotify, um Songs zu empfehlen, und YouTube, um Videos vorzuschlagen, die Sie aufgrund Ihrer Interessen ansehen sollten.

Natürliche Sprachverarbeitung (NLP)

Die Verarbeitung natürlicher Sprache (NLP) ermöglicht es Computern, menschliche Sprache zu verarbeiten und zu verstehen. Die Erzeugung natürlicher Sprache (NLG) ermöglicht es Computern, menschliche Sprache zu erzeugen.

Diese Technologie wird von Chatbots, Sprachübersetzungs-Tools, Stimmungsanalyse-Tools und mehr verwendet. ChatGPT ist eines der bekanntesten Beispiele für die Nutzung von NLP und NLG.

Möchten Sie mehr über ChatGPT erfahren? Sehen Sie sich unseren anderen Artikel an: Wie erstelle ich eine App mit ChatGPT?

Computer Vision und Bilderkennung

Computer Vision verleiht Computern die Fähigkeit, Bilder und Videos zu “sehen” und zu “verstehen”. So können sie (in Echtzeit) Segmentierungen vornehmen, Objekte, Gesichter und sogar Emotionen erkennen.

Diese Technologie wird von Foto-Apps verwendet, um Ihre Freunde automatisch zu markieren. Außerdem wird sie von Überwachungssystemen verwendet, um verdächtiges Verhalten zu erkennen.

Aufdeckung von Betrug

Unternehmen setzen maschinelles Lernen ein, um verdächtige Aktivitäten bei Transaktionen oder Nutzerverhalten zu erkennen. Diese Systeme können durch die Untersuchung von Trends und Anomalien potenziell betrügerische Handlungen erkennen und Unternehmen und Kunden vor Betrug und Cyberkriminalität schützen.

Selbstfahrende Autos

Autonomes Fahren ist eines der komplizierteren Probleme des maschinellen Lernens. Es kombiniert verschiedene Anwendungen wie Computer Vision, Erkennung von Anomalien, Verhaltensvorhersage, Pfadplanung usw.

Zum Zeitpunkt der Erstellung dieses Berichts sind wir noch weit von vollautonomen Autos entfernt. Die derzeitigen “selbstfahrenden” Autos funktionieren nur in begrenzten geografischen Gebieten gut.

Optionen für den Einsatz von maschinellem Lernen

Um ein Modell für maschinelles Lernen bereitzustellen, wird es in der Regel aus einer Webanwendung bereitgestellt. Daher sind die Optionen für die Bereitstellung von Modellen für maschinelles Lernen praktisch dieselben wie für die Bereitstellung von Webanwendungen. Schauen wir sie uns an!

Vor-Ort

Die Vor-Ort-Bereitstellung umfasst das Hosting und die Verwaltung von IT-Geräten wie Servern und Speichergeräten in den Räumlichkeiten eines Unternehmens.

Diese herkömmliche Strategie erfordert beträchtliche Anfangsinvestitionen in Hardware und Software sowie laufende Wartung und Support.

Zu den Vorteilen gehören ein höheres Maß an Kontrolle und Sicherheit sowie eine leichter zugängliche Anpassungsmöglichkeit. Auf der anderen Seite sind die Nachteile die Kosten, die Skalierbarkeit und die Wartung.

Wolke

Im Gegensatz dazu werden bei der Cloud-Bereitstellung Dienste von Drittanbietern genutzt, um Infrastruktur und Anwendungen über das Internet zu hosten.

Dieses Modell ermöglicht es den Nutzern, nach Bedarf für skalierbare Ressourcen und Dienste zu zahlen, die von Cloud-Anbietern verwaltet werden.

Zu den Vorteilen gehören Skalierbarkeit, Benutzerfreundlichkeit und keine Vorlaufkosten. Auf der anderen Seite sind die Nachteile ein geringeres Maß an Kontrolle, weniger Flexibilität und eine mögliche Bindung an einen Anbieter.

Beispiele für Cloud-basierte Plattformen sind:

• Back4app
• Amazon Web Services (AWS)
• Google Cloud Platform
• Microsoft Azure

Beliebte Algorithmen für maschinelles Lernen

Beliebte Algorithmen für maschinelles Lernen sind:

• k-Nearest Neighbours (kNN)
• Decision Trees & Random Forests
• Support Vector Machines (SVM)
• Linear Regression
• Naive Bayes
• K-means

Im praktischen Beispiel werden wir k-Nächste Nachbarn verwenden.

Wie setzt man ein Modell für maschinelles Lernen ein?

In diesem Artikel werden wir ein Modell für maschinelles Lernen erstellen, es mit FastAPI bereitstellen, es andocken und schließlich in Back4app Containern bereitstellen.

Voraussetzungen

• Grundkenntnisse des maschinellen Lernens
• Erfahrung mit Python und FastAPI
• Grundlegendes Verständnis von Docker und der Containerisierungstechnologie
• Git und Docker Desktop sind auf Ihrem lokalen Rechner installiert

Überblick über das Projekt

Bevor wir zeigen, wie man ein Modell für maschinelles Lernen einsetzt, werden wir eines erstellen. Wir werden einen einfachen kNN-Klassifikator mit dem beliebten Iris-Datensatz erstellen. Das Modell soll anhand verschiedener Merkmale vorhersagen, ob eine Beobachtung “setosa”, “versicolour” oder “virginica” ist.

Anschließend speichern wir das Modell in einer Datei, laden es in FastAPI und stellen es über einen Endpunkt bereit. Danach docken wir die App an, pushen sie auf GitHub und stellen sie auf Back4app Containers bereit.

Modell erstellen

Zur Erstellung des Modells verwenden wir Jupyter Notebooks. Sie können Jupyter entweder auf Ihrem lokalen Rechner installieren oder Google Colab kostenlos nutzen.

Erstellen Sie zunächst ein neues Jupyter-Notizbuch.

Jeder Codeblock in diesem Artikelabschnitt stellt eine Jupyter-Zelle dar. Sie können sie über das Menü oder mit der Tastenkombination “B” (im Befehlsmodus) erstellen.

Vergessen Sie auch nicht, sie zu starten (entweder über das Menü oder mit “ALT + ENTER”).

Fügen Sie die folgenden Importe in die erste Zelle ein:

import numpy as np
import pandas as pd

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score

from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

from joblib import dump

Datensatz laden

Der Iris-Datensatz ist in Scikit-learn standardmäßig enthalten. Sie müssen lediglich die Funktion load_iris() aufrufen und das Objekt in einen Rahmen umwandeln.

Erstellen Sie eine neue Zelle:

df = load_iris(as_frame=True)["data"]
df["target"] = load_iris(as_frame=True)["target"]

Wenn Sie den Iris-Datensatz laden, wird er nach der Zielvariablen geordnet. Das ist nicht gut, weil unser maschinelles Lernmodell in der Trainingsphase möglicherweise nur einige Arten von Beispielen sieht. Z. B. nur “setosa” und “versicolour”.

Um dieses Problem zu vermeiden, können wir sie mischen:

df = df.sample(frac=1, random_state=42)

Das Attribut random_state dient der Reproduzierbarkeit. Sie können jede beliebige Zahl verwenden.

Datensatz erforschen

Bevor Sie ein Modell erstellen, ist es eine gute Idee zu untersuchen, mit welchen Daten Sie es zu tun haben. Dazu können Sie die eingebauten Pandas-Funktionen wie head(), describe() und so weiter verwenden.

# Displays the first five rows of the dataset
df.head(5)

# Generates descriptive statistics
df.describe()

Darüber hinaus sollten Sie den Datensatz visualisieren, um herauszufinden, welche Merkmale die Beispiele am besten trennen und welcher Algorithmus für maschinelles Lernen für Ihr Problem nützlich sein könnte.

Das obige Bild wurde aus dem Artikel Guide to Data Visualization with Python entliehen. Schauen Sie sich den Artikel an, um mehr über Datenvisualisierung zu erfahren.

Das Bild zeigt, dass die “roten” Punkte linear von den beiden anderen trennbar sind. Der “blaue” und der “grüne” Punkt sind dagegen nicht linear trennbar.

Geteilter Datensatz

Lassen Sie uns nun die Merkmale (Prädiktoren) und die Zielvariable definieren:

features = [
    "sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"
]
target = "target"

Anschließend werden sie in X (Merkmalsdaten) und y (Zielvariablendaten) extrahiert und durch Test-Train aufgeteilt:

X = df[features].values
y = df[target].values

dev_X, test_X, dev_y, test_y = train_test_split(X, y, test_size=0.25, random_state=42)

Bei der Verwendung von test_size=0,25 werden 25 % des Datensatzes zum Testen und 75 % zum Trainieren verwendet.

Modell bauen

Als Nächstes erstellen Sie eine Pipeline, die zunächst die Daten skaliert und dann den kNN-Klassifikator verwendet:

knn = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("predictor", KNeighborsClassifier()),
])
knn.fit(dev_X, dev_y)

Warum die Skalierung so wichtig ist, erfahren Sie in diesem Artikel.

Verwenden Sie dann die 10-fache Kreuzvalidierung und überprüfen Sie den Validierungsfehler:

cross_val_score(knn, dev_X, dev_y, cv=10, scoring="accuracy").mean()

# 0.9363636363636362

Bewerten Sie das Modell anhand der Testmenge:

accuracy_score(test_y, knn.predict(test_X))

# 0.9736842105263158

Die Validierungs- und Testgenauigkeit sind ziemlich gleich. Dies zeigt, dass unser Modell weder unter- noch überangepasst ist.

Modell speichern

Zum Schluss trainieren Sie das Modell mit allen Daten neu und speichern es in der Datei model.pkl:

knn.fit(X, y)
dump(knn, "model.pkl")

Wenn Sie Google Colab verwendet haben, laden Sie die Datei model.pk herunter, da wir sie im nächsten Schritt benötigen werden.

Modell servieren

Wie bereits erwähnt, werden wir FastAPI verwenden, um das Modell zu bedienen.

Erstellen Sie ein neues FastAPI-Projekt und ersetzen Sie main.py wie folgt:

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {
        "name": "back4app-deploy-ml-model",
        "description": "A FastAPI app serving an ML model",
        "version": "1.0.0",
    }

Starten Sie den Entwicklungsserver:

$ uvicorn app.main:app --reload

Navigieren Sie zu http://localhost:8000/, und Sie sollten die folgende Antwort erhalten:

{
    "name": "back4app-deploy-ml-model",
    "description": "A FastAPI app serving an ML model",
    "version": "1.0.0"
}

Lastmodell

Als nächstes laden wir das Modell und definieren die model_classes.

Kopieren Sie zunächst model.pkl aus dem vorherigen Schritt in das Stammverzeichnis Ihres Projekts. Dann laden Sie das Modell und definieren die Klassen direkt unter der Initialisierung der FastAPI-App wie folgt:

# ...

model = load("model.pkl")
model_classes = {
    0: "setosa",
    1: "versicolor",
    2: "virginica",
}

# ...

Wir werden model_classes verwenden, um die Zielvariable von numerisch in Text zu übersetzen.

Lastmodell

Erstellen Sie dann den Endpunkt /predict, der die Merkmale aufnimmt und das geladene Modell verwendet, um eine Vorhersage zu treffen:

# main.py

# ...

class Observation(BaseModel):
    """
    A Pydantic model for the observation data.
    This is our ML model's input data.
    """
    sepal_length: float
    sepal_width: float
    petal_length: float
    petal_width: float


@app.post("/predict")
async def predict(observation: Observation):
    predictions = model.predict([[
        observation.sepal_length,
        observation.sepal_width,
        observation.petal_length,
        observation.petal_width,
    ]])
    prediction = predictions[0]
    prediction_class = model_classes[prediction]
    return {
        "prediction": int(prediction),
        "prediction_class": prediction_class,
    }

Der Endpunkt gibt sowohl die numerische Vorhersage als auch die benutzerfreundliche Testvorhersage zurück.

Vergessen Sie nicht die Importe am Anfang der Datei:

from joblib import load
from pydantic import BaseModel

Ihre endgültige main.py sollte wie folgt aussehen.

Starten Sie den Entwicklungsserver neu und navigieren Sie in Ihrem bevorzugten Webbrowser zu http://localhost:8000/docs. FastAPI generiert automatisch eine interaktive Dokumentation für alle Ihre Endpunkte.

Testen Sie das Modell, indem Sie eine Anfrage wie diese einreichen:

Großartig, unsere Webanwendung ist jetzt voll funktionsfähig!

Dockerize-App

In diesem Artikelabschnitt werden wir die Webanwendung dockerisieren. Wir erstellen eine Dockerdatei und konfigurieren die .dockerignore-Datei.

Dockerdatei

Ein Dockerfile ist eine Datei, die Anweisungen für die Docker Engine enthält, um das Image zu erstellen.

Dazu gehören in der Regel die Übertragung von Dateien, die Definition des Basis-Images, die Konfiguration des Arbeitsverzeichnisses, die Ausführung benutzerdefinierter Befehle und vieles mehr.

Dockerfile-Befehle werden in der Regel in Großbuchstaben geschrieben und werden direkt von den entsprechenden Argumenten gefolgt.

<COMMAND> <arg1> <arg2> ... <arg_n>

# Example
WORKDIR /app

Besuchen Sie die Dockerfile-Referenz, um mehr über alle Anweisungen zu erfahren.

Erstellen Sie im Stammverzeichnis des Projekts eine Dockerdatei:

# Dockerfile

# Set the base image
FROM python:3.12.2-alpine3.19

# Install the required dependencies (gcc)
RUN apk add build-base

# Set the working directory
WORKDIR /app

# Confingure Python using environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Copy the requirements file into the image and install them
COPY ./requirements.txt .
RUN pip install --no-cache-dir --upgrade pip
RUN pip install --no-cache-dir --upgrade -r ./requirements.txt

# Copy the source code into the image
COPY . .

# Expose the port
EXPOSE 8000

# Start the Uvicorn server
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

.dockerignore

Wenn Sie mit Docker arbeiten, sollten Sie möglichst kleine Images erstellen.

Eine Möglichkeit, die Bildgröße zu verringern, ist die Verwendung einer .dockerignore-Datei. Diese Datei funktioniert ähnlich wie eine .gitignore-Datei. Sie ermöglicht es Ihnen, Dateien auszulassen, die nicht in das Abbild aufgenommen werden müssen.

Erstellen Sie im Stammverzeichnis des Projekts eine .dockerignore:

.git/
.idea/

__pycache__/
venv/

create_model.ipynb

Stellen Sie sicher, dass Sie die .dockerignore-Datei an die Anforderungen Ihres Projekts anpassen (z. B. wenn Sie eine andere IDE verwenden).

Bauen, ausführen, testen

Bevor Sie das Bild in die Cloud stellen, sollten Sie es lokal testen.

Um diese Anleitung zu befolgen, müssen Sie Docker Desktop auf Ihrem Rechner installieren.

Öffnen Sie das Terminal und prüfen Sie die derzeit installierten Images:

$ docker images

Als Nächstes erstellen Sie das Image mithilfe der Dockerdatei:

$ docker build -t iris-webapp:1.0 .

Es wird eine ganze Weile dauern, bis Docker das Image erstellt hat. Das liegt vor allem daran, dass Scikit-learn nicht für Docker-Container optimiert ist. Machen Sie ruhig eine kurze Kaffeepause.

Überprüfen Sie nach Beendigung des Befehls die Bilder erneut. Das neu erstellte Image sollte dort zu finden sein.

Schließlich verwenden Sie das Bild, um einen neuen Container zu erstellen:

 $ docker run -p 8000:8000 --name iris-webapp iris-webapp:1.0

Das war’s!

Ihre Webanwendung ist nun containerisiert. Sie sollte unter http://localhost:8000/ zugänglich sein und genauso funktionieren wie zuvor.

Auf GitHub verschieben

Navigieren Sie zunächst zu GitHub und erstellen Sie ein neues Repository. Notieren Sie sich die Remote-URL, da wir sie in einem späteren Schritt benötigen werden.

Kehren Sie nun zu Ihrem Projektstamm zurück.

Bevor Sie den Quellcode in die Cloud stellen, erstellen Sie eine .gitignore-Datei. Mit einer .gitignore-Datei können Sie angeben, welche Dateien und Verzeichnisse in der Versionskontrolle ausgelassen werden sollen.

Dieser Dateityp funktioniert auf die gleiche Weise wie eine .dockerignore-Datei.

Erstellen Sie im Stammverzeichnis des Projekts eine .gitignore-Datei:

#.dockerignore

.idea/
__pycache__/
venv/

Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus, um Git zu initialisieren:

$ git init

Fügen Sie alle Dateien zum VCS hinzu und übertragen Sie sie:

$ git add .
$ git commit -m "first commit"

Schließlich fügen Sie den entfernten GitHub-Ursprung unter Verwendung der URL von zuvor hinzu und pushen den Quellcode:

$ git remote add origin <remote_url>
$ git push origin master

Stellen Sie sicher, dass die Remote-URL aus dem vorangegangenen Schritt anstelle von .

Das war’s. Wenn Sie jetzt die Seite des GitHub-Repositorys besuchen, sollten Sie sehen, dass alle Dateien hinzugefügt worden sind.

App bereitstellen

Um eine Anwendung in Back4app Containers bereitzustellen, müssen Sie sich zunächst registrieren oder anmelden (wenn Sie bereits ein Konto haben).

Wenn Sie sich mit Ihrem Back4app-Konto authentifizieren, werden Sie zu Ihrem App-Dashboard weitergeleitet. Um eine neue App zu erstellen, klicken Sie auf “Neue App erstellen”.

Back4app ermöglicht die Bereitstellung von Backend as a Service und Containern as a Service. Da wir eine containerisierte Anwendung bereitstellen, wählen wir die letztere Option.

Als nächstes müssen Sie Ihr GitHub-Konto mit Back4app verbinden. Dadurch kann Back4app den Quellcode aus Ihren Repositories abrufen. Sie können entweder Zugriff auf alle Repositories gewähren oder bestimmte auswählen.

Sobald die Repositories importiert wurden, klicken Sie auf “Auswählen”.

Die Konfiguration der Umgebung ist bis auf die Angabe eines beschreibenden Anwendungsnamens nicht erforderlich.

Klicken Sie dann auf “Erstellen”.

Back4app wird ein paar Minuten brauchen, um das Image zu erstellen, es in die Container-Registry zu übertragen und einen Container zu starten. Sobald die Bereitstellung abgeschlossen ist, sollte sich der Status Ihrer App auf “Bereit” ändern.

Um Ihre App zu besuchen, klicken Sie auf die URL, wie in der Abbildung unten gezeigt.

Großartig, Sie haben erfolgreich ein maschinelles Lernmodell auf Back4app Containern bereitgestellt. Die Web-App sollte genauso funktionieren wie lokal. Stellen Sie sicher, dass Sie die App noch einmal testen.

Zusammenfassung

In diesem Artikel haben Sie die Grundlagen des maschinellen Lernens, seine Anwendungen und den Einsatz eines maschinellen Lernmodells kennengelernt.

Sie sollten nun in der Lage sein, Ihre eigenen einfachen Modelle zu erstellen, sie mit FastAPI zu bedienen und sie in Back4app Containern bereitzustellen.

Holen Sie sich den endgültigen Quellcode aus dem back4app-deploy-ml-model GitHub-Repository.