1. Übersicht
In diesem Lab erfahren Sie, wie Sie einen Trainingsjob für ein benutzerdefiniertes Modell mit dem Kubeflow Pipelines SDK in Vertex Pipelines ausführen.
Lerninhalte
Die folgenden Themen werden behandelt:
- Mit dem Kubeflow Pipelines SDK skalierbare ML-Pipelines erstellen
- Erstellen und containerisieren Sie einen benutzerdefinierten Scikit-learn-Modelltrainingsjob, der von Vertex AI verwaltete Datasets verwendet und in einer Pipeline in Vertex AI Training ausgeführt wird.
- Batchvorhersagejob in Vertex-Pipelines ausführen
- Vordefinierte Komponenten, die über die Bibliothek
google_cloud_pipeline_componentsbereitgestellt werden, für die Interaktion mit Vertex AI-Diensten nutzen
Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud betragen etwa 5$.
2. Einführung in Vertex AI
In diesem Lab wird Vertex AI verwendet, unsere End-to-End-Plattform für verwaltetes maschinelles Lernen in Google Cloud. Vertex AI vereint die ML-Angebote von Google Cloud in einer nahtlosen Entwicklungsumgebung. Neben Diensten für das Modelltraining und die Bereitstellung umfasst Vertex AI auch eine Vielzahl von MLOps-Produkten, darunter Vertex Pipelines (der Schwerpunkt dieses Labs), Model Monitoring und Feature Store. Alle Vertex AI-Produkte finden Sie im folgenden Diagramm.
Wenn Sie Feedback haben, lesen Sie bitte die Supportseite.
Warum sind ML-Pipelines nützlich?
Sehen wir uns erst einmal an, warum der Einsatz von Pipelines sinnvoll ist. Stellen Sie sich vor, Sie entwickeln einen ML-Workflow, der Datenverarbeitung, Modelltraining, Hyperparameter-Abstimmung, Bewertung und Modellbereitstellung umfasst. Jeder dieser Schritte kann andere Abhängigkeiten haben, was die Bearbeitung erschweren kann, wenn Sie den gesamten Workflow als eine Einheit behandeln. Beim Skalieren des ML-Prozesses kann es sinnvoll sein, Ihren ML-Workflow mit anderen Teammitgliedern zu teilen, damit diese ihn ebenfalls ausführen und Code beitragen können. Ohne zuverlässigen, reproduzierbaren Prozess kann dies schwierig sein. Pipelines sorgen dafür, dass es für jeden Schritt des ML-Prozesses einen eigenen Container gibt. So können Sie Schritte unabhängig voneinander entwickeln und die Ein- und Ausgaben jedes Schrittes verfolgen und reproduzieren. Außerdem können Sie Ausführungen der Pipeline basierend auf anderen Ereignissen in Ihrer Cloud-Umgebung planen oder auslösen, zum Beispiel wenn neue Trainingsdaten verfügbar sind.
Kurz gesagt: Pipelines helfen Ihnen, Ihre ML-Workflows zu optimieren und zu reproduzieren.
3. Cloud-Umgebung einrichten
Für dieses Codelab benötigen Sie ein Google Cloud Platform-Projekt mit aktivierter Abrechnung. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.
Schritt 1: Cloud Shell starten
In diesem Lab arbeiten Sie in einer Cloud Shell-Sitzung. Das ist ein Befehlsinterpreter, der auf einer virtuellen Maschine in der Google-Cloud gehostet wird. Sie könnten diesen Abschnitt genauso gut lokal auf Ihrem eigenen Computer ausführen, aber mit Cloud Shell hat jeder Zugriff auf eine reproduzierbare Umgebung. Nach dem Lab können Sie diesen Abschnitt gern auf Ihrem eigenen Computer wiederholen.
Cloud Shell aktivieren
Klicken Sie oben rechts in der Cloud Console auf die Schaltfläche unten, um Cloud Shell zu aktivieren:
Wenn Sie die Cloud Shell zuvor noch nicht gestartet haben, wird ein Fenster mit einer Beschreibung eingeblendet. Klicken Sie in diesem Fall einfach auf Weiter. So sieht dieses Fenster aus:
Das Herstellen der Verbindung mit der Cloud Shell sollte nur wenige Augenblicke dauern.
Auf dieser virtuellen Maschine sind alle Entwicklungstools installiert, die Sie benötigen. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht sogar alle Aufgaben in diesem Codelab können mit einem Browser oder Ihrem Chromebook erledigt werden.
Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie bereits authentifiziert sind und für das Projekt schon Ihre Projekt-ID eingestellt ist.
Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:
gcloud auth list
Die Befehlsausgabe sollte in etwa so aussehen:
Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt:
gcloud config list project
Befehlsausgabe
[core] project = <PROJECT_ID>
Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:
gcloud config set project <PROJECT_ID>
Befehlsausgabe
Updated property [core/project].
Cloud Shell hat einige Umgebungsvariablen, darunter GOOGLE_CLOUD_PROJECT, die den Namen unseres aktuellen Cloud-Projekts enthält. Wir werden diese Variable an verschiedenen Stellen in diesem Lab verwenden. Sie können sie mit folgendem Befehl aufrufen:
echo $GOOGLE_CLOUD_PROJECT
Schritt 2: APIs aktivieren
In späteren Schritten sehen Sie, wo diese Dienste benötigt werden und warum. Führen Sie jetzt diesen Befehl aus, um Ihrem Projekt Zugriff auf die Dienste Compute Engine, Container Registry und Vertex AI zu gewähren:
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
Wenn die Aktivierung erfolgreich war, erhalten Sie eine Meldung, die ungefähr so aussieht:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
Schritt 3: Cloud Storage-Bucket erstellen
Wenn wir einen Trainingsjob in Vertex AI ausführen möchten, benötigen wir einen Speicher-Bucket zum Speichern unserer gespeicherten Modell-Assets. Der Bucket muss regional sein. Wir verwenden hier us-central, Sie können aber auch eine andere Region verwenden (ersetzen Sie sie einfach in diesem Lab). Wenn Sie bereits einen Bucket haben, können Sie diesen Schritt überspringen.
Führen Sie die folgenden Befehle in Ihrem Cloud Shell-Terminal aus, um einen Bucket zu erstellen:
BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME
Als Nächstes gewähren wir unserem Compute-Dienstkonto Zugriff auf diesen Bucket. So wird sichergestellt, dass Vertex Pipelines die erforderlichen Berechtigungen zum Schreiben von Dateien in diesen Bucket hat. Führen Sie den folgenden Befehl aus, um diese Berechtigung hinzuzufügen:
gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin
Schritt 4: Vertex AI Workbench-Instanz erstellen
Klicken Sie in der Cloud Console im Bereich „Vertex AI“ auf „Workbench“:
Klicken Sie dort unter Nutzerverwaltete Notebooks auf Neues Notebook:
Wählen Sie dann den Instanztyp TensorFlow Enterprise 2.3 (mit LTS) ohne GPUs aus:
Übernehmen Sie die Standardoptionen und klicken Sie auf Erstellen.
Schritt 5: Notebook öffnen
Nachdem die Instanz erstellt wurde, klicken Sie auf JupyterLab öffnen:
4. Vertex Pipelines einrichten
Damit wir Vertex Pipelines nutzen können, müssen wir noch einige zusätzliche Bibliotheken installieren:
- Kubeflow Pipelines: Dieses SDK wird zum Erstellen der Pipeline verwendet. Vertex Pipelines unterstützt das Ausführen von mit Kubeflow Pipelines oder TFX erstellten Pipelines.
- Google Cloud Pipeline Components: Diese Bibliothek enthält vordefinierte Komponenten, die das Interagieren mit Vertex AI-Diensten in Ihren Pipelineschritten erleichtern.
1. Schritt: Python-Notebook erstellen und Bibliotheken installieren
Erstellen Sie zuerst im Launcher-Menü in Ihrer Notebook-Instanz (auf das Sie zugreifen können, indem Sie oben links in Ihrem Notebook auf das Pluszeichen klicken) ein Notebook, indem Sie Python 3 auswählen:
In das Launcher-Menü gelangen Sie, wenn Sie oben links in der Notebook-Instanz auf das +-Zeichen klicken.
Legen Sie zuerst das Flag „user“ in einer Notebook-Zelle fest, um beide für dieses Lab benötigten Dienste zu installieren:
USER_FLAG = "--user"
Führen Sie dann folgenden Code im Notebook aus:
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0
Nach dem Installieren dieser Pakete müssen Sie den Kernel neu starten:
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Prüfen Sie zum Abschluss, ob die Pakete korrekt installiert wurden. Die KFP SDK-Version sollte mindestens 1.8 sein:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"
2. Schritt: Projekt-ID und Bucket einrichten
Während des Labs benötigen Sie immer wieder Ihre Cloud-Projekt-ID und den zuvor erstellten Bucket. Als Nächstes erstellen wir dafür Variablen.
Falls Sie die Projekt-ID nicht kennen, können Sie sie abrufen, indem Sie diesen Befehl ausführen:
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
Andernfalls legen Sie sie hier fest:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Erstellen Sie dann eine Variable zum Speichern des Bucket-Namens. Wenn Sie sie in diesem Lab erstellt haben, funktioniert Folgendes. Andernfalls müssen Sie dies manuell festlegen:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
3. Schritt: Bibliotheken importieren
Fügen Sie Folgendes hinzu, um die Bibliotheken für dieses Codelab zu importieren:
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
4. Schritt: Konstanten definieren
Jetzt definieren wir noch einige konstante Variablen. Anschließend können wir mit dem Erstellen der Pipeline beginnen. PIPELINE_ROOT ist der Cloud Storage-Pfad, in den die durch die Pipeline erstellten Artefakte geschrieben werden. Wir verwenden hier us-central1 als Region, aber falls Sie beim Erstellen des Buckets eine andere Region ausgewählt haben, passen Sie die Variable REGION im folgenden Code an:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Nach dem Ausführen des obigen Codes sollte das Stammverzeichnis für Ihre Pipeline ausgegeben werden. Dies ist der Cloud Storage-Speicherort, in den die Artefakte aus Ihrer Pipeline geschrieben werden. Sie hat das Format gs://YOUR-BUCKET-NAME/pipeline_root/.
5. Benutzerdefinierten Modelltrainingsjob konfigurieren
Bevor wir unsere Pipeline einrichten, müssen wir den Code für unseren benutzerdefinierten Modelltrainingsjob schreiben. Zum Trainieren des Modells verwenden wir das UCI Machine Learning-Dataset Dry Beans aus: KOKLU, M. und OZKAN, I.A., (2020), „Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques“ in Computers and Electronics in Agriculture, 174, 105507. DOI
Im ersten Schritt der Pipeline wird in Vertex AI ein verwaltetes Dataset aus einer BigQuery-Tabelle erstellt, die eine Version dieser Bohnendaten enthält. Das Dataset wird als Eingabe an unseren Trainingsjob übergeben. In unserem Trainingscode haben wir Zugriff auf die Umgebungsvariable, um auf dieses verwaltete Dataset zuzugreifen.
So richten wir unseren benutzerdefinierten Trainingsjob ein:
- Ein Scikit-learn-
DecisionTreeClassifier-Modell zum Klassifizieren von Bohnensorten in unseren Daten schreiben - Trainingscode in einem Docker-Container verpacken und in die Container Registry übertragen
Von dort aus können wir einen Vertex AI Training-Job direkt über unsere Pipeline starten. Los geht's!
Schritt 1: Trainingscode in einem Docker-Container definieren
Öffnen Sie in Ihrer Notebook-Instanz den Launcher und wählen Sie „Terminal“ aus:
Führen Sie dann den folgenden Befehl aus, um ein Verzeichnis einzurichten, in dem Sie Ihren containerisierten Code hinzufügen:
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
Nachdem Sie diese Befehle ausgeführt haben, sollte links ein Verzeichnis namens traincontainer/ angezeigt werden. Möglicherweise müssen Sie auf das Aktualisierungssymbol klicken, damit es angezeigt wird. Im Verzeichnis traincontainer/ wird Folgendes angezeigt:
+ Dockerfile
+ trainer/
+ train.py
Der erste Schritt beim Containerisieren unseres Codes ist das Erstellen eines Dockerfile. Unser Dockerfile enthält alle Befehle, die zum Ausführen unseres Images erforderlich sind. Dadurch werden alle von uns verwendeten Bibliotheken installiert und der Einstiegspunkt für unseren Trainingscode eingerichtet. Öffnen Sie das gerade erstellte Dockerfile und fügen Sie Folgendes hinzu:
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
Wenn Sie Dateien speichern möchten, während Sie sie in Ihrer Notebook-Instanz bearbeiten, können Sie ctrl+s verwenden.
Öffnen Sie als Nächstes die Datei train.py. Hier fügen wir unseren Trainingscode hinzu. Kopieren Sie Folgendes in train.py. Dadurch werden die Daten aus unserem verwalteten Dataset abgerufen, in einen Pandas-DataFrame eingefügt, ein Scikit-learn-Modell trainiert und das trainierte Modell in Cloud Storage hochgeladen:
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
Kehren Sie dann zu Ihrem Notebook zurück und führen Sie den folgenden Befehl aus, um YOUR_GCS_BUCKET im obigen Skript durch den Namen Ihres Cloud Storage-Buckets zu ersetzen:
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
Sie können dies auch manuell tun, wenn Sie möchten. Wenn Sie das tun, achten Sie darauf, dass Sie gs:// nicht in den Bucket-Namen einfügen, wenn Sie das Skript aktualisieren.
Unser Trainingscode befindet sich jetzt in einem Docker-Container und wir können das Training in der Cloud ausführen.
Schritt 2: Container per Push an Container Registry übertragen
Da unser Trainingscode fertig ist, können wir ihn jetzt in Google Container Registry übertragen. Später, wenn wir die Trainingskomponente unserer Pipeline konfigurieren, verweisen wir mit Vertex Pipelines auf diesen Container.
Kehren Sie zum Terminal zurück und definieren Sie im Stammverzeichnis Ihres traincontainer/-Verzeichnisses eine Variable mit dem URI für Ihr Container-Image in Container Registry.
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
Erstellen Sie dann Ihren Container, indem Sie Folgendes ausführen:
docker build ./ -t $IMAGE_URI
Übertragen Sie den Container schließlich per Push an Container Registry:
docker push $IMAGE_URI
Rufen Sie in der Cloud Console den Abschnitt „Container Registry“ auf, um zu prüfen, ob Ihr Container vorhanden ist. Dies könnte beispielsweise so aussehen:
6. Batchvorhersagejob konfigurieren
Im letzten Schritt unserer Pipeline wird ein Batchvorhersage-Job ausgeführt. Dazu müssen wir eine CSV-Datei in Cloud Storage bereitstellen, die die Beispiele enthält, für die wir Vorhersagen erhalten möchten. Wir erstellen diese CSV-Datei in unserem Notebook und kopieren sie mit dem Befehlszeilentool gsutil in Cloud Storage.
Batchvorhersagebeispiele in Cloud Storage kopieren
Die folgende Datei enthält drei Beispiele aus jeder Klasse in unserem Bohnen-Dataset. Das Beispiel unten enthält nicht die Spalte Class, da dies die Spalte ist, die von unserem Modell vorhergesagt wird. Führen Sie den folgenden Code aus, um diese CSV-Datei lokal in Ihrem Notebook zu erstellen:
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
Kopieren Sie die Datei dann in Ihren Cloud Storage-Bucket:
!gsutil cp batch_examples.csv $BUCKET_NAME
Wir werden in der nächsten Phase, in der wir unsere Pipeline definieren, auf diese Datei verweisen.
7. Pipeline mit vorgefertigten Komponenten erstellen
Da sich unser Trainingscode jetzt in der Cloud befindet, können wir ihn über unsere Pipeline aufrufen. Für die Pipeline, die wir definieren, werden drei vordefinierte Komponenten aus der Bibliothek google_cloud_pipeline_components verwendet, die wir zuvor installiert haben. Diese vordefinierten Komponenten vereinfachen den Code, den wir zum Einrichten unserer Pipeline schreiben müssen, und ermöglichen es uns, Vertex AI-Dienste wie Modelltraining und Batchvorhersage zu verwenden.
So funktioniert unsere dreistufige Pipeline:
- Verwaltetes Dataset in Vertex AI erstellen
- Trainingsjob in Vertex AI mit dem von uns eingerichteten benutzerdefinierten Container ausführen
- Batchvorhersagejob für das trainierte Scikit-learn-Klassifizierungsmodell ausführen
Schritt 1: Pipeline definieren
Da wir vordefinierte Komponenten verwenden, können wir die gesamte Pipeline in der Pipelinedefinition einrichten. Fügen Sie Folgendes in eine Notebookzelle ein:
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
Schritt 2: Pipeline kompilieren und ausführen
Nachdem Sie Ihre Pipeline definiert haben, können Sie sie kompilieren. Mit dem folgenden Befehl erstellen Sie eine JSON-Datei, die Sie zum Ausführen der Pipeline verwenden:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
Erstellen Sie als Nächstes eine TIMESTAMP-Variable. Wir verwenden dies in unserer Job-ID:
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Definieren Sie dann Ihren Pipeline-Job und übergeben Sie einige projektspezifische Parameter:
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
Führen Sie den Job aus, um eine neue Pipelineausführung zu erstellen:
pipeline_job.submit()
Nach dem Ausführen dieser Zelle sollten Logs mit einem Link angezeigt werden, über den Sie die Pipelineausführung in der Console sehen können:
Rufen Sie diesen Link auf. Sie können auch über das Pipelines-Dashboard darauf zugreifen. Die Pipeline sollte am Ende so aussehen:
Das Ausführen der Pipeline dauert 5–10 Minuten. Sie können aber mit dem nächsten Schritt fortfahren, bevor sie abgeschlossen ist. Als Nächstes erfahren Sie mehr darüber, was in den einzelnen Pipelineschritten passiert.
8. Pipeline-Ausführung analysieren
Sehen wir uns die drei Pipeline-Schritte genauer an.
Pipelineschritt 1: Verwaltetes Dataset erstellen
Im ersten Schritt unserer Pipeline wird ein verwaltetes Dataset in Vertex AI erstellt. Wenn Sie im Bereich „Pipelines“ Ihrer Konsole auf den folgenden Dataset-Link klicken:
Ihr Dataset wird in Vertex AI angezeigt. Es enthält einen Link zur Datenquelle in BigQuery sowie Informationen zu den verschiedenen Spalten in Ihrem Dataset. Nachdem Sie ein verwaltetes Dataset in Vertex AI hochgeladen haben, kann es zum Trainieren eines AutoML-Modells oder eines benutzerdefinierten Modells verwendet werden.
Bei benutzerdefinierten Modelljobs, die verwaltete Datasets verwenden, übergibt Vertex AI spezielle Umgebungsvariablen an Ihre Trainingsjobs und teilt Ihre Daten in Trainings- und Testsets auf. Wir werden sie im nächsten Pipelineschritt verwenden.
Pipelineschritt 2: Modell in Vertex AI Training trainieren
Während Ihr benutzerdefinierter Trainingsjob ausgeführt wird, können Sie auf die Logs klicken, um sie direkt in der Vertex Pipelines Console aufzurufen:
Details zum benutzerdefinierten Trainingsjob finden Sie auch im Vertex AI-Training-Dashboard. Nach Abschluss des Trainingsjobs wird in Vertex AI eine Modellressource erstellt. Wir können dieses Modell dann auf einem Endpunkt für Onlinevorhersagen bereitstellen oder einen Batchvorhersagejob erstellen. Das werden wir im nächsten Pipelineschritt tun.
Pipelineschritt 3: Batchvorhersagejob für das Modell ausführen
Schließlich werden für die Beispiele, die wir über eine CSV-Datei übergeben haben, Vorhersagen generiert. Wenn der Batchvorhersagejob abgeschlossen ist, schreibt Vertex AI eine CSV-Datei an den Speicherort, den wir in Cloud Storage angegeben haben. Wenn dieser Pipelineschritt ausgeführt wird, können Sie in der Vertex AI-Konsole zum Abschnitt „Batchvorhersagen“ wechseln, um den erstellten Job aufzurufen.
Klicken Sie auf den Job, wenn er abgeschlossen ist, um die Cloud Storage-URL Ihrer Batchvorhersagen aufzurufen:
Klicken Sie auf diesen Link, um zum Cloud Storage-Verzeichnis zu gelangen, in dem sich die Vorhersageergebnisse befinden. Klicken Sie dann auf eine der prediction.results-Dateien, um sie herunterzuladen. In der Datei sollten Zeilen wie die folgenden zu sehen sein:
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
Dazu gehören die Attributwerte für eine bestimmte Instanz sowie die Klasse, die von unserem Modell vorhergesagt wurde. In diesem Beispiel geht unser Modell davon aus, dass es sich um eine „HOROZ“-Bohne handelt.
Damit haben Sie das Lab abgeschlossen.
🎉 Das wars! 🎉
Sie haben gelernt, wie Sie Vertex AI für folgende Aufgaben verwenden:
- Mit dem Kubeflow Pipelines SDK End-to-End-Pipelines mit benutzerdefinierten Komponenten erstellen
- Pipelines in Vertex Pipelines ausführen und Pipelineausführungen mit dem SDK starten
- Vertex Pipelines-Diagramm in der Console ansehen und analysieren
- Vordefinierte Pipelinekomponenten verwenden, um Vertex AI-Dienste in Ihre Pipeline einzufügen
- Wiederkehrende Pipelinejobs planen
Weitere Informationen zu den verschiedenen Bereichen von Vertex finden Sie in der Dokumentation.
9. Bereinigen
Damit keine Gebühren anfallen, sollten Sie die in diesem Lab erstellten Ressourcen löschen.
Schritt 1: Notebooks-Instanz beenden oder löschen
Wenn Sie das in diesem Lab erstellte Notebook weiterhin verwenden möchten, sollten Sie es deaktivieren, wenn Sie es nicht nutzen. Wählen Sie in der Notebooks-Benutzeroberfläche in der Cloud Console das Notebook und dann Beenden aus. Wenn Sie die Instanz vollständig löschen möchten, wählen Sie Löschen aus:
Schritt 2: Cloud Storage-Bucket löschen
Wenn Sie den Storage-Bucket löschen möchten, rufen Sie in der Cloud Console über das Navigationsmenü „Storage“ auf, wählen Sie den Bucket aus und klicken Sie auf „Löschen“:
