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
- Benutzerdefinierten Trainingsjob für das Scikit-learn-Modell erstellen und containerisieren, der von Vertex AI verwaltete Datasets verwendet und in Vertex AI Training in einer Pipeline ausgeführt wird
- Batchvorhersagejob in Vertex Pipelines ausführen
- Vordefinierte Komponenten für die Interaktion mit Vertex AI-Diensten verwenden, die über die
google_cloud_pipeline_components-Bibliothek bereitgestellt werden
Die Gesamtkosten für das Lab in Google Cloud betragen etwa 5$.
2. Einführung in Vertex AI
In diesem Lab wird Vertex AI verwendet, unsere End-to-End-ML-Plattform in Google Cloud. Vertex AI bindet die ML-Angebote von Google in Google Cloud in eine nahtlose Entwicklungsumgebung ein. Neben Modelltrainings- und Bereitstellungsdiensten umfasst Vertex AI auch eine Vielzahl von MLOps-Produkten, darunter Vertex Pipelines (Schwerpunkt dieses Labs), Modellmonitoring, Feature Store und mehr. Im Diagramm unten sehen Sie alle Vertex AI-Produktangebote.
Wenn Sie uns Feedback geben möchten, besuchen Sie die Supportseite.
Warum sind ML-Pipelines nützlich?
Bevor wir loslegen, müssen wir verstehen, warum Sie eine Pipeline verwenden sollten. Stellen Sie sich vor, Sie erstellen einen ML-Workflow, der die Verarbeitung von Daten, das Trainieren eines Modells, die Hyperparameter-Abstimmung, die Bewertung und die Modellbereitstellung umfasst. Jeder dieser Schritte kann unterschiedliche Abhängigkeiten haben, die unübersichtlich werden können, wenn Sie den gesamten Workflow als monolithische Anwendung behandeln. Wenn Sie mit der Skalierung Ihres ML-Prozesses beginnen, möchten Sie möglicherweise Ihren ML-Workflow mit anderen in Ihrem Team teilen, damit diese ihn ausführen und Code beitragen können. Ohne einen zuverlässigen, reproduzierbaren Prozess kann dies schwierig werden. Bei Pipelines ist jeder Schritt in Ihrem ML-Prozess ein eigener Container. Auf diese Weise können Sie Schritte unabhängig entwickeln und die Ein- und Ausgabe jedes Schritts auf reproduzierbare Weise verfolgen. Sie können Ausführungen Ihrer Pipeline auch basierend auf anderen Ereignissen in Ihrer Cloud-Umgebung planen oder auslösen, z. B. eine Pipelineausführung starten, wenn neue Trainingsdaten verfügbar sind.
Kurzfassung: Pipelines helfen Ihnen, ML-Workflows zu optimieren und zu reproduzieren.
3. Cloud-Umgebung einrichten
Sie benötigen ein Google Cloud Platform-Projekt mit aktivierter Abrechnung, um dieses Codelab auszuführen. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.
Schritt 1: Cloud Shell starten
In diesem Lab arbeiten Sie in einer Cloud Shell-Sitzung, einem Befehlsinterpreter, der von einer virtuellen Maschine in der Cloud von Google gehostet wird. Sie können diesen Abschnitt genauso einfach lokal auf Ihrem Computer ausführen, aber mit Cloud Shell erhalten alle Zugriff auf eine reproduzierbare Version in einer einheitlichen Umgebung. Sie können diesen Abschnitt nach dem Lab gerne auf Ihrem eigenen Computer wiederholen.
Cloud Shell aktivieren
Klicken Sie rechts oben in der Cloud Console auf die Schaltfläche unten, um Cloud Shell zu aktivieren:
Wenn Sie Cloud Shell noch nie gestartet haben, wird ein Zwischenbildschirm (below the fold) angezeigt, in dem beschrieben wird, worum es sich dabei handelt. Klicken Sie in diesem Fall auf Weiter. Der Chat wird nie wieder angezeigt. So sieht dieser einmalige Bildschirm aus:
Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.
Diese virtuelle Maschine verfügt über alle Entwicklungstools, die Sie benötigen. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können Sie ganz einfach mit einem Browser oder Ihrem Chromebook erledigen.
Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie bereits authentifiziert sind und dass das Projekt bereits auf Ihre Projekt-ID eingestellt ist.
Führen Sie in 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 in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob 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, das den Namen des aktuellen Cloud-Projekts enthält. Wir werden sie in diesem Lab an verschiedenen Stellen verwenden. Sie können es sich ansehen, indem Sie folgenden Befehl ausführen:
echo $GOOGLE_CLOUD_PROJECT
Schritt 2: APIs aktivieren
In späteren Schritten werden Sie sehen, wo diese Dienste benötigt werden (und warum). Führen Sie vorerst diesen Befehl aus, um Ihrem Projekt Zugriff auf die Compute Engine-, Container Registry- und Vertex AI-Dienste 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
Zum Ausführen eines Trainingsjobs in Vertex AI benötigen wir einen Storage-Bucket zum Speichern der 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 dem Compute-Dienstkonto Zugriff auf diesen Bucket. Dadurch 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 im Bereich Vertex AI der Cloud Console 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:
Verwenden Sie die Standardoptionen und klicken Sie dann auf Erstellen.
Schritt 5: Notebook öffnen
Nachdem die Instanz erstellt wurde, wählen Sie JupyterLab öffnen aus:
4. Vertex Pipelines einrichten
Zur Verwendung von Vertex Pipelines müssen einige zusätzliche Bibliotheken installiert werden:
- Kubeflow Pipelines: Dies ist das SDK, das wir zum Erstellen unserer Pipeline verwenden. Vertex Pipelines unterstützt die Ausführung von Pipelines, die mit Kubeflow Pipelines oder TFX erstellt wurden.
- Google Cloud-Pipelinekomponenten: Diese Bibliothek enthält vordefinierte Komponenten, die die Interaktion mit Vertex AI-Diensten über Ihre Pipelineschritte erleichtern.
Schritt 1: Python-Notebook erstellen und Bibliotheken installieren
Erstellen Sie zuerst aus dem Launcher-Menü in Ihrer Notebook-Instanz, auf die Sie durch Klicken auf das Pluszeichen links oben im Notebook zugreifen können, ein Notebook. Wählen Sie dazu Python 3 aus:
Sie können auf das Launcher-Menü zugreifen, indem Sie links oben in Ihrer Notebookinstanz auf das Pluszeichen + klicken.
Um beide Dienste zu installieren, die wir in diesem Lab verwenden werden, legen Sie zuerst das Nutzer-Flag in einer Notebook-Zelle fest:
USER_FLAG = "--user"
Führen Sie dann in Ihrem Notebook folgenden Befehl 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 der Installation 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 abschließend, ob Sie die Pakete korrekt installiert haben. Die KFP SDK-Version muss größer als 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__))"
Schritt 2: Projekt-ID und Bucket festlegen
In diesem Lab verweisen Sie auf Ihre Cloud-Projekt-ID und den Bucket, den Sie zuvor erstellt haben. Als Nächstes erstellen wir Variablen für jede dieser Elemente.
Wenn Sie Ihre Projekt-ID nicht kennen, können Sie sie möglicherweise abrufen, indem Sie den folgenden 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 die Einstellungen manuell vornehmen:
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
Schritt 3: Bibliotheken importieren
Fügen Sie Folgendes hinzu, um die Bibliotheken zu importieren, die wir in diesem Codelab verwenden:
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
Schritt 4: Konstanten definieren
Als Letztes müssen wir vor dem Erstellen der Pipeline noch einige konstante Variablen definieren. PIPELINE_ROOT ist der Cloud Storage-Pfad, in den die von unserer Pipeline erstellten Artefakte geschrieben werden. Wir verwenden hier us-central1 als Region. Wenn Sie beim Erstellen des Buckets jedoch eine andere Region verwendet haben, aktualisieren Sie die Variable REGION im Code unten:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
Nachdem Sie den obigen Code ausgeführt haben, sollte das Stammverzeichnis Ihrer Pipeline ausgegeben werden. Dies ist der Cloud Storage-Speicherort, an den die Artefakte aus Ihrer Pipeline geschrieben werden. Sie hat das Format gs://YOUR-BUCKET-NAME/pipeline_root/.
5. Trainingsjob für benutzerdefiniertes Modell konfigurieren
Bevor wir unsere Pipeline einrichten, müssen wir den Code für unseren Trainingsjob für das benutzerdefinierte Modell schreiben. Zum Trainieren des Modells verwenden wir das UCI Machine Learning Dry Beans Dataset von: 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 Pipelineschritt erstellen Sie ein verwaltetes Dataset in Vertex AI mithilfe einer BigQuery-Tabelle, die eine Version dieser Beans-Daten enthält. Das Dataset wird als Eingabe an unseren Trainingsjob übergeben. In unserem Trainingscode haben wir Zugriff auf Umgebungsvariable, um auf dieses verwaltete Dataset zuzugreifen.
So richten wir unseren benutzerdefinierten Trainingsjob ein:
- Ein Scikit-learn-
DecisionTreeClassifier-Modell zum Klassifizieren von Bean-Typen in unseren Daten schreiben - Trainingscode in einem Docker-Container verpacken und per Push in Container Registry übertragen
Von dort aus können wir einen Vertex AI Training-Job direkt über unsere Pipeline starten. Los gehts!
Schritt 1: Trainingscode in einem Docker-Container definieren
Öffnen Sie in Ihrer Notebooks-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 Containercode hinzufügen können:
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, um es anzuzeigen). In Ihrem traincontainer/-Verzeichnis sehen Sie Folgendes:
+ Dockerfile
+ trainer/
+ train.py
Der erste Schritt bei der Containerisierung unseres Codes besteht darin, ein Dockerfile zu erstellen. In unser Dockerfile geben wir alle Befehle ein, die zum Ausführen des Images erforderlich sind. Damit werden alle Bibliotheken installiert, die wir verwenden, und der Einstiegspunkt für unseren Trainingscode wird eingerichtet. Öffnen Sie das soeben 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"]
Um Dateien während der Bearbeitung in Ihrer Notebookinstanz zu speichern, können Sie ctrl+s verwenden.
Öffnen Sie als Nächstes die Datei train.py. Hier fügen wir den Trainingscode ein. Kopieren Sie den folgenden Code 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")
Gehen Sie dann zurück zu Ihrem Notebook und führen Sie den folgenden Befehl aus, um YOUR_GCS_BUCKET aus dem 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. Achten Sie in diesem Fall darauf, dass Sie gs:// nicht in den Bucket-Namen aufnehmen, wenn Sie das Skript aktualisieren.
Jetzt befindet sich unser Trainingscode in einem Docker-Container und wir können das Training in der Cloud ausführen.
Schritt 2: Container per Push an Container Registry übertragen
Wenn der Trainingscode vollständig ist, können wir dies in Google Container Registry übertragen. Wenn wir später die Trainingskomponente der Pipeline konfigurieren, verweisen wir Vertex Pipelines auf diesen Container.
Gehen Sie zurück zum Terminal 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 den Container mit dem folgenden Befehl:
docker build ./ -t $IMAGE_URI
Übertragen Sie den Container schließlich per Push in Container Registry:
docker push $IMAGE_URI
Rufen Sie in der Cloud Console den Abschnitt Container Registry auf, um zu prüfen, ob sich der Container dort befindet. Dies könnte beispielsweise so aussehen:
6. Batchvorhersagejob konfigurieren
Im letzten Schritt der Pipeline wird ein Batchvorhersagejob ausgeführt. Dazu müssen wir in Cloud Storage eine CSV-Datei mit den Beispielen bereitstellen, für die Vorhersagen abgerufen werden sollen. Wir erstellen diese CSV-Datei in unserem Notebook und kopieren sie mit dem gsutil-Befehlszeilentool in Cloud Storage.
Beispiele für Batchvorhersagen nach Cloud Storage kopieren
Die folgende Datei enthält drei Beispiele aus jeder Klasse in unserem Beans-Dataset. Im folgenden Beispiel ist die Spalte Class nicht enthalten, da unser Modell diese Vorhersage vorhersagt. Führen Sie den folgenden Befehl 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 verweisen im nächsten Schritt, wenn wir unsere Pipeline definieren, auf diese Datei.
7. Pipeline mit vordefinierten Komponenten erstellen
Da sich unser Trainingscode jetzt in der Cloud befindet, können wir ihn über unsere Pipeline aufrufen. Die von uns definierte Pipeline verwendet drei vordefinierte Komponenten aus der zuvor installierten google_cloud_pipeline_components-Bibliothek. 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.
Unsere dreistufige Pipeline bewirkt Folgendes:
- Verwaltetes Dataset in Vertex AI erstellen
- Mit dem von uns eingerichteten benutzerdefinierten Container einen Trainingsjob in Vertx AI ausführen
- Batchvorhersagejob mit unserem trainierten Scikit-learn-Klassifizierungsmodell ausführen
Schritt 1: Unsere Pipeline definieren
Da wir vordefinierte Komponenten verwenden, können wir unsere gesamte Pipeline in der Pipelinedefinition einrichten. Fügen Sie einer Notebook-Zelle Folgendes hinzu:
@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 wird eine JSON-Datei generiert, mit der Sie die Pipeline ausführen:
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 anschließend Ihren Pipelinejob 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 schließlich den Job aus, um eine neue Pipelineausführung zu erstellen:
pipeline_job.submit()
Nachdem Sie diese Zelle ausgeführt haben, sollten Sie Logs mit einem Link zum Ansehen der Pipelineausführung in Ihrer Konsole sehen:
Rufen Sie diesen Link auf. Sie können auch darauf zugreifen, indem Sie Ihr Pipelines-Dashboard öffnen. Ihre Pipeline sollte nach Abschluss wie folgt aussehen:
Die Ausführung dieser Pipeline dauert 5 bis 10 Minuten. Sie können jedoch mit dem nächsten Schritt fortfahren, bevor die Ausführung abgeschlossen ist. Als Nächstes erfahren Sie mehr über die einzelnen Pipelineschritte.
8. Informationen zur Pipelineausführung
Sehen wir uns die drei Pipelineschritte genauer an.
Pipelineschritt 1: Verwaltetes Dataset erstellen
Im ersten Schritt der Pipeline wird ein verwaltetes Dataset in Vertex AI erstellt. Wenn Sie im Abschnitt „Pipelines“ Ihrer Console auf den folgenden Dataset-Link klicken:
Sie sehen Ihr Dataset in Vertex AI. 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, können Sie damit entweder ein AutoML- oder ein benutzerdefiniertes Modell trainieren.
Bei benutzerdefinierten Modelljobs, die verwaltete Datasets verwenden, übergibt Vertex AI spezielle Umgebungsvariablen an Ihre Trainingsjobs und übernimmt die Aufteilung Ihrer Daten in Trainings- und Test-Datasets. Wir werden diese im nächsten Pipelineschritt nutzen.
Pipelineschritt 2: Modell in Vertex AI Training trainieren
Während der benutzerdefinierte Trainingsjob ausgeführt wird, können Sie Logs per Klick direkt in der Vertex Pipelines-Konsole aufrufen:
Details zum benutzerdefinierten Trainingsjob finden Sie auch im Trainings-Dashboard von Vertex AI. Wenn der Trainingsjob abgeschlossen ist, wird eine Modellressource in Vertex AI erstellt. Wir können dieses Modell dann auf einem Endpunkt für Onlinevorhersagen bereitstellen oder einen Batchvorhersagejob erstellen, was wir im nächsten Pipelineschritt tun werden.
Pipelineschritt 3: Batchvorhersagejob für unser Modell ausführen
Schließlich erhält unsere Pipeline Vorhersagen zu den Beispielen, die wir über eine CSV-Datei übergeben haben. Wenn der Batchvorhersagejob abgeschlossen ist, schreibt Vertex AI eine CSV-Datei in den Speicherort, den wir in Cloud Storage angegeben haben. Sobald dieser Pipelineschritt ausgeführt wird, können Sie in der Vertex AI-Konsole zum Abschnitt Batchvorhersagen gehen, um den erstellten Job zu sehen.
Klicken Sie nach Abschluss auf den Job, um die Cloud Storage-URL Ihrer Batchvorhersagen anzuzeigen:
Klicken Sie auf diesen Link, um das Cloud Storage-Verzeichnis aufzurufen, in dem Sie die Vorhersageergebnisse finden, und klicken Sie dann, um eine der prediction.results-Dateien herunterzuladen. Die Datei sollte Zeilen wie diese enthalten:
{"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 Featurewerte für eine bestimmte Instanz sowie die Klasse, die unser Modell vorhergesagt hat. In diesem Beispiel hält unser Modell es für ein „HOROZ“. Bohnen.
Damit haben Sie das Lab abgeschlossen!
🎉 Glückwunsch! 🎉
Sie haben gelernt, wie Sie mit Vertex AI Folgendes tun können:
- 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 Ihrer Pipeline Vertex AI-Dienste hinzuzufügen
- Wiederkehrende Pipelinejobs planen
Weitere Informationen zu den verschiedenen Teilen von Vertex finden Sie in der Dokumentation.
9. Bereinigen
Damit Ihnen keine Kosten entstehen, sollten Sie die in diesem Lab erstellten Ressourcen löschen.
Schritt 1: Notebooks-Instanz beenden oder löschen
Wenn Sie das Notebook, das Sie in diesem Lab erstellt haben, weiter verwenden möchten, sollten Sie es deaktivieren, wenn Sie es nicht verwenden. Wählen Sie in der Notebooks-UI 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, gehen Sie im Navigationsmenü der Cloud Console zu „Storage“, wählen Sie den Bucket aus und klicken Sie auf „Löschen“:
