Batcharbeitslast für maschinelles Lernen bereitstellen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

In dieser Anleitung wird gezeigt, wie Sie mit Google Kubernetes Engine (GKE) fehlertolerante Batcharbeitslasten verwalten und gleichzeitig Ihre Kosten niedrig halten. In dieser Anleitung wird die Verwendung von Jobs und kostenoptimierten Spot-VMs sowie die Konfiguration eines In-ClustersRedis-Jobwarteschlange in GKE beschrieben.

Hintergrund

Eine Batcharbeitslast ist ein Prozess, der in der Regel aus einem Start- und einem Abschlusspunkt besteht. Sie sollten Batch-Arbeitslasten in GKE in Betracht ziehen, wenn Ihre Architektur Daten aufnimmt, verarbeitet und ausgibt, anstatt Rohdaten zu verwenden. Bereiche wie maschinelles Lernen, künstliche Intelligenz und Hochleistungs-Computing bieten verschiedene Arten von Batcharbeitslasten, z. B. Offline-Modelltraining, Batchvorhersage, Datenanalyse, Simulation physischer Systeme und Video-Verarbeitung.

Durch das Entwerfen von containerisierten Batcharbeitslasten können Sie die folgenden GKE-Vorteile nutzen:

  • Eine umfassende Community mit offenem Standard und ein verwalteter Dienst.
  • Kosteneffizienz durch effektive Orchestrierung von Arbeitslasten und Infrastrukturen sowie spezielle Computing-Ressourcen.
  • Isolation und Portabilität der Containerisierung, wodurch die Nutzung der Cloud als Überlaufkapazität bei gleichzeitiger Wahrung der Datensicherheit ermöglicht wird.
  • Verfügbarkeit der Burst-Kapazität gefolgt von einer schnellen Herunterskalierung von GKE-Clustern.

Ziele

Diese Anleitung richtet sich an Entwickler von maschinellem Lernen oder Data Scientists, die lernen möchten, wie sie ML-Batch-Arbeitslasten in GKE auf der folgenden kostengünstigen und skalierbaren Architektur ausführen:

Architekturaufbau

Diese Anleitung umfasst die folgenden Schritte:

  1. Erstellen Sie einen GKE-Cluster mit Standard- und Spot-VM-Knotenpools.
  2. Erstellen Sie ein Filestore-NFS-Volume.
  3. eine Redis-Jobwarteschlange im Cluster erstellen
  4. Übertragen Sie Datasets auf das NFS-Volume und stellen Sie sie in die Warteschlange, damit sie von der Arbeitslast konsumiert werden.
  5. Führen Sie ein Beispiel für eine ML-Batch-Arbeitslast im GKE-Cluster aus.

Kosten

In dieser Anleitung werden die folgenden kostenpflichtigen Komponenten von Google Cloud verwendet:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.


Klicken Sie auf Anleitung, um eine detaillierte Anleitung für diese Aufgabe direkt in der Google Cloud Console aufzurufen.

Anleitung


Hinweis

Projekt einrichten

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.
  2. Klicken Sie in der Google Cloud Console auf der Projektauswahlseite auf Projekt erstellen, um mit der Erstellung eines neuen Google Cloud-Projekts zu starten.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  4. Compute Engine, GKE, and Filestore APIs aktivieren.

    Aktivieren Sie die APIs

  5. Klicken Sie in der Google Cloud Console auf der Projektauswahlseite auf Projekt erstellen, um mit der Erstellung eines neuen Google Cloud-Projekts zu starten.

    Zur Projektauswahl

  6. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.

  7. Compute Engine, GKE, and Filestore APIs aktivieren.

    Aktivieren Sie die APIs

Umgebung einrichten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die in Google Cloud gehostet werden. In Cloud Shell sind Docker und die kubectl- und gcloud-Befehlszeile vorinstalliert.

So richten Sie Ihre Umgebung mit Cloud Shell ein:

  1. Starten Sie in der Google Cloud Console eine Cloud Shell-Instanz.
    Cloud Shell öffnen

  2. Laden Sie den Quellcode für diese Beispielanwendung herunter.

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
    
    cd kubernetes-engine-samples/batch/aiml-workloads
    
  3. Aktualisieren Sie die Datei scripts/variables.sh mit Ihren Projektinformationen:

    sed -i "\
      s/<YOUR_PROJECT_ID>/PROJECT_ID/g; \
      s/<YOUR_REGION>/REGION/g; \
      s/<YOUR_ZONE>/ZONE/g" \
      scripts/variables.sh
    

    Dabei gilt:

  4. Legen Sie die erforderlichen Umgebungsvariablen und gcloud-Standardeinstellungen fest.

    source scripts/variables.sh
    gcloud config set project ${PROJECT_ID}
    gcloud config set compute/region ${REGION}
    gcloud config set compute/zone ${ZONE}
    gcloud config set filestore/zone ${ZONE}
    

GKE-Cluster erstellen

Erstellen Sie einen GKE-Cluster mit zwei Knotenpools, in denen GKE das nichtflüchtige Volume hostet und die Arbeitslast mit der Redis-Jobwarteschlange ausführt.

  1. GKE-Standardcluster erstellen Dieser Cluster initialisiert einen Knotenpool mit Standardkonfigurationen.

    gcloud container clusters create ${CLUSTER_NAME} \
      --machine-type=e2-standard-2 --num-nodes=3
    
  2. Prüfen Sie, ob der GKE-Cluster ausgeführt wird:

    gcloud container clusters list
    

    Der Wert STATUS für den Cluster batch-aiml lautet RUNNING.

  3. Erstellen Sie einen zweiten Knotenpool im GKE-Cluster, für den Spot-VMs aktiviert werden:

    gcloud beta container node-pools create batch-node-pool \
      --cluster=${CLUSTER_NAME} --spot
    

    Sie stellen die Batcharbeitslast später in der Anleitung in diesem Spot-VM-Knotenpool bereit.

Dataset-Speicher mit einem Netzwerk-Dateisystem (NFS) einrichten

Die Arbeitslast für maschinelles Lernen erfordert eine Speicherlösung für die Datasets und Ausgabedateien. In dieser Anleitung erstellen Sie eine Filestore-Instanz, auf die alle Knoten (Lese- und Schreibvorgänge) in einem GKE-Cluster über ein nichtflüchtiges Volume (PV) undAnspruch auf nichtflüchtiges Volume (PVC) zugreifen können.

Weitere Informationen finden Sie unter Optimale Speicherstrategie entwerfen und Auf Dateifreigaben von GKE-Clustern aus zugreifen.

Filestore-Instanz erstellen

  1. Filestore-Instanz erstellen:

    gcloud filestore instances create ${FILESTORE_ID} \
      --tier=BASIC_HDD \
      --file-share=name="NFSVol",capacity=1TB \
      --network=name="default"
    

    wobei

    • tier ist die Dienststufe für die Filestore-Instanz. In diesem Beispiel wird das grundlegende Angebot verwendet. Weitere Informationen zu den anderen Optionen finden Sie unter Dienststufen.

    • network=name ist der Name des Compute Engine Virtual Private Cloud-Netzwerks (VPC), mit dem die Instanz verbunden ist. Der GKE-Cluster muss sich im selben VPC-Netzwerk wie die Filestore-Instanz befinden.

    • capacity ist die gewünschte Größe des Volumes. Geben Sie den Speicherwert in einer der unterstützten Einheiten an, die unter Ressourcenmengen beschrieben sind.

  2. Prüfen Sie, ob die Filestore-Instanz bereitgestellt wurde:

    gcloud filestore instances list --project=${PROJECT_ID} --zone=${ZONE}
    

    Die Ausgabe sieht etwa so aus, wobei der Wert STATE für die Instanz batch-aiml-filestore READY ist:

    INSTANCE_NAME: batch-aiml-filestore
    LOCATION: us-central1-b
    TIER: BASIC_HDD
    CAPACITY_GB: 1024
    FILE_SHARE_NAME: NFSVol
    IP_ADDRESS: 10.152.101.10
    STATE: READY
    CREATE_TIME: 2022-03-15T18:23:51
    
  3. Notieren Sie sich aus der Ausgabe den Wert IP_ADDRESS. Er wird im nächsten Abschnitt verwendet.

Nichtflüchtiges Volume erstellen

Die Kubernetes-Spezifikation Nichtflüchtiges Volume (PV) ermöglicht es dem GKE-Cluster, eine Verbindung zur Filestore-Instanz herzustellen.

  1. Aktualisieren Sie die Datei kubernetes-manifests/persistent-volume.yaml mit der IP-Adresse der Filestore-Instanz:

    sed -i "\
      s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \
      kubernetes-manifests/persistent-volume.yaml
    

    Ersetzen Sie IP_ADDRESS durch den Wert, den Sie beim Erstellen der Filestore-Instanz notiert haben.

  2. Stellen Sie die PV-Spezifikation bereit:

    kubectl apply -f kubernetes-manifests/persistent-volume.yaml
    

Anspruch auf ein nichtflüchtiges Volume erstellen

Die Spezifikation Anspruch auf ein nichtflüchtiges Volume (PVC) von Kubernetes ermöglicht Kubernetes-Pods und -Jobs den Zugriff auf die Speicherressourcen eines nichtflüchtigen Volumes.

Stellen Sie die PVC-Spezifikation bereit:

kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml

Anspruch auf nichtflüchtiges Volume verwenden

Wenn der nichtflüchtiges Volume und der Anspruch auf nichtflüchtiges Volume im GKE-Cluster eingerichtet sind, können Sie den Redis-Server und die Batchjobs so konfigurieren, dass sie den Anspruch auf nichtflüchtiges Volume konsumieren. Dies wird als bereitstellbares Speicher-Volume in der VM angezeigt, auf der die Kubernetes-Ressourcen ausgeführt werden.

Prüfen Sie die Dateien kubernetes-manifests/redis-pod.yaml und kubernetes-manifests/workload.yaml. Die Manifestkonfigurationen sehen in etwa so aus:

  spec:
  …
  containers:
  - name: workload
    image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
    volumeMounts:
    - mountPath: /mnt/fileserver
      name: workload-pvc
  volumes:
  - name: workload-pvc
    persistentVolumeClaim:
      claimName: fileserver-claim
      readOnly: false

wobei

  • spec.volumes gibt die zu konsumierenden Ansprüche auf nichtflüchtige Volumes an.

  • spec.containers.volumeMounts gibt den lokalen Dateipfad auf der VM an, wo auf die Filestore-Dateifreigabe zugegriffen werden kann.

Redis-Jobwarteschlange einrichten

Die Arbeitslast verarbeitet Daten in Batches, um das Betrugserkennungsmodell iterativ zu trainieren. Zum Verwalten der aktuell verarbeiteten oder noch in der Warteschlange enthaltenen Datasets stellen Sie den Redis-Server im GKE-Cluster bereit.

Der Einfachheit halber starten Sie in diesem Beispiel eine einzelne Instanz von Redis. Ein Beispiel für die skalierbare und redundante Bereitstellung von Redis finden Sie unter Gästebuch mit Redis und PHP erstellen.

  1. Stellen Sie die Spezifikation des Redis-Servers bereit.

    kubectl apply -f kubernetes-manifests/redis-pod.yaml
    
  2. Prüfen Sie, ob der Pod ausgeführt wird, bevor Sie fortfahren. In der Ausgabe des folgenden Befehls sollte für STATUS der redis-leader-Pod Running lauten.

    kubectl get pods
    

    Die entsprechende Ausgabe sieht etwa so aus:

    NAME           READY   STATUS    RESTARTS   AGE
    redis-leader   1/1     Running   0          118s
    
  3. Übertragen Sie die Dateien mit den Trainings- und Test-Datasets auf das NFS-Volume.

    sh scripts/transfer-datasets.sh
    

    Dieses Skript kopiert die Dateien aus dem Beispielcode-Repository in das Verzeichnis /mnt/fileserver/datasets/ auf dem Pod redis-leader.

  4. Füllen Sie die Redis-Warteschlange aus.

    sh scripts/queue-jobs.sh
    

    Dieses Skript überträgt die Dateipfade für die Trainings-Datasets per Push in eine Liste mit dem Namen datasets in der Redis-Datenbank. Diese Warteschlange wird von der Arbeitslast verwendet, um das nächste zu verarbeitende Dataset zu ermitteln.

  5. Stellen Sie den Dienst bereit, damit der Redis-Server im GKE-Cluster gefunden werden kann.

    kubectl apply -f ./kubernetes-manifests/redis-service.yaml
    

Batch-Arbeitslast ausführen

Jetzt haben Sie den GKE-Cluster, die Redis-Jobwarteschlange und die Dateifreigabe vorbereitet. Jetzt können Sie Ihre Batch-Arbeitslast ausführen.

In diesem Abschnitt verwenden Sie ein Container-Image einer Beispielarbeitslast, um ein Betrugserkennungsmodell mithilfe von Batches an Finanztransaktionsdaten zu trainieren. Der Trainingsprozess kann so zusammengefasst werden:

  1. Ein Redis-Client beansprucht Jobs (Dateipfade zu Datasets) in der Redis-Warteschlange und entfernt sie nach dem Abschluss aus der Warteschlange.

  2. Die Modelltrainingadministratorklasse FraudDetectionModelTrainer lädt einen neuen Datenbatch und optional einen gespeicherten Zustand eines ML-Modells. Das Dataset wird zur Verfeinerung des Modells verwendet (ein Prozess, der als „Warmstart”-Training bezeichnet wird).

  3. Der neue Status des Modells und ein Bericht der Batchdetails und Leistungspunktzahlen werden im Filestore-NFS-Volume gespeichert, auf das im GKE-Cluster über einen Anspruch auf ein nichtflüchtiges Volume zugegriffen werden kann.

Weitere Informationen finden Sie wenn Sie Quellcode erkunden.

Job definieren

Das folgende Manifest beschreibt die Batchjobspezifikation für das Arbeitslast-Image. Dieses Manifest verwendet die Kubernetes-Jobressource.

apiVersion: batch/v1
kind: Job
metadata:
  name: workload
spec:
  parallelism: 1
  template:
    metadata:
      name: workload
    spec:
      nodeSelector:
        cloud.google.com/gke-spot: "true"
      containers:
      - name: workload
        image: "us-docker.pkg.dev/google-samples/containers/gke/batch-ml-workload"
        volumeMounts:
        - mountPath: /mnt/fileserver
          name: workload-pvc
      volumes:
      - name: workload-pvc
        persistentVolumeClaim:
          claimName: fileserver-claim
          readOnly: false
      restartPolicy: OnFailure

Arbeitslast bereitstellen

  1. Wenden Sie die Spezifikation für den Batchjob an.

    kubectl apply -f ./kubernetes-manifests/workload.yaml
    
  2. Prüfen Sie, ob der Status des Pods workload-XXX abgeschlossen ist.

    watch kubectl get pods
    

    Das kann einige Sekunden dauern. Sie können zur Befehlszeile zurückkehren, indem Sie Ctrl+C drücken.

    Die entsprechende Ausgabe sieht etwa so aus:

    NAME             READY   STATUS      RESTARTS   AGE
    redis-leader     1/1     Running     0          16m
    workload-4p55d   0/1     Completed   0          83s
    
  3. Prüfen Sie die Logs des Jobs workload:

    kubectl logs job/workload
    

    Die entsprechende Ausgabe sieht etwa so aus:

    Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72
    Initial queue state: empty=False
    Processing dataset: datasets/training/2018-04-04.pkl
    Processing dataset: datasets/training/2018-04-03.pkl
    Processing dataset: datasets/training/2018-04-02.pkl
    Processing dataset: datasets/training/2018-04-01.pkl
    Queue empty, exiting
    

    Die .pkl-Dateien sind Serialisierung von Datasets mit einem Batch von Kreditkartentransaktionen, die als gültig oder betrügerisch markiert sind. Der workload-Job durchläuft diese Dateien, entpackt die Datasets und verwendet sie zum Trainieren des Modells für maschinelles Lernen, bevor sie aus der Redis-Warteschlange entfernt werden. Die Arbeitslast verarbeitet die Daten weiterhin in Batches, bis die Redis-Warteschlange geleert wird, bevor sie erfolgreich beendet wird.

NFS-Volume ansehen

Während des Vorgangs erstellt die Arbeitslast Dateien im bereitgestellten NFS-Volume, auf die im Cluster für andere Batchjobs oder Onlineanwendungen zugegriffen werden kann. So prüfen Sie die Dateien auf dem NFS-Volume:

  1. Listen Sie die von der Arbeitslast erstellten Dateien auf:

    kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
    

    Die Ausgabe sollte so aussehen:

    model_cpt_2018-04-01.pkl
    model_cpt_2018-04-02.pkl
    model_cpt_2018-04-03.pkl
    model_cpt_2018-04-04.pkl
    report.txt
    

    Prüfpunkte für das trainierte Modell (Dateinamen wie model_cpt_XXX.pkl) und ein Bericht zur Modellleistung (report.txt) wurden im Verzeichnis /mnt/fileserver/output auf dem NFS-Volume erstellt.

  2. Sehen Sie sich den Modellleistungsbericht an:

    kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
    

    Folgendes ist ein Snippet aus der Ausgabe:

    Report generated on: 2022-02-09 14:19:42.303619
    Training dataset: 2018-04-04.pkl
    Model checkpoint: model_cpt_2018-04-04.pkl
    ---
    Accuracy on training data: 0.9981112277019937
    Accuracy on testing data: 0.9977204434773599
    

    Die Datei enthält Einträge, die die Zeit des Trainings, das verwendete Dataset, die erreichte Genauigkeit und den Dateinamen des mit dem Training assoziierten Modellprüfpunkts enthalten.

Weitere Informationen zu NFS-Volumes finden Sie in den Filestore-Leitfäden.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

So entfernen Sie die einzelnen Ressourcen, die für diese Anleitung erstellt wurden:

sh scripts/cleanup.sh

Nächste Schritte