![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-laribi.jpeg\")
![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/04\/Medium-Blog.png\" "\\"Mittel")
<\/span><\/div>Teil 1 - Wie stelle ich eine Mlflow-Verfolgungsinstanz auf Kubernetes bereit?<\/h1><\/div>Einf\u00fchrung<\/h2><\/div>Mlflow ist ein in der data Science\/ML-Community weit verbreitetes Tool zur Verfolgung von Experimenten und zur Verwaltung von Modellen f\u00fcr maschinelles Lernen in verschiedenen Phasen. Damit k\u00f6nnen wir Metriken, Modelle und Artefakte speichern, um die Leistung von Modellen einfach zu vergleichen und ihre Lebenszyklen zu verwalten. Au\u00dferdem bietet Mlflow ein Modul, mit dem Modelle als API-Endpunkt bereitgestellt werden k\u00f6nnen, was die Integration in beliebige Produkte oder Webanwendungen erleichtert.<\/p>\n<\/div>
Der Einsatz von maschinellem Lernen in Online-Produkten ist zwar cool, aber je nach Modellgr\u00f6\u00dfe, Art (ML, Deep Learning,...) und Last (Nutzeranfragen) kann es eine Herausforderung sein, die ben\u00f6tigten Ressourcen zu dimensionieren und eine angemessene Antwortzeit zu garantieren. Daher ist die Verwendung einer skalierbaren Infrastruktur wie Kubernetes-Cluster der Schl\u00fcssel zur Aufrechterhaltung der Serviceverf\u00fcgbarkeit und Leistung in der Inferenzphase.<\/p>\n
In diesem Zusammenhang ver\u00f6ffentlichen wir eine dreiteilige Serie, in der wir die folgenden Fragen beantworten:<\/p>\n<\/div>
- <\/i><\/span>Wie kann ich die Mlflow-Tracking-Instanz in Kubernetes einrichten und verwenden?<\/div><\/li>
- <\/i><\/span>Wie kann man Modelle f\u00fcr maschinelles Lernen mit Hilfe von Mlflow als API bereitstellen?<\/div><\/li>
- <\/i><\/span>Wie k\u00f6nnen wir eine gro\u00dfe Anzahl von Anfragen bew\u00e4ltigen und unsere Inferenzaufgabe f\u00fcr industrialisierte Produkte skalierbar machen?<\/div><\/li><\/ul>
Beginnen wir also diesen ersten Artikel mit einer Einf\u00fchrung in Kubernetes und seine Komponenten und gehen wir die Bereitstellung einer Tracking-Instanz f\u00fcr Protokollmodelle durch.<\/p>\n<\/div>
\u00dcberblick \u00fcber Kubernetes<\/h2><\/div>Kubernetes ist ein Open-Source-Projekt, das von Google im Jahr 2014 ver\u00f6ffentlicht wurde. Es handelt sich um ein Container-Kontroll- und Orchestrierungssystem, das die automatische Bereitstellung, Skalierung und Planung von Anwendungen erm\u00f6glicht. Es hat die folgende Architektur:<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27705%27%20height%3D%270%27%20viewBox%3D%270%200%20705%200%27%3E%3Crect%20width%3D%27705%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Meister<\/strong>: Er verwaltet Eingabekonfigurationen, plant containerisierte Anwendungen auf den verschiedenen Knoten und \u00fcberwacht deren Status. Der Master besteht aus:<\/p>\n<\/div>- <\/i><\/span>API-Server:\u00a0<\/strong>erm\u00f6glicht die Interaktion mit dem Cluster und validiert die vom Entwickler gesendeten Befehle zur Aktualisierung des Clusters oder des App-Status.<\/div><\/li>
- <\/i><\/span>Planer<\/strong>: entscheidet\u00a0<\/strong>auf welchen Knoten neue Objekte ausgef\u00fchrt werden sollen, um Stabilit\u00e4t und Lastausgleich zu gew\u00e4hrleisten.<\/div><\/li>
- <\/i><\/span>Etcd:<\/strong>\u00a0eine database mit Schl\u00fcsselwerten, die die verschiedenen Ressourcenkonfigurationen und -zust\u00e4nde speichert<\/div><\/li>
- <\/i><\/span>Controller Manager:<\/strong>\u00fcberwacht den Zustand des Clusters und der verschiedenen Ressourcen und stellt sicher, dass der aktuelle Zustand dem gew\u00fcnschten entspricht.<\/div><\/li><\/ul>
Knotenpunkte:<\/strong> Sie sind die Ausf\u00fchrungsknoten, in denen sich die bereitgestellten Container befinden. Ihre Hauptkomponenten sind:<\/p>\n<\/div>- <\/i><\/span>Pods:\u00a0<\/strong>sind die grundlegende Ausf\u00fchrungseinheit in Kubernetes. Ein Pod kapselt eine Anwendung entweder als einzelnen Container oder als mehrere Container, die mit gemeinsam genutzten Speichervolumes und Netzwerken zusammenarbeiten.<\/div><\/li>
- <\/i><\/span>\n
Kubelet:<\/strong>ist\u00a0<\/strong>eine\u00a0<\/strong>Agent zur \u00dcberpr\u00fcfung des Container-Status und zur Kommunikation mit dem Kubernetes-Master.<\/p>\n<\/div><\/li><\/ul>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\u00fcr die Interaktion mit anderen hat. Au\u00dferdem bietet es die interessante M\u00f6glichkeit, eine Anwendung zu skalieren, ohne sich um die Verwaltung oder Synchronisierung neuer Dienste k\u00fcmmern zu m\u00fcssen, und Ressourcen zwischen verschiedenen Rechnern auszugleichen.<\/p>\n
Als data-Wissenschaftler oder ML-Ingenieure werden wir mit Kubernetes \u00fcber die Server-API interagieren, indem wir CLI-Befehle oder YAML-Konfigurationsdateien verwenden, um Anwendungen bereitzustellen und zu ver\u00f6ffentlichen oder den Status unserer Ressourcen abzurufen.<\/p>\n<\/div>
Praktische Vorraussetzungen<\/h2><\/div>F\u00fcr diese praktische \u00dcbung werden wir GCP als cloud-Anbieter verwenden. Zun\u00e4chst m\u00fcssen wir :<\/p>\n<\/div>
1. Schaffen Sie die infrastrukturellen Elemente<\/h3><\/div>- <\/i><\/span>mlflow_gke:<\/strong> einen Eimer zum Speichern von Dateien, datasets...<\/div><\/li>
- <\/i><\/span>\n
mlflow-k8s<\/strong>: einen GKE-Cluster mit drei Knoten (e2-highcpu-4), um sowohl das Tracking-Modul als auch das maschinelle Lernmodell einzusetzen.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Belastungstests:\u00a0<\/strong>einen GKE-Cluster mit drei Knoten (e2-standard-2), um Lasttests durchzuf\u00fchren. Er wird im dritten Artikel dieser Serie verwendet.<\/p>\n<\/div><\/li><\/ul>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27659%27%20height%3D%270%27%20viewBox%3D%270%200%20659%200%27%3E%3Crect%20width%3D%27659%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
2. Konfigurieren Sie die lokale Workstation<\/h3><\/div>- <\/i><\/span>\n
Installieren Sie die Python-Anforderungen f\u00fcr die Interaktion mit GCP und mlflow cli<\/p>\n
pip install mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Haben\u00a0gcloud<\/a>\u00a0und\u00a0kubectl<\/a>\u00a0mit den Anmeldeinformationen f\u00fcr den Zugriff auf das GCP-Projekt und die Cluster konfiguriert<\/div><\/li>
- <\/i><\/span>Sie haben Helm CLI installiert und initialisiert. Bitte\u00a0finden Sie hier die Anleitung<\/a>\u00a0f\u00fcr den Fall, dass Sie den Client noch nicht haben.<\/div><\/li><\/ul>
3. Klonen Sie das Hands-on-Projekt-Repository, um den Code zu erhalten<\/h3><\/div>Git-Klon https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>Bereitstellung der Mlflow Tracking-Instanz<\/h2><\/div>1. Einrichten der Cluster-Umgebung<\/h3><\/div>- <\/i><\/span>Erstellen Sie ein Dienstkonto, um die Interaktion mit GCS zu erm\u00f6glichen
\n<\/strong>Dies kann \u00fcber die Google cloud-Konsole erfolgen, unter dem Men\u00fcpunkt\u00a0iam-Abschnitt<\/a>. Wir m\u00fcssen ein Dienstkonto mit der Berechtigung zum Verwalten von Speicherobjekten erstellen, einen Authentifizierungsschl\u00fcssel erzeugen und ihn als keyfile.json herunterladen.<\/div><\/li>- <\/i><\/span>H\u00e4ngen Sie die Authentifizierungsdatei als Geheimnis ein<\/strong>
\n<\/strong>Geheimnisse erm\u00f6glichen es uns, die Zugangsdaten auf sichere Weise zu behandeln, so dass sie nur f\u00fcr die entsprechenden Ressourcen sichtbar sind.\u00a0<\/strong>Zu diesem Zweck erstellen wir ein geheimes Volume und geben die Authentifizierungsdatei nur f\u00fcr die ben\u00f6tigten Container frei.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27634%27%20height%3D%270%27%20viewBox%3D%270%200%20634%200%27%3E%3Crect%20width%3D%27634%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
2. Verfolgung des Servereinsatzes<\/h3><\/div>- <\/i><\/span>Postgres-Speicher<\/strong>
\n<\/strong>Postgre dient als Backend-Speicherelement f\u00fcr mlflow, um Modelle metadata und Metriken zu speichern.
\nF\u00fcr die Bereitstellung werden wir Helm verwenden: ein Ressourcenmanager f\u00fcr Kubernetes, in dem viele Anwendungen in Form von Diagrammen oder Vorlagen verf\u00fcgbar sind, die mit einfachen Befehlen konfiguriert werden k\u00f6nnen.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo add bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Verfolgungsinstanz<\/strong>
\n<\/strong>Wir werden auch Helm-Charts f\u00fcr die Bereitstellung des Tracking-Servers verwenden, aber zun\u00e4chst m\u00fcssen wir ein Docker-Image mit der gew\u00fcnschten Version erstellen, damit es von Helm heruntergeladen und bereitgestellt werden kann. Beachten Sie, dass das Image f\u00fcr Postgres bereits in einem \u00f6ffentlichen Repository enthalten war, aber hier werden wir unser eigenes Image erstellen.<\/p>\ncd mlflow-serving-beispiel<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Sobald das Image in die Image-Registry \u00fcbertragen wurde, k\u00f6nnen wir es mit den folgenden Befehlen \u00fcber helm auf dem Cluster verteilen.<\/p>\n
helm repo hinzuf\u00fcgen mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>helm install mlf-ts mlflow-tracking\/mlflow-tracking-server\n--setzen env.mlflowArtifactPath=$\n--set env.mlflowDBAddr=mlf-db-postgresql\n--set env.mlflowUser=postgres\n--set env.mlflowPass=mlflow\n-setzen env.mlflowDBName=mlflow_db\n--set env.mlflowDBPort=5432\n--set service.type=LoadBalancer\n--set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nJetzt sollte Mlflow funktionieren und die Benutzeroberfl\u00e4che sollte \u00fcber die IP des Load Balancers zug\u00e4nglich sein. Wir k\u00f6nnen die zugewiesene IP \u00fcberpr\u00fcfen mit\u00a0k<\/em>ubectl get Dienste<\/em>.<\/em><\/strong>A<\/em>Au\u00dferdem k\u00f6nnen wir die Bereitstellung debuggen, indem wir auf die Protokolle zugreifen\u00a0\u00fcber\u00a0<\/em>kubectl beschreibt Pods<\/strong>.<\/em>
Bislang sieht unsere derzeitige Architektur wie folgt aus:<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27621%27%20height%3D%270%27%20viewBox%3D%270%200%20621%200%27%3E%3Crect%20width%3D%27621%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Bitte beachten Sie, dass Load Balancer f\u00fcr jeden im Internet zug\u00e4nglich sind. Daher ist es wichtig, dass wir unsere Tracking-Instanz durch eine Authentifizierungsschicht absichern. Dies k\u00f6nnte mit dem\u00a0identit\u00e4tsbewusster Proxy<\/a>\u00a0auf GCP, wird aber in diesem Artikel nicht behandelt.<\/p>\n<\/div>3. Grundlegende Modellerstellung<\/h3><\/div>Nun, da unsere Infrastruktur und die Mlflow-Instanz bereit sind, k\u00f6nnen wir versuchen, ein einfaches ML-Modell auszuf\u00fchren und es zur sp\u00e4teren Verwendung in der Modellregistrierung zu speichern.
\nWir werden das Weinqualit\u00e4tsset 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.
\nDies ist ein klassisches Beispiel, in dem wir ein Xgboost-Regressionsmodell trainieren und es zusammen mit seinen Parametern und Metriken speichern. Den vollst\u00e4ndigen Code finden Sie in diesem\u00a0Notizbuch<\/a>.
\nSie haben vielleicht schon bemerkt, dass die Integration von Mlflow sehr einfach ist und in dem folgenden Codeschnipsel zusammengefasst werden kann, der Folgendes aufruft\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() und mlflow.xgboost.log_model()<\/strong><\/em>um jeweils ein neues Experiment zu erstellen, die Trainingsparameter, die Bewertungsmetriken und das trainierte Modell selbst zu speichern.<\/p>\n<\/div>mit mlflow.start_run() als run:\n \n # mlflow-Sitzung starten\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"sch\u00e4tzer\", sch\u00e4tzer)\n\n # Modell erstellen und anpassen\n model = xgb.XGBRegressor(\n max_depth=max_depth,\n min_child_weight=min_child_weight,\n n_estimators=estimators\n random_state=42)\n model.fit(X_train, y_train)\n\n # MLflow-Metriken\n Vorhersagen = model.predict(X_test)\n rmse = np.sqrt(mittlerer_quadratischer_Fehler(y_test, Vorhersagen))\n mlflow.log_metric(\"rmse\", rmse)\n\n # Log-Modell\n mlflow.xgboost.log_model(model, \"xgboost-model\", registered_model_name = model_name)\nWenn Sie das mitgelieferte Notizbuch ausf\u00fchren, wird eine neue Zeile in der Tracking-Instanz-Schnittstelle hinzugef\u00fcgt, die dem neuen Experiment entspricht.<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27642%27%20height%3D%270%27%20viewBox%3D%270%200%20642%200%27%3E%3Crect%20width%3D%27642%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Wenn wir schlie\u00dflich mit der Leistung des Modells zufrieden sind, k\u00f6nnen wir es aus der Tracking-Instanz laden und f\u00fcr die Inferenz in Python verwenden. Dies k\u00f6nnte auch mit dem zuvor geteilten Notebook geschehen. Beachten Sie, dass wir in diesem Beispiel das Modell \u00fcber die Lauf-ID geladen haben. Beachten Sie jedoch, dass Mlflow auch andere interessante M\u00f6glichkeiten bietet, Modelle \u00fcber Tags, Versionen oder Phasen zu identifizieren. Weitere Einzelheiten finden Sie in der Dokumentation zur Modellregistrierung\u00a0Hier<\/a>.<\/p>\n<\/div>Fazit<\/h2><\/div>In diesem Artikel haben wir es geschafft, eine Mlflow-Tracking-Instanz f\u00fcr unsere data-Wissenschaftsexperimente einzurichten, und wir haben ein kurzes Beispiel durchgespielt, das zeigt, wie man ein Modell protokolliert und es f\u00fcr zuk\u00fcnftige Inferenzen in Python speichert. Im n\u00e4chsten Artikel dieser Serie werden wir lernen, wie wir dieses Modell als API bereitstellen k\u00f6nnen. Dies ist von gro\u00dfer Bedeutung, da es die Interaktion mit dem Modell und seine Integration in ein Produkt oder eine Anwendung erleichtert. Au\u00dferdem sorgt die Ausf\u00fchrung auf Kubernetes daf\u00fcr, dass es leicht skalierbar bleibt und verschiedene Laststufen bew\u00e4ltigen kann.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
Einf\u00fchrung<\/h2><\/div>Mlflow ist ein in der data Science\/ML-Community weit verbreitetes Tool zur Verfolgung von Experimenten und zur Verwaltung von Modellen f\u00fcr maschinelles Lernen in verschiedenen Phasen. Damit k\u00f6nnen wir Metriken, Modelle und Artefakte speichern, um die Leistung von Modellen einfach zu vergleichen und ihre Lebenszyklen zu verwalten. Au\u00dferdem bietet Mlflow ein Modul, mit dem Modelle als API-Endpunkt bereitgestellt werden k\u00f6nnen, was die Integration in beliebige Produkte oder Webanwendungen erleichtert.<\/p>\n<\/div>
Der Einsatz von maschinellem Lernen in Online-Produkten ist zwar cool, aber je nach Modellgr\u00f6\u00dfe, Art (ML, Deep Learning,...) und Last (Nutzeranfragen) kann es eine Herausforderung sein, die ben\u00f6tigten Ressourcen zu dimensionieren und eine angemessene Antwortzeit zu garantieren. Daher ist die Verwendung einer skalierbaren Infrastruktur wie Kubernetes-Cluster der Schl\u00fcssel zur Aufrechterhaltung der Serviceverf\u00fcgbarkeit und Leistung in der Inferenzphase.<\/p>\n
In diesem Zusammenhang ver\u00f6ffentlichen wir eine dreiteilige Serie, in der wir die folgenden Fragen beantworten:<\/p>\n<\/div>
- <\/i><\/span>Wie kann ich die Mlflow-Tracking-Instanz in Kubernetes einrichten und verwenden?<\/div><\/li>
- <\/i><\/span>Wie kann man Modelle f\u00fcr maschinelles Lernen mit Hilfe von Mlflow als API bereitstellen?<\/div><\/li>
- <\/i><\/span>Wie k\u00f6nnen wir eine gro\u00dfe Anzahl von Anfragen bew\u00e4ltigen und unsere Inferenzaufgabe f\u00fcr industrialisierte Produkte skalierbar machen?<\/div><\/li><\/ul>
Beginnen wir also diesen ersten Artikel mit einer Einf\u00fchrung in Kubernetes und seine Komponenten und gehen wir die Bereitstellung einer Tracking-Instanz f\u00fcr Protokollmodelle durch.<\/p>\n<\/div>
\u00dcberblick \u00fcber Kubernetes<\/h2><\/div>Kubernetes ist ein Open-Source-Projekt, das von Google im Jahr 2014 ver\u00f6ffentlicht wurde. Es handelt sich um ein Container-Kontroll- und Orchestrierungssystem, das die automatische Bereitstellung, Skalierung und Planung von Anwendungen erm\u00f6glicht. Es hat die folgende Architektur:<\/p>\n<\/div>
Meister<\/strong>: Er verwaltet Eingabekonfigurationen, plant containerisierte Anwendungen auf den verschiedenen Knoten und \u00fcberwacht deren Status. Der Master besteht aus:<\/p>\n<\/div>- <\/i><\/span>API-Server:\u00a0<\/strong>erm\u00f6glicht die Interaktion mit dem Cluster und validiert die vom Entwickler gesendeten Befehle zur Aktualisierung des Clusters oder des App-Status.<\/div><\/li>
- <\/i><\/span>Planer<\/strong>: entscheidet\u00a0<\/strong>auf welchen Knoten neue Objekte ausgef\u00fchrt werden sollen, um Stabilit\u00e4t und Lastausgleich zu gew\u00e4hrleisten.<\/div><\/li>
- <\/i><\/span>Etcd:<\/strong>\u00a0eine database mit Schl\u00fcsselwerten, die die verschiedenen Ressourcenkonfigurationen und -zust\u00e4nde speichert<\/div><\/li>
- <\/i><\/span>Controller Manager:<\/strong>\u00fcberwacht den Zustand des Clusters und der verschiedenen Ressourcen und stellt sicher, dass der aktuelle Zustand dem gew\u00fcnschten entspricht.<\/div><\/li><\/ul>
Knotenpunkte:<\/strong> Sie sind die Ausf\u00fchrungsknoten, in denen sich die bereitgestellten Container befinden. Ihre Hauptkomponenten sind:<\/p>\n<\/div>- <\/i><\/span>Pods:\u00a0<\/strong>sind die grundlegende Ausf\u00fchrungseinheit in Kubernetes. Ein Pod kapselt eine Anwendung entweder als einzelnen Container oder als mehrere Container, die mit gemeinsam genutzten Speichervolumes und Netzwerken zusammenarbeiten.<\/div><\/li>
- <\/i><\/span>\n
Kubelet:<\/strong>ist\u00a0<\/strong>eine\u00a0<\/strong>Agent zur \u00dcberpr\u00fcfung des Container-Status und zur Kommunikation mit dem Kubernetes-Master.<\/p>\n<\/div><\/li><\/ul>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\u00fcr die Interaktion mit anderen hat. Au\u00dferdem bietet es die interessante M\u00f6glichkeit, eine Anwendung zu skalieren, ohne sich um die Verwaltung oder Synchronisierung neuer Dienste k\u00fcmmern zu m\u00fcssen, und Ressourcen zwischen verschiedenen Rechnern auszugleichen.<\/p>\n
Als data-Wissenschaftler oder ML-Ingenieure werden wir mit Kubernetes \u00fcber die Server-API interagieren, indem wir CLI-Befehle oder YAML-Konfigurationsdateien verwenden, um Anwendungen bereitzustellen und zu ver\u00f6ffentlichen oder den Status unserer Ressourcen abzurufen.<\/p>\n<\/div>
Praktische Vorraussetzungen<\/h2><\/div>F\u00fcr diese praktische \u00dcbung werden wir GCP als cloud-Anbieter verwenden. Zun\u00e4chst m\u00fcssen wir :<\/p>\n<\/div>
1. Schaffen Sie die infrastrukturellen Elemente<\/h3><\/div>- <\/i><\/span>mlflow_gke:<\/strong> einen Eimer zum Speichern von Dateien, datasets...<\/div><\/li>
- <\/i><\/span>\n
mlflow-k8s<\/strong>: einen GKE-Cluster mit drei Knoten (e2-highcpu-4), um sowohl das Tracking-Modul als auch das maschinelle Lernmodell einzusetzen.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
Belastungstests:\u00a0<\/strong>einen GKE-Cluster mit drei Knoten (e2-standard-2), um Lasttests durchzuf\u00fchren. Er wird im dritten Artikel dieser Serie verwendet.<\/p>\n<\/div><\/li><\/ul>2. Konfigurieren Sie die lokale Workstation<\/h3><\/div>- <\/i><\/span>\n
Installieren Sie die Python-Anforderungen f\u00fcr die Interaktion mit GCP und mlflow cli<\/p>\n
pip install mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Haben\u00a0gcloud<\/a>\u00a0und\u00a0kubectl<\/a>\u00a0mit den Anmeldeinformationen f\u00fcr den Zugriff auf das GCP-Projekt und die Cluster konfiguriert<\/div><\/li>
- <\/i><\/span>Sie haben Helm CLI installiert und initialisiert. Bitte\u00a0finden Sie hier die Anleitung<\/a>\u00a0f\u00fcr den Fall, dass Sie den Client noch nicht haben.<\/div><\/li><\/ul>
3. Klonen Sie das Hands-on-Projekt-Repository, um den Code zu erhalten<\/h3><\/div>Git-Klon https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>Bereitstellung der Mlflow Tracking-Instanz<\/h2><\/div>1. Einrichten der Cluster-Umgebung<\/h3><\/div>- <\/i><\/span>Erstellen Sie ein Dienstkonto, um die Interaktion mit GCS zu erm\u00f6glichen
\n<\/strong>Dies kann \u00fcber die Google cloud-Konsole erfolgen, unter dem Men\u00fcpunkt\u00a0iam-Abschnitt<\/a>. Wir m\u00fcssen ein Dienstkonto mit der Berechtigung zum Verwalten von Speicherobjekten erstellen, einen Authentifizierungsschl\u00fcssel erzeugen und ihn als keyfile.json herunterladen.<\/div><\/li>- <\/i><\/span>H\u00e4ngen Sie die Authentifizierungsdatei als Geheimnis ein<\/strong>
\n<\/strong>Geheimnisse erm\u00f6glichen es uns, die Zugangsdaten auf sichere Weise zu behandeln, so dass sie nur f\u00fcr die entsprechenden Ressourcen sichtbar sind.\u00a0<\/strong>Zu diesem Zweck erstellen wir ein geheimes Volume und geben die Authentifizierungsdatei nur f\u00fcr die ben\u00f6tigten Container frei.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>2. Verfolgung des Servereinsatzes<\/h3><\/div>- <\/i><\/span>Postgres-Speicher<\/strong>
\n<\/strong>Postgre dient als Backend-Speicherelement f\u00fcr mlflow, um Modelle metadata und Metriken zu speichern.
\nF\u00fcr die Bereitstellung werden wir Helm verwenden: ein Ressourcenmanager f\u00fcr Kubernetes, in dem viele Anwendungen in Form von Diagrammen oder Vorlagen verf\u00fcgbar sind, die mit einfachen Befehlen konfiguriert werden k\u00f6nnen.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo add bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Verfolgungsinstanz<\/strong>
\n<\/strong>Wir werden auch Helm-Charts f\u00fcr die Bereitstellung des Tracking-Servers verwenden, aber zun\u00e4chst m\u00fcssen wir ein Docker-Image mit der gew\u00fcnschten Version erstellen, damit es von Helm heruntergeladen und bereitgestellt werden kann. Beachten Sie, dass das Image f\u00fcr Postgres bereits in einem \u00f6ffentlichen Repository enthalten war, aber hier werden wir unser eigenes Image erstellen.<\/p>\ncd mlflow-serving-beispiel<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Sobald das Image in die Image-Registry \u00fcbertragen wurde, k\u00f6nnen wir es mit den folgenden Befehlen \u00fcber helm auf dem Cluster verteilen.<\/p>\n
helm repo hinzuf\u00fcgen mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>helm install mlf-ts mlflow-tracking\/mlflow-tracking-server\n--setzen env.mlflowArtifactPath=$\n--set env.mlflowDBAddr=mlf-db-postgresql\n--set env.mlflowUser=postgres\n--set env.mlflowPass=mlflow\n-setzen env.mlflowDBName=mlflow_db\n--set env.mlflowDBPort=5432\n--set service.type=LoadBalancer\n--set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nJetzt sollte Mlflow funktionieren und die Benutzeroberfl\u00e4che sollte \u00fcber die IP des Load Balancers zug\u00e4nglich sein. Wir k\u00f6nnen die zugewiesene IP \u00fcberpr\u00fcfen mit\u00a0k<\/em>ubectl get Dienste<\/em>.<\/em><\/strong>A<\/em>Au\u00dferdem k\u00f6nnen wir die Bereitstellung debuggen, indem wir auf die Protokolle zugreifen\u00a0\u00fcber\u00a0<\/em>kubectl beschreibt Pods<\/strong>.<\/em>
Bislang sieht unsere derzeitige Architektur wie folgt aus:<\/p>\n<\/div>Bitte beachten Sie, dass Load Balancer f\u00fcr jeden im Internet zug\u00e4nglich sind. Daher ist es wichtig, dass wir unsere Tracking-Instanz durch eine Authentifizierungsschicht absichern. Dies k\u00f6nnte mit dem\u00a0identit\u00e4tsbewusster Proxy<\/a>\u00a0auf GCP, wird aber in diesem Artikel nicht behandelt.<\/p>\n<\/div>3. Grundlegende Modellerstellung<\/h3><\/div>Nun, da unsere Infrastruktur und die Mlflow-Instanz bereit sind, k\u00f6nnen wir versuchen, ein einfaches ML-Modell auszuf\u00fchren und es zur sp\u00e4teren Verwendung in der Modellregistrierung zu speichern.
\nWir werden das Weinqualit\u00e4tsset 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.
\nDies ist ein klassisches Beispiel, in dem wir ein Xgboost-Regressionsmodell trainieren und es zusammen mit seinen Parametern und Metriken speichern. Den vollst\u00e4ndigen Code finden Sie in diesem\u00a0Notizbuch<\/a>.
\nSie haben vielleicht schon bemerkt, dass die Integration von Mlflow sehr einfach ist und in dem folgenden Codeschnipsel zusammengefasst werden kann, der Folgendes aufruft\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() und mlflow.xgboost.log_model()<\/strong><\/em>um jeweils ein neues Experiment zu erstellen, die Trainingsparameter, die Bewertungsmetriken und das trainierte Modell selbst zu speichern.<\/p>\n<\/div>mit mlflow.start_run() als run:\n \n # mlflow-Sitzung starten\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"sch\u00e4tzer\", sch\u00e4tzer)\n\n # Modell erstellen und anpassen\n model = xgb.XGBRegressor(\n max_depth=max_depth,\n min_child_weight=min_child_weight,\n n_estimators=estimators\n random_state=42)\n model.fit(X_train, y_train)\n\n # MLflow-Metriken\n Vorhersagen = model.predict(X_test)\n rmse = np.sqrt(mittlerer_quadratischer_Fehler(y_test, Vorhersagen))\n mlflow.log_metric(\"rmse\", rmse)\n\n # Log-Modell\n mlflow.xgboost.log_model(model, \"xgboost-model\", registered_model_name = model_name)\nWenn Sie das mitgelieferte Notizbuch ausf\u00fchren, wird eine neue Zeile in der Tracking-Instanz-Schnittstelle hinzugef\u00fcgt, die dem neuen Experiment entspricht.<\/p>\n<\/div>
Wenn wir schlie\u00dflich mit der Leistung des Modells zufrieden sind, k\u00f6nnen wir es aus der Tracking-Instanz laden und f\u00fcr die Inferenz in Python verwenden. Dies k\u00f6nnte auch mit dem zuvor geteilten Notebook geschehen. Beachten Sie, dass wir in diesem Beispiel das Modell \u00fcber die Lauf-ID geladen haben. Beachten Sie jedoch, dass Mlflow auch andere interessante M\u00f6glichkeiten bietet, Modelle \u00fcber Tags, Versionen oder Phasen zu identifizieren. Weitere Einzelheiten finden Sie in der Dokumentation zur Modellregistrierung\u00a0Hier<\/a>.<\/p>\n<\/div>Fazit<\/h2><\/div>In diesem Artikel haben wir es geschafft, eine Mlflow-Tracking-Instanz f\u00fcr unsere data-Wissenschaftsexperimente einzurichten, und wir haben ein kurzes Beispiel durchgespielt, das zeigt, wie man ein Modell protokolliert und es f\u00fcr zuk\u00fcnftige Inferenzen in Python speichert. Im n\u00e4chsten Artikel dieser Serie werden wir lernen, wie wir dieses Modell als API bereitstellen k\u00f6nnen. Dies ist von gro\u00dfer Bedeutung, da es die Interaktion mit dem Modell und seine Integration in ein Produkt oder eine Anwendung erleichtert. Au\u00dferdem sorgt die Ausf\u00fchrung auf Kubernetes daf\u00fcr, dass es leicht skalierbar bleibt und verschiedene Laststufen bew\u00e4ltigen kann.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
Mlflow ist ein in der data Science\/ML-Community weit verbreitetes Tool zur Verfolgung von Experimenten und zur Verwaltung von Modellen f\u00fcr maschinelles Lernen in verschiedenen Phasen. Damit k\u00f6nnen wir Metriken, Modelle und Artefakte speichern, um die Leistung von Modellen einfach zu vergleichen und ihre Lebenszyklen zu verwalten. Au\u00dferdem bietet Mlflow ein Modul, mit dem Modelle als API-Endpunkt bereitgestellt werden k\u00f6nnen, was die Integration in beliebige Produkte oder Webanwendungen erleichtert.<\/p>\n<\/div>
Der Einsatz von maschinellem Lernen in Online-Produkten ist zwar cool, aber je nach Modellgr\u00f6\u00dfe, Art (ML, Deep Learning,...) und Last (Nutzeranfragen) kann es eine Herausforderung sein, die ben\u00f6tigten Ressourcen zu dimensionieren und eine angemessene Antwortzeit zu garantieren. Daher ist die Verwendung einer skalierbaren Infrastruktur wie Kubernetes-Cluster der Schl\u00fcssel zur Aufrechterhaltung der Serviceverf\u00fcgbarkeit und Leistung in der Inferenzphase.<\/p>\n
In diesem Zusammenhang ver\u00f6ffentlichen wir eine dreiteilige Serie, in der wir die folgenden Fragen beantworten:<\/p>\n<\/div>
- <\/i><\/span>Wie kann ich die Mlflow-Tracking-Instanz in Kubernetes einrichten und verwenden?<\/div><\/li>
- <\/i><\/span>
Wie kann man Modelle f\u00fcr maschinelles Lernen mit Hilfe von Mlflow als API bereitstellen?<\/div><\/li>- <\/i><\/span>
Wie k\u00f6nnen wir eine gro\u00dfe Anzahl von Anfragen bew\u00e4ltigen und unsere Inferenzaufgabe f\u00fcr industrialisierte Produkte skalierbar machen?<\/div><\/li><\/ul>Beginnen wir also diesen ersten Artikel mit einer Einf\u00fchrung in Kubernetes und seine Komponenten und gehen wir die Bereitstellung einer Tracking-Instanz f\u00fcr Protokollmodelle durch.<\/p>\n<\/div>
\u00dcberblick \u00fcber Kubernetes<\/h2><\/div>
Kubernetes ist ein Open-Source-Projekt, das von Google im Jahr 2014 ver\u00f6ffentlicht wurde. Es handelt sich um ein Container-Kontroll- und Orchestrierungssystem, das die automatische Bereitstellung, Skalierung und Planung von Anwendungen erm\u00f6glicht. Es hat die folgende Architektur:<\/p>\n<\/div>
Meister<\/strong>: Er verwaltet Eingabekonfigurationen, plant containerisierte Anwendungen auf den verschiedenen Knoten und \u00fcberwacht deren Status. Der Master besteht aus:<\/p>\n<\/div>
- <\/i><\/span>API-Server:\u00a0<\/strong>erm\u00f6glicht die Interaktion mit dem Cluster und validiert die vom Entwickler gesendeten Befehle zur Aktualisierung des Clusters oder des App-Status.<\/div><\/li>
- <\/i><\/span>
Planer<\/strong>: entscheidet\u00a0<\/strong>auf welchen Knoten neue Objekte ausgef\u00fchrt werden sollen, um Stabilit\u00e4t und Lastausgleich zu gew\u00e4hrleisten.<\/div><\/li>- <\/i><\/span>
Etcd:<\/strong>\u00a0eine database mit Schl\u00fcsselwerten, die die verschiedenen Ressourcenkonfigurationen und -zust\u00e4nde speichert<\/div><\/li>- <\/i><\/span>
Controller Manager:<\/strong>\u00fcberwacht den Zustand des Clusters und der verschiedenen Ressourcen und stellt sicher, dass der aktuelle Zustand dem gew\u00fcnschten entspricht.<\/div><\/li><\/ul>Knotenpunkte:<\/strong> Sie sind die Ausf\u00fchrungsknoten, in denen sich die bereitgestellten Container befinden. Ihre Hauptkomponenten sind:<\/p>\n<\/div>
- <\/i><\/span>Pods:\u00a0<\/strong>sind die grundlegende Ausf\u00fchrungseinheit in Kubernetes. Ein Pod kapselt eine Anwendung entweder als einzelnen Container oder als mehrere Container, die mit gemeinsam genutzten Speichervolumes und Netzwerken zusammenarbeiten.<\/div><\/li>
- <\/i><\/span>
\nKubelet:<\/strong>ist\u00a0<\/strong>eine\u00a0<\/strong>Agent zur \u00dcberpr\u00fcfung des Container-Status und zur Kommunikation mit dem Kubernetes-Master.<\/p>\n<\/div><\/li><\/ul>
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\u00fcr die Interaktion mit anderen hat. Au\u00dferdem bietet es die interessante M\u00f6glichkeit, eine Anwendung zu skalieren, ohne sich um die Verwaltung oder Synchronisierung neuer Dienste k\u00fcmmern zu m\u00fcssen, und Ressourcen zwischen verschiedenen Rechnern auszugleichen.<\/p>\n
Als data-Wissenschaftler oder ML-Ingenieure werden wir mit Kubernetes \u00fcber die Server-API interagieren, indem wir CLI-Befehle oder YAML-Konfigurationsdateien verwenden, um Anwendungen bereitzustellen und zu ver\u00f6ffentlichen oder den Status unserer Ressourcen abzurufen.<\/p>\n<\/div>
Praktische Vorraussetzungen<\/h2><\/div>
F\u00fcr diese praktische \u00dcbung werden wir GCP als cloud-Anbieter verwenden. Zun\u00e4chst m\u00fcssen wir :<\/p>\n<\/div>
1. Schaffen Sie die infrastrukturellen Elemente<\/h3><\/div>
- <\/i><\/span>mlflow_gke:<\/strong> einen Eimer zum Speichern von Dateien, datasets...<\/div><\/li>
- <\/i><\/span>
\nmlflow-k8s<\/strong>: einen GKE-Cluster mit drei Knoten (e2-highcpu-4), um sowohl das Tracking-Modul als auch das maschinelle Lernmodell einzusetzen.<\/p>\n<\/div><\/li>
- <\/i><\/span>
\nBelastungstests:\u00a0<\/strong>einen GKE-Cluster mit drei Knoten (e2-standard-2), um Lasttests durchzuf\u00fchren. Er wird im dritten Artikel dieser Serie verwendet.<\/p>\n<\/div><\/li><\/ul>
2. Konfigurieren Sie die lokale Workstation<\/h3><\/div>
- <\/i><\/span>\n
Installieren Sie die Python-Anforderungen f\u00fcr die Interaktion mit GCP und mlflow cli<\/p>\n
pip install mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>
Haben\u00a0gcloud<\/a>\u00a0und\u00a0kubectl<\/a>\u00a0mit den Anmeldeinformationen f\u00fcr den Zugriff auf das GCP-Projekt und die Cluster konfiguriert<\/div><\/li>- <\/i><\/span>
Sie haben Helm CLI installiert und initialisiert. Bitte\u00a0finden Sie hier die Anleitung<\/a>\u00a0f\u00fcr den Fall, dass Sie den Client noch nicht haben.<\/div><\/li><\/ul>3. Klonen Sie das Hands-on-Projekt-Repository, um den Code zu erhalten<\/h3><\/div>
Git-Klon https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>
Bereitstellung der Mlflow Tracking-Instanz<\/h2><\/div>
1. Einrichten der Cluster-Umgebung<\/h3><\/div>
- <\/i><\/span>Erstellen Sie ein Dienstkonto, um die Interaktion mit GCS zu erm\u00f6glichen
\n<\/strong>Dies kann \u00fcber die Google cloud-Konsole erfolgen, unter dem Men\u00fcpunkt\u00a0iam-Abschnitt<\/a>. Wir m\u00fcssen ein Dienstkonto mit der Berechtigung zum Verwalten von Speicherobjekten erstellen, einen Authentifizierungsschl\u00fcssel erzeugen und ihn als keyfile.json herunterladen.<\/div><\/li>- <\/i><\/span>
H\u00e4ngen Sie die Authentifizierungsdatei als Geheimnis ein<\/strong>
\n<\/strong>Geheimnisse erm\u00f6glichen es uns, die Zugangsdaten auf sichere Weise zu behandeln, so dass sie nur f\u00fcr die entsprechenden Ressourcen sichtbar sind.\u00a0<\/strong>Zu diesem Zweck erstellen wir ein geheimes Volume und geben die Authentifizierungsdatei nur f\u00fcr die ben\u00f6tigten Container frei.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>2. Verfolgung des Servereinsatzes<\/h3><\/div>
- <\/i><\/span>Postgres-Speicher<\/strong>
\n<\/strong>Postgre dient als Backend-Speicherelement f\u00fcr mlflow, um Modelle metadata und Metriken zu speichern.
\nF\u00fcr die Bereitstellung werden wir Helm verwenden: ein Ressourcenmanager f\u00fcr Kubernetes, in dem viele Anwendungen in Form von Diagrammen oder Vorlagen verf\u00fcgbar sind, die mit einfachen Befehlen konfiguriert werden k\u00f6nnen.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo add bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>
Verfolgungsinstanz<\/strong>
\n<\/strong>Wir werden auch Helm-Charts f\u00fcr die Bereitstellung des Tracking-Servers verwenden, aber zun\u00e4chst m\u00fcssen wir ein Docker-Image mit der gew\u00fcnschten Version erstellen, damit es von Helm heruntergeladen und bereitgestellt werden kann. Beachten Sie, dass das Image f\u00fcr Postgres bereits in einem \u00f6ffentlichen Repository enthalten war, aber hier werden wir unser eigenes Image erstellen.<\/p>\ncd mlflow-serving-beispiel<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Sobald das Image in die Image-Registry \u00fcbertragen wurde, k\u00f6nnen wir es mit den folgenden Befehlen \u00fcber helm auf dem Cluster verteilen.<\/p>\n
helm repo hinzuf\u00fcgen mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>helm install mlf-ts mlflow-tracking\/mlflow-tracking-server\n--setzen env.mlflowArtifactPath=$\n--set env.mlflowDBAddr=mlf-db-postgresql\n--set env.mlflowUser=postgres\n--set env.mlflowPass=mlflow\n-setzen env.mlflowDBName=mlflow_db\n--set env.mlflowDBPort=5432\n--set service.type=LoadBalancer\n--set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nJetzt sollte Mlflow funktionieren und die Benutzeroberfl\u00e4che sollte \u00fcber die IP des Load Balancers zug\u00e4nglich sein. Wir k\u00f6nnen die zugewiesene IP \u00fcberpr\u00fcfen mit\u00a0k<\/em>ubectl get Dienste<\/em>.<\/em><\/strong>A<\/em>Au\u00dferdem k\u00f6nnen wir die Bereitstellung debuggen, indem wir auf die Protokolle zugreifen\u00a0\u00fcber\u00a0<\/em>kubectl beschreibt Pods<\/strong>.<\/em>
Bislang sieht unsere derzeitige Architektur wie folgt aus:<\/p>\n<\/div>Bitte beachten Sie, dass Load Balancer f\u00fcr jeden im Internet zug\u00e4nglich sind. Daher ist es wichtig, dass wir unsere Tracking-Instanz durch eine Authentifizierungsschicht absichern. Dies k\u00f6nnte mit dem\u00a0identit\u00e4tsbewusster Proxy<\/a>\u00a0auf GCP, wird aber in diesem Artikel nicht behandelt.<\/p>\n<\/div>
3. Grundlegende Modellerstellung<\/h3><\/div>
Nun, da unsere Infrastruktur und die Mlflow-Instanz bereit sind, k\u00f6nnen wir versuchen, ein einfaches ML-Modell auszuf\u00fchren und es zur sp\u00e4teren Verwendung in der Modellregistrierung zu speichern.
\nWir werden das Weinqualit\u00e4tsset 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.
\nDies ist ein klassisches Beispiel, in dem wir ein Xgboost-Regressionsmodell trainieren und es zusammen mit seinen Parametern und Metriken speichern. Den vollst\u00e4ndigen Code finden Sie in diesem\u00a0Notizbuch<\/a>.
\nSie haben vielleicht schon bemerkt, dass die Integration von Mlflow sehr einfach ist und in dem folgenden Codeschnipsel zusammengefasst werden kann, der Folgendes aufruft\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() und mlflow.xgboost.log_model()<\/strong><\/em>um jeweils ein neues Experiment zu erstellen, die Trainingsparameter, die Bewertungsmetriken und das trainierte Modell selbst zu speichern.<\/p>\n<\/div>mit mlflow.start_run() als run:\n \n # mlflow-Sitzung starten\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"sch\u00e4tzer\", sch\u00e4tzer)\n\n # Modell erstellen und anpassen\n model = xgb.XGBRegressor(\n max_depth=max_depth,\n min_child_weight=min_child_weight,\n n_estimators=estimators\n random_state=42)\n model.fit(X_train, y_train)\n\n # MLflow-Metriken\n Vorhersagen = model.predict(X_test)\n rmse = np.sqrt(mittlerer_quadratischer_Fehler(y_test, Vorhersagen))\n mlflow.log_metric(\"rmse\", rmse)\n\n # Log-Modell\n mlflow.xgboost.log_model(model, \"xgboost-model\", registered_model_name = model_name)\nWenn Sie das mitgelieferte Notizbuch ausf\u00fchren, wird eine neue Zeile in der Tracking-Instanz-Schnittstelle hinzugef\u00fcgt, die dem neuen Experiment entspricht.<\/p>\n<\/div>
Wenn wir schlie\u00dflich mit der Leistung des Modells zufrieden sind, k\u00f6nnen wir es aus der Tracking-Instanz laden und f\u00fcr die Inferenz in Python verwenden. Dies k\u00f6nnte auch mit dem zuvor geteilten Notebook geschehen. Beachten Sie, dass wir in diesem Beispiel das Modell \u00fcber die Lauf-ID geladen haben. Beachten Sie jedoch, dass Mlflow auch andere interessante M\u00f6glichkeiten bietet, Modelle \u00fcber Tags, Versionen oder Phasen zu identifizieren. Weitere Einzelheiten finden Sie in der Dokumentation zur Modellregistrierung\u00a0Hier<\/a>.<\/p>\n<\/div>
Fazit<\/h2><\/div>
In diesem Artikel haben wir es geschafft, eine Mlflow-Tracking-Instanz f\u00fcr unsere data-Wissenschaftsexperimente einzurichten, und wir haben ein kurzes Beispiel durchgespielt, das zeigt, wie man ein Modell protokolliert und es f\u00fcr zuk\u00fcnftige Inferenzen in Python speichert. Im n\u00e4chsten Artikel dieser Serie werden wir lernen, wie wir dieses Modell als API bereitstellen k\u00f6nnen. Dies ist von gro\u00dfer Bedeutung, da es die Interaktion mit dem Modell und seine Integration in ein Produkt oder eine Anwendung erleichtert. Au\u00dferdem sorgt die Ausf\u00fchrung auf Kubernetes daf\u00fcr, dass es leicht skalierbar bleibt und verschiedene Laststufen bew\u00e4ltigen kann.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-article2.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-article3.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais-4.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais5.png\")
![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/03\/medium.png\" "\\"mittel\\"")
<\/span><\/div>