Lesen Sie unseren Artikel über

.

MLflow ist ein häufig verwendetes Tool für die Verfolgung von Experimenten zum maschinellen Lernen, die Versionierung von Modellen und das Serving. In unserem ersten Artikel der Serie “ML-Modelle in großem Umfang bereitstellen” erklären wir, wie Sie die Tracking-Instanz auf Kubernetes bereitstellen und sie zum Protokollieren von Experimenten und Speichern von Modellen verwenden.

Teil 1 - Wie stelle ich eine Mlflow-Verfolgungsinstanz auf Kubernetes bereit?

Einführung

Mlflow ist ein in der data Science/ML-Community weit verbreitetes Tool zur Verfolgung von Experimenten und zur Verwaltung von Modellen für maschinelles Lernen in verschiedenen Phasen. Damit können wir Metriken, Modelle und Artefakte speichern, um die Leistung von Modellen einfach zu vergleichen und ihre Lebenszyklen zu verwalten. Außerdem bietet Mlflow ein Modul, mit dem Modelle als API-Endpunkt bereitgestellt werden können, was die Integration in beliebige Produkte oder Webanwendungen erleichtert.

Der Einsatz von maschinellem Lernen in Online-Produkten ist zwar cool, aber je nach Modellgröße, Art (ML, Deep Learning,...) und Last (Nutzeranfragen) kann es eine Herausforderung sein, die benötigten Ressourcen zu dimensionieren und eine angemessene Antwortzeit zu garantieren. Daher ist die Verwendung einer skalierbaren Infrastruktur wie Kubernetes-Cluster der Schlüssel zur Aufrechterhaltung der Serviceverfügbarkeit und Leistung in der Inferenzphase.

In diesem Zusammenhang veröffentlichen wir eine dreiteilige Serie, in der wir die folgenden Fragen beantworten:

  • Wie kann ich die Mlflow-Tracking-Instanz in Kubernetes einrichten und verwenden?
  • Wie kann man Modelle für maschinelles Lernen mit Hilfe von Mlflow als API bereitstellen?
  • Wie können wir eine große Anzahl von Anfragen bewältigen und unsere Inferenzaufgabe für industrialisierte Produkte skalierbar machen?

Beginnen wir also diesen ersten Artikel mit einer Einführung in Kubernetes und seine Komponenten und gehen wir die Bereitstellung einer Tracking-Instanz für Protokollmodelle durch.

Überblick über Kubernetes

Kubernetes ist ein Open-Source-Projekt, das von Google im Jahr 2014 veröffentlicht wurde. Es handelt sich um ein Container-Kontroll- und Orchestrierungssystem, das die automatische Bereitstellung, Skalierung und Planung von Anwendungen ermöglicht. Es hat die folgende Architektur:

Image

Meister: Er verwaltet Eingabekonfigurationen, plant containerisierte Anwendungen auf den verschiedenen Knoten und überwacht deren Status. Der Master besteht aus:

  • API-Server: ermöglicht die Interaktion mit dem Cluster und validiert die vom Entwickler gesendeten Befehle zur Aktualisierung des Clusters oder des App-Status.
  • Planer: entscheidet auf welchen Knoten neue Objekte ausgeführt werden sollen, um Stabilität und Lastausgleich zu gewährleisten.
  • Etcd: eine database mit Schlüsselwerten, die die verschiedenen Ressourcenkonfigurationen und -zustände speichert
  • Controller Manager:überwacht den Zustand des Clusters und der verschiedenen Ressourcen und stellt sicher, dass der aktuelle Zustand dem gewünschten entspricht.

Knotenpunkte: Sie sind die Ausführungsknoten, in denen sich die bereitgestellten Container befinden. Ihre Hauptkomponenten sind:

  • Pods: sind die grundlegende Ausführungseinheit in Kubernetes. Ein Pod kapselt eine Anwendung entweder als einzelnen Container oder als mehrere Container, die mit gemeinsam genutzten Speichervolumes und Netzwerken zusammenarbeiten.
  • Kubelet:ist eine Agent zur Überprüfung des Container-Status und zur Kommunikation mit dem Kubernetes-Master.

Es ist die erste Wahl, wenn eine Anwendung aus mehreren Diensten besteht, die miteinander kommunizieren, denn es stellt sicher, dass jeder Dienst seine eigene Container-Umgebung mit einer Reihe von Regeln für die Interaktion mit anderen hat. Außerdem bietet es die interessante Möglichkeit, eine Anwendung zu skalieren, ohne sich um die Verwaltung oder Synchronisierung neuer Dienste kümmern zu müssen, und Ressourcen zwischen verschiedenen Rechnern auszugleichen.

Als data-Wissenschaftler oder ML-Ingenieure werden wir mit Kubernetes über die Server-API interagieren, indem wir CLI-Befehle oder YAML-Konfigurationsdateien verwenden, um Anwendungen bereitzustellen und zu veröffentlichen oder den Status unserer Ressourcen abzurufen.

Praktische Vorraussetzungen

Für diese praktische Übung werden wir GCP als cloud-Anbieter verwenden. Zunächst müssen wir :

1. Schaffen Sie die infrastrukturellen Elemente

  • mlflow_gke: einen Eimer zum Speichern von Dateien, datasets...
  • mlflow-k8s: einen GKE-Cluster mit drei Knoten (e2-highcpu-4), um sowohl das Tracking-Modul als auch das maschinelle Lernmodell einzusetzen.

  • Belastungstests: einen GKE-Cluster mit drei Knoten (e2-standard-2), um Lasttests durchzuführen. Er wird im dritten Artikel dieser Serie verwendet.

Image

2. Konfigurieren Sie die lokale Workstation

  • Installieren Sie die Python-Anforderungen für die Interaktion mit GCP und mlflow cli

    pip install mlflow gcsfs google-cloud google-cloud-storage kubernetes
  • Haben gcloud und kubectl mit den Anmeldeinformationen für den Zugriff auf das GCP-Projekt und die Cluster konfiguriert
  • Sie haben Helm CLI installiert und initialisiert. Bitte finden Sie hier die Anleitung für den Fall, dass Sie den Client noch nicht haben.

3. Klonen Sie das Hands-on-Projekt-Repository, um den Code zu erhalten

Bereitstellung der Mlflow Tracking-Instanz

1. Einrichten der Cluster-Umgebung

  • Erstellen Sie ein Dienstkonto, um die Interaktion mit GCS zu ermöglichen
    Dies kann über die Google cloud-Konsole erfolgen, unter dem Menüpunkt iam-Abschnitt. Wir müssen ein Dienstkonto mit der Berechtigung zum Verwalten von Speicherobjekten erstellen, einen Authentifizierungsschlüssel erzeugen und ihn als keyfile.json herunterladen.
  • Hängen Sie die Authentifizierungsdatei als Geheimnis ein
    Geheimnisse ermöglichen es uns, die Zugangsdaten auf sichere Weise zu behandeln, so dass sie nur für die entsprechenden Ressourcen sichtbar sind. Zu diesem Zweck erstellen wir ein geheimes Volume und geben die Authentifizierungsdatei nur für die benötigten Container frei.
    kubectl create secret generic gcsfs-creds -from-file=./keyfile.json
Image

2. Verfolgung des Servereinsatzes

  • Postgres-Speicher
    Postgre dient als Backend-Speicherelement für mlflow, um Modelle metadata und Metriken zu speichern.
    Für die Bereitstellung werden wir Helm verwenden: ein Ressourcenmanager für Kubernetes, in dem viele Anwendungen in Form von Diagrammen oder Vorlagen verfügbar sind, die mit einfachen Befehlen konfiguriert werden können.

    #docs: https://artifacthub.io/packages/helm/bitnami/postgresqlhelm repo add bitnami https://charts.bitnami.com/bitnamihelm install mlf-db bitnami/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort
  • Verfolgungsinstanz
    Wir werden auch Helm-Charts für die Bereitstellung des Tracking-Servers verwenden, aber zunächst müssen wir ein Docker-Image mit der gewünschten Version erstellen, damit es von Helm heruntergeladen und bereitgestellt werden kann. Beachten Sie, dass das Image für Postgres bereits in einem öffentlichen Repository enthalten war, aber hier werden wir unser eigenes Image erstellen.

    cd mlflow-serving-beispieldocker build --tag $/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .docker push $/mlflow-tracking-server:v1

Sobald das Image in die Image-Registry übertragen wurde, können wir es mit den folgenden Befehlen über helm auf dem Cluster verteilen.

helm repo hinzufügen mlflow-tracking https://artefactory-global.github.io/mlflow-tracking-server/helm install mlf-ts mlflow-tracking/mlflow-tracking-server
--setzen env.mlflowArtifactPath=$
--set env.mlflowDBAddr=mlf-db-postgresql
--set env.mlflowUser=postgres
--set env.mlflowPass=mlflow
-setzen env.mlflowDBName=mlflow_db
--set env.mlflowDBPort=5432
--set service.type=LoadBalancer
--set image.repository=$/mlflow-tracking-server
--set image.tag=v1

Jetzt sollte Mlflow funktionieren und die Benutzeroberfläche sollte über die IP des Load Balancers zugänglich sein. Wir können die zugewiesene IP überprüfen mit kubectl get Dienste.AAußerdem können wir die Bereitstellung debuggen, indem wir auf die Protokolle zugreifen über kubectl beschreibt Pods.
Bislang sieht unsere derzeitige Architektur wie folgt aus:

Image

Bitte beachten Sie, dass Load Balancer für jeden im Internet zugänglich sind. Daher ist es wichtig, dass wir unsere Tracking-Instanz durch eine Authentifizierungsschicht absichern. Dies könnte mit dem identitätsbewusster Proxy auf GCP, wird aber in diesem Artikel nicht behandelt.

3. Grundlegende Modellerstellung

Nun, da unsere Infrastruktur und die Mlflow-Instanz bereit sind, können wir versuchen, ein einfaches ML-Modell auszuführen und es zur späteren Verwendung in der Modellregistrierung zu speichern.
Wir werden das Weinqualitätsset data verwenden, das aus etwa 4900 Proben und 11 Merkmalen besteht, die die Eigenschaften des Weins widerspiegeln. Das Etikett reicht von 3 bis 9 und kann als Bewertung angesehen werden.
Dies ist ein klassisches Beispiel, in dem wir ein Xgboost-Regressionsmodell trainieren und es zusammen mit seinen Parametern und Metriken speichern. Den vollständigen Code finden Sie in diesem Notizbuch.
Sie haben vielleicht schon bemerkt, dass die Integration von Mlflow sehr einfach ist und in dem folgenden Codeschnipsel zusammengefasst werden kann, der Folgendes aufruft mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() und mlflow.xgboost.log_model()um jeweils ein neues Experiment zu erstellen, die Trainingsparameter, die Bewertungsmetriken und das trainierte Modell selbst zu speichern.

mit mlflow.start_run() als run: # mlflow-Sitzung starten mlflow.log_param("max_depth", max_depth) mlflow.log_param("min_child_weight", min_child_weight) mlflow.log_param("schätzer", schätzer) # Modell erstellen und anpassen model = xgb.XGBRegressor( max_depth=max_depth, min_child_weight=min_child_weight, n_estimators=estimators random_state=42) model.fit(X_train, y_train) # MLflow-Metriken Vorhersagen = model.predict(X_test) rmse = np.sqrt(mittlerer_quadratischer_Fehler(y_test, Vorhersagen)) mlflow.log_metric("rmse", rmse) # Log-Modell mlflow.xgboost.log_model(model, "xgboost-model", registered_model_name = model_name)

Wenn Sie das mitgelieferte Notizbuch ausführen, wird eine neue Zeile in der Tracking-Instanz-Schnittstelle hinzugefügt, die dem neuen Experiment entspricht.

Image

Wenn wir schließlich mit der Leistung des Modells zufrieden sind, können wir es aus der Tracking-Instanz laden und für die Inferenz in Python verwenden. Dies könnte auch mit dem zuvor geteilten Notebook geschehen. Beachten Sie, dass wir in diesem Beispiel das Modell über die Lauf-ID geladen haben. Beachten Sie jedoch, dass Mlflow auch andere interessante Möglichkeiten bietet, Modelle über Tags, Versionen oder Phasen zu identifizieren. Weitere Einzelheiten finden Sie in der Dokumentation zur Modellregistrierung Hier.

Fazit

In diesem Artikel haben wir es geschafft, eine Mlflow-Tracking-Instanz für unsere data-Wissenschaftsexperimente einzurichten, und wir haben ein kurzes Beispiel durchgespielt, das zeigt, wie man ein Modell protokolliert und es für zukünftige Inferenzen in Python speichert. Im nächsten Artikel dieser Serie werden wir lernen, wie wir dieses Modell als API bereitstellen können. Dies ist von großer Bedeutung, da es die Interaktion mit dem Modell und seine Integration in ein Produkt oder eine Anwendung erleichtert. Außerdem sorgt die Ausführung auf Kubernetes dafür, dass es leicht skalierbar bleibt und verschiedene Laststufen bewältigen kann.

Mittel Blog von Artefact.

Dieser Artikel wurde ursprünglich veröffentlicht auf Medium.com.
Folgen Sie uns auf unserem Medium Blog !