Vertex ML Metadata mit Pipelines verwenden

1. Übersicht

In diesem Lab lernen Sie, wie Sie Metadaten aus Ihren Vertex Pipelines-Ausführungen mit Vertex ML Metadata 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 vergleichen, sowohl in der Cloud Console als auch programmatisch
• Herkunft für Pipeline-generierte Artefakte verfolgen
• Fragen Sie die Metadaten der Pipelineausführung ab

Die Gesamtkosten für das Lab in Google Cloud belaufen sich auf 2$.

2. Einführung in Vertex AI

In diesem Lab wird das neueste KI-Produktangebot von Google Cloud verwendet. Vertex AI bindet die ML-Angebote in Google Cloud in eine nahtlose Entwicklungsumgebung ein. Zuvor 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.

Neben Modelltrainings- und Bereitstellungsdiensten umfasst Vertex AI auch eine Vielzahl von MLOps-Produkten, darunter Vertex Pipelines, ML-Metadaten, Modellmonitoring, Feature Store. Im Diagramm unten sehen 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. Stellen Sie sich vor, Sie erstellen einen ML-Workflow, der die Verarbeitung von Daten, das Trainieren eines Modells, die Hyperparameter-Abstimmung, die Bewertung und die Modellbereitstellung umfasst. Jeder dieser Schritte kann unterschiedliche Abhängigkeiten haben, die unübersichtlich werden können, wenn Sie den gesamten Workflow als monolithische Anwendung behandeln. Wenn Sie mit der Skalierung Ihres ML-Prozesses beginnen, möchten Sie möglicherweise Ihren ML-Workflow mit anderen in Ihrem Team teilen, damit diese ihn ausführen und Code beitragen können. Ohne einen zuverlässigen, reproduzierbaren Prozess kann dies schwierig werden. Bei Pipelines ist jeder Schritt in Ihrem ML-Prozess ein eigener Container. Auf diese Weise können Sie Schritte unabhängig entwickeln und die Ein- und Ausgabe jedes Schritts auf reproduzierbare Weise verfolgen. Sie können Ausführungen Ihrer Pipeline auch basierend auf anderen Ereignissen in Ihrer Cloud-Umgebung planen oder auslösen, z. B. eine Pipelineausführung starten, wenn neue Trainingsdaten verfügbar sind.

Kurzfassung: Mit Pipelines können Sie Ihren ML-Workflow automatisieren und reproduzieren.

3. Cloud-Umgebung einrichten

Sie benötigen ein Google Cloud Platform-Projekt mit aktivierter Abrechnung, um dieses Codelab auszuführen. Folgen Sie dieser Anleitung, um ein Projekt zu erstellen.

Cloud Shell starten

In diesem Lab arbeiten Sie in einer Cloud Shell-Sitzung, einem Befehlsinterpreter, der von einer virtuellen Maschine in der Cloud von Google gehostet wird. Sie können diesen Abschnitt genauso einfach lokal auf Ihrem Computer ausführen, aber mit Cloud Shell erhalten alle Zugriff auf eine reproduzierbare Version in einer einheitlichen Umgebung. Sie können diesen Abschnitt nach dem Lab gerne auf Ihrem eigenen Computer wiederholen.

Wenn Sie in Cloud Shell zum ersten Mal eine Anfrage stellen, für die eine Autorisierung erforderlich ist, wird die Meldung „Cloud Shell autorisieren“ angezeigt. wie im unten gezeigten Dialogfeld, in dem Sie ohne Bedenken auf den Link "Autorisieren" klicken können. Schaltfläche.

Cloud Shell aktivieren

Klicken Sie rechts oben in der Cloud Console auf die Schaltfläche unten, um Cloud Shell zu aktivieren:

Wenn Sie Cloud Shell noch nie gestartet haben, wird ein Zwischenbildschirm (below the fold) angezeigt, in dem beschrieben wird, worum es sich dabei handelt. Klicken Sie in diesem Fall auf Weiter. Der Chat wird nie wieder angezeigt. So sieht dieser einmalige Bildschirm aus:

Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.

Diese virtuelle Maschine verfügt über alle Entwicklungstools, die Sie benötigen. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt. Dadurch werden die Netzwerkleistung und die Authentifizierung erheblich verbessert. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können Sie ganz einfach mit einem Browser oder Ihrem Chromebook erledigen.

Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie bereits authentifiziert sind und dass das Projekt bereits auf Ihre Projekt-ID eingestellt ist.

Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

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 die Tab-Vervollständigung unterstützt wird. Weitere Informationen finden Sie in der Übersicht zum 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, das den Namen des aktuellen Cloud-Projekts enthält. Wir werden sie in diesem Lab an verschiedenen Stellen verwenden. Sie können es sich ansehen, indem Sie folgenden Befehl ausführen:

echo $GOOGLE_CLOUD_PROJECT

APIs aktivieren

In späteren Schritten werden Sie sehen, wo diese Dienste benötigt werden (und warum). Führen Sie vorerst diesen Befehl aus, um Ihrem Projekt Zugriff auf die Compute Engine-, Container Registry- und Vertex AI-Dienste zu gewähren:

gcloud services enable compute.googleapis.com         \
                       containerregistry.googleapis.com  \
                       aiplatform.googleapis.com

Wenn die Aktivierung erfolgreich war, erhalten Sie eine Meldung, die ungefähr so aussieht:

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

Cloud Storage-Bucket erstellen

Zum Ausführen eines Trainingsjobs in Vertex AI benötigen wir einen Storage-Bucket zum Speichern der gespeicherten Modell-Assets. Der Bucket muss regional sein. Wir verwenden hier us-central. Sie können aber auch eine andere Region verwenden. Ersetzen Sie sie einfach in diesem Lab. Wenn Sie bereits einen Bucket haben, können Sie diesen Schritt überspringen.

Führen Sie die folgenden Befehle in Ihrem Cloud Shell-Terminal aus, um einen Bucket zu erstellen:

BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME

Als Nächstes gewähren wir dem Compute-Dienstkonto Zugriff auf diesen Bucket. Dadurch wird sichergestellt, dass Vertex Pipelines die erforderlichen Berechtigungen zum Schreiben von Dateien in diesen Bucket hat. Führen Sie den folgenden Befehl aus, um diese Berechtigung hinzuzufügen:

gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}[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 im Bereich Vertex AI der Cloud Console auf Workbench:

Klicken Sie dort unter Nutzerverwaltete Notebooks auf Neues Notebook:

Wählen Sie dann den Instanztyp TensorFlow Enterprise 2.3 (mit LTS) ohne GPUs aus:

Verwenden Sie die Standardoptionen und klicken Sie dann auf Erstellen.

Notizbuch öffnen

Nachdem die Instanz erstellt wurde, wählen Sie JupyterLab öffnen aus:

4. Vertex Pipelines einrichten

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

• Kubeflow Pipelines: Dies ist das SDK, das wir zum Erstellen unserer Pipeline verwenden. Vertex Pipelines unterstützt die Ausführung von Pipelines, die mit Kubeflow Pipelines oder TFX erstellt wurden.
• Vertex AI SDK: Dieses SDK optimiert den Aufruf der Vertex AI API. Damit führen wir unsere Pipeline in Vertex AI aus.

Python-Notebook erstellen und Bibliotheken installieren

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

Sie können auf das Launcher-Menü zugreifen, indem Sie links oben in Ihrer Notebookinstanz auf das Pluszeichen + klicken.

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

USER_FLAG = "--user"

Führen Sie dann in Ihrem Notebook folgenden Befehl aus:

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0
!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 korrekt 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 1.6.2 oder höher ist:

!pip list | grep aiplatform

Projekt-ID und Bucket festlegen

In diesem Lab verweisen Sie auf Ihre Cloud-Projekt-ID und den Bucket, den Sie zuvor erstellt haben. Als Nächstes erstellen wir Variablen für jede dieser Elemente.

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

import os
PROJECT_ID = ""

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

Andernfalls legen Sie sie hier fest:

if PROJECT_ID == "" or PROJECT_ID is None:
    PROJECT_ID = "your-project-id"  # @param {type:"string"}

Erstellen Sie dann eine Variable zum Speichern des Bucket-Namens. Wenn Sie sie in diesem Lab erstellt haben, funktioniert Folgendes: Andernfalls müssen Sie die Einstellungen manuell vornehmen:

BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"

Bibliotheken importieren

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

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

Als Letztes müssen wir vor dem Erstellen der Pipeline noch einige konstante Variablen definieren. PIPELINE_ROOT ist der Cloud Storage-Pfad, in den die von unserer Pipeline erstellten Artefakte geschrieben werden. Wir verwenden hier us-central1 als Region. Wenn Sie beim Erstellen des Buckets jedoch eine andere Region verwendet haben, aktualisieren Sie die Variable REGION im Code unten:

PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"

PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT

Nachdem Sie den obigen Code ausgeführt haben, sollte das Stammverzeichnis Ihrer Pipeline ausgegeben werden. Dies ist der Cloud Storage-Speicherort, an den die Artefakte aus Ihrer Pipeline geschrieben werden. Sie hat das Format gs://YOUR-BUCKET-NAME/pipeline_root/.

5. Pipeline in drei Schritten 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. Hier 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: Exportiertes Scikit Learn-Modell auf einem Endpunkt in Vertex AI bereitstellen

In dieser Pipeline verwenden wir das UCI Machine Learning Dry Beans Dataset von: KOKLU, M. und OZKAN, I.A., (2020), „Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques“, „In Computers and Electronics in Agriculture“, 174, 105507. DOI:

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. Beginnen wir mit dem Programmieren!

Funktionsbasierte Python-Komponenten erstellen

Mit dem KFP SDK können wir Komponenten basierend auf Python-Funktionen erstellen. Wir verwenden das 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 bei Ausführung der Pipeline in eine Komponente. Sie benötigen sie immer dann, wenn Sie eine benutzerdefinierte Komponente schreiben.
• Der Parameter base_image gibt das Container-Image an, das von dieser Komponente verwendet wird.
• Diese Komponente verwendet einige Python-Bibliotheken, die wir über den Parameter packages_to_install festlegen.
• 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 Notebookinstanz 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 verwendet diese Komponente die BigQuery Python-Clientbibliothek, um Daten aus BigQuery in einen Pandas DataFrame herunterzuladen. Anschließend erstellt sie ein Ausgabeartefakt dieser Daten als CSV-Datei. Diese wird als Eingabe an unsere nächste Komponente

Komponente zum Trainieren eines Scikit-learn-Modells erstellen

In dieser Komponente trainieren wir mit der zuvor erstellten CSV-Datei ein Scikit-learn-Entscheidungsbaummodell. 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, das zum Trainieren des Modells verwendet 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 definieren, um das Modell hochzuladen und in Vertex AI bereitzustellen

Die letzte Komponente wird das trainierte Modell aus dem vorherigen Schritt in Vertex AI hochladen und auf einem Endpunkt bereitstellen:

@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 vordefinierten Container für die Vorhersage hochzuladen. Anschließend wird das Modell auf einem Endpunkt bereitgestellt und die URIs sowohl an die Modell- als auch an die 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 der Fluss von Eingabe- und Ausgabeartefakten zwischen den Schritten beschrieben:

@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
    )

Mit dem folgenden Befehl 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 Ausführungen unserer Pipeline. Lassen Sie uns zuerst einen Zeitstempel definieren, der für unsere Pipelinejob-IDs 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 nur einen Parameter verwendet: die bq_table, die wir für die Trainingsdaten verwenden möchten. Bei dieser Pipelineausführung wird eine kleinere Version des Beans-Datasets 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 eine weitere Pipelineausführung 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 schließlich die Pipelineausführungen für beide Ausführungen. Es empfiehlt sich, dies in zwei separaten Notebook-Zellen zu tun, damit Sie die Ausgabe für jede Ausführung sehen können.

run1.submit()

Starten Sie dann die zweite Ausführung:

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:

Wenn er abgeschlossen ist (diese Pipeline dauert etwa 10 bis 15 Minuten pro Ausführung), erhalten Sie in etwa folgendes Ergebnis:

Nachdem Sie nun zwei abgeschlossene Pipelineausführungen haben, können Sie sich Pipelineartefakte, -messwerte und -herkunft genauer ansehen.

6. Pipelineartefakte und Lineage verstehen

In Ihrer Pipelinegrafik sehen Sie nach jedem Schritt kleine Kästchen. Das sind Artefakte oder Ausgaben, die aus einem Pipelineschritt generiert wurden. 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 seines URI. Wenn Sie beispielsweise auf das Artefakt vertex_endpoint klicken, wird der URI angezeigt, unter dem Sie den bereitgestellten Endpunkt in Ihrer Vertex AI-Konsole 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 Messwertartefakt, um die Details aufzurufen:

Für jedes Artefakt gibt es Lineage. Damit werden die anderen Artefakte beschrieben, mit denen es verbunden ist. Klicken Sie noch einmal auf das Artefakt vertex_endpoint der Pipeline und dann auf die Schaltfläche Lineage anzeigen:

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 werden das Modell, die Messwerte und das Dataset angezeigt, 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. Das Lineage-Diagramm hilft Ihnen, jedes Artefakt im Kontext des restlichen ML-Systems zu verstehen. Sie können auch programmatisch auf die Herkunft zugreifen, wie wir später in diesem Codelab noch sehen werden.

7. Pipelineausführungen vergleichen

Wahrscheinlich wird eine einzelne Pipeline mehrmals ausgeführt, vielleicht mit unterschiedlichen Eingabeparametern, neuen Daten oder von Mitgliedern Ihres Teams. 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 Ausführungen erläutert.

Ausführungen in der Pipelines-UI vergleichen

Rufen Sie in der Cloud Console Ihr Pipelines-Dashboard auf. So erhalten Sie einen Überblick über jede ausgeführte Pipelineausführung. Prüfen Sie die 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 unterschiedlichen BigQuery-Tabellen, Dataset-Größen und Genauigkeitswerte:

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

Ausführungen mit dem Vertex AI SDK vergleichen

Bei vielen Pipelineausführungen benötigen Sie möglicherweise eine Möglichkeit, diese Vergleichsmesswerte programmatisch abzurufen, um Messwertdetails genauer unter die Lupe zu nehmen 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 der Pipeline in unserer 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 zwar nur zweimal ausgeführt, aber Sie können sich vorstellen, wie viele Messwerte Sie mit mehr Ausführungen hätten. Als Nächstes erstellen wir eine benutzerdefinierte Visualisierung mit matplotlib, um den Zusammenhang zwischen der Genauigkeit unseres Modells und der für das Training verwendeten Datenmenge zu ermitteln.

Führen Sie den folgenden Befehl in einer neuen Notebook-Zelle 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. Pipelinemesswerte abfragen

Neben dem Abrufen eines DataFrames aller Pipelinemesswerte können Sie in Ihrem ML-System erstellte Artefakte programmatisch abfragen. Dort können Sie ein benutzerdefiniertes Dashboard erstellen oder anderen in Ihrer Organisation Details zu bestimmten Artefakten zur Verfügung stellen.

Alle Modellartefakte abrufen

Um Artefakte auf diese Weise abzufragen, erstellen wir einen 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 in unserer Antwort enthalten sein sollen. Rufen wir zuerst alle Artefakte in unserem Projekt ab, bei denen es sich um Modelle handelt. Führen Sie dazu folgenden Befehl 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. Rufen Sie als Nächstes alle Artefakte ab, die nach dem 10. August 2021 mit dem Status LIVE erstellt wurden. Nachdem wir diese Anfrage ausgeführt haben, zeigen wir die Ergebnisse in einem Pandas-DataFrame an. 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)

Zeigen Sie dann die Ergebnisse in einem DataFrame an:

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 in etwa Folgendes:

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

Damit haben Sie das Lab abgeschlossen!

🎉 Glückwunsch! 🎉

Sie haben gelernt, wie Sie mit Vertex AI Folgendes tun können:

• Mit dem Kubeflow Pipelines SDK 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 vergleichen, sowohl in der Cloud Console als auch programmatisch
• 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 entstehen, sollten Sie die in diesem Lab erstellten Ressourcen löschen.

Notebooks-Instanz beenden oder löschen

Wenn Sie das Notebook, das Sie in diesem Lab erstellt haben, weiter verwenden möchten, sollten Sie es deaktivieren, wenn Sie es nicht verwenden. Wählen Sie in der Notebooks-UI in der Cloud Console das Notebook und dann Beenden aus. Wenn Sie die Instanz vollständig löschen möchten, wählen Sie Löschen aus:

Vertex AI-Endpunkte löschen

Wenn Sie den von Ihnen bereitgestellten Endpunkt löschen möchten, gehen Sie in der Vertex AI-Konsole zum Abschnitt Endpunkte und klicken Sie auf das Symbol zum 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“: