arrow_back

Vertex Pipelines: Qwik Start

Anmelden Teilnehmen
Quick tip: Review the prerequisites before you run the lab
Use an Incognito or private browser window to run this lab. This prevents any conflicts between your personal account and the student account, which may cause extra charges incurred to your personal account.
Testen und teilen Sie Ihr Wissen mit unserer Community.
done
Sie erhalten Zugriff auf über 700 praxisorientierte Labs, Skill-Logos und Kurse

Vertex Pipelines: Qwik Start

Lab 1 Stunde 30 Minuten universal_currency_alt 5 Guthabenpunkte show_chart Mittelstufe
info Dieses Lab kann KI-Tools enthalten, die den Lernprozess unterstützen.
Testen und teilen Sie Ihr Wissen mit unserer Community.
done
Sie erhalten Zugriff auf über 700 praxisorientierte Labs, Skill-Logos und Kurse

GSP965

Logo: Google Cloud-Labs zum selbstbestimmten Lernen

Ü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

  1. 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
  2. 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.
  3. 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.

  4. Klicken Sie auf Weiter.

  5. 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.

  6. 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.
  7. 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ü. Symbol für Navigationsmenü

Aufgabe 1: Vertex-Notebook-Instanz erstellen

  1. Klicken Sie auf das Navigationsmenü.

  2. Klicken Sie auf Vertex AI und dann auf Workbench.

  3. Rufen Sie auf der Seite mit den Notebook-Instanzen den Tab Nutzerverwaltete Notebooks auf und warten Sie, bis ai-notebook erstellt ist.

Maximiertes Navigationsmenü, in dem die Option „Workbench“ hervorgehoben ist

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

Auf der Instanzseite hervorgehobener Link „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

  1. Erstellen Sie im Launcher-Menü in Ihrer Notebook-Instanz ein Notebook, indem Sie Python 3 auswählen:

Hervorgehobene Python 3-Kachel im Abschnitt „Notebook“

  1. In das Launcher-Menü gelangen Sie, wenn Sie oben links in der Notebook-Instanz auf das +-Zeichen klicken.

  2. 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"
  1. 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.
  1. 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)
  1. 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.

  1. 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)
  1. 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

  • Erstellen Sie mit dem KFP SDK eine kurze Pipeline. Diese Pipeline erfüllt noch keine ML-Aufgaben (das kommt später), aber Sie sollen dadurch lernen:

    • wie im KFP SDK benutzerdefinierte Komponenten erstellt werden
    • wie eine Pipeline in Vertex Pipelines ausgeführt und überwacht wird

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

  1. 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.
  1. 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.

  1. 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.

  2. 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

  1. 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" )
  1. Als Nächstes instanziieren Sie einen API-Client:
api_client = AIPlatformClient( project_id=PROJECT_ID, region=REGION, )
  1. 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:

Console-Bildschirm mit Pipelineausführung und Verbindungen zwischen „build-sentence“ und „emoji“ sowie zwischen „build-sentence“ und „product-name“

  1. 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:

Komponente „build_sentence“ zeigt die endgültige Ausgabe an

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.

  1. 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)
  1. 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

  1. Nachdem die komplette Pipeline definiert wurde, können Sie sie kompilieren:
compiler.Compiler().compile( pipeline_func=pipeline, package_path="tab_classif_pipeline.json" )
  1. 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} )
  1. 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:

Console mit der abgeschlossenen AutoML-Pipeline

  1. 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:

Artefakt-Infobildschirm, auf dem der URI-Link angezeigt wird

  1. 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:

Dashboard, in dem die metricsc-Wahrheitsmatrix angezeigt wird

  1. 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:

Tab „Bereitstellen und testen“, auf dem der Modellendpunkt angezeigt wird

  1. Auf diese Seite gelangen Sie auch, wenn Sie in der Pipelinegrafik auf das Artefakt endpoint klicken.

  2. Neben dem Betrachten der Pipelinegrafik in der Console können Sie auch Vertex Pipelines für das Verfolgen der Lineage nutzen.

  3. 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:

Seite „Artefaktinformationen“ mit hervorgehobener Schaltfläche „Lineage ansehen“

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

Console mit Anzeige der Lineage-Details und Modell-Pop-up

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.

Before you begin

  1. Labs create a Google Cloud project and resources for a fixed time
  2. Labs have a time limit and no pause feature. If you end the lab, you'll have to restart from the beginning.
  3. On the top left of your screen, click Start lab to begin

Use private browsing

  1. Copy the provided Username and Password for the lab
  2. Click Open console in private mode

Sign in to the Console

  1. Sign in using your lab credentials. Using other credentials might cause errors or incur charges.
  2. Accept the terms, and skip the recovery resource page
  3. Don't click End lab unless you've finished the lab or want to restart it, as it will clear your work and remove the project

Diese Inhalte sind derzeit nicht verfügbar

Bei Verfügbarkeit des Labs benachrichtigen wir Sie per E-Mail

Sehr gut!

Bei Verfügbarkeit kontaktieren wir Sie per E-Mail

One lab at a time

Confirm to end all existing labs and start this one

Setup your console before you begin

Use an Incognito or private browser window to run this lab. This prevents any conflicts between your personal account and the Student account, which may cause extra charges incurred to your personal account.