Kubeflow Pipelines – GitHub-Problemzusammenfassung

1. Einführung

Kubeflow ist ein Toolkit für maschinelles Lernen für Kubernetes. Ziel des Projekts ist es, Deployments von ML-Workflows in Kubernetes einfach, portabel und skalierbar zu gestalten. Erstklassige Open-Source-Systeme für ML sollen auf einfache Weise in verschiedenen Infrastrukturen bereitgestellt werden können.

Ein Workflow für maschinelles Lernen kann viele Schritte mit gegenseitigen Abhängigkeiten umfassen, von der Datenvorbereitung und ‑analyse über das Training und die Bewertung bis hin zur Bereitstellung. Es ist schwierig, diese Prozesse ad hoc zu erstellen und nachzuverfolgen, z. B. in einer Reihe von Notebooks oder Skripts. Außerdem werden Dinge wie Auditierung und Reproduzierbarkeit zunehmend problematisch.Kubeflow Pipelines (KFP) bietet eine Lösung für diese Probleme, indem es eine Möglichkeit bietet, robuste, wiederholbare Machine-Learning-Pipelines zusammen mit Überwachung, Auditierung, Versionsverwaltung und Reproduzierbarkeit bereitzustellen. Mit Cloud AI Pipelines lässt sich eine KFP-Installation ganz einfach einrichten.

Umfang

In diesem Codelab erstellen Sie eine Webanwendung, in der GitHub-Probleme anhand eines Modells zusammengefasst werden, das mit Kubeflow Pipelines trainiert und bereitgestellt wird. Es basiert auf einem Beispiel im Kubeflow Examples-Repository. Am Ende enthält Ihre Infrastruktur die folgenden Komponenten:

Ein Google Kubernetes Engine-Cluster (GKE) mit installierten Kubeflow Pipelines (über Cloud AI Pipelines).
Eine Pipeline, die ein Tensor2Tensor-Modell auf GPUs trainiert
Einen Bereitstellungscontainer für Vorhersagen aus dem trainierten Modell
Eine Benutzeroberfläche, die die Vorhersagen interpretiert, um Zusammenfassungen für GitHub-Probleme zu erstellen
Ein Notebook, in dem eine Pipeline von Grund auf mit dem Kubeflow Pipelines (KFP) SDK erstellt wird

Lerninhalte

In der Pipeline, die Sie erstellen, wird ein Tensor2Tensor-Modell mit Daten zu GitHub-Problemen trainiert, um aus dem Text von Problemen die Titel von Problemen vorherzusagen. Anschließend wird das trainierte Modell exportiert und mit Tensorflow Serving bereitgestellt. Im letzten Schritt der Pipeline wird eine Web-App gestartet, die mit der TF-Serving-Instanz interagiert, um Modellvorhersagen zu erhalten.

Kubeflow Pipelines in einem GKE-Cluster installieren
ML-Workflows mit Kubeflow Pipelines erstellen und ausführen
Pipelines in einem AI Platform Notebook definieren und ausführen

Voraussetzungen

Grundlegendes Verständnis von Kubernetes ist hilfreich, aber nicht erforderlich.
Ein aktives GCP-Projekt, für das Sie die Berechtigung „Inhaber“ haben
(Optional) Ein GitHub-Konto
Zugriff auf Google Cloud Shell, das in der Google Cloud Console verfügbar ist

2. Einrichtung

Cloud Shell

Rufen Sie die GCP Console im Browser auf und melden Sie sich mit Ihren Projektanmeldedaten an:

Klicken Sie bei Bedarf auf „Projekt auswählen“, damit Sie mit Ihrem Codelab-Projekt arbeiten.

Klicken Sie dann rechts oben in der Konsole auf das Symbol „Cloud Shell aktivieren“, um eine Cloud Shell zu starten.

Wenn Sie die Cloud Shell starten, wird der Name des Projekts angezeigt, das verwendet wird. Prüfen Sie, ob diese Einstellung korrekt ist.

Die Projekt-ID finden Sie in der GCP Console auf der Startseite. Wenn der Bildschirm leer ist, klicken Sie auf „Ja“, um ein Dashboard zu erstellen.

Führen Sie dann im Cloud Shell-Terminal diese Befehle aus, um gcloud für die Verwendung des richtigen Projekts zu konfigurieren:

export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}

Storage-Bucket erstellen

Erstellen Sie einen Cloud Storage-Bucket zum Speichern von Pipeline-Dateien. Sie müssen eine global eindeutige ID verwenden. Daher ist es sinnvoll, einen Bucket-Namen zu definieren, der Ihre Projekt-ID enthält. Erstellen Sie den Bucket mit dem Befehl gsutil mb (Bucket erstellen):

export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}

Alternativ können Sie einen Bucket über die GCP Console erstellen.

Optional: GitHub-Token erstellen

In diesem Codelab wird die GitHub API aufgerufen, um öffentlich verfügbare Daten abzurufen. Richten Sie ein Zugriffstoken ohne Berechtigungen ein, um eine Ratenbegrenzung zu vermeiden, die insbesondere dann auftritt, wenn eine große Anzahl anonymisierter Anforderungen an die GitHub-APIs gesendet werden. Das Zugriffstoken autorisiert Sie als Person und nicht als anonymen Nutzer.

Rufen Sie https://github.com/settings/tokens auf und generieren Sie ein neues Token ohne Bereiche.
Bewahren Sie es an einem sicheren Ort auf. Wenn Sie ihn verlieren, müssen Sie ihn löschen und einen neuen erstellen.

Wenn Sie diesen Schritt überspringen, funktioniert das Lab trotzdem. Sie haben dann nur weniger Optionen zum Generieren von Eingabedaten zum Testen Ihres Modells.

Optional: Nützliche Dashboards anpinnen

Pinnen Sie in der GCP Console die Dashboards Kubernetes Engine und Storage, um leichter darauf zugreifen zu können.

AI Platform Pipelines-Installation (gehostete Kubeflow-Pipelines) erstellen

Folgen Sie der Anleitung in den Abschnitten „Vorbereitung“ und „Instanz einrichten“ auf dieser Seite, um eine GKE-Instanz mit installierten KFP einzurichten. Achten Sie darauf, das Kästchen Zugriff auf folgende Cloud APIs zulassen zu aktivieren, wie in der Dokumentation beschrieben. Andernfalls wird die Beispielpipeline nicht erfolgreich ausgeführt. Lassen Sie den Installations-Namespace auf default eingestellt.

Sie müssen eine Zone auswählen, die Nvidia K80 unterstützt. Sie können us-central1-a oder us-central1-c als Standardwerte verwenden.

Notieren Sie sich den Clusternamen und die Zone des GKE-Clusters, die für Ihre Installation im AI Pipelines-Dashboard aufgeführt sind, sobald die Installation abgeschlossen ist. Legen Sie zur Vereinfachung Umgebungsvariablen für diese Werte fest.

export ZONE=<your zone>
export CLUSTER_NAME=<your cluster name>

kubectl für die Verwendung der Anmeldedaten Ihres neuen GKE-Clusters einrichten

Nachdem der GKE-Cluster erstellt wurde, konfigurieren Sie kubectl so, dass die Anmeldedaten des neuen Clusters verwendet werden. Führen Sie dazu den folgenden Befehl in Cloud Shell aus:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --project ${PROJECT_ID} \
  --zone ${ZONE}

Alternativ können Sie im AI Pipelines-Dashboard auf den Namen des Clusters klicken, um die zugehörige GKE-Seite aufzurufen, und dann oben auf der Seite auf „Verbinden“ klicken. Fügen Sie den Befehl aus dem Pop-up-Fenster in Ihre Cloud Shell ein.

Dadurch wird der kubectl-Kontext so konfiguriert, dass Sie mit Ihrem Cluster interagieren können. Führen Sie den folgenden Befehl aus, um die Konfiguration zu überprüfen:

kubectl get nodes -o wide

Es sollten Knoten mit dem Status „Ready“ sowie weitere Informationen zu Alter, Version, externer IP-Adresse, Betriebssystem-Image, Kernelversion und Container-Laufzeit der Knoten aufgeführt sein.

Cluster so konfigurieren, dass der Nvidia-Treiber auf GPU-fähigen Knotenpools installiert wird

Als Nächstes wenden wir ein DaemonSet auf den Cluster an, wodurch der Nvidia-Treiber auf allen GPU-fähigen Clusternknoten installiert wird:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Führen Sie dann den folgenden Befehl aus, um den KFP-Komponenten die Berechtigung zum Erstellen neuer Kubernetes-Ressourcen zu erteilen:

kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner

GPU-Knotenpool erstellen

Als Nächstes richten wir einen GPU-Knotenpool mit der Größe 1 ein:

gcloud container node-pools create gpu-pool \
    --cluster=${CLUSTER_NAME} \
    --zone ${ZONE} \
    --num-nodes=1 \
    --machine-type n1-highmem-8 \
    --scopes cloud-platform --verbosity error \
    --accelerator=type=nvidia-tesla-k80,count=1

3. Pipeline über das Pipelines-Dashboard ausführen

Pipelines-Dashboard öffnen

Rufen Sie in der Cloud Console den Bereich „Pipelines“ auf, falls Sie sich noch nicht dort befinden. Klicken Sie dann für Ihre Installation auf PIPELINES-DASHBOARD ÖFFNEN und in der linken Menüleiste auf Pipelines. Wenn ein Ladefehler auftritt, aktualisieren Sie den Tab. Sie sollten eine neue Seite wie diese sehen:

Pipelinebeschreibung

Die Pipeline, die Sie ausführen, hat mehrere Schritte (siehe Anhang dieses Codelabs für Details):

Ein vorhandener Modell-Checkpoint wird in Ihren Bucket kopiert.
Ein Tensor2Tensor-Modell wird mit vorverarbeiteten Daten trainiert.

Das Training beginnt mit dem vorhandenen Modell-Checkpoint, der im ersten Schritt kopiert wurde, und wird dann für einige hundert weitere Schritte fortgesetzt. (Es würde zu lange dauern, das Modell während des Codelabs vollständig zu trainieren.)
Nach Abschluss des Trainings wird das Modell im Pipelineschritt in einem Format exportiert, das für die Bereitstellung durch TensorFlow Serving geeignet ist.

Eine TensorFlow Serving-Instanz wird mit diesem Modell bereitgestellt.
Eine Web-App wird gestartet, um mit dem bereitgestellten Modell zu interagieren und Vorhersagen abzurufen.

Pipeline herunterladen und kompilieren

In diesem Abschnitt erfahren Sie, wie Sie eine Pipelinedefinition kompilieren. Als Erstes müssen wir das KFP SDK installieren. Führen Sie in Cloud Shell den folgenden Befehl aus:

pip3 install -U kfp

Führen Sie den folgenden Befehl in Cloud Shell aus, um die Pipeline-Definitionsdatei herunterzuladen:

curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py

Kompilieren Sie dann die Pipelinedefinitionsdatei, indem Sie sie so ausführen:

python3 gh_summ_hosted_kfp.py

Die Datei gh_summ_hosted_kfp.py.tar.gz wird als Ergebnis angezeigt.

Kompilierte Pipeline hochladen

Klicken Sie in der Kubeflow Pipelines-Web-UI auf Pipeline hochladen und wählen Sie Per URL importieren aus. Kopieren Sie die folgende URL und fügen Sie sie ein. Sie verweist auf dieselbe Pipeline, die Sie gerade kompiliert haben. Das Hochladen einer Datei aus Cloud Shell erfordert einige zusätzliche Schritte. Wir nehmen daher eine Abkürzung.

https://storage.googleapis.com/aju-dev-demos-codelabs/KF/compiled_pipelines/gh_summ_hosted_kfp.py.tar.gz

Geben Sie der Pipeline einen Namen, z.B. gh_summ.

Pipeline ausführen

Klicken Sie in der Liste auf die hochgeladene Pipeline, um das statische Diagramm der Pipeline aufzurufen. Klicken Sie dann auf Test erstellen, um einen neuen Test mit der Pipeline zu erstellen. Mit einem Test können Sie semantisch verwandte Läufe gruppieren.

Geben Sie dem Test einen Namen, z.B. denselben Namen wie für die Pipeline (gh_summ), und klicken Sie dann auf Weiter, um den Test zu erstellen.

Daraufhin wird eine Seite aufgerufen, auf der Sie die Parameter für einen Lauf eingeben und ihn starten können.

Möglicherweise möchten Sie die folgenden Befehle in Cloud Shell ausführen, um die Parameter auszufüllen.

gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"

Der Name des Laufs wird automatisch ausgefüllt. Sie können ihm aber auch einen anderen Namen geben.

Füllen Sie dann drei Parameterfelder aus:

project
(optional) github-token
working-dir

Geben Sie für „working-dir“ einen Pfad unter dem von Ihnen erstellten GCS-Bucket ein. Geben Sie das Präfix „gs://“ an. Geben Sie für das Feld github-token entweder das Token ein, das Sie optional zuvor generiert haben, oder lassen Sie den Platzhalterstring unverändert, wenn Sie kein Token generiert haben.

Klicken Sie nach dem Ausfüllen der Felder auf Starten und dann auf den aufgeführten Lauf, um die Details aufzurufen. Während ein bestimmter Pipelineschritt ausgeführt wird, können Sie darauf klicken, um weitere Informationen dazu zu erhalten, einschließlich der Pod-Logs. Sie können die Logs für einen Pipelineschritt auch über den Link zu den Cloud Logging (Stackdriver)-Logs aufrufen, auch wenn der Clusterknoten entfernt wurde.

Pipelinedefinition ansehen

Während die Pipeline ausgeführt wird, können Sie sich genauer ansehen, wie sie zusammengesetzt ist und was sie tut. Weitere Informationen finden Sie im Anhang dieses Codelabs.

Informationen zum Modelltraining in TensorBoard ansehen

Wenn der Trainingsschritt abgeschlossen ist, wählen Sie den Tab Visualisierungen aus und klicken Sie auf die blaue Schaltfläche TensorBoard starten. Wenn TensorBoard bereit ist, klicken Sie auf TensorBoard öffnen.

Dashboard „Artefakte und Ausführungen“ ansehen

Kubeflow Pipelines protokolliert automatisch Metadaten zu den Pipelineschritten, während eine Pipeline ausgeführt wird. Sowohl Artifact- als auch Execution-Informationen werden aufgezeichnet. Klicken Sie im Dashboard in der linken Navigationsleiste auf diese Einträge, um weitere Informationen zu erhalten.

Für Artefakte können Sie sowohl einen Übersichtsbereich als auch einen Lineage Explorer-Bereich aufrufen.

Die von der Pipeline erstellte Webanwendung aufrufen und einige Vorhersagen treffen

Im letzten Schritt der Pipeline wird eine Web-App bereitgestellt, die eine Benutzeroberfläche zum Abfragen des trainierten Modells bietet, das über TF Serving bereitgestellt wird, um Vorhersagen zu treffen.

Nachdem die Pipeline abgeschlossen ist, stellen Sie eine Verbindung zur Web-App her, indem Sie eine Portweiterleitung zu ihrem Dienst einrichten. Wir richten eine Portweiterleitung ein, da der Web-App-Dienst für dieses Codelab nicht für einen externen Endpunkt eingerichtet ist.

Rufen Sie den Dienstnamen ab, indem Sie diesen Befehl in Cloud Shell ausführen:

kubectl get services

Suchen Sie in der Liste nach einem Dienstnamen wie ghsumm-*-webappsvc.

Leiten Sie dann in Cloud Shell den Port an diesen Dienst weiter. Ändern Sie dazu den folgenden Befehl so, dass der Name Ihres „webappsvc“ verwendet wird:

kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80

Wenn die Portweiterleitung ausgeführt wird, klicken Sie über dem Cloud Shell-Bereich auf das Symbol „Vorschau“ und dann im Drop-down-Menü auf „Vorschau auf Port 8080“.

In einem neuen Tab sollte eine Seite wie diese angezeigt werden:

Klicken Sie auf die Schaltfläche Populate Random Issue (Zufälliges Problem darstellen), um einen Textblock abzurufen. Klicken Sie auf Titel generieren, um das trainierte Modell aufzurufen und eine Vorhersage anzeigen zu lassen.

Wenn Ihre Pipeline-Parameter ein gültiges GitHub-Token enthalten, können Sie alternativ eine GitHub-URL in das zweite Feld eingeben und dann auf „Titel generieren“ klicken. Wenn Sie kein gültiges GitHub-Token eingerichtet haben, verwenden Sie nur das Feld „Populate Random Issue“.

4. Pipeline aus einem AI Platform Notebook ausführen

Sie können Kubeflow-Pipelines auch interaktiv über ein Jupyter-Notebook mit dem KFP SDK definieren und ausführen. Mit AI Platform Notebooks, die wir in diesem Codelab verwenden, ist das ganz einfach.

Eine Notebook-Instanz erstellen

Wir erstellen eine Notebook-Instanz über die Cloud Shell mit der API. Alternativ können Sie ein Notebook über die Cloud Console erstellen. Weitere Informationen

Legen Sie in Cloud Shell die folgenden Umgebungsvariablen fest:

export INSTANCE_NAME="kfp-ghsumm"
export VM_IMAGE_PROJECT="deeplearning-platform-release"
export VM_IMAGE_FAMILY="tf2-2-3-cpu"
export MACHINE_TYPE="n1-standard-4"
export LOCATION="us-central1-c"

Führen Sie dann in Cloud Shell den Befehl zum Erstellen der Notebook-Instanz aus:

gcloud beta notebooks instances create $INSTANCE_NAME \
  --vm-image-project=$VM_IMAGE_PROJECT \
  --vm-image-family=$VM_IMAGE_FAMILY \
  --machine-type=$MACHINE_TYPE --location=$LOCATION

Wenn Sie diesen Befehl zum ersten Mal ausführen, werden Sie möglicherweise aufgefordert, die notebooks API für Ihr Projekt zu aktivieren. Antworte mit „y“, wenn das der Fall ist.

Nach einigen Minuten ist Ihr Notebook-Server einsatzbereit. Ihre Notebook-Instanzen werden in der Cloud Console aufgeführt.

Codelab-Notebook hochladen

Klicken Sie nach dem Erstellen der Notebookinstanz auf diesen Link, um das Jupyter-Notebook des Codelabs hochzuladen. Wählen Sie die zu verwendende Notebook-Instanz aus. Das Notebook wird automatisch geöffnet.

Notebook ausführen

Folgen Sie der Anleitung im Notebook für den Rest des Labs. Beachten Sie, dass Sie im Abschnitt „Einrichtung“ des Notebooks Ihre eigenen Werte eingeben müssen, bevor Sie den Rest des Notebooks ausführen.

Wenn Sie Ihr eigenes Projekt verwenden, denken Sie daran, zu diesem Lab zurückzukehren und den Abschnitt „Bereinigen“ durchzuführen.

5. Bereinigen

Wenn Sie ein temporäres Codelab-Konto verwenden, ist dies nicht erforderlich. Wenn Sie jedoch Ihr eigenes Projekt verwenden, sollten Sie die Pipelines-Installation und das Notebook entfernen.

Pipelines-GKE-Cluster deaktivieren

Sie können den Pipelines-Cluster über die Cloud Console löschen. Sie haben die Möglichkeit, nur die Pipelines-Installation zu löschen, wenn Sie den GKE-Cluster wiederverwenden möchten.

AI Notebook-Instanz löschen

Wenn Sie den Notebook-Teil des Codelabs ausgeführt haben, können Sie die Notebook-Instanz über die Cloud Console LÖSCHEN oder BEENDEN.

Optional: GitHub-Token entfernen

Gehen Sie zu https://github.com/settings/tokens und entfernen Sie das generierte Token.

6. Anhang

Codebeispiel

Pipeline definieren

Die in diesem Codelab verwendete Pipeline ist hier definiert.

Sehen wir uns an, wie sie definiert ist und wie ihre Komponenten (Schritte) definiert sind. Wir gehen auf einige Highlights ein. Weitere Informationen finden Sie in der Dokumentation.

Kubeflow-Pipelines-Schritte basieren auf Containern. Wenn Sie eine Pipeline erstellen, können Sie vordefinierte Komponenten mit bereits erstellten Container-Images verwenden oder eigene Komponenten erstellen. Für dieses Codelab haben wir unsere eigene erstellt.

Vier der Pipelinesteps werden aus wiederverwendbaren Komponenten definiert, auf die über ihre Komponentendefinitionsdateien zugegriffen wird. Im ersten Code-Snippet greifen wir über die URL auf diese Komponentendefinitionsdateien zu und verwenden diese Definitionen, um „Ops“ zu erstellen, mit denen wir einen Pipelineschritt erstellen.

import kfp.dsl as dsl
import kfp.gcp as gcp
import kfp.components as comp

...

copydata_op = comp.load_component_from_url(
  'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/datacopy_component.yaml'
  )

train_op = comp.load_component_from_url(
  'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/train_component.yaml'
  )

Unten sehen Sie eine der Komponentendefinitionen für den Trainingsvorgang im YAML-Format. Sie sehen, dass die Ein- und Ausgaben, das Container-Image und die Container-Entrypoint-Argumente definiert sind.

name: Train T2T model
description: |
  A Kubeflow Pipeline component to train a Tensor2Tensor
  model
metadata:
  labels:
    add-pod-env: 'true'
inputs:
  - name: train_steps
    description: '...'
    type: Integer
    default: 2019300
  - name: data_dir
    description: '...'
    type: GCSPath
  - name: model_dir
    description: '...'
    type: GCSPath
  - name: action
    description: '...'
    type: String
  - name: deploy_webapp
    description: '...'
    type: String
outputs:
  - name: launch_server
    description: '...'
    type: String
  - name: train_output_path
    description: '...'
    type: GCSPath
  - name: MLPipeline UI metadata
    type: UI metadata
implementation:
  container:
    image: gcr.io/google-samples/ml-pipeline-t2ttrain:v3ap
    args: [
      --data-dir, {inputValue: data_dir},
      --action, {inputValue: action},
      --model-dir, {inputValue: model_dir},
      --train-steps, {inputValue: train_steps},
      --deploy-webapp, {inputValue: deploy_webapp},
      --train-output-path, {outputPath: train_output_path}
    ]
    env:
      KFP_POD_NAME: "{{pod.name}}"
    fileOutputs:
      launch_server: /tmp/output
      MLPipeline UI metadata: /mlpipeline-ui-metadata.json

Sie können einen Pipeline-Schritt auch über den dsl.ContainerOp-Konstruktor definieren, wie unten beschrieben.

Unten sehen Sie den Großteil der Pipelinedefinition. Wir definieren die Pipeline-Eingaben (und ihre Standardwerte). Anschließend definieren wir die Pipelineschritte. Für die meisten verwenden wir die oben definierten „ops“, aber wir definieren auch einen „serve“-Schritt inline über ContainerOp und geben das Container-Image und die Einstiegspunktargumente direkt an.

Sie sehen, dass in den Schritten train, log_model und serve Ausgaben aus vorherigen Schritten als Eingaben verwendet werden. Weitere Informationen

@dsl.pipeline(
 name='Github issue summarization',
 description='Demonstrate Tensor2Tensor-based training and TF-Serving'
)
def gh_summ(  #pylint: disable=unused-argument
 train_steps: 'Integer' = 2019300,
 project: str = 'YOUR_PROJECT_HERE',
 github_token: str = 'YOUR_GITHUB_TOKEN_HERE',
 working_dir: 'GCSPath' = 'gs://YOUR_GCS_DIR_HERE',
 checkpoint_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/model_output_tbase.bak2019000/',
 deploy_webapp: str = 'true',
 data_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/t2t_data_gh_all/'
 ):


 copydata = copydata_op(
   data_dir=data_dir,
   checkpoint_dir=checkpoint_dir,
   model_dir='%s/%s/model_output' % (working_dir, dsl.RUN_ID_PLACEHOLDER),
   action=COPY_ACTION,
   )


 train = train_op(
   data_dir=data_dir,
   model_dir=copydata.outputs['copy_output_path'],
   action=TRAIN_ACTION, train_steps=train_steps,
   deploy_webapp=deploy_webapp
   )

 serve = dsl.ContainerOp(
     name='serve',
     image='gcr.io/google-samples/ml-pipeline-kubeflow-tfserve:v6',
     arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
         "--model_path", train.outputs['train_output_path']
         ]
     )

 train.set_gpu_limit(1)

Der Schritt „train“ muss auf einem Knoten im Cluster ausgeführt werden, auf dem mindestens eine GPU verfügbar ist.

  train.set_gpu_limit(1)

Der letzte Schritt in der Pipeline, der ebenfalls inline definiert ist, ist bedingt. Er wird nach Abschluss des Schritts „serve“ ausgeführt, aber nur, wenn die Ausgabe des Trainingsschritts launch_server der String „true“ ist. Dadurch wird die Webanwendung für Vorhersagen gestartet, mit der wir Zusammenfassungen von Problemen vom trainierten T2T-Modell angefordert haben.

 with dsl.Condition(train.outputs['launch_server'] == 'true'):
   webapp = dsl.ContainerOp(
       name='webapp',
       image='gcr.io/google-samples/ml-pipeline-webapp-launcher:v1',
       arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
           "--github_token", github_token]

       )
   webapp.after(serve)

Die Container-Image-Definitionen der Komponente

In der Kubeflow Pipelines-Dokumentation werden einige Best Practices für das Erstellen eigener Komponenten beschrieben. Im Rahmen dieses Prozesses müssen Sie ein Container-Image definieren und erstellen. Die einzelnen Schritte für die Pipeline dieses Codelabs finden Sie hier. Die Dockerfile-Definitionen befinden sich in den Unterverzeichnissen containers, z.B. hier.

VMs auf Abruf mit GPUs für das Training verwenden

VMs auf Abruf sind Compute Engine-VM-Instanzen mit einer maximalen Gültigkeit von 24 Stunden, jedoch ohne Verfügbarkeitsgarantien. Die Preise für VMs auf Abruf sind niedriger als für Standard-VMs von Compute Engine.

Mit Google Kubernetes Engine (GKE) ist es ganz einfach, einen Cluster oder Knotenpool mit Preemptible-VMs einzurichten. Sie können einen solchen Knotenpool mit GPUs einrichten, die an die Instanzen auf Abruf angehängt sind. Diese funktionieren genauso wie normale GPU-fähige Knoten, aber die GPUs bleiben nur für die Lebensdauer der Instanz bestehen.

Sie können einen GPU-fähigen Knotenpool auf Abruf für Ihren Cluster einrichten, indem Sie einen Befehl ähnlich dem folgenden ausführen. Bearbeiten Sie den folgenden Befehl mit Ihrem Clusternamen und Ihrer Zone und passen Sie den Beschleunigertyp und die Anzahl entsprechend Ihren Anforderungen an. Optional können Sie den Knotenpool so definieren, dass er basierend auf den aktuellen Arbeitslasten automatisch skaliert wird.

gcloud container node-pools create preemptible-gpu-pool \
    --cluster=<your-cluster-name> \
    --zone <your-cluster-zone> \
    --enable-autoscaling --max-nodes=4 --min-nodes=0 \
    --machine-type n1-highmem-8 \
    --preemptible \
    --node-taints=preemptible=true:NoSchedule \
    --scopes cloud-platform --verbosity error \
    --accelerator=type=nvidia-tesla-k80,count=4

Sie können einen Knotenpool auch über die Cloud Console einrichten.

Kubeflow-Pipeline definieren, die VMs auf Abruf in GKE verwendet

Wenn Sie Kubeflow in GKE ausführen, können Sie jetzt ganz einfach Kubeflow-Pipelines definieren und ausführen, in denen ein oder mehrere Pipelineschritte (Komponenten) auf unterbrechbaren Knoten ausgeführt werden. So lassen sich die Kosten für die Ausführung eines Jobs senken. Damit die Verwendung von VMs auf Abruf korrekte Ergebnisse liefert, sollten die Schritte, die Sie als auf Abruf identifizieren, entweder idempotent sein (d. h., wenn Sie einen Schritt mehrmals ausführen, hat er dasselbe Ergebnis) oder die Arbeit so speichern, dass der Schritt bei einer Unterbrechung dort fortgesetzt werden kann, wo er unterbrochen wurde.

Wenn Sie eine Kubeflow-Pipeline definieren, können Sie angeben, dass ein bestimmter Schritt auf einem unterbrechbaren Knoten ausgeführt werden soll. Dazu ändern Sie den Vorgang so:

your_pipelines_op.apply(gcp.use_preemptible_nodepool())

Weitere Informationen finden Sie in der Dokumentation.

Wahrscheinlich möchten Sie den Schritt auch einige Male wiederholen, wenn der Knoten vorzeitig beendet wird. Das geht so: Hier geben wir 5 Wiederholungsversuche an.

your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)

Bearbeiten Sie die Kubeflow-Pipeline, die wir in diesem Codelab verwendet haben, um den Trainingsschritt auf einer VM auf Abruf auszuführen.

Ändern Sie die folgende Zeile in der Pipelinespezifikation, um zusätzlich einen Knotenpool auf Abruf zu verwenden (achten Sie darauf, dass Sie einen wie oben beschrieben erstellt haben) und 5 Wiederholungen zu versuchen:

  train.set_gpu_limit(1)

Kompilieren Sie die Pipeline dann neu, laden Sie die neue Version hoch (geben Sie ihr einen neuen Namen) und führen Sie die neue Version der Pipeline aus.