Website-Suche

So stellen Sie ein Deep-Learning-Modell auf Kubernetes bereit


Erfahren Sie, wie Sie mit der Kubermatic Kubernetes-Plattform ein Deep-Learning-Modell bereitstellen, skalieren und verwalten, das Bilderkennungsvorhersagen liefert.

Da Unternehmen verstärkt künstliche Intelligenz (KI), maschinelles Lernen (ML) und Deep Learning (DL) einsetzen, stellt sich eine entscheidende Frage: Wie können sie die ML-Entwicklung skalieren und industrialisieren? Diese Gespräche konzentrieren sich oft auf das ML-Modell; Allerdings ist dies nur ein Schritt auf dem Weg zu einer Komplettlösung. Um eine Anwendung und Skalierung in der Produktion zu erreichen, muss die Modellentwicklung einen wiederholbaren Prozess umfassen, der die kritischen Aktivitäten berücksichtigt, die der Entwicklung vorausgehen und folgen, einschließlich der Einführung des Modells in eine öffentliche Bereitstellung.

In diesem Artikel wird gezeigt, wie Sie mithilfe der Kubermatic Kubernetes-Plattform ein Deep-Learning-Modell bereitstellen, skalieren und verwalten, das Bilderkennungsvorhersagen liefert.

Kubermatic Kubernetes Platform ist ein Open-Source-Cluster-Management-Tool für Kubernetes in Produktionsqualität, das Flexibilität und Automatisierung für die Integration in ML/DL-Workflows mit vollständiger Cluster-Lebenszyklusverwaltung bietet.

Loslegen

In diesem Beispiel wird ein Deep-Learning-Modell für die Bilderkennung eingesetzt. Es verwendet den CIFAR-10-Datensatz, der aus 60.000 32x32-Farbbildern in 10 Klassen besteht, mit der Gluon-Bibliothek in Apache MXNet und NVIDIA-GPUs, um die Arbeitslast zu beschleunigen. Wenn Sie ein vorab trainiertes Modell für den CIFAR-10-Datensatz verwenden möchten, lesen Sie den Leitfaden „Erste Schritte“.

Das Modell wurde über einen Zeitraum von 200 Epochen trainiert, solange der Validierungsfehler langsam abnahm, ohne dass es zu einer Überanpassung des Modells kam. Dieses Diagramm zeigt den Trainingsprozess:

(Chaimaa Zyami, CC BY-SA 4.0)

Nach dem Training ist es wichtig, die Parameter des Modells zu speichern, damit sie später geladen werden können:

file_name = "net.params"
net.save_parameters(file_name)

Sobald das Modell fertig ist, packen Sie Ihren Vorhersagecode in einen Flask-Server. Dadurch kann der Server ein Bild als Argument für seine Anfrage akzeptieren und die Vorhersage des Modells in der Antwort zurückgeben:

from gluoncv.model_zoo import get_model
import matplotlib.pyplot as plt
from mxnet import gluon, nd, image
from mxnet.gluon.data.vision import transforms
from gluoncv import utils
from PIL import Image
import io
import flask 
app = flask.Flask(__name__)

@app.route("/predict",methods=["POST"])
def predict():
    if flask.request.method == "POST":
        if flask.request.files.get("img"):
            img = Image.open(io.BytesIO(flask.request.files["img"].read()))
            transform_fn = transforms.Compose([
            transforms.Resize(32),
            transforms.CenterCrop(32),
            transforms.ToTensor(),
            transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])])
            img = transform_fn(nd.array(img))
            net = get_model('cifar_resnet20_v1', classes=10)
            net.load_parameters('net.params')
            pred = net(img.expand_dims(axis=0))
            class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
                       'dog', 'frog', 'horse', 'ship', 'truck']
            ind = nd.argmax(pred, axis=1).astype('int')
            prediction = 'The input picture is classified as [%s], with probability %.3f.'%
                         (class_names[ind.asscalar()], nd.softmax(pred)[0][ind].asscalar())
    return prediction

if __name__ == '__main__':
    app.run(host='0.0.0.0')

Containerisieren Sie das Modell

Bevor Sie Ihr Modell auf Kubernetes bereitstellen können, müssen Sie Docker installieren und ein Container-Image mit Ihrem Modell erstellen.

  1. Laden Sie Docker herunter, installieren Sie es und starten Sie es:

    sudo yum install -y yum-utils device-mapper-persistent-data lvm2
    
    sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
    
    sudo yum install docker-ce
    
    sudo systemctl start docker
  2. Erstellen Sie ein Verzeichnis, in dem Sie Ihren Code und Ihre Abhängigkeiten organisieren können:

    mkdir kubermatic-dl
    cd kubermatic-dl
  3. Erstellen Sie eine requirements.txt-Datei, die die Pakete enthält, die der Code zum Ausführen benötigt:

    flask
    gluoncv
    matplotlib
    mxnet
    requests
    Pillow
  4. Erstellen Sie die Docker-Datei, die Docker liest, um das Modell zu erstellen und auszuführen:

    FROM python:3.6
    WORKDIR /app
    COPY requirements.txt /app
    RUN pip install -r ./requirements.txt
    COPY app.py /app
    CMD ["python", "app.py"]~

    Dieses Dockerfile kann in drei Schritte unterteilt werden. Zuerst wird die Docker-Datei erstellt und Docker angewiesen, ein Basis-Image von Python 3 herunterzuladen. Als Nächstes wird Docker aufgefordert, den Python-Paketmanager pip zu verwenden, um die Pakete in requirements.txt zu installieren. . Schließlich weist es Docker an, Ihr Skript über python app.py auszuführen.

  5. Erstellen Sie den Docker-Container:

    sudo docker build -t kubermatic-dl:latest .

    Dadurch wird Docker angewiesen, einen Container für den Code in Ihrem aktuellen Arbeitsverzeichnis kubermatic-dl zu erstellen.

  6. Überprüfen Sie, ob Ihr Container funktioniert, indem Sie ihn auf Ihrem lokalen Computer ausführen:

    sudo docker run -d -p 5000:5000 kubermatic-dl
  7. Überprüfen Sie den Status Ihres Containers, indem Sie sudo docker ps -a:
    ausführen

    (Chaimaa Zyami, CC BY-SA 4.0)

Laden Sie das Modell auf Docker Hub hoch

Bevor Sie das Modell auf Kubernetes bereitstellen können, muss es öffentlich verfügbar sein. Tun Sie dies, indem Sie es zum Docker Hub hinzufügen. (Sie müssen ein Docker Hub-Konto erstellen, falls Sie noch keines haben.)

  1. Melden Sie sich bei Ihrem Docker Hub-Konto an:

    sudo docker login
  2. Kennzeichnen Sie das Bild, damit Sie beim Hochladen auf Docker Hub zur Versionierung darauf verweisen können:

    sudo docker tag <your-image-id> <your-docker-hub-name>/<your-app-name>
    
    sudo docker push <your-docker-hub-name>/<your-app-name>

    (Chaimaa Zyami, CC BY-SA 4.0)

  3. Überprüfen Sie Ihre Bild-ID, indem Sie sudo docker images ausführen.

Stellen Sie das Modell in einem Kubernetes-Cluster bereit

  1. Erstellen Sie ein Projekt auf der Kubermatic Kubernetes-Plattform und erstellen Sie dann mithilfe des Schnellstart-Tutorials einen Kubernetes-Cluster.

    (Chaimaa Zyami, CC BY-SA 4.0)

  2. Laden Sie die kubeconfig herunter, die zum Konfigurieren des Zugriffs auf Ihren Cluster verwendet wird, ändern Sie sie in das Download-Verzeichnis und exportieren Sie sie in Ihre Umgebung:

    (Chaimaa Zyami, CC BY-SA 4.0)

  3. Überprüfen Sie mit kubectl die Clusterinformationen, z. B. die Dienste, die kube-system auf Ihrem Cluster startet:

    kubectl cluster-info

    (Chaimaa Zyami, CC BY-SA 4.0)

  4. Um den Container im Cluster auszuführen, müssen Sie eine Bereitstellung (deployment.yaml) erstellen und auf den Cluster anwenden:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: kubermatic-dl-deployment
    spec:
      selector:
        matchLabels:
          app: kubermatic-dl
      replicas: 3
      template:
        metadata:
          labels:
            app: kubermatic-dl
        spec:
         containers:
         - name: kubermatic-dl
           image: kubermatic00/kubermatic-dl:latest
           imagePullPolicy: Always
           ports:
           - containerPort: 8080
    kubectl apply -f deployment.yaml
  5. Um Ihre Bereitstellung der Außenwelt zugänglich zu machen, benötigen Sie ein Dienstobjekt, das eine extern erreichbare IP für Ihren Container erstellt:

    kubectl expose deployment kubermatic-dl-deployment  --type=LoadBalancer --port 80 --target-port 5000
  6. Du bist fast da! Überprüfen Sie Ihre Dienste, um den Status Ihrer Bereitstellung zu ermitteln und die IP-Adresse zum Aufrufen Ihrer Bilderkennungs-API zu erhalten:

    kubectl get service

    (Chaimaa Zyami, CC BY-SA 4.0)

  7. Testen Sie Ihre API mit diesen beiden Bildern unter Verwendung der externen IP:

    (Chaimaa Zyami, CC BY-SA 4.0)

    (Chaimaa Zyami, CC BY-SA 4.0)

    (Chaimaa Zyami, CC BY-SA 4.0)

Zusammenfassung

In diesem Tutorial haben Sie mit Flask ein Deep-Learning-Modell erstellt, das als REST-API bereitgestellt werden soll. Es platzierte die Anwendung in einem Docker-Container, lud den Container auf Docker Hub hoch und stellte ihn mit Kubernetes bereit. Dann stellte Kubermatic Kubernetes Platform mit nur wenigen Befehlen die App bereit und machte sie der Welt zugänglich.

Verwandte Artikel: