Vertex ML Metadata mit Pipelines verwenden

1. Übersicht

In diesem Lab erfahren Sie, wie Sie Metadaten aus Ihren Vertex Pipelines-Ausführungen mit Vertex ML-Metadaten analysieren.

Lerninhalte

Die folgenden Themen werden behandelt:

• Mit dem Kubeflow Pipelines SDK eine ML-Pipeline erstellen, die ein Dataset in Vertex AI erstellt und ein benutzerdefiniertes Scikit-learn-Modell für dieses Dataset trainiert und bereitstellt
• Schreiben Sie benutzerdefinierte Pipelinekomponenten, die Artefakte und Metadaten generieren
• Vertex Pipelines-Ausführungen sowohl in der Cloud Console als auch programmatisch vergleichen
• Herkunft für Pipeline-generierte Artefakte verfolgen
• Fragen Sie die Metadaten der Pipelineausführung ab

Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud betragen etwa 2$.

2. Einführung in Vertex AI

In diesem Lab wird das neueste KI-Angebot von Google Cloud verwendet. Vertex AI bindet die ML-Angebote in Google Cloud in eine nahtlose Entwicklungsumgebung ein. Bisher waren mit AutoML trainierte und benutzerdefinierte Modelle über separate Dienste zugänglich. Das neue Angebot vereint beides in einer einzigen API sowie weitere neue Produkte. Sie können auch vorhandene Projekte zu Vertex AI migrieren.

Zusätzlich zu den Diensten für das Modelltraining und die Bereitstellung umfasst Vertex AI auch eine Vielzahl von MLOps-Produkten, darunter Vertex Pipelines, ML-Metadaten, Modellmonitoring, Feature Store. Im Diagramm unten finden Sie alle Vertex AI-Produktangebote.

In diesem Lab geht es um Vertex Pipelines und Vertex ML Metadata.

Wenn Sie Feedback zu Vertex AI haben, 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, die unübersichtlich werden können, wenn Sie den gesamten Workflow als monolithische Anwendung behandeln. Wenn Sie mit der Skalierung Ihres ML-Prozesses beginnen, möchten Sie möglicherweise Ihren ML-Workflow mit anderen in Ihrem Team teilen, damit diese ihn ausführen und Code beitragen können. Ohne einen zuverlässigen, reproduzierbaren Prozess kann das schwierig werden. Bei Pipelines hat jeder Schritt in Ihrem ML-Prozess einen eigenen Container. So können Sie Schritte unabhängig entwickeln und die Eingabe 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.

Zusammenfassung: Pipelines helfen Ihnen, Ihren ML-Workflow zu automatisieren 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. Eine Anleitung zum Erstellen eines Projekts finden Sie hier.

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 genauso einfach lokal auf Ihrem Computer ausführen, aber mit Cloud Shell erhalten alle Zugriff auf eine reproduzierbare Version in einer einheitlichen Umgebung. Sie können diesen Abschnitt nach dem Lab gerne auf Ihrem eigenen Computer wiederholen.

Wenn Sie in Cloud Shell zum ersten Mal eine Anfrage stellen, für die eine Autorisierung erforderlich ist, wird das Dialogfeld "Cloud Shell autorisieren" wie das unten abgebildete angezeigt. Klicken Sie dort auf die Schaltfläche "Autorisieren".

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 zum ersten Mal verwenden, sehen Sie „below the fold“ (mit Scrollen sichtbar) auf einem Zwischenbildschirm mit einer Beschreibung des Tools. Klicken Sie in diesem Fall auf Continue (Weiter). So sieht dieser einmalige Bildschirm aus:

Die Bereitstellung und Verbindung mit Cloud Shell sollte nur wenige Minuten dauern.

Auf dieser virtuellen Maschine sind alle erforderlichen Entwicklungstools installiert. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Die meisten, wenn nicht alle Aufgaben in diesem Codelab können Sie 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

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Hinweis: Das gcloud-Befehlszeilentool ist ein leistungsstarkes und einheitliches Befehlszeilentool in Google Cloud. Es ist in Cloud Shell vorinstalliert. Sie werden feststellen, dass es die Tab-Vervollständigung unterstützt. Weitere Informationen finden Sie in der Übersicht über das gcloud-Befehlszeilentool.

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 werden sie in diesem Lab an verschiedenen Stellen verwenden. Sie können sie mit dem folgenden Befehl aufrufen:

echo $GOOGLE_CLOUD_PROJECT

APIs aktivieren

In späteren Schritten erfahren Sie, wo 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.

Cloud Storage-Bucket erstellen

Zum Ausführen eines Trainingsjobs in Vertex AI benötigen wir einen Storage-Bucket zum Speichern der gespeicherten Modell-Assets. Der Bucket muss regional sein. Wir verwenden hier us-central, Sie können aber auch eine andere Region verwenden. Ersetzen Sie sie 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//\'/}[e-mail]"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin

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.

Öffnen Sie Ihr Notebook.

Wählen Sie nach dem Erstellen der Instanz JupyterLab öffnen aus:

4. Vertex Pipelines einrichten

Zur Verwendung von Vertex Pipelines müssen einige zusätzliche Bibliotheken installiert werden:

• 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.
• Vertex AI SDK: Dieses SDK optimiert den Aufruf der Vertex AI API. Wir verwenden es, um unsere Pipeline in Vertex AI auszuführen.

Python-Notebook erstellen und Bibliotheken installieren

Erstellen Sie zuerst ein Notebook in Ihrer Notebook-Instanz. Wählen Sie dazu im Launcher-Menü die Option Python 3 aus:

Klicken Sie links oben in Ihrer Notebookinstanz auf das +-Zeichen, um das Launcher-Menü aufzurufen.

Um beide Dienste zu installieren, die wir in diesem Lab verwenden werden, legen Sie zuerst das Nutzer-Flag in einer Notebook-Zelle fest:

USER_FLAG = "--user"

Führen Sie dann Folgendes in Ihrem Notebook aus:

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0
!pip3 install {USER_FLAG} kfp==1.8.9

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 als Nächstes, ob Sie die KFP SDK-Version richtig installiert haben. Der Wert sollte größer als 1,8 sein:

!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

Prüfen Sie dann, ob Ihre Vertex AI SDK-Version mindestens 1.6.2 ist:

!pip list | grep aiplatform

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 jede davon Variablen.

Wenn Sie Ihre Projekt-ID nicht kennen, können Sie sie möglicherweise abrufen, indem Sie den folgenden Befehl ausführen:

import os
PROJECT_ID = ""

# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
    shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
    PROJECT_ID = shell_output[0]
    print("Project ID: ", PROJECT_ID)

Andernfalls 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"

Bibliotheken importieren

Fügen Sie Folgendes hinzu, um die Bibliotheken zu importieren, die wir in diesem Codelab verwenden werden:

import matplotlib.pyplot as plt
import pandas as pd

from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline, component, Artifact, Dataset, Input, Metrics, Model, Output, InputPath, OutputPath

from google.cloud import aiplatform

# We'll use this namespace for metadata querying
from google.cloud import aiplatform_v1

Konstanten definieren

Bevor wir unsere Pipeline erstellen, müssen wir noch einige Konstantenvariablen definieren. PIPELINE_ROOT ist der Cloud Storage-Pfad, in den die von der 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. Drei-Schritte-Pipeline mit benutzerdefinierten Komponenten erstellen

In diesem Lab geht es um Metadaten aus Pipelineausführungen. Dazu benötigen wir eine Pipeline, die in Vertex Pipelines ausgeführt wird. Damit beginnen wir. Hier definieren wir eine dreistufige Pipeline mit den folgenden benutzerdefinierten Komponenten:

• get_dataframe: Daten aus einer BigQuery-Tabelle abrufen und in einen Pandas DataFrame konvertieren
• train_sklearn_model: Mit dem Pandas DataFrame ein Scikit Learn-Modell zusammen mit einigen Messwerten trainieren und exportieren
• deploy_model: Das exportierte Scikit Learn-Modell in einem Endpunkt in Vertex AI bereitstellen

In dieser Pipeline 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.

Dies ist ein tabellarisches Dataset. In unserer Pipeline verwenden wir das Dataset, um ein Scikit-learn-Modell zu trainieren, zu bewerten und bereitzustellen, das Bohnen anhand ihrer Eigenschaften in einen von sieben Typen einteilt. Los gehts mit dem Programmieren!

Funktionsbasierte Python-Komponenten erstellen

Mit dem KFP SDK können wir Komponenten basierend auf Python-Funktionen erstellen. Wir verwenden ihn für die drei Komponenten in dieser Pipeline.

BigQuery-Daten herunterladen und in CSV konvertieren

Zuerst erstellen wir die get_dataframe-Komponente:

@component(
    packages_to_install=["google-cloud-bigquery", "pandas", "pyarrow", "db-dtypes"],
    base_image="python:3.9",
    output_component_file="create_dataset.yaml"
)
def get_dataframe(
    bq_table: str,
    output_data_path: OutputPath("Dataset")
):
    from google.cloud import bigquery
    import pandas as pd
    import os

    project_number = os.environ["CLOUD_ML_PROJECT_ID"]
    bqclient = bigquery.Client(project=project_number)
    table = bigquery.TableReference.from_string(
        bq_table
    )
    rows = bqclient.list_rows(
        table
    )
    dataframe = rows.to_dataframe(
        create_bqstorage_client=True,
    )
    dataframe = dataframe.sample(frac=1, random_state=2)
    dataframe.to_csv(output_data_path)

Sehen wir uns genauer an, was in dieser Komponente passiert:

• Der @component-Decorator kompiliert diese Funktion in eine Komponente, wenn die Pipeline ausgeführt wird. Sie verwenden diese Funktion immer, wenn Sie eine benutzerdefinierte Komponente schreiben.
• Der Parameter base_image gibt das Container-Image an, das für diese Komponente verwendet wird.
• Für diese Komponente werden einige Python-Bibliotheken verwendet, die über den Parameter packages_to_install angegeben werden.
• Der Parameter output_component_file ist optional und gibt die YAML-Datei an, in die die kompilierte Komponente geschrieben werden soll. Nachdem Sie die Zelle ausgeführt haben, sollte die Datei in Ihre Notebook-Instanz geschrieben werden. Wenn Sie diese Komponente für einen Nutzer freigeben möchten, können Sie ihm die generierte YAML-Datei senden, die dann so geladen wird:

# This is optional, it shows how to load a component from a yaml file
# dataset_component = kfp.components.load_component_from_file('./create_dataset.yaml')

• Als Nächstes werden mit der BigQuery Python-Clientbibliothek die Daten aus BigQuery in einen Pandas-DataFrame heruntergeladen und dann ein Ausgabeartefakt dieser Daten als CSV-Datei erstellt. Dieser Wert wird als Eingabe an die nächste Komponente übergeben.

Komponente zum Trainieren eines Scikit-learn-Modells erstellen

In dieser Komponente verwenden wir die zuvor generierte CSV-Datei, um ein Entscheidungsbaummodell mit Scikit-learn zu trainieren. Diese Komponente exportiert das resultierende Scikit-Modell zusammen mit einem Metrics-Artefakt, das die Genauigkeit, das Framework und die Größe des Datasets enthält, mit dem das Modell trainiert wurde:

@component(
    packages_to_install=["sklearn", "pandas", "joblib", "db-dtypes"],
    base_image="python:3.9",
    output_component_file="beans_model_component.yaml",
)
def sklearn_train(
    dataset: Input[Dataset],
    metrics: Output[Metrics],
    model: Output[Model]
):
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.metrics import roc_curve
    from sklearn.model_selection import train_test_split
    from joblib import dump

    import pandas as pd
    df = pd.read_csv(dataset.path)
    labels = df.pop("Class").tolist()
    data = df.values.tolist()
    x_train, x_test, y_train, y_test = train_test_split(data, labels)

    skmodel = DecisionTreeClassifier()
    skmodel.fit(x_train,y_train)
    score = skmodel.score(x_test,y_test)
    print('accuracy is:',score)

    metrics.log_metric("accuracy",(score * 100.0))
    metrics.log_metric("framework", "Scikit Learn")
    metrics.log_metric("dataset_size", len(df))
    dump(skmodel, model.path + ".joblib")

Komponente zum Hochladen und Bereitstellen des Modells in Vertex AI definieren

Die letzte Komponente übernimmt das trainierte Modell aus dem vorherigen Schritt, lädt es in Vertex AI hoch und stellt es auf einem Endpunkt bereit:

@component(
    packages_to_install=["google-cloud-aiplatform"],
    base_image="python:3.9",
    output_component_file="beans_deploy_component.yaml",
)
def deploy_model(
    model: Input[Model],
    project: str,
    region: str,
    vertex_endpoint: Output[Artifact],
    vertex_model: Output[Model]
):
    from google.cloud import aiplatform

    aiplatform.init(project=project, location=region)

    deployed_model = aiplatform.Model.upload(
        display_name="beans-model-pipeline",
        artifact_uri = model.uri.replace("model", ""),
        serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest"
    )
    endpoint = deployed_model.deploy(machine_type="n1-standard-4")

    # Save data to the output params
    vertex_endpoint.uri = endpoint.resource_name
    vertex_model.uri = deployed_model.resource_name

Hier verwenden wir das Vertex AI SDK, um das Modell mit einem vorkonfigurierten Container für die Vorhersage hochzuladen. Anschließend wird das Modell auf einem Endpunkt bereitgestellt und die URIs für die Modell- und Endpunktressourcen zurückgegeben. Später in diesem Codelab erfahren Sie mehr darüber, was es bedeutet, diese Daten als Artefakte zurückzugeben.

Pipeline definieren und kompilieren

Nachdem Sie nun unsere drei Komponenten definiert haben, erstellen wir unsere Pipeline-Definition. Hier wird beschrieben, wie Eingabe- und Ausgabeartefakte zwischen den Schritten fließen:

@pipeline(
    # Default pipeline root. You can override it when submitting the pipeline.
    pipeline_root=PIPELINE_ROOT,
    # A name for the pipeline.
    name="mlmd-pipeline",
)
def pipeline(
    bq_table: str = "",
    output_data_path: str = "data.csv",
    project: str = PROJECT_ID,
    region: str = REGION
):
    dataset_task = get_dataframe(bq_table)

    model_task = sklearn_train(
        dataset_task.output
    )

    deploy_task = deploy_model(
        model=model_task.outputs["model"],
        project=project,
        region=region
    )

Dadurch wird eine JSON-Datei generiert, mit der Sie die Pipeline ausführen:

compiler.Compiler().compile(
    pipeline_func=pipeline, package_path="mlmd_pipeline.json"
)

Zwei Pipelineausführungen starten

Als Nächstes starten wir zwei Durchläufe unserer Pipeline. Definieren wir zuerst einen Zeitstempel, der für die IDs unserer Pipelinejobs verwendet werden soll:

from datetime import datetime

TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")

Denken Sie daran, dass unsere Pipeline beim Ausführen einen Parameter verwendet: die bq_table, die wir für die Trainingsdaten verwenden möchten. Für diese Pipelineausführung wird eine kleinere Version des Datasets „beans“ verwendet:

run1 = aiplatform.PipelineJob(
    display_name="mlmd-pipeline",
    template_path="mlmd_pipeline.json",
    job_id="mlmd-pipeline-small-{0}".format(TIMESTAMP),
    parameter_values={"bq_table": "sara-vertex-demos.beans_demo.small_dataset"},
    enable_caching=True,
)

Erstellen Sie als Nächstes einen weiteren Pipelinelauf mit einer größeren Version desselben Datasets.

run2 = aiplatform.PipelineJob(
    display_name="mlmd-pipeline",
    template_path="mlmd_pipeline.json",
    job_id="mlmd-pipeline-large-{0}".format(TIMESTAMP),
    parameter_values={"bq_table": "sara-vertex-demos.beans_demo.large_dataset"},
    enable_caching=True,
)

Starten Sie abschließend die Pipelineausführungen für beide Ausführungen. Am besten tun Sie dies in zwei separaten Notebookzellen, damit Sie die Ausgabe für jeden Durchlauf sehen können.

run1.submit()

Starten Sie dann den zweiten Durchlauf:

run2.submit()

Nachdem Sie diese Zelle ausgeführt haben, wird ein Link zum Ansehen der einzelnen Pipeline in der Vertex AI Console angezeigt. Öffnen Sie diesen Link, um weitere Details zu Ihrer Pipeline zu sehen:

Nach Abschluss der Ausführung (diese Pipeline dauert etwa 10 bis 15 Minuten pro Ausführung) wird in etwa Folgendes angezeigt:

Nachdem Sie nun zwei Pipelineausführungen durchgeführt haben, können Sie sich die Pipeline-Artefakte, Messwerte und die Herkunft genauer ansehen.

6. Pipeline-Artefakte und Herkunft

In Ihrer Pipelinegrafik sehen Sie nach jedem Schritt kleine Kästchen. Das sind Artefakte, also Ausgaben, die von einem Pipelineschritt generiert werden. Es gibt viele Arten von Artefakten. In dieser speziellen Pipeline haben wir Dataset-, Messwert-, Modell- und Endpunktartefakte. Klicken Sie oben in der Benutzeroberfläche auf den Schieberegler Artefakte maximieren, um weitere Details zu den einzelnen Artefakten zu sehen:

Wenn Sie auf ein Artefakt klicken, werden weitere Details angezeigt, einschließlich des URI. Wenn Sie beispielsweise auf das Artefakt vertex_endpoint klicken, wird der URI angezeigt, unter dem Sie diesen bereitgestellten Endpunkt in der Vertex AI Console finden:

Mit einem Metrics-Artefakt können Sie benutzerdefinierte Messwerte übergeben, die mit einem bestimmten Pipelineschritt verknüpft sind. In der sklearn_train-Komponente unserer Pipeline haben wir Messwerte zur Accuracy, dem Framework und der Dataset-Größe unseres Modells protokolliert. Klicken Sie auf das Messwert-Artefakt, um diese Details aufzurufen:

Jedes Artefakt hat eine Abstammung, die die anderen Artefakte beschreibt, mit denen es verbunden ist. Klicken Sie noch einmal auf das Artefakt vertex_endpoint Ihrer Pipeline und dann auf die Schaltfläche Herkunft ansehen:

Dadurch wird ein neuer Tab geöffnet, auf dem Sie alle Artefakte sehen können, die mit dem ausgewählten Element verbunden sind. Die Herkunftsgrafik sieht ungefähr so aus:

Hier sehen wir das Modell, die Messwerte und den Datensatz, die mit diesem Endpunkt verknüpft sind. Welchen Nutzen bieten sie? Möglicherweise haben Sie ein Modell auf mehreren Endpunkten bereitgestellt oder müssen das spezifische Dataset kennen, das zum Trainieren des Modells auf dem jeweiligen Endpunkt verwendet wurde. Anhand des Stammbaumdiagramms können Sie jedes Artefakt im Kontext des restlichen ML-Systems verstehen. Sie können auch programmatisch auf die Herkunft zugreifen, wie wir später in diesem Codelab noch sehen werden.

7. Pipelineausführungen vergleichen

Es ist wahrscheinlich, dass eine einzelne Pipeline mehrmals ausgeführt wird, möglicherweise mit unterschiedlichen Eingabeparametern, neuen Daten oder von Personen in Ihrem Team. Um den Überblick über Pipelineausführungen zu behalten, wäre es hilfreich, eine Möglichkeit zu haben, sie anhand verschiedener Messwerte zu vergleichen. In diesem Abschnitt werden zwei Möglichkeiten zum Vergleichen von Läufen beschrieben.

Ausführungen in der Pipelines-Benutzeroberfläche vergleichen

Rufen Sie in der Cloud Console Ihr Pipelines-Dashboard auf. Hier erhalten Sie einen Überblick über alle von Ihnen ausgeführten Pipelineausführungen. Setzen Sie ein Häkchen bei den letzten beiden Ausführungen und klicken Sie dann oben auf die Schaltfläche Vergleichen:

Dadurch gelangen Sie zu einer Seite, auf der Sie Eingabeparameter und Messwerte für jeden der ausgewählten Durchläufe vergleichen können. Beachten Sie bei diesen beiden Ausführungen die verschiedenen BigQuery-Tabellen, Dataset-Größen und Genauigkeitswerte:

Mit dieser UI-Funktion können Sie mehr als zwei Ausführungen und sogar Ausführungen aus verschiedenen Pipelines vergleichen.

Ausführungen mit dem Vertex AI SDK vergleichen

Bei vielen Pipelineausführungen möchten Sie diese Vergleichsmesswerte möglicherweise programmatisch abrufen, um sich detaillierte Messwertinformationen anzusehen und Visualisierungen zu erstellen.

Mit der Methode aiplatform.get_pipeline_df() können Sie auf Ausführungsmetadaten zugreifen. Hier werden Metadaten für die letzten beiden Ausführungen derselben Pipeline abgerufen und in einen Pandas DataFrame geladen. Der Parameter pipeline bezieht sich hier auf den Namen, den wir unserer Pipeline in der Pipelinedefinition gegeben haben:

df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df

Wenn Sie den DataFrame drucken, sehen Sie in etwa Folgendes:

Wir haben unsere Pipeline hier nur zweimal ausgeführt, aber Sie können sich vorstellen, wie viele Messwerte Sie bei mehr Ausführungen hätten. Als Nächstes erstellen wir mit matplotlib eine benutzerdefinierte Visualisierung, um die Beziehung zwischen der Genauigkeit unseres Modells und der Menge der für das Training verwendeten Daten zu sehen.

Führen Sie in einer neuen Notebookzelle Folgendes aus:

plt.plot(df["metric.dataset_size"], df["metric.accuracy"],label="Accuracy")
plt.title("Accuracy and dataset size")
plt.legend(loc=4)
plt.show()

Auf dem Bildschirm sollte Folgendes zu sehen sein:

8. Pipeline-Messwerte abfragen

Sie können nicht nur einen DataFrame mit allen Pipeline-Messwerten abrufen, sondern auch programmatisch Artefakte abfragen, die in Ihrem ML-System erstellt wurden. Anschließend können Sie ein benutzerdefiniertes Dashboard erstellen oder anderen Nutzern in Ihrer Organisation Details zu bestimmten Artefakten zur Verfügung stellen.

Alle Modellartefakte abrufen

Um Artefakte auf diese Weise abzufragen, erstellen wir eine MetadataServiceClient:

API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
metadata_client = aiplatform_v1.MetadataServiceClient(
  client_options={
      "api_endpoint": API_ENDPOINT
  }
)

Als Nächstes senden wir eine list_artifacts-Anfrage an diesen Endpunkt und übergeben einen Filter, der angibt, welche Artefakte wir in unserer Antwort benötigen. Rufen wir zuerst alle Modelle in unserem Projekt ab. Führen Sie dazu Folgendes in Ihrem Notebook aus:

MODEL_FILTER="schema_title = \"system.Model\""
artifact_request = aiplatform_v1.ListArtifactsRequest(
    parent="projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
    filter=MODEL_FILTER
)
model_artifacts = metadata_client.list_artifacts(artifact_request)

Die resultierende model_artifacts-Antwort enthält ein iterierbares Objekt für jedes Modellartefakt in Ihrem Projekt sowie zugehörige Metadaten für jedes Modell.

Objekte filtern und in einem DataFrame anzeigen

Es wäre praktisch, wenn wir die resultierende Artefaktabfrage einfacher visualisieren könnten. Als Nächstes rufen wir alle Artefakte ab, die nach dem 10. August 2021 mit dem Status LIVE erstellt wurden. Nachdem wir diese Anfrage ausgeführt haben, werden die Ergebnisse in einem Pandas DataFrame angezeigt. Führen Sie zuerst die Anfrage aus:

LIVE_FILTER = "create_time > \"2021-08-10T00:00:00-00:00\" AND state = LIVE"
artifact_req = {
    "parent": "projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
    "filter": LIVE_FILTER
}
live_artifacts = metadata_client.list_artifacts(artifact_req)

Anschließend können Sie die Ergebnisse in einem DataFrame anzeigen:

data = {'uri': [], 'createTime': [], 'type': []}

for i in live_artifacts:
    data['uri'].append(i.uri)
    data['createTime'].append(i.create_time)
    data['type'].append(i.schema_title)

df = pd.DataFrame.from_dict(data)
df

Sie sehen etwa Folgendes:

Sie können zusätzlich zu dem, was Sie hier ausprobiert haben, Artefakte auch anhand anderer Kriterien filtern.

Damit ist das Lab abgeschlossen.

🎉 Glückwunsch! 🎉

Sie haben gelernt, wie Sie Vertex AI für Folgendes verwenden:

• Mit dem Kubeflow Pipelines SDK eine ML-Pipeline erstellen, die ein Dataset in Vertex AI erstellt und ein benutzerdefiniertes Scikit-Learn-Modell auf diesem Dataset trainiert und bereitstellt
• Schreiben Sie benutzerdefinierte Pipelinekomponenten, die Artefakte und Metadaten generieren
• Vertex Pipelines-Ausführungen sowohl in der Cloud Console als auch programmatisch vergleichen
• Herkunft für Pipeline-generierte Artefakte verfolgen
• Fragen Sie die Metadaten der Pipelineausführung ab

Weitere Informationen zu den verschiedenen Teilen 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.

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:

Vertex AI-Endpunkte löschen

Wenn Sie den bereitgestellten Endpunkt löschen möchten, rufen Sie in der Vertex AI-Konsole den Bereich Endpunkte auf und klicken Sie auf das Symbol „Löschen“:

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“: