Deployment von Machine-Learning-Modellen mit Seldon Core

In diesem Artikel sehen wir uns an, wie wir Machine-Learning- und Deep-Learning-Modelle mit Seldon Core deployen können. Seldon Core ist eine Open-Source-Plattform, um Modelle auf einem Kubernetes-Cluster in Betrieb zu nehmen. Bevor wir uns Seldon Core widmen, werfen wir einen kurzen Blick auf Container und Kubernetes in der Data-Science-Welt. Als praktisches Beispiel deployen wir ein ONNX-Modell zur Emotionserkennung mit Seldon Core auf einem Kubernetes-Cluster.

Die Rolle von Kubernetes in der Data-Science-Welt

Docker und Container gehören heute für einen Großteil der Software-Entwickler zum Tagesgeschäft. Der Mehrwert von Containern ist, dass eine Applikation mit deren Abhängigkeiten zu Softwarepaketen und -bibliotheken als ein Paket ausgeliefert werden kann. Dies erleichtert die Inbetriebnahme und Weiterentwicklung der Applikation.

Kubernetes ist ein Open-Source-System für die Orchestrierung von Containern. Die Orchestrierung bezieht sich auf Deployment, Scaling und Management der Container-Applikationen. Dadurch wird der manuelle Aufwand für die Verwaltung der Container auf ein Minimum reduziert. Ausfallsicherheit und Monitoring sind bei der Konzeptionierung von Kubernetes berücksichtigt. Des Weiteren werden bei einem Kubernetes-Cluster die verfügbaren Ressourcen wie Memory oder CPU der Server zusammengeschlossen und individuell für die Anwendungen verteilt.

In der Data-Science-Welt sind Reproduzierbarkeit der Experimente und Portierbarkeit der Umgebungen essentiell für die erfolgreiche Implementierung. Diese zwei Kernaspekte können mit Kubernetes abgebildet werden. Weiterhin haben wir den Vorteil, dass wir unsere entwickelten Komponenten und Pipelines je nach Bedarf skalieren können. Bei der lokalen Entwicklung der Data-Science-Projekte muss Software entwickelt werden, die in der Lage ist, große Datenmengen zu verarbeiten und Modelle zu trainieren. Mithilfe von Kubernetes können wir anschließend unsere Software unproblematisch in der Cloud oder im Rechenzentrum skalieren. 

Für das Modelldeployment müssen mehr Konzepte aus DevOps als aus Data Science berücksichtigt werden. Dazu gehören beispielsweise Rolling-Updates, Monitoring und automatisierte Skalierung. In der Software-Welt gehören diese Themen den Best Practices an. Diese Konzepte sind in Kubernetes integriert. Im Zuge der Professionalisierung von Data Science kann sowohl die Modellentwicklung als auch das Modelldeployment durch den Einsatz von Kubernetes profitieren, wenn es ein bestehendes Kubernetes-Cluster gibt.

Seldon Core

Seldon Core ist eine Plattform, mit der Modelle auf einem Kubernetes-Cluster in Betrieb genommen werden können. Seldon Core fokussiert sich dabei auf die Inferenz der Modelle. Die Plattform enthält eine umfangreiche Anzahl von Features für das Modelldeployment. Einige der Core Features sind im Folgenden aufgelistet:

• Deployment: Das Deployment bezieht sich auf Inbetriebnahme, Skalierung und Update des Modells. Seldon Core stellt passenden Komponenten zur Verfügung, um ein Modell auf dem Kubernetes-Cluster zu deployen und zu skalieren. Das Ausrollen einer neuen Modellversion geschieht unter dem Zero-Down-Time-Aspekt. Das bedeutet, dass die alte Version eines Modells solange erreichbar ist, bis die neue Version erfolgreich deployed wurde. Des Weiteren können verschiedene Modellversionen mithilfe von A/B Testing verglichen werden. 
• API des Modells: Nur das Deployment eines Modells liefert keinen Mehrwert für das Unternehmen. Erst wenn das Modell in den Unternehmenskontext integriert ist, wird ein Mehrwert über die Automatisierung von datengetriebenen Entscheidungen erschaffen. Dazu muss die Schnittstelle der Laufzeitumgebung des Modells in existierende Anwendungen und neue Produkte integriert werden. Seldon Core stellt das Modell als REST- oder GRPC-Schnittstelle zur Verfügung.
• Inferenz-Optimierung: Durch den hohen Grad an Konfigurationsmöglichkeiten mithilfe von Kubernetes kann die Ausführungszeit der Inferenz auf die Infrastruktur angepasst werden. Dadurch können wir die Latenz und den Durchsatz der Laufzeit für unseren Anwendungsfall optimieren.

Deployment eines ONNX-Modells mit Seldon Core als Docker Container 

Wir schauen uns an wie wir mit Seldon Core ein ONNX-Modell als Docker Container deployen können. Als Anwendungsfalls wollen wir ein Modell deployen, das in der Lage ist, anhand von Gesichtsbildern Emotionen wie neutral oder glücklich zu erkennen. Dazu verwenden wir ein bereits trainiertes Deep Convolutional Neural Network . Als Input für das Modell wird erwartet, dass die Bilder im Grayscale Format (1, 64, 64) vorliegen.

Inferenz mit nGraph

Seldon Core verwendet für die Ausführung von ONNX-Modellen den nGraph Compiler. Der nGraph Compiler zielt darauf, die Inferenz der Modelle je nach vorliegender Hardware zu beschleunigen. Dies bedeutet, dass der Compiler passend zur Hardware die optimalen Instruktionen finden. Im Vergleich zu den nativen Deep Learning Frameworks, wirbt nGraph mit einer 45-fachen Beschleunigung der Workloads. Das funktioniert sowohl für die CPU als auch GPU. nGraph kann als Python-Paket installiert werden.

Python und Docker Wrapping des ONNX-Modells

Die Inferenz des Modells wird für Seldon Core in Python-Code entwickelt. Wir erstellen die Klasse EmotionModel, die die Inferenz mit nGraph implementiert. Dazu müssen wir in der Klasse die Methode predict() implementieren. Zusätzlich haben wir noch eine Softmax- und Postprocess-Funktion hinzugefügt, um als Rückgabewert den Labelnamen und dessen zugehörige Wahrscheinlichkeit zurückzugeben.

Anschließend erstellen wir ein zugehöriges Dockerfile. Darin müssen wir für Seldon Core folgende Umgebungsvariable spezifizieren: 

• MODEL bezeichnet den Name des Python-Scripts das ausgeführt wird.
• API_TYPE bezeichnet die Art der Schnittstelle. Gültige Werte sind REST oder GRPC
• SERVICE_TYPE bezeichnet, um welche Art von Service es sich handelt. Für den Artikel beschränken wir uns hier auf den MODEL. Eine vollständige Liste der möglichen Service-Konfigurationen gibt es hier .
• PERSISTENCE hat als die 0 und 1 als die gültigen Werte. Mit dem Wert 0 werden keine Daten gespeichert. Mit dem Wert 1 werden auf einem Redis Input und das Ergebnis gespeichert.

Die Applikation ist als REST-Schnittstelle unter dem Port 5000 erreichbar. Um eine Prediction auszuführen, müssen wir den Endpoint /predict mit einem POST Request aufrufen. Mit dem folgenden Script können wir ein Bild als Payload gegen den Endpoint schicken, um ihn zu testen.

Deployment von Seldon Core auf einem Kubernetes-Cluster

Als Nächstes wird das Modell auf einem Kubernetes-Cluster deployed. Das vollständige Tutorial steht auf GitHub zur Verfügung. In diesem Artikel werden die relevanten Befehle gezeigt. Folgende Pakete werden benötigt, um das Tutorial zu absolvieren:

• minikube : Lokales Kubernetes-Cluster
• helm : Paket-Manager für Kubernetes
• s2i (source-to-image) : Container erstellen mithilfe von Templates und Quellcode.

Zuerst müssen wir das Kubernetes-Cluster erstellen und starten. Dazu führen wir minikube start in der Shell aus.

1. Docker Container mit Source-to-image erstellen

Kubernetes ist für die Orchestrierung von Containern zuständig. Aus diesem Grund müssen wir aus unserem Modell sowie zugehörigem Code einen Container erstellen. Seldon empfiehlt dazu s2i (source-to-image). s2i erstellt anhand eines Templates und dem Quellcode einen Container. Seldon hat das Template seldonio/seldon-core-s2i-python37:0.11 erstellt. Die Benutzerbedienung des Templates kann mit dem Befehl s2i usage seldonio/seldon-core-s2i-python37:0.11 erhalten werden. Die Umgebungsvariablen, die im Dockerfile angelegt wurden, müssen in die Datei .s2i/Environment kopiert werden. Mit dem folgenden Befehl erstellen wir das Image emotion-service:0.1.

eval $(minikube docker-env) && s2i build . seldonio/seldon-core-s2i-python37:0.11 emotion-service:0.1 

2. Seldon Core Operator auf Kubernetes-Cluster installieren

Anschließend installieren wir den Paket-Manager helm auf dem Cluster, um seldon-core-operator zu installieren. Dazu führen wir den Befehl helm init aus. Als Nächstes können wir den seldon-core-operator installieren. Er kümmert sich um das Deployment der Modelle. Operatoren bieten in Kubernetes die Möglichkeit, eine Applikationen auf einem Cluster zu installieren und zu deployen. Ein Operator besteht aus einer Custom Resource Definition (CRD) und einem Controller, der im Cluster deployed wird. Das CRD ist eine Art Template, mit dem die zugehörige Applikation sowie deren Eigenschaft in das Kubernetes-Cluster deployed werden können. In unserem Fall spezifizieren hierzu anhand des Templates unsere Modellapplikationen. Für mehr Details kann ich den Artikel von meinem Kollegen Roman Seyffarth empfehlen. 

Der seldon-core-operator wird über helm installiert. Dazu müssen wir das Repository des Operators hinzufügen und anschließend installieren.

helm repo add seldon https://storage.googleapis.com/seldon-charts
helm install seldon/seldon-core-operator --version 0.4.0

Nachdem wir den Operatoren installiert haben, spezifizieren wir das Deployment des Modells. Dazu nehmen wir die YAML Vorlage des seldon-core-operator und erstellen anschließend die Datei emotion_service_deployment.json .

Das Deployment erstellen wir anschließend mit dem Befehl kubectl create -f emotion_service_deployment.json. Anschließend haben wir das Modell für die Inferenz in Kubernetes deployed.

3. Gateway Ambassador installieren

Ein Problem an dieser Stelle ist, dass der Modellendpunkt nicht außerhalb des Kubernetes-Clusters zur Verfügung steht. Um den Endpunkt nach außen zur Verfügung zu stellen und somit das Modell ansteuern zu können, müssen wir Ambassador im Cluster deployen. Ambassador ist ein API Gateway für Kubernetes, der ebenfalls über helm installiert werden kann.

helm install stable/ambassador --name ambassador --set crds.keep=false

Testen des Models

Um das Modell zu testen benötigen wir die IP des Kubernetes-Cluster und den Port von Ambassador:

minikube ip
kubectl get svc ambassador -o jsonpath='{.spec.ports[0].nodePort}'

Der Endpoint besteht anschließend aus http:// {minikube ip}: {ambassador port} / seldon / {namespace} / {deployment name} /api/v0.1/predictions und kann als POST Request erreicht werden.

curl -vX POST http://192.168.99.100:30809/seldon/default/seldon-emotion/api/v0.1/predictions -d @payload.json --header "Content-Type: application/json"

Der Code sowie das vollständige Kubernetes-Tutorial können im GitHub Repository naxty/seldon-core-onnx gefunden werden.

Fazit

Das Data-Science-Ökosystem von Kubernetes wächst. Mit Seldon Core haben wir eine umfangreiche Plattform, mit der Modelle in ein Kubernetes-Cluster deployed und skaliert werden können. Die Modelle können als GRPC- oder REST-Schnittstelle deployen. Weiterhin bietet Seldon Core umfangreiche Operationen, um die Daten zu transformieren und co. Der seldon-core-operator vereinfacht die Deployments eines Modells. 

Credits

Ein Großteil des Tutorials wurde auf Basis von der Entwicklerdokumentation von Seldon Core erstellt und kann hier gefunden werden.