1. Einführung
| Kubeflow ist ein Toolkit für maschinelles Lernen für Kubernetes. Ziel des Projekts ist es, Deployments von Workflows für maschinelles Lernen (ML) in Kubernetes einfach, portabel und skalierbar zu gestalten. Ziel ist es, eine einfache Möglichkeit zu bieten, erstklassige Open-Source-Systeme für ML in verschiedenen Infrastrukturen bereitzustellen. |
| Ein ML-Workflow kann viele Schritte umfassen, die voneinander abhängig sind, z. B. Datenvorbereitung und -analyse, Training, Bewertung und Bereitstellung. Es ist schwierig, diese Prozesse ad hoc zu erstellen und zu verfolgen, z. B. in einer Reihe von Notebooks oder Skripts, und Dinge wie Auditing und Reproduzierbarkeit werden zunehmend problematisch.Kubeflow Pipelines (KFP) hilft bei der Lösung dieser Probleme, indem es robuste, wiederholbare Pipelines für maschinelles Lernen sowie Monitoring, Auditing, Versionsverfolgung und Reproduzierbarkeit bietet. Cloud AI Pipelines erleichtert die Einrichtung einer KFP-Installation. |
Inhalt
In diesem Codelab erstellen Sie eine Webanwendung, die GitHub-Probleme mithilfe von Kubeflow Pipelines zum Trainieren und Bereitstellen eines Modells zusammenfasst. Sie basiert auf einem Beispiel aus dem Kubeflow-Beispiel-Repository. Am Ende enthält Ihre Infrastruktur die folgenden Komponenten:
- Einen GKE-Cluster (Google Kubernetes Engine) mit installierter Kubeflow Pipelines (über Cloud AI Pipelines).
- Eine Pipeline, die ein Tensor2Tensor-Modell auf GPUs trainiert
- Einen Bereitstellungscontainer, der Vorhersagen aus dem trainierten Modell bereitstellt
- Eine Benutzeroberfläche, die die Vorhersagen interpretiert, um Zusammenfassungen für GitHub-Probleme zu liefern
- Ein Notebook, das mit dem Kubeflow Pipelines (KFP) SDK eine Pipeline von Grund auf neu erstellt
Aufgaben in diesem Lab
Die von Ihnen erstellte Pipeline trainiert ein Tensor2Tensor-Modell mit GitHub-Problemdaten und lernt damit, Problemtitel aus Problemtexten vorherzusagen. Anschließend wird das trainierte Modell exportiert und das exportierte Modell mithilfe von Tensorflow Serving bereitgestellt. Im letzten Schritt der Pipeline wird eine Webanwendung gestartet, die mit der TF-Serving-Instanz interagiert, um Modellvorhersagen abzurufen.
- Kubeflow Pipelines in einem GKE-Cluster installieren
- ML-Workflows mit Kubeflow Pipelines erstellen und ausführen
- Pipelines aus einem AI Platform Notebook definieren und ausführen
Voraussetzungen
- Grundlegende Kenntnisse von Kubernetes sind hilfreich, aber nicht erforderlich.
- Ein aktives GCP-Projekt, für das Sie Inhaberberechtigungen haben
- Optional: Ein GitHub-Konto
- Zugriff auf Google Cloud Shell, verfügbar in der Google Cloud Platform Console (GCP)
2. Einrichtung
Cloud Shell
Rufen Sie im Browser die GCP Console auf und melden Sie sich mit Ihren Projektanmeldedaten an:
Klicken Sie auf „Projekt auswählen“. damit Sie mit Ihrem Codelab-Projekt arbeiten.
Klicken Sie dann auf die Schaltfläche um Cloud Shell zu starten.
Wenn Sie Cloud Shell starten, wird der Name des Projekts angezeigt, das verwendet werden soll. Prüfen Sie, ob diese Einstellung korrekt ist.
Sie finden Ihre Projekt-ID im Steuerfeld der GCP Console. Wenn der Bildschirm leer ist, klicken Sie auf „Ja“. auf die Eingabeaufforderung, um ein Dashboard zu erstellen.
Führen Sie dann bei Bedarf die folgenden Befehle im Cloud Shell-Terminal 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 Pipelinedateien. Da Sie eine global eindeutige ID verwenden müssen, ist es praktisch, einen Bucket-Namen zu definieren, der Ihre Projekt-ID enthält. Erstellen Sie den Bucket mit dem Befehl gsutil mb (make bucket):
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. Um eine Ratenbegrenzung zu vermeiden, insbesondere bei Ereignissen, bei denen eine große Anzahl anonymisierter Anfragen an die GitHub-APIs gesendet wird, sollten Sie ein Zugriffstoken ohne Berechtigungen einrichten. 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 sie verlieren, müssen Sie sie löschen und ein neues erstellen.
Wenn Sie diesen Schritt überspringen, funktioniert das Lab trotzdem. Sie haben dann nur noch ein wenig weniger Möglichkeiten, Eingabedaten zu generieren, um Ihr Modell zu testen.
Optional: Nützliche Dashboards anpinnen
Für einen leichteren Zugriff können Sie in der GCP Console die Dashboards Kubernetes Engine und Storage anpinnen.
Installation von AI Platform Pipelines (gehostete Kubeflow Pipelines) erstellen
Folgen Sie der Anleitung unter „Bevor Sie beginnen“. und „Instanz einrichten“ Abschnitte hier, um eine GKE-Instanz mit installiertem KFP einzurichten. Achten Sie darauf, wie in der Dokumentation angegeben das Kästchen Zugriff auf die folgenden Cloud APIs zulassen anzuklicken. Andernfalls wird die Beispielpipeline nicht erfolgreich ausgeführt. Belassen Sie den Installations-Namespace auf default.
Sie müssen eine Zone auswählen, die das Nvidia k80s unterstützt. Sie können us-central1-a oder us-central1-c als Standardeinstellungen verwenden.
Notieren Sie sich nach Abschluss der Installation den GKE-Clusternamen und die GKE-Zone, die für Ihre Installation im AI Pipelines-Dashboard aufgeführt sind. Legen Sie außerdem die Umgebungsvariablen auf diese Werte fest.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Richten Sie kubectl für die Verwendung der Anmeldedaten Ihres neuen GKE-Clusters ein
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 auf „Verbinden“ klicken. oben auf der Seite. Fügen Sie den Befehl aus dem Pop-up-Fenster in Cloud Shell ein.
Dadurch wird der kubectl-Kontext konfiguriert, sodass Sie mit dem Cluster interagieren können. Führen Sie den folgenden Befehl aus, um die Konfiguration zu prüfen:
kubectl get nodes -o wide
Sie sollten Knoten mit dem Status „Ready“ sowie weitere Informationen zu Knotenalter, Version, externer IP-Adresse, Betriebssystem-Image, Kernel-Version und Containerlaufzeit sehen.
Cluster für die Installation des Nvidia-Treibers in GPU-fähigen Knotenpools konfigurieren
Als Nächstes wenden wir ein DaemonSet auf den Cluster an, wodurch der Nvidia-Treiber auf allen GPU-fähigen Clusterknoten 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, der den KFP-Komponenten die Berechtigung zum Erstellen neuer Kubernetes-Ressourcen erteilt:
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
GPU-Knotenpool erstellen
Anschließend 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 noch nicht geschehen. Klicken Sie dann auf PIPELINES-DASHBOARD ÖFFNEN. für Ihre Installation und klicken Sie in der linken Menüleiste auf Pipelines. Wenn ein Ladefehler angezeigt wird, aktualisieren Sie den Tab. Sie sollten eine neue Seite wie die folgende sehen:
Beschreibung der Pipeline
Die Pipeline, die Sie ausführen werden, umfasst mehrere Schritte (Details finden Sie im Anhang dieses Codelabs):
- Ein vorhandener Modellprüfpunkt wird in den Bucket kopiert.
- Ein Tensor2Tensor-Modell wird mit vorverarbeiteten Daten trainiert.
- Das Training beginnt mit dem vorhandenen Modellprüfpunkt, der im ersten Schritt kopiert wurde, und wird dann für einige weitere hundert Schritte trainiert. Es würde zu lange dauern, sie während des Codelabs vollständig zu trainieren.
- Nach Abschluss des Trainings exportiert der Pipelineschritt das Modell in eine Form, die für die TensorFlow-Bereitstellung geeignet ist.
- Eine TensorFlow-Bereitstellungsinstanz wird mit diesem Modell bereitgestellt.
- Eine Webanwendung wird gestartet, um mit dem bereitgestellten Modell zu interagieren, um 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 den folgenden Befehl in Cloud Shell aus:
pip3 install -U kfp
Führen Sie den folgenden Befehl in Cloud Shell aus, um die Pipelinedefinitionsdatei 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 Upload Pipeline (Pipeline hochladen) und wählen Sie Import by URL (Nach URL importieren) aus. Kopieren Sie die folgende URL und fügen Sie sie ein. Sie verweist auf dieselbe Pipeline, die Sie gerade kompiliert haben. Zum Hochladen einer Datei aus Cloud Shell sind ein paar zusätzliche Schritte erforderlich, daher nehmen wir eine Verknüpfung.
Geben Sie der Pipeline einen Namen (z.B. gh_summ).
Pipeline ausführen
Klicken Sie in der Liste auf die hochgeladene Pipeline. Daraufhin wird das statische Diagramm der Pipeline angezeigt. Klicken Sie dann auf Test erstellen, um mit der Pipeline einen neuen Test zu erstellen. Ein Experiment ist eine Möglichkeit, semantisch verwandte Ausführungen zu gruppieren.
Geben Sie dem Test einen Namen (z.B. denselben Namen wie die Pipeline, gh_summ) und klicken Sie dann auf Weiter, um den Test zu erstellen.
Es wird eine Seite geöffnet, auf der Sie die Parameter für eine Ausführung eingeben und starten können.
Sie können die folgenden Befehle in Cloud Shell ausführen, um die Parameter auszufüllen.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
Der Ausführungsname wird automatisch ausgefüllt, Sie können der Ausführung aber bei Bedarf einen anderen Namen geben.
Füllen Sie dann drei Parameterfelder aus:
project- (optional)
github-token working-dir
Geben Sie für das Arbeitsverzeichnis einen Pfad unter dem von Ihnen erstellten GCS-Bucket ein. Fügen Sie „gs://“ hinzu. . Geben Sie im Feld github-token entweder das Token ein, das Sie zuvor optional generiert haben, oder lassen Sie den Platzhalterstring unverändert, wenn Sie kein Token generiert haben.
Nachdem Sie die Felder ausgefüllt haben, klicken Sie auf Start (Starten) und dann auf die aufgeführte Ausführung, um die Details aufzurufen. Während ein Pipelineschritt ausgeführt wird, können Sie darauf klicken, um weitere Informationen dazu zu erhalten, einschließlich der Anzeige der Pod-Logs. Sie können die Logs für einen Pipelineschritt auch über den Link zu den zugehörigen Cloud Logging-Logs (Stackdriver) aufrufen, selbst wenn der Clusterknoten gelöscht wurde.
Pipelinedefinition ansehen
Während die Pipeline ausgeführt wird, können Sie sich genauer ansehen, wie sie zusammengesetzt ist und welche Funktion sie bewirkt. Weitere Informationen finden Sie im Codelab im Abschnitt Anhang.
Informationen zum Modelltraining in TensorBoard ansehen
Sobald der Trainingsschritt abgeschlossen ist, wählen Sie den Tab Visualisierungen aus und klicken auf die blaue Schaltfläche TensorBoard starten. Anschließend klicken Sie auf TensorBoard öffnen.
Das Dashboard für Artefakte und Ausführungen
Kubeflow Pipelines protokolliert automatisch Metadaten zu den Pipelineschritten, während eine Pipeline ausgeführt wird. Es werden sowohl Informationen zum Artifact als auch zur Artifact aufgezeichnet. Klicken Sie in der linken Navigationsleiste des Dashboards auf diese Einträge, um weitere Informationen zu erhalten.
Für Artefakte können Sie sich sowohl einen Übersichtsbereich als auch einen Lineage-Explorer ansehen.
Von der Pipeline erstellte Webanwendung aufrufen und Vorhersagen treffen
Im letzten Schritt der Pipeline wird eine Webanwendung bereitgestellt, die eine Benutzeroberfläche zum Abfragen des trainierten Modells (über TF Serving) für Vorhersagen bereitstellt.
Stellen Sie nach Abschluss der Pipeline eine Verbindung zur Webanwendung her, indem Sie eine Portweiterleitung zu ihrem Dienst einrichten. Dies ist eine Portweiterleitung, da der Webapp-Dienst für dieses Codelab nicht für einen externen Endpunkt eingerichtet ist.
Führen Sie den folgenden Befehl in Cloud Shell aus, um den Dienstnamen zu ermitteln:
kubectl get services
Suchen Sie in der Liste nach einem Dienstnamen wie diesem: ghsumm-*-webappsvc.
Führen Sie dann in Cloud Shell eine Portweiterleitung an diesen Dienst durch, indem Sie den folgenden Befehl so ändern, dass der Name Ihrer webappsvc verwendet wird:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Sobald die Portweiterleitung läuft, klicken Sie auf "Vorschau". über dem Cloud Shell-Bereich und klicken Sie im Drop-down-Menü auf „Preview on port 8080“ (Vorschau auf Port 8080).
Eine Seite wie diese sollte in einem neuen Tab angezeigt werden:
Klicken Sie auf die Schaltfläche fill Random Issue (Zufälliges Problem einfügen), um einen Textblock abzurufen. Klicken Sie auf Generate Tabelle (Tabelle generieren), um das trainierte Modell aufzurufen und eine Vorhersage anzuzeigen.
Wenn Ihre Pipelineparameter 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 „Popup Random Issue“. ein.
4. Pipeline von einem AI Platform Notebook ausführen
Mit dem KFP SDK können Sie Kubeflow-Pipelines auch interaktiv über ein Jupyter-Notebook definieren und ausführen. AI Platform Notebooks, das wir für dieses Codelab verwenden, macht dies sehr einfach.
Eine Notebook-Instanz erstellen
Wir erstellen mit der zugehörigen API eine Notebookinstanz in Cloud Shell. (Alternativ können Sie ein Notebook über die Cloud Console erstellen. Weitere Informationen finden Sie in der Dokumentation.
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 aus, um die Notebookinstanz zu erstellen:
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. Mit „y“ antworten wenn ja.
Nach einigen Minuten ist Ihr Notebook-Server einsatzbereit. Sie können Ihre Notebook-Instanzen in der Cloud Console auflisten.
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 Notebookinstanz aus. Das Notebook wird automatisch geöffnet.
Notebook ausführen
Folgen Sie für den Rest des Labs der Anleitung im Notebook. Beachten Sie, dass unter „Einrichtung“ Teil des Notebooks, müssen Sie Ihre eigenen Werte eingeben, bevor Sie den Rest des Notebooks ausführen.
Falls Sie Ihr eigenes Projekt verwenden, vergessen Sie nicht, hierher zurückzukehren und den Abschnitt „Bereinigen“ in diesem Lab zu lesen.
5. Bereinigen
Dies ist nicht erforderlich, wenn Sie ein temporäres Codelab-Konto verwenden. Sie können jedoch Ihre Pipelines-Installation und das Notebook entfernen, wenn Sie ein eigenes Projekt verwenden.
GKE-Cluster von Pipelines deaktivieren
Sie können den Pipelines-Cluster über die Cloud Console löschen. Sie haben die Möglichkeit, einfach die Pipelines-Installation zu löschen, wenn Sie den GKE-Cluster wiederverwenden möchten.
AI Notebook-Instanz löschen
Wenn Sie das „Notizbuch“ ausgeführt haben Teil des Codelabs können Sie die Notebookinstanz über die Cloud Console LÖSCHEN oder ANHALTEN.
Optional: GitHub-Token entfernen
Rufen Sie https://github.com/settings/tokens auf und entfernen Sie das generierte Token.
6. Anhänge
Ein Blick auf den Code
Pipeline definieren
Die in diesem Codelab verwendete Pipeline wird hier definiert.
Sehen wir uns an, wie es definiert ist und wie seine Komponenten (Schritte) definiert sind. Einige wichtige Informationen werden hier behandelt. Weitere Informationen finden Sie in der Dokumentation.
Die Schritte der Kubeflow-Pipeline sind containerbasiert. 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 ein eigenes erstellt.
Vier der Pipelineschritte werden aus wiederverwendbaren Komponenten definiert, auf die über die zugehörigen Komponentendefinitionsdateien zugegriffen wird. In diesem ersten Code-Snippet greifen wir auf diese Komponentendefinitionsdateien über ihre URL zu und verwenden diese Definitionen, um Operationen zu erstellen. mit dem 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. Wie Sie sehen, sind die Argumente für Eingaben und Ausgaben sowie für das Container-Image und den Containereinstiegspunkt definiert.
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 auch einen Pipelineschritt über den dsl.ContainerOp-Konstruktor definieren, wie unten gezeigt.
Nachfolgend finden Sie den Großteil der Pipelinedefinition. Wir definieren die Pipelineeingaben (und ihre Standardwerte). Dann definieren wir die Pipelineschritte. In den meisten Fällen verwenden wir die Wir definieren aber auch eine „Lieferung“, Schritt inline über ContainerOp, wobei die Container-Image- und Einstiegspunktargumente direkt angegeben werden.
Sie sehen, dass die Schritte train, log_model und serve als Eingaben auf Ausgaben der vorherigen Schritte zugreifen. Weitere Informationen dazu findest du hier.
@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)
Beachten Sie, dass der „Zug“ Schritt, um auf einem Knoten im Cluster auszuführen, auf dem mindestens 1 GPU verfügbar ist.
train.set_gpu_limit(1)
Der letzte Schritt in der Pipeline, der auch inline definiert ist, ist bedingt. Sie wird nach „serve“ ausgeführt. Schritt abgeschlossen ist, nur wenn die Ausgabe des Trainingsschritts launch_server der String „true“ ist. Sie startet die „Web-App für Vorhersagen“, mit der wir Problemzusammenfassungen 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)
Definitionen des Container-Images der Komponenten
In der Dokumentation zur Kubeflow Pipeline werden einige Best Practices für die Erstellung Ihrer eigenen Komponenten beschrieben. Im Rahmen dieses Prozesses müssen Sie ein Container-Image definieren und erstellen. Die Komponentenschritte für die Pipeline dieses Codelabs finden Sie hier. Die Dockerfile-Definitionen befinden sich in den containers-Unterverzeichnissen, z.B. finden Sie hier.
VMs auf Abruf mit GPUs zum Trainieren 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 die von standardmäßigen Compute Engine-VMs.
Mit Google Kubernetes Engine (GKE) ist es ganz einfach, einen Cluster oder Knotenpool einzurichten, der VMs auf Abruf verwendet. Sie können einen solchen Knotenpool mit an die Instanzen auf Abruf angehängten GPUs einrichten. Diese funktionieren 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, den folgenden Befehl mit dem Namen und der Zone Ihres Clusters bearbeiten und den Beschleunigertyp und die Anzahl entsprechend Ihren Anforderungen anpassen. Sie können den Knotenpool optional so definieren, dass er automatisch anhand der aktuellen Arbeitslasten 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 die GKE-Knoten auf Abruf 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 Knoten auf Abruf ausgeführt werden. Dadurch sinken die Kosten für die Ausführung eines Jobs. Damit VMs auf Abruf korrekte Ergebnisse liefern, 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 einen Prüfpunkt, der 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 präemptiven Knoten ausgeführt werden soll, indem Sie den Vorgang wie folgt ändern:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Weitere Informationen finden Sie in der Dokumentation.
Sie möchten den Schritt vermutlich auch einige Male wiederholen, wenn der Knoten präemptiv beendet wurde. Sie können dies wie folgt tun – hier geben wir fünf Wiederholungsversuche an.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Bearbeiten Sie die in diesem Codelab verwendete Kubeflow-Pipeline, 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 oben zu verwenden (wie oben angegeben) und den Vorgang fünfmal zu wiederholen:
train.set_gpu_limit(1)
Kompilieren Sie anschließend die Pipeline neu, laden Sie die neue Version hoch (geben Sie ihr einen neuen Namen) und führen Sie dann die neue Version der Pipeline aus.