1. Übersicht
In diesem Lab erfahren Sie, wie Sie mit dem Kubeflow Pipelines SDK einen Trainingsjob für ein benutzerdefiniertes Modell in Vertex Pipelines ausführen.
Lerninhalte
Die folgenden Themen werden behandelt:
- Mit dem Kubeflow Pipelines SDK skalierbare ML-Pipelines erstellen
- Benutzerdefinierten Scikit-Learn-Modelltrainingsjob erstellen und containerisieren, der von Vertex AI verwaltete Datasets verwendet und in einer Pipeline mit Vertex AI Training 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 die Ausführung dieses Labs in Google Cloud belaufen sich auf etwa 5$.
2. Einführung in Vertex AI
In diesem Lab wird Vertex AI verwendet, unsere vollständig verwaltete ML-Plattform in Google Cloud. Vertex AI integriert die ML-Angebote von Google in Google Cloud und bietet so eine nahtlose Entwicklungsumgebung. Neben Diensten zum Trainieren und Bereitstellen von Modellen umfasst Vertex AI auch eine Vielzahl von MLOps-Produkten, darunter Vertex Pipelines (im Mittelpunkt dieses Labs), Model Monitoring und Feature Store. 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. Angenommen, Sie erstellen einen ML-Workflow, der die Verarbeitung von Daten, das Training eines Modells, die Hyperparameter-Abstimmung, die Bewertung und die Bereitstellung des Modells umfasst. Jeder dieser Schritte kann unterschiedliche Abhängigkeiten haben, was unübersichtlich werden kann, wenn Sie den gesamten Workflow als monolithischen Prozess behandeln. Wenn Sie mit der Skalierung Ihres ML-Prozesses beginnen, möchten Sie Ihren ML-Workflow möglicherweise mit anderen Mitgliedern Ihres Teams teilen, damit diese ihn ausführen und Code beisteuern können. Ohne einen zuverlässigen, reproduzierbaren Prozess kann dies schwierig werden. Bei Pipelines hat jeder Schritt in Ihrem ML-Prozess einen eigenen 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 auch Ausführungen Ihrer Pipeline basierend auf anderen Ereignissen in Ihrer Cloud-Umgebung planen oder auslösen, z. B. einen Pipelinelauf 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-Projekt mit aktivierter Abrechnung, um dieses Codelab ausführen zu können. 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 Befehlszeileninterpreter, der von einer virtuellen Maschine gehostet wird, die in der Google-Cloud ausgeführt wird. Sie können diesen Abschnitt auch lokal auf Ihrem eigenen Computer ausführen. Mit Cloud Shell haben alle Nutzer jedoch Zugriff auf eine reproduzierbare Umgebung. Nach dem Lab können Sie diesen Abschnitt auf Ihrem eigenen Computer noch einmal 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 (unten) angezeigt, auf dem beschrieben wird, was es ist. Klicken Sie in diesem Fall auf Weiter. Dieser Bildschirm wird dann nicht mehr angezeigt. So sieht dieser einmalige Bildschirm aus:
Die Bereitstellung und Verbindung zu Cloud Shell dauert nur einen Moment.
Auf dieser virtuellen Maschine sind alle erforderlichen Entwicklungstools installiert. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und 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 das Projekt bereits auf Ihre Projekt-ID festgelegt 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, die den Namen unseres aktuellen Cloud-Projekts enthält. Wir verwenden diese Variable an verschiedenen Stellen in diesem Lab. Sie können sie mit dem folgenden Befehl aufrufen:
echo $GOOGLE_CLOUD_PROJECT
Schritt 2: APIs aktivieren
In späteren Schritten erfahren Sie, wofür und warum diese Dienste erforderlich sind. Führen Sie jetzt einfach diesen Befehl aus, um Ihrem Projekt Zugriff auf die 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
Zum Ausführen eines Trainingsjobs in Vertex AI benötigen Sie 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 dann 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:
Verwenden Sie die Standardoptionen und klicken Sie dann auf Erstellen.
Schritt 5: Notebook öffnen
Wählen Sie nach dem Erstellen der Instanz JupyterLab öffnen aus:
4. Vertex Pipelines einrichten
Es gibt noch einige zusätzliche Bibliotheken, die wir installieren müssen, um Vertex Pipelines verwenden zu können:
- Kubeflow Pipelines: Das SDK, mit dem wir unsere Pipeline erstellen. Vertex Pipelines unterstützt das Ausführen 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, legen Sie zuerst das Nutzer-Flag in einer Notebook-Zelle fest:
USER_FLAG = "--user"
Führen Sie dann Folgendes in Ihrem 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 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 richtig 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 beziehen Sie sich auf Ihre Cloud-Projekt-ID und den zuvor erstellten Bucket. Als Nächstes erstellen wir für jeden davon Variablen.
Wenn Sie Ihre Projekt-ID nicht kennen, können Sie sie möglicherweise mit dem folgenden Befehl abrufen:
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 können Sie sie hier festlegen:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
Erstellen Sie dann eine Variable, um den Namen Ihres Buckets zu speichern. Wenn Sie es in diesem Lab erstellt haben, funktioniert Folgendes: Andernfalls müssen Sie dies manuell festlegen:
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 werden:
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 eine andere Region verwendet haben, aktualisieren Sie die Variable REGION im folgenden Code:
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 Code oben ausgeführt haben, sollte das Stammverzeichnis Ihrer Pipeline ausgegeben werden. Dies ist der Cloud Storage-Speicherort, an dem die Artefakte aus Ihrer Pipeline geschrieben werden. Er hat das Format gs://YOUR-BUCKET-NAME/pipeline_root/.
5. Benutzerdefinierten Trainingsjob für ein Modell konfigurieren
Bevor wir unsere Pipeline einrichten, müssen wir den Code für unseren benutzerdefinierten Trainingsjob schreiben. Zum Trainieren des Modells verwenden wir das Dataset „Dry beans“ (Trockenbohnen) aus dem UCI Machine Learning Repository von KOKLU, M. und OZKAN, I.A., (2020), „Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques“ (Mehrklassenklassifizierung von Trockenbohnen mithilfe von Computer Vision und maschinellem Lernen). In Computers and Electronics in Agriculture, 174, 105507. DOI.
Im ersten Pipelineschritt wird ein verwaltetes Dataset in Vertex AI mit 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 diesen verwalteten Datensatz zuzugreifen.
So richten wir unseren benutzerdefinierten Trainingsjob ein:
- Scikit-learn-
DecisionTreeClassifier-Modell zum Klassifizieren von Bohnensorten 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-Trainingsjob 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 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 das Verzeichnis traincontainer/ angezeigt werden. Möglicherweise müssen Sie auf das Aktualisierungssymbol klicken, um es zu sehen. Im traincontainer/-Verzeichnis sehen Sie Folgendes:
+ Dockerfile
+ trainer/
+ train.py
Der erste Schritt zum Containerisieren 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 den gerade erstellten 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 während der Bearbeitung in Ihrer Notebook-Instanz speichern möchten, 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")
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 aber auch manuell tun. Achten Sie in diesem Fall darauf, den gs:// nicht in den Bucket-Namen aufzunehmen, wenn Sie das Script aktualisieren.
Jetzt befindet sich unser Trainingscode in einem Docker-Container und wir können das Training in der Cloud ausführen.
Schritt 2: Container in die Container Registry übertragen
Wenn der Trainingscode vollständig ist, können wir dies in Google Container Registry übertragen. Später, wenn wir die Trainingskomponente unserer Pipeline konfigurieren, weisen wir Vertex Pipelines auf diesen Container hin.
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 Bereich Container Registry auf, um zu prüfen, ob sich Ihr Container dort befindet. 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 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 Dataset mit Bohnen. Das folgende Beispiel enthält nicht die Spalte Class, da unser Modell diese vorhersagen wird. 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
Auf diese Datei wird im nächsten Schritt verwiesen, wenn wir unsere Pipeline definieren.
7. Pipeline mit vorgefertigten Komponenten erstellen
Nachdem unser Trainingscode in der Cloud ist, können wir ihn über unsere Pipeline aufrufen. Für die Pipeline, die wir definieren, werden drei vordefinierte Komponenten aus der zuvor installierten google_cloud_pipeline_components-Bibliothek verwendet. Diese vordefinierten Komponenten vereinfachen den Code, den wir zum Einrichten unserer Pipeline schreiben müssen, und ermöglichen uns die Verwendung von Vertex AI-Diensten wie dem Modelltraining und der Batch-Vorhersage.
So funktioniert unsere dreistufige Pipeline:
- Verwaltetes Dataset in Vertex AI erstellen
- Trainingsjob mit dem von uns eingerichteten benutzerdefinierten Container in Vertex AI ausführen
- Einen Batchvorhersagejob für unser trainiertes Scikit-learn-Klassifizierungsmodell ausführen
Schritt 1: Pipeline definieren
Da wir vordefinierte Komponenten verwenden, können wir unsere gesamte Pipeline in der Pipelinedefinition einrichten. Fügen Sie einer Notebookzelle 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 die Pipeline definiert haben, können Sie sie kompilieren. Dadurch 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. Diese verwenden wir 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 geben Sie einige projektspezifische Parameter an:
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()
Nachdem Sie diese Zelle ausgeführt haben, sollten Sie Protokolle mit einem Link sehen, über den Sie die Pipelineausführung in der Konsole aufrufen können:
Rufen Sie diesen Link auf. Sie können auch darauf zugreifen, indem Sie Ihr Pipelines-Dashboard öffnen. Ihre Pipeline sollte dann so aussehen:
Die Ausführung dieser Pipeline dauert 5 bis 10 Minuten. Sie können mit dem nächsten Schritt fortfahren, bevor sie abgeschlossen ist. Im Folgenden erfahren Sie mehr darüber, was in den einzelnen Pipelineschritten passiert.
8. Informationen zur Pipelineausführung
Sehen wir uns die einzelnen Schritte der Pipeline genauer an.
Pipelineschritt 1: Verwaltetes Dataset erstellen
Im ersten Schritt unserer Pipeline wird ein verwaltetes Dataset in Vertex AI erstellt. Klicken Sie in der Console im Bereich „Pipelines“ auf den folgenden Dataset-Link:
In Vertex AI sehen Sie Ihr Dataset mit einem 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 Jobs für benutzerdefinierte Modelle, die verwaltete Datasets verwenden, übergibt Vertex AI spezielle Umgebungsvariablen an Ihre Trainingsjobs und übernimmt die Aufteilung Ihrer Daten in Trainings- und Test-Datasets. Das nutzen wir im nächsten Schritt der Pipeline.
Pipeline – Schritt 2: Modell in Vertex AI Training trainieren
Während Ihr benutzerdefinierter Trainingsjob ausgeführt wird, können Sie Logs direkt in der Vertex Pipelines Console aufrufen:
Details zum benutzerdefinierten Trainingsjob finden Sie auch im Vertex AI-Dashboard für Training. Nach Abschluss des Trainingsjobs wird in Vertex AI eine Modellressource erstellt. Wir können dieses Modell dann für Onlinevorhersagen auf einem Endpunkt bereitstellen oder einen Batch-Vorhersagejob 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 für die Beispiele, 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. Wenn dieser Pipelineschritt ausgeführt wird, können Sie in der Vertex AI Console im Bereich Batchvorhersagen den erstellten Job aufrufen.
Klicken Sie auf den Job, wenn er abgeschlossen ist, um die Cloud Storage-URL Ihrer Batchvorhersagen aufzurufen:
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 Merkmalswerte für eine bestimmte Instanz sowie die Klasse, die unser Modell vorhergesagt hat. In diesem Beispiel geht unser Modell davon aus, dass es sich um eine „HOROZ“-Bohne handelt.
Damit ist das Lab abgeschlossen.
🎉 Glückwunsch! 🎉
Sie haben gelernt, wie Sie Vertex AI für Folgendes 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 Pipeline-Komponenten verwenden, um Ihrer Pipeline Vertex AI-Dienste hinzuzufügen
- Wiederkehrende Pipeline-Jobs planen
Weitere Informationen zu den verschiedenen Bereichen von Vertex finden Sie in der Dokumentation.
9. Bereinigen
Damit Ihnen keine Kosten in Rechnung gestellt werden, 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 verwenden. Wählen Sie in der Notebook-Benutzeroberfläche in der Cloud Console das Notebook und dann Anhalten 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“:
