GSP965

Übersicht
Pipelines unterstützen Sie dabei, Ihren ML-Workflow zu automatisieren und zu reproduzieren. Vertex AI vereint die ML-Angebote von Google Cloud in einer nahtlosen Entwicklungsumgebung. Bisher musste auf mit AutoML trainierte und benutzerdefinierte Modelle über verschiedene Dienste zugegriffen werden. Vertex AI kombiniert diese und weitere, neue Produkte zu einer einzigen API. Außerdem beinhaltet Vertex AI verschiedene MLOps-Produkte wie Vertex Pipelines. In diesem Lab lernen Sie, wie ML-Pipelines mit Vertex Pipelines erstellt und ausgeführt werden.
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.
Lernziele
Aufgaben in diesem Lab:
- Mit dem Kubeflow Pipelines SDK skalierbare ML-Pipelines erstellen
- Einführungspipeline mit drei Schritten und Text als Eingabe erstellen und ausführen
- Pipeline erstellen und ausführen, die ein AutoML-Klassifizierungsmodell trainiert, bewertet und bereitstellt
- Vordefinierte Komponenten, die über die Bibliothek google_cloud_pipeline_components bereitgestellt werden, für die Interaktion mit Vertex AI-Diensten nutzen
- Pipelinejob mit Cloud Scheduler planen
Einrichtung und Anforderungen
Vor dem Klick auf „Start Lab“ (Lab starten)
Lesen Sie diese Anleitung. Labs sind zeitlich begrenzt und können nicht pausiert werden. Der Timer beginnt zu laufen, wenn Sie auf Lab starten klicken, und zeigt Ihnen, wie lange die Ressourcen für das Lab verfügbar sind.
In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung selbst durchführen – nicht in einer Simulations- oder Demo-Umgebung. Dazu erhalten Sie neue, temporäre Anmeldedaten, mit denen Sie für die Dauer des Labs auf Google Cloud zugreifen können.
Für dieses Lab benötigen Sie Folgendes:
- Einen Standardbrowser (empfohlen wird Chrome)
Hinweis: Nutzen Sie den privaten oder Inkognitomodus, um dieses Lab durchzuführen. So wird verhindert, dass es zu Konflikten zwischen Ihrem persönlichen Konto und dem Teilnehmerkonto kommt und zusätzliche Gebühren für Ihr persönliches Konto erhoben werden.
- Zeit für die Durchführung des Labs – denken Sie daran, dass Sie ein begonnenes Lab nicht unterbrechen können.
Hinweis: Wenn Sie über ein persönliches Google Cloud-Konto oder -Projekt verfügen, verwenden Sie es nicht für dieses Lab. So werden zusätzliche Kosten für Ihr Konto vermieden.
Lab starten und bei der Google Cloud Console anmelden
-
Klicken Sie auf Lab starten. Wenn Sie für das Lab bezahlen müssen, wird ein Pop-up-Fenster geöffnet, in dem Sie Ihre Zahlungsmethode auswählen können.
Auf der linken Seite befindet sich der Bereich Details zum Lab mit diesen Informationen:
- Schaltfläche Google Cloud Console öffnen
- Restzeit
- Temporäre Anmeldedaten für das Lab
- Ggf. weitere Informationen für dieses Lab
-
Klicken Sie auf Google Cloud Console öffnen (oder klicken Sie mit der rechten Maustaste und wählen Sie Link in Inkognitofenster öffnen aus, wenn Sie Chrome verwenden).
Im Lab werden Ressourcen aktiviert. Anschließend wird ein weiterer Tab mit der Seite Anmelden geöffnet.
Tipp: Ordnen Sie die Tabs nebeneinander in separaten Fenstern an.
Hinweis: Wird das Dialogfeld Konto auswählen angezeigt, klicken Sie auf Anderes Konto verwenden.
-
Kopieren Sie bei Bedarf den folgenden Nutzernamen und fügen Sie ihn in das Dialogfeld Anmelden ein.
{{{user_0.username | "Username"}}}
Sie finden den Nutzernamen auch im Bereich Details zum Lab.
-
Klicken Sie auf Weiter.
-
Kopieren Sie das folgende Passwort und fügen Sie es in das Dialogfeld Willkommen ein.
{{{user_0.password | "Password"}}}
Sie finden das Passwort auch im Bereich Details zum Lab.
-
Klicken Sie auf Weiter.
Wichtig: Sie müssen die für das Lab bereitgestellten Anmeldedaten verwenden. Nutzen Sie nicht die Anmeldedaten Ihres Google Cloud-Kontos.
Hinweis: Wenn Sie Ihr eigenes Google Cloud-Konto für dieses Lab nutzen, können zusätzliche Kosten anfallen.
-
Klicken Sie sich durch die nachfolgenden Seiten:
- Akzeptieren Sie die Nutzungsbedingungen.
- Fügen Sie keine Wiederherstellungsoptionen oder Zwei-Faktor-Authentifizierung hinzu (da dies nur ein temporäres Konto ist).
- Melden Sie sich nicht für kostenlose Testversionen an.
Nach wenigen Augenblicken wird die Google Cloud Console in diesem Tab geöffnet.
Hinweis: Wenn Sie sich eine Liste der Google Cloud-Produkte und ‑Dienste ansehen möchten, klicken Sie oben links auf das Navigationsmenü.
Aufgabe 1: Vertex-Notebook-Instanz erstellen
-
Klicken Sie auf das Navigationsmenü.
-
Klicken Sie auf Vertex AI und dann auf Workbench.
-
Rufen Sie auf der Seite mit den Notebook-Instanzen den Tab Nutzerverwaltete Notebooks auf und warten Sie, bis ai-notebook
erstellt ist.

Hinweis: Es dauert ein paar Minuten, bis das Notebook erstellt ist.
- Nachdem die Instanz erstellt wurde, klicken Sie auf JupyterLab öffnen:

Prüfen, ob das Notebook erstellt wurde
Aufgabe 2: Vertex Pipelines einrichten
Damit Sie Vertex Pipelines nutzen können, müssen Sie 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 im Launcher-Menü in Ihrer Notebook-Instanz 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.59.0
!pip3 install {USER_FLAG} kfp google-cloud-pipeline-components==0.1.1 --upgrade
!pip3 uninstall -y shapely pygeos geopandas
!pip3 install shapely==1.8.5.post1 pygeos==0.12.0 geopandas>=0.12.2
!pip3 install google-cloud-pipeline-components
Hinweis: Ihnen werden Warnungen und Fehlermeldungen zu Versionen angezeigt. Diese können Sie ignorieren.
- 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.6 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 Sie 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)
- Erstellen Sie dann eine Variable zum Speichern des Bucket-Namens.
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
3. Schritt: Bibliotheken importieren
- Fügen Sie Folgendes hinzu, um die Bibliotheken für dieses Lab zu importieren:
from typing import NamedTuple
import kfp
from kfp import dsl
from kfp.v2 import compiler
from kfp.v2.dsl import (Artifact, Dataset, Input, InputPath, Model, Output,
OutputPath, ClassificationMetrics, Metrics, component)
from kfp.v2.google.client import AIPlatformClient
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
4. Schritt: Konstanten definieren
- Jetzt definieren Sie noch einige konstante Variablen. Anschließend können Sie mit dem Erstellen der Pipeline beginnen.
PIPELINE_ROOT
ist der Cloud Storage-Pfad, in den die durch die Pipeline erstellten Artefakte geschrieben werden. Sie verwenden hier als Region, aber falls Sie beim Erstellen des Buckets einen anderen Wert für region
im Code ausgewählt haben, passen Sie die REGION-Variable im folgenden Code an:
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="{{{ project_0.default_region | Placeholder value. }}}"
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. Das Format lautet gs://<bucket_name>/pipeline_root/
.
Aufgabe 3: Erste Pipeline erstellen
Sie erstellen eine Pipeline, die anhand von zwei Ausgaben – eines Produktnamens und einer Emojibeschreibung – einen Satz bildet. Diese Pipeline besteht aus drei Komponenten:
-
product_name
: Diese Komponente verwendet einen Produktnamen als Eingabe und gibt den String als Ausgabe zurück.
-
emoji
: Diese Komponente verwendet die Beschreibung eines Emojis als Eingabe und wandelt sie in einen Emoji um. Der Textcode für ✨ lautet beispielsweise „sparkles“. Diese Komponente zeigt Ihnen anhand einer Emojibibliothek, wie Sie externe Abhängigkeiten in Ihrer Pipeline verwalten.
-
build_sentence
: Diese letzte Komponente erstellt aus der Ausgabe der anderen beiden einen Satz, der das Emoji enthält. Die Ausgabe könnte zum Beispiel „Vertex Pipelines ist ✨“ sein.
1. Schritt: Auf Python-Funktionen basierende Komponente erstellen
Mit dem KFP SDK können Sie auf Python-Funktionen basierende Komponenten erstellen. Zuerst erstellen Sie die Komponente product_name
, die einen String als Eingabe verwendet und diesen wieder ausgibt.
- Fügen Sie Folgendes zu Ihrem Notebook hinzu:
@component(base_image="python:3.9", output_component_file="first-component.yaml")
def product_name(text: str) -> str:
return text
Sehen Sie sich die Syntax einmal genauer an:
- Der Decorator
@component
kompiliert diese Funktion in eine Komponente, wenn die Pipeline ausgeführt wird. Dies verwenden Sie immer, wenn Sie eine benutzerdefinierte Komponente schreiben.
- Mit dem Parameter
base_image
wird das Container-Image angegeben, das diese Komponente verwendet.
- Der Parameter
output_component_file
ist optional. Er gibt die YAML-Datei an, in die die kompilierte Komponente geschrieben werden soll. Nachdem die Zelle ausgeführt wurde, sollte diese Datei in Ihre Notebook-Instanz geschrieben worden sein. Wenn Sie die Komponente für eine andere Person freigeben möchten, können Sie ihr die erstellte YAML-Datei senden und sie bitten, diese mit folgendem Befehl zu laden:
product_name_component = kfp.components.load_component_from_file('./first-component.yaml')
Mit -> str
nach der Funktionsdefinition wird der Ausgabetyp für diese Komponente angegeben.
2. Schritt: Zwei weitere Komponenten erstellen
- Erstellen Sie zwei weitere Komponenten, um die Pipeline zu vervollständigen. Die erste verwendet einen String als Eingabe und wandelt diesen in das entsprechende Emoji um (sofern vorhanden). Sie gibt ein Tupel mit dem übergebenen Eingabetext und das zugehörige Emoji zurück:
@component(base_image="python:3.9", output_component_file="second-component.yaml", packages_to_install=["emoji"])
def emoji(
text: str,
) -> NamedTuple(
"Outputs",
[
("emoji_text", str), # Return parameters
("emoji", str),
],
):
import emoji
emoji_text = text
emoji_str = emoji.emojize(':' + emoji_text + ':', language='alias')
print("output one: {}; output_two: {}".format(emoji_text, emoji_str))
return (emoji_text, emoji_str)
Diese Komponente ist etwas komplexer als die vorherige. Das ist neu:
- Der Parameter
packages_to_install
liefert der Komponente alle externen Bibliotheksabhängigkeiten für diesen Container. In diesem Fall verwenden Sie die Bibliothek „emoji“.
- Diese Komponente gibt ein
NamedTuple
namens Outputs
zurück. Die Strings in diesem Tupel haben Schlüssel: emoji_text
und emoji
. Diese verwenden Sie in der nächsten Komponente, um auf die Ausgabe zuzugreifen.
- Die letzte Komponente in dieser Pipeline nimmt die Ausgaben der ersten beiden auf und macht daraus einen String, den sie dann ausgibt:
@component(base_image="python:3.9", output_component_file="third-component.yaml")
def build_sentence(
product: str,
emoji: str,
emojitext: str
) -> str:
print("We completed the pipeline, hooray!")
end_str = product + " is "
if len(emoji) > 0:
end_str += emoji
else:
end_str += emojitext
return(end_str)
Vielleicht fragen Sie sich: Woher weiß diese Komponente, dass sie die Ausgaben der vorherigen, von Ihnen definierten Schritte verwenden soll?
Gute Frage. Die Erklärung kommt im nächsten Schritt.
3. Schritt: Komponenten in einer Pipeline verknüpfen
Durch die oben festgelegten Komponentendefinitionen wurden Factory-Funktionen erstellt, die in einer Pipelinedefinition zum Erstellen von Schritten verwendet werden können.
-
Verwenden Sie zum Einrichten einer Pipeline den Decorator @dsl.pipeline
, geben Sie der Pipeline einen Namen und eine Beschreibung und geben Sie den Stammpfad an, an den die Artefakte der Pipeline geschrieben werden sollen. Artefakte sind in diesem Fall alle von der Pipeline generierten Ausgabedateien. Diese Einführungspipeline erstellt keine, aber die nächste Pipeline schon.
-
Im nächsten Codeblock definieren Sie eine intro_pipeline
-Funktion. Darin legen Sie die Eingaben für die ersten Pipelineschritte und die Verbindung der Schritte untereinander fest:
-
product_task
verwendet einen Produktnamen als Eingabe. Hier übergeben Sie „Vertex Pipelines“, aber Sie können auch etwas anderes angeben.
-
emoji_task
verwendet den Textcode eines Emojis als Eingabe. Auch hier können Sie einen beliebigen Wert angeben. „party_face“ entspricht beispielsweise diesem Emoji: 🥳. Da diese Komponente und product_task
keine Schritte haben, die ihnen eine Eingabe liefern, legen Sie die Eingabe dafür manuell beim Definieren der Pipeline fest.
- Der letzte Schritt in der Pipeline –
consumer_task
– hat drei Eingabeparameter:
- Die Ausgabe von
product_task
. Da dieser Schritt nur eine Ausgabe liefert, können Sie darauf mit product_task.output
verweisen.
- Die
emoji
-Ausgabe des Schritts emoji_task
. Oben haben Sie für die emoji
-Komponente die Ausgabeparameter festgelegt.
- Die Ausgabe
emoji_text
der emoji
-Komponente. Falls Text an Ihre Pipeline übergeben wird, zu dem es kein Emoji gibt, wird dieser Text verwendet, um einen Satz zu formulieren.
@dsl.pipeline(
name="hello-world",
description="An intro pipeline",
pipeline_root=PIPELINE_ROOT,
)
# You can change the `text` and `emoji_str` parameters here to update the pipeline output
def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"):
product_task = product_name(text)
emoji_task = emoji(emoji_str)
consumer_task = build_sentence(
product_task.output,
emoji_task.outputs["emoji"],
emoji_task.outputs["emoji_text"],
)
4. Schritt: 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=intro_pipeline, package_path="intro_pipeline_job.json"
)
- Als Nächstes instanziieren Sie einen API-Client:
api_client = AIPlatformClient(
project_id=PROJECT_ID,
region=REGION,
)
- Führen Sie nun die Pipeline aus:
response = api_client.create_run_from_job_spec(
job_spec_path="intro_pipeline_job.json",
# pipeline_root=PIPELINE_ROOT # this argument is necessary if you did not specify PIPELINE_ROOT as part of the pipeline definition.
)
Beim Ausführen der Pipeline sollte ein Link erzeugt werden, über den Sie die Pipelineausführung in der Console sehen können. Wenn alles fertig ist, sollte es so aussehen:

- Das Ausführen der Pipeline dauert fünf bis sechs Minuten. Wenn der Vorgang abgeschlossen ist, können Sie auf die Komponente
build-sentence
klicken, um die endgültige Ausgabe zu sehen:

Jetzt wissen Sie, wie das KFP SDK und Vertex Pipelines funktionieren, und können eine Pipeline erstellen, die mit anderen Vertex AI-Diensten ein ML-Modell erstellt und bereitstellt.
Prüfen, ob die Emojipipeline vollständig ausgeführt wurde
Aufgabe 4: End-to-End-ML-Pipeline erstellen
Jetzt erstellen Sie Ihre erste ML-Pipeline. Darin verwenden Sie 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.
Hinweis: Das Ausführen dieser Pipeline dauert mehr als zwei Stunden. Sie müssen daher nicht warten, bis die Pipeline fertig ausgeführt wurde, um das Lab abzuschließen. Folgen Sie den Schritten, bis Ihr Pipelinejob gestartet wird.
Dies ist ein tabellarisches Dataset, das Sie in Ihrer Pipeline dazu verwenden, ein AutoML-Modell zu trainieren, zu bewerten und bereitzustellen. Dieses Modell ordnet Bohnen anhand ihrer Merkmale einer von sieben Arten zu.
Diese Pipeline:
- erstellt ein Dataset in Vertex AI
- trainiert ein tabellarisches Klassifikationsmodell mit AutoML
- ruft Bewertungsmesswerte für das Modell ab
- entscheidet abhängig von den Bewertungsmesswerten, ob das Modell mit bedingter Logik in Vertex Pipelines bereitgestellt wird
- stellt das Modell anhand von Vertex Prediction auf einem Endpunkt bereit
Jeder der beschriebenen Schritte entspricht einer Komponente. Für die meisten Pipelineschritte werden vordefinierte Komponenten für Vertex AI-Dienste aus der Bibliothek google_cloud_pipeline_components
verwendet, die Sie in diesem Lab bereits importiert haben.
In diesem Abschnitt definieren wir zuerst eine benutzerdefinierte Komponente. Anschließend definieren wir den Rest der Pipelineschritte mithilfe vordefinierter Komponenten. Diese erleichtern den Zugriff auf Vertex AI-Dienste beispielsweise für Modelltraining und ‑bereitstellung.
Am längsten dauert in dieser Pipeline das AutoML-Training, das etwa eine Stunde in Anspruch nimmt.
1. Schritt: Benutzerdefinierte Komponente für die Modellbewertung erstellen
Die von Ihnen erstellte benutzerdefinierte Komponente kommt am Ende der Pipeline zum Einsatz, wenn das Modelltraining abgeschlossen ist. Diese Komponente hat die folgenden Aufgaben:
- Bewertungsmesswerte aus dem trainierten AutoML-Klassifikationsmodell abrufen
- Messwerte parsen und in der Vertex Pipelines-Benutzeroberfläche rendern
- Messwerte mit einem Schwellenwert vergleichen, um festzustellen, ob das Modell bereitgestellt werden soll
Bevor Sie die Komponente definieren, sollten Sie ihre Eingabe- und Ausgabeparameter verstehen. Als Eingabe verwendet diese Pipeline einige Metadaten über Ihr Cloud-Projekt, das daraus resultierende trainierte Modell (diese Komponente definieren Sie später), die Bewertungsmesswerte des Modells und thresholds_dict_str
.
Sie definieren thresholds_dict_str
, wenn Sie die Pipeline ausführen. Bei diesem Klassifikationsmodell entspricht dieser Wert der Fläche unterhalb der Kurve des ROC-Werts, bei dem das Modell bereitgestellt werden soll. Wenn Sie beispielsweise den Wert 0,95 übergeben, bedeutet dies, dass die Pipeline das Modell nur bereitstellen soll, wenn dieser Messwert über 95 % liegt.
Die Bewertungskomponente gibt einen String zurück, der angibt, ob das Modell bereitgestellt werden soll.
- Fügen Sie den folgenden Code in eine Notebook-Zelle ein, um die benutzerdefinierte Komponente zu erstellen:
@component(
base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest",
output_component_file="tables_eval_component.yaml", # Optional: you can use this to load the component later
packages_to_install=["google-cloud-aiplatform"],
)
def classif_model_eval_metrics(
project: str,
location: str, # "region",
api_endpoint: str, # "region-aiplatform.googleapis.com",
thresholds_dict_str: str,
model: Input[Model],
metrics: Output[Metrics],
metricsc: Output[ClassificationMetrics],
) -> NamedTuple("Outputs", [("dep_decision", str)]): # Return parameter.
"""This function renders evaluation metrics for an AutoML Tabular classification model.
It retrieves the classification model evaluation generated by the AutoML Tabular training
process, does some parsing, and uses that info to render the ROC curve and confusion matrix
for the model. It also uses given metrics threshold information and compares that to the
evaluation results to determine whether the model is sufficiently accurate to deploy.
"""
import json
import logging
from google.cloud import aiplatform
# Fetch model eval info
def get_eval_info(client, model_name):
from google.protobuf.json_format import MessageToDict
response = client.list_model_evaluations(parent=model_name)
metrics_list = []
metrics_string_list = []
for evaluation in response:
print("model_evaluation")
print(" name:", evaluation.name)
print(" metrics_schema_uri:", evaluation.metrics_schema_uri)
metrics = MessageToDict(evaluation._pb.metrics)
for metric in metrics.keys():
logging.info("metric: %s, value: %s", metric, metrics[metric])
metrics_str = json.dumps(metrics)
metrics_list.append(metrics)
metrics_string_list.append(metrics_str)
return (
evaluation.name,
metrics_list,
metrics_string_list,
)
# Use the given metrics threshold(s) to determine whether the model is
# accurate enough to deploy.
def classification_thresholds_check(metrics_dict, thresholds_dict):
for k, v in thresholds_dict.items():
logging.info("k {}, v {}".format(k, v))
if k in ["auRoc", "auPrc"]: # higher is better
if metrics_dict[k] < v: # if under threshold, don't deploy
logging.info(
"{} < {}; returning False".format(metrics_dict[k], v)
)
return False
logging.info("threshold checks passed.")
return True
def log_metrics(metrics_list, metricsc):
test_confusion_matrix = metrics_list[0]["confusionMatrix"]
logging.info("rows: %s", test_confusion_matrix["rows"])
# log the ROC curve
fpr = []
tpr = []
thresholds = []
for item in metrics_list[0]["confidenceMetrics"]:
fpr.append(item.get("falsePositiveRate", 0.0))
tpr.append(item.get("recall", 0.0))
thresholds.append(item.get("confidenceThreshold", 0.0))
print(f"fpr: {fpr}")
print(f"tpr: {tpr}")
print(f"thresholds: {thresholds}")
metricsc.log_roc_curve(fpr, tpr, thresholds)
# log the confusion matrix
annotations = []
for item in test_confusion_matrix["annotationSpecs"]:
annotations.append(item["displayName"])
logging.info("confusion matrix annotations: %s", annotations)
metricsc.log_confusion_matrix(
annotations,
test_confusion_matrix["rows"],
)
# log textual metrics info as well
for metric in metrics_list[0].keys():
if metric != "confidenceMetrics":
val_string = json.dumps(metrics_list[0][metric])
metrics.log_metric(metric, val_string)
# metrics.metadata["model_type"] = "AutoML Tabular classification"
logging.getLogger().setLevel(logging.INFO)
aiplatform.init(project=project)
# extract the model resource name from the input Model Artifact
model_resource_path = model.uri.replace("aiplatform://v1/", "")
logging.info("model path: %s", model_resource_path)
client_options = {"api_endpoint": api_endpoint}
# Initialize client that will be used to create and send requests.
client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
eval_name, metrics_list, metrics_str_list = get_eval_info(
client, model_resource_path
)
logging.info("got evaluation name: %s", eval_name)
logging.info("got metrics list: %s", metrics_list)
log_metrics(metrics_list, metricsc)
thresholds_dict = json.loads(thresholds_dict_str)
deploy = classification_thresholds_check(metrics_list[0], thresholds_dict)
if deploy:
dep_decision = "true"
else:
dep_decision = "false"
logging.info("deployment decision is %s", dep_decision)
return (dep_decision,)
2. Schritt: Vordefinierte Google Cloud-Komponenten hinzufügen
In diesem Schritt definieren Sie die restlichen Pipelinekomponenten und sehen sich an, wie sie zusammenpassen.
- Definieren Sie als Erstes mit einem Zeitstempel den Anzeigenamen für die Pipelineausführung:
import time
DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time())))
print(DISPLAY_NAME)
- Kopieren Sie dann folgenden Code in eine neue Notebook-Zelle:
@kfp.dsl.pipeline(name="automl-tab-beans-training-v2",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://aju-dev-demos.beans.beans1",
display_name: str = DISPLAY_NAME,
project: str = PROJECT_ID,
gcp_region: str = "{{{ project_0.default_region | Placeholder value. }}}",
api_endpoint: str = "{{{ project_0.default_region | Placeholder value. }}}-aiplatform.googleapis.com",
thresholds_dict_str: str = '{"auRoc": 0.95}',
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
project=project, display_name=display_name, bq_source=bq_source
)
training_op = gcc_aip.AutoMLTabularTrainingJobRunOp(
project=project,
display_name=display_name,
optimization_prediction_type="classification",
budget_milli_node_hours=1000,
column_transformations=[
{"numeric": {"column_name": "Area"}},
{"numeric": {"column_name": "Perimeter"}},
{"numeric": {"column_name": "MajorAxisLength"}},
{"numeric": {"column_name": "MinorAxisLength"}},
{"numeric": {"column_name": "AspectRation"}},
{"numeric": {"column_name": "Eccentricity"}},
{"numeric": {"column_name": "ConvexArea"}},
{"numeric": {"column_name": "EquivDiameter"}},
{"numeric": {"column_name": "Extent"}},
{"numeric": {"column_name": "Solidity"}},
{"numeric": {"column_name": "roundness"}},
{"numeric": {"column_name": "Compactness"}},
{"numeric": {"column_name": "ShapeFactor1"}},
{"numeric": {"column_name": "ShapeFactor2"}},
{"numeric": {"column_name": "ShapeFactor3"}},
{"numeric": {"column_name": "ShapeFactor4"}},
{"categorical": {"column_name": "Class"}},
],
dataset=dataset_create_op.outputs["dataset"],
target_column="Class",
)
model_eval_task = classif_model_eval_metrics(
project,
gcp_region,
api_endpoint,
thresholds_dict_str,
training_op.outputs["model"],
)
with dsl.Condition(
model_eval_task.outputs["dep_decision"] == "true",
name="deploy_decision",
):
deploy_op = gcc_aip.ModelDeployOp( # noqa: F841
model=training_op.outputs["model"],
project=project,
machine_type="e2-standard-4",
)
Was dieser Code bewirkt:
- Zuerst definieren Sie wie in der vorherigen Pipeline die Eingabeparameter. Diese müssen Sie manuell festlegen, da sie nicht von der Ausgabe anderer Schritte in der Pipeline abhängen.
- In der restlichen Pipeline kommen einige vordefinierte Komponenten für die Interaktion mit Vertex AI-Diensten zum Einsatz:
-
TabularDatasetCreateOp
erstellt ein tabellarisches Dataset in Vertex AI, wenn eine Dataset-Quelle in Cloud Storage oder BigQuery vorhanden ist. In dieser Pipeline übergeben Sie die Daten über eine BigQuery-Tabellen-URL.
-
AutoMLTabularTrainingJobRunOp
startet einen AutoML-Trainingsjob für ein tabellarisches Dataset. Sie übergeben dieser Komponente einige Konfigurationsparameter, darunter den Modelltyp (in diesem Fall: Klassifikation), einige Daten zu den Spalten, die gewünschte Trainingsdauer und einen Verweis auf das Dataset. Damit das Dataset an diese Komponente übergeben werden kann, stellen Sie die Ausgabe der vorherigen Komponente über dataset_create_op.outputs["dataset"]
bereit.
-
ModelDeployOp
stellt ein Modell auf einem Endpunkt in Vertex AI bereit. Es sind weitere Konfigurationsoptionen verfügbar, aber hier geben Sie den Maschinentyp des Endpunkts, das Projekt und das Modell zur Bereitstellung an. Sie übergeben das Modell, indem Sie auf die Ausgaben des Trainingsschritts in Ihrer Pipeline zugreifen.
- Diese Pipeline verwendet außerdem bedingte Logik, eine Funktion von Vertex Pipelines, mit der Sie eine Bedingung und, basierend auf deren Ergebnis, verschiedene Verzweigungen definieren können. Beim Definieren der Pipeline haben Sie den Parameter
thresholds_dict_str
übergeben. Dies ist der Accuracy-Schwellenwert, mit dem Sie festlegen, ob das Modell auf einem Endpunkt bereitgestellt werden soll. Verwenden Sie zum Implementieren die Klasse Condition
aus dem KFP SDK. Die übergebene Bedingung ist die Ausgabe der benutzerdefinierten Bewertungskomponente, die Sie zuvor im Lab definiert haben. Wenn die Bedingung erfüllt ist, führt die Pipeline die Komponente deploy_op
weiter aus. Entspricht die Accuracy nicht dem vordefinierten Schwellenwert, endet die Pipeline und es wird kein Modell bereitgestellt.
3. Schritt: End-to-End-ML-Pipeline kompilieren und ausführen
- Nachdem die komplette Pipeline definiert wurde, können Sie sie kompilieren:
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="tab_classif_pipeline.json"
)
- Jetzt starten Sie die Pipelineausführung:
response = api_client.create_run_from_job_spec(
"tab_classif_pipeline.json", pipeline_root=PIPELINE_ROOT,
parameter_values={"project": PROJECT_ID,"display_name": DISPLAY_NAME}
)
- Klicken Sie auf den Link, der angezeigt wird, nachdem Sie die obige Zelle ausgeführt haben, um Ihre Pipeline in der Console zu sehen. Das Ausführen dieser Pipeline dauert etwas mehr als eine Stunde. Der größte Zeitaufwand entfällt auf den AutoML-Trainingsschritt. Die abgeschlossene Pipeline sieht in etwa so aus:

- Wenn Sie oben auf die Schaltfläche zum Ein-/Ausblenden der Artefakte klicken, werden Ihnen Details zu den durch Ihre Pipeline erstellten Artefakten angezeigt. Durch Klicken auf das Artefakt
dataset
erhalten Sie beispielsweise Details zum erstellten Vertex AI-Dataset. Sie können hier auf den Link klicken, um zur Seite für dieses Dataset zu wechseln:

- Wenn Sie die Messwertvisualisierungen aus Ihrer benutzerdefinierten Bewertungskomponente sehen möchten, klicken Sie auf das Artefakt metricsc. Auf der rechten Seite des Dashboards sehen Sie die Wahrheitsmatrix für dieses Modell:

- Wechseln Sie zum Modellabschnitt und klicken Sie auf das Modell
automl-beans
, um sich das Modell und den Endpunkt anzusehen, die durch diese Pipelineausführung erstellt wurden. Dort sollten Sie sehen, dass das Modell auf einem Endpunkt bereitgestellt wurde:

-
Auf diese Seite gelangen Sie auch, wenn Sie in der Pipelinegrafik auf das Artefakt endpoint klicken.
-
Neben dem Betrachten der Pipelinegrafik in der Console können Sie auch Vertex Pipelines für das Verfolgen der Lineage nutzen.
-
Mit dem Verfolgen der Lineage werden Artefakte verfolgt, die in Ihrer Pipeline erstellt wurden. Dadurch erfahren Sie, wo Artefakte erstellt wurden und wie sie in einem ML-Workflow verwendet werden. Wenn Sie die Lineage-Verfolgung für das in dieser Pipeline erstellte Dataset sehen möchten, klicken Sie auf das Dataset-Artefakt und dann auf Lineage ansehen:

Hier sehen Sie alle Orte, an denen dieses Artefakt verwendet wird:

Hinweis: Warten Sie, bis der Trainingsjob in Ihrer Pipeline gestartet wurde, bevor Sie unten den Fortschritt prüfen. Der Trainingsjob dauert länger als dieses Lab, aber Sie erhalten für das Senden des Trainingsjobs die volle Punktzahl.
Prüfen, ob der Trainingsjob in der End-to-End-ML-Pipeline gestartet wurde
4. Schritt: Messwerte mehrerer Pipelineausführungen vergleichen (optional)
- Wenn Sie diese Pipeline mehrfach ausführen, können Sie die Messwerte der einzelnen Ausführungen vergleichen. Mit der Methode
aiplatform.get_pipeline_df()
können Sie auf die Metadaten der Ausführungen zugreifen. Hier erhalten wir Metadaten für alle Ausführungen dieser Pipeline und laden diese in einen Pandas DataFrame:
pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2")
small_pipeline_df = pipeline_df.head(2)
small_pipeline_df
Sie haben gelernt, wie Sie eine End-to-End-ML-Pipeline in Vertex Pipelines erstellen, ausführen und Metadaten dafür abrufen.
Glückwunsch!
In diesem Lab haben Sie eine Emojipipeline erstellt und ausgeführt. Außerdem haben Sie gelernt, wie Sie eine End-to-End-ML-Pipeline in Vertex Pipelines erstellen, ausführen und Metadaten dafür abrufen.
Weitere Informationen
Sie können dieses Szenario mit dem Developer Relations-Codelab auch in Ihrem eigenen Google Cloud-Projekt ausprobieren.
Google Cloud-Schulungen und -Zertifizierungen
In unseren Schulungen erfahren Sie alles zum optimalen Einsatz unserer Google Cloud-Technologien und können sich entsprechend zertifizieren lassen. Unsere Kurse vermitteln technische Fähigkeiten und Best Practices, damit Sie möglichst schnell mit Google Cloud loslegen und Ihr Wissen fortlaufend erweitern können. Wir bieten On-Demand-, Präsenz- und virtuelle Schulungen für Anfänger wie Fortgeschrittene an, die Sie individuell in Ihrem eigenen Zeitplan absolvieren können. Mit unseren Zertifizierungen weisen Sie nach, dass Sie Experte im Bereich Google Cloud-Technologien sind.
Handbuch zuletzt am 7. Oktober 2024 aktualisiert
Lab zuletzt am 7. Oktober 2024 getestet
© 2025 Google LLC. Alle Rechte vorbehalten. Google und das Google-Logo sind Marken von Google LLC. Alle anderen Unternehmens- und Produktnamen können Marken der jeweils mit ihnen verbundenen Unternehmen sein.