1. Übersicht
In diesem Lab erstellen Sie mit Vertex AI eine Pipeline, die ein benutzerdefiniertes Keras-Modell in TensorFlow trainiert. Anschließend verwenden Sie die neue Funktion in Vertex AI Experiments, um Modellläufe zu verfolgen und zu vergleichen, um die Kombination von Hyperparametern zu ermitteln, die die beste Leistung erzielt.
Lerninhalte
Die folgenden Themen werden behandelt:
- Benutzerdefiniertes Keras-Modell trainieren, um Spielerbewertungen vorherzusagen (z.B. Regression)
- Mit dem Kubeflow Pipelines SDK skalierbare ML-Pipelines erstellen
- Eine Pipeline mit fünf Schritten erstellen und ausführen, die Daten aus Cloud Storage aufnimmt, die Daten skaliert, das Modell trainiert, es auswertet und das resultierende Modell wieder in Cloud Storage speichert
- Vertex ML Metadata verwenden, um Modellartefakte wie Modelle und Modellmesswerte zu speichern
- Vertex AI Experiments verwenden, um die Ergebnisse der verschiedenen Pipelineausführungen zu vergleichen
Die Gesamtkosten für die Ausführung dieses Labs in Google Cloud betragen etwa 1$.
2. Einführung in Vertex AI
In diesem Lab wird das neueste KI-Produkt von Google Cloud verwendet. 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. Das neue Angebot kombiniert diese und weitere, neue Produkte zu einer einzigen API. Sie können auch vorhandene Projekte zu Vertex AI migrieren.
Vertex AI umfasst viele verschiedene Produkte zur Unterstützung von End-to-End-ML-Workflows. In diesem Lab konzentrieren wir uns auf die unten hervorgehobenen Produkte: Experiments, Pipelines, ML Metadata und Workbench
3. Anwendungsfallübersicht
Wir verwenden ein beliebtes Fußball-Dataset aus der FIFA-Videospielreihe von EA Sports. Es enthält über 25.000 Fußballspiele und mehr als 10.000 Spieler aus den Saisons 2008 bis 2016. Die Daten wurden im Voraus vorverarbeitet, damit Sie leichter loslegen können. Sie verwenden dieses Dataset im gesamten Lab. Es befindet sich jetzt in einem öffentlichen Cloud Storage-Bucket. Weitere Informationen zum Zugriff auf das Dataset finden Sie später in diesem Codelab. Unser Ziel ist es, die Gesamtbewertung eines Spielers anhand verschiedener Aktionen im Spiel wie Abfangen und Strafen vorherzusagen.
Warum ist Vertex AI Experiments für Data Science nützlich?
Data Science ist von Natur aus experimentell. Die Experten werden schließlich nicht kostenlos als Wissenschaftler bezeichnet. Gute Data Scientists sind hypothesengesteuert und verwenden Trial-and-Error, um verschiedene Hypothesen zu testen. Sie hoffen, dass aufeinanderfolgende Iterationen zu einem leistungsfähigeren Modell führen.
Data Science-Teams nutzen zwar Tests, haben aber oft Schwierigkeiten, ihre Arbeit und die „Geheimzutat“ zu verfolgen, die sie durch ihre Tests entdeckt haben. Das hat mehrere Gründe:
- Das Verfolgen von Trainingsjobs kann umständlich sein, sodass es leicht passieren kann, dass man den Überblick verliert, was funktioniert und was nicht.
- Dieses Problem wird noch verstärkt, wenn man sich ein Data Science-Team ansieht, da nicht alle Mitglieder Tests verfolgen oder ihre Ergebnisse mit anderen teilen.
- Die Datenerfassung ist zeitaufwendig und die meisten Teams verwenden manuelle Methoden (z. B. Tabellen oder Dokumente), die zu inkonsistenten und unvollständigen Informationen führen, aus denen man lernen kann.
Kurz gesagt:Vertex AI Experiments erledigt die Arbeit für Sie und hilft Ihnen, Ihre Tests einfacher zu verfolgen und zu vergleichen.
Warum Vertex AI Experiments für Spiele?
Spiele waren schon immer ein Spielplatz für maschinelles Lernen und ML-Tests. Spiele generieren nicht nur Milliarden von Echtzeitereignissen pro Tag, sondern nutzen diese Daten auch, indem sie ML und ML-Tests verwenden, um das Spielerlebnis zu verbessern, Spieler zu binden und die verschiedenen Spieler auf ihrer Plattform zu bewerten. Daher haben wir uns für ein Gaming-Dataset für unsere allgemeine Testübung entschieden.
4. Umgebung einrichten
Für dieses Codelab benötigen Sie ein Google Cloud Platform-Projekt mit aktivierter Abrechnung. Eine Anleitung zum Erstellen eines Projekts finden Sie hier.
Schritt 1: Compute Engine API aktivieren
Rufen Sie Compute Engine auf und wählen Sie Aktivieren aus, falls die API noch nicht aktiviert ist.
Schritt 2: Vertex AI API aktivieren
Rufen Sie den Bereich „Vertex AI“ in der Cloud Console auf und klicken Sie auf **Vertex AI API aktivieren**.
Schritt 3: Vertex AI Workbench-Instanz erstellen
Klicken Sie im Bereich „Vertex AI“ der Cloud Console auf „Workbench“:
Aktivieren Sie die Notebooks API, falls sie noch nicht aktiviert ist.
Klicken Sie nach der Aktivierung auf VERWALTETE NOTEBOOKS:
Wählen Sie dann NEUES NOTEBOOK aus.
Geben Sie Ihrem Notebook einen Namen und klicken Sie dann auf Erweiterte Einstellungen.
Aktivieren Sie unter „Erweiterte Einstellungen“ das Herunterfahren bei Inaktivität und legen Sie die Anzahl der Minuten auf 60 fest. Das bedeutet, dass Ihr Notebook bei Nichtnutzung automatisch heruntergefahren wird, damit keine unnötigen Kosten entstehen.
Schritt 4: Notebook öffnen
Nachdem die Instanz erstellt wurde, klicken Sie auf JupyterLab öffnen.
Schritt 5: Authentifizieren (nur beim ersten Mal)
Wenn Sie eine neue Instanz zum ersten Mal verwenden, werden Sie aufgefordert, sich zu authentifizieren. Folgen Sie dazu der Anleitung auf der Benutzeroberfläche.
Schritt 6: Geeigneten Kernel auswählen
Verwaltete Notebooks bieten mehrere Kernel in einer einzigen Benutzeroberfläche. Wählen Sie den Kernel für TensorFlow 2 (lokal) aus.
5. Ersteinrichtung im Notebook
Sie müssen eine Reihe zusätzlicher Schritte ausführen, um Ihre Umgebung in Ihrem Notebook einzurichten, bevor Sie Ihre Pipeline erstellen. Dazu gehören das Installieren zusätzlicher Pakete, das Festlegen von Variablen, das Erstellen Ihres Cloud Storage-Buckets, das Kopieren des Gaming-Datasets aus einem öffentlichen Storage-Bucket sowie das Importieren von Bibliotheken und das Definieren zusätzlicher Konstanten.
Schritt 1: Zusätzliche Pakete installieren
Wir müssen zusätzliche Paketabhängigkeiten installieren, die derzeit nicht in Ihrer Notebookumgebung installiert sind. Ein Beispiel ist das KFP SDK.
!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts
Starten Sie dann den Notebook-Kernel neu, damit Sie die heruntergeladenen Pakete in Ihrem Notebook verwenden können.
# Automatically restart kernel after installs
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Schritt 2: Variablen festlegen
Wir möchten unsere PROJECT_ID definieren. Wenn Sie Ihre Project_ID nicht kennen, können Sie sie möglicherweise mit gcloud abrufen.PROJECT_ID
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 hier Ihre PROJECT_ID fest.
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
Wir legen auch die Variable REGION fest, die im restlichen Notebook verwendet wird. Unten sind die für Vertex AI unterstützten Regionen aufgeführt. Wir empfehlen, die Region auszuwählen, die Ihnen am nächsten ist.
- Amerika: us-central1
- Europa: europe-west4
- Asien-Pazifik: asia-east1
Verwenden Sie für das Training mit Vertex AI keinen multi-regionalen Bucket. Nicht alle Regionen bieten Unterstützung für alle Vertex-AI-Dienste. Weitere Informationen zu Vertex-AI-Regionen.
#set your region
REGION = "us-central1" # @param {type: "string"}
Zum Schluss legen wir eine Variable TIMESTAMP fest. Diese Variable wird verwendet, um Namenskonflikte zwischen Nutzern bei erstellten Ressourcen zu vermeiden. Erstellen Sie einen TIMESTAMP für jede Instanzsitzung und fügen Sie ihn an den Namen der Ressourcen an, die Sie in dieser Anleitung erstellen.
#set timestamp to avoid collisions between multiple users
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Schritt 3: Cloud Storage-Bucket erstellen
Sie müssen einen Cloud Storage-Staging-Bucket angeben und verwenden. Im Staging-Bucket werden alle Daten im Zusammenhang mit Ihren Dataset- und Modellressourcen sitzungsübergreifend aufbewahrt.
Legen Sie unten den Namen des Cloud Storage-Buckets fest. Bucket-Namen dürfen in allen Google Cloud-Projekten nur einmal vorkommen, einschließlich der Projekte außerhalb Ihrer Organisation.
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
Wenn Ihr Bucket noch nicht vorhanden ist, können Sie die folgende Zelle ausführen, um Ihren Cloud Storage-Bucket zu erstellen.
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
Anschließend können Sie den Zugriff auf Ihren Cloud Storage-Bucket überprüfen, indem Sie die folgende Zelle ausführen.
#verify access
! gsutil ls -al $BUCKET_URI
Schritt 4: Gaming-Dataset kopieren
Wie bereits erwähnt, verwenden Sie ein beliebtes Gaming-Dataset aus dem Hit-Videospiel FIFA von EA Sports. Wir haben die Vorverarbeitung für Sie erledigt. Sie müssen das Dataset nur aus dem öffentlichen Storage-Bucket kopieren und in den von Ihnen erstellten Bucket verschieben.
# copy the data over to your cloud storage bucket
DATASET_URI = "gs://cloud-samples-data/vertex-ai/structured_data/player_data"
!gsutil cp -r $DATASET_URI $BUCKET_URI
Schritt 5: Bibliotheken importieren und zusätzliche Konstanten definieren
Als Nächstes importieren wir unsere Bibliotheken für Vertex AI, KFP usw.
import logging
import os
import time
logger = logging.getLogger("logger")
logging.basicConfig(level=logging.INFO)
import kfp.v2.compiler as compiler
# Pipeline Experiments
import kfp.v2.dsl as dsl
# Vertex AI
from google.cloud import aiplatform as vertex_ai
from kfp.v2.dsl import Artifact, Input, Metrics, Model, Output, component
from typing import NamedTuple
Wir definieren auch zusätzliche Konstanten, auf die wir im restlichen Notebook zurückgreifen, z. B. die Dateipfade zu unseren Trainingsdaten.
#import libraries and define constants
# Experiments
TASK = "regression"
MODEL_TYPE = "tensorflow"
EXPERIMENT_NAME = f"{PROJECT_ID}-{TASK}-{MODEL_TYPE}-{TIMESTAMP}"
# Pipeline
PIPELINE_URI = f"{BUCKET_URI}/pipelines"
TRAIN_URI = f"{BUCKET_URI}/player_data/data.csv"
LABEL_URI = f"{BUCKET_URI}/player_data/labels.csv"
MODEL_URI = f"{BUCKET_URI}/model"
DISPLAY_NAME = "experiments-demo-gaming-data"
BQ_DATASET = "player_data"
BQ_LOCATION = "US"
VIEW_NAME = 'dataset_test'
PIPELINE_JSON_PKG_PATH = "experiments_demo_gaming_data.json"
PIPELINE_ROOT = f"gs://{BUCKET_URI}/pipeline_root"
6. Pipeline erstellen
Jetzt kann es losgehen und wir können Vertex AI verwenden, um unsere Trainingspipeline zu erstellen. Wir initialisieren das Vertex AI SDK, richten unseren Trainingsjob als Pipelinekomponente ein, erstellen unsere Pipeline, senden unsere Pipelineausführungen und verwenden das Vertex AI SDK, um Tests anzusehen und ihren Status zu überwachen.
Schritt 1: Vertex AI SDK initialisieren
Initialisieren Sie das Vertex AI SDK und legen Sie Ihre PROJECT_ID und BUCKET_URI fest.
#initialize vertex AI SDK
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)
Schritt 2: Trainingsjob als Pipelinekomponente einrichten
Um mit der Ausführung unserer Tests zu beginnen, müssen wir unseren Trainingsjob angeben, indem wir ihn als Pipelinekomponente definieren. Unsere Pipeline verwendet Trainingsdaten und Hyperparameter (z.B. DROPOUT_RATE, LEARNING_RATE, EPOCHS) als Eingaben und gibt Modellmesswerte (z.B. MAE und RMSE) und ein Modellartefakt aus.
@component(
packages_to_install=[
"numpy==1.21.0",
"pandas==1.3.5",
"scikit-learn==1.0.2",
"tensorflow==2.9.0",
]
)
def custom_trainer(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
metrics: Output[Metrics],
model_metadata: Output[Model],
):
# import libraries
import logging
import uuid
from pathlib import Path as path
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout
from tensorflow.keras.metrics import Metric
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error
import numpy as np
from math import sqrt
import os
import tempfile
# set variables and use gcsfuse to update prefixes
gs_prefix = "gs://"
gcsfuse_prefix = "/gcs/"
train_path = train_uri.replace(gs_prefix, gcsfuse_prefix)
label_path = label_uri.replace(gs_prefix, gcsfuse_prefix)
model_path = model_uri.replace(gs_prefix, gcsfuse_prefix)
def get_logger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
logger.addHandler(handler)
return logger
def get_data(
train_path: str,
label_path: str
) -> (pd.DataFrame):
#load data into pandas dataframe
data_0 = pd.read_csv(train_path)
labels_0 = pd.read_csv(label_path)
#drop unnecessary leading columns
data = data_0.drop('Unnamed: 0', axis=1)
labels = labels_0.drop('Unnamed: 0', axis=1)
#save as numpy array for reshaping of data
labels = labels.values
data = data.values
# Split the data
labels = labels.reshape((labels.size,))
train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size=0.2, shuffle=True, random_state=7)
#Convert data back to pandas dataframe for scaling
train_data = pd.DataFrame(train_data)
test_data = pd.DataFrame(test_data)
train_labels = pd.DataFrame(train_labels)
test_labels = pd.DataFrame(test_labels)
#Scale and normalize the training dataset
scaler = StandardScaler()
scaler.fit(train_data)
train_data = pd.DataFrame(scaler.transform(train_data), index=train_data.index, columns=train_data.columns)
test_data = pd.DataFrame(scaler.transform(test_data), index=test_data.index, columns=test_data.columns)
return train_data,train_labels, test_data, test_labels
""" Train your Keras model passing in the training data and values for learning rate, dropout rate,and the number of epochs """
def train_model(
learning_rate: float,
dropout_rate: float,
epochs: float,
train_data: pd.DataFrame,
train_labels: pd.DataFrame):
# Train tensorflow model
param = {"learning_rate": learning_rate, "dropout_rate": dropout_rate, "epochs": epochs}
model = Sequential()
model.add(Dense(500, input_dim=train_data.shape[1], activation= "relu"))
model.add(Dropout(param['dropout_rate']))
model.add(Dense(100, activation= "relu"))
model.add(Dense(50, activation= "relu"))
model.add(Dense(1))
model.compile(
tf.keras.optimizers.Adam(learning_rate= param['learning_rate']),
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.MeanAbsoluteError()])
model.fit(train_data, train_labels, epochs= param['epochs'])
return model
# Get Predictions
def get_predictions(model, test_data):
dtest = pd.DataFrame(test_data)
pred = model.predict(dtest)
return pred
# Evaluate predictions with MAE
def evaluate_model_mae(pred, test_labels):
mae = mean_absolute_error(test_labels, pred)
return mae
# Evaluate predictions with RMSE
def evaluate_model_rmse(pred, test_labels):
rmse = np.sqrt(np.mean((test_labels - pred)**2))
return rmse
#Save your trained model in GCS
def save_model(model, model_path):
model_id = str(uuid.uuid1())
model_path = f"{model_path}/{model_id}"
path(model_path).parent.mkdir(parents=True, exist_ok=True)
model.save(model_path + '/model_tensorflow')
# Main ----------------------------------------------
train_data, train_labels, test_data, test_labels = get_data(train_path, label_path)
model = train_model(learning_rate, dropout_rate, epochs, train_data,train_labels )
pred = get_predictions(model, test_data)
mae = evaluate_model_mae(pred, test_labels)
rmse = evaluate_model_rmse(pred, test_labels)
save_model(model, model_path)
# Metadata ------------------------------------------
#convert numpy array to pandas series
mae = pd.Series(mae)
rmse = pd.Series(rmse)
#log metrics and model artifacts with ML Metadata. Save metrics as a list.
metrics.log_metric("mae", mae.to_list())
metrics.log_metric("rmse", rmse.to_list())
model_metadata.uri = model_uri
Schritt 3: Pipeline erstellen
Jetzt richten wir unseren Workflow mit der Domain Specific Language (DSL) ein, die in KFP verfügbar ist, und kompilieren unsere Pipeline in eine JSON-Datei.
# define our workflow
@dsl.pipeline(name="gaming-custom-training-pipeline")
def pipeline(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
):
custom_trainer(
train_uri,label_uri, dropout_rate,learning_rate,epochs, model_uri
)
#compile our pipeline
compiler.Compiler().compile(pipeline_func=pipeline, package_path="gaming_pipeline.json")
Schritt 4: Pipelineausführungen senden
Die Einrichtung unserer Komponente und die Definition unserer Pipeline sind abgeschlossen. Wir können jetzt verschiedene Ausführungen der oben angegebenen Pipeline senden. Dazu müssen wir die Werte für unsere verschiedenen Hyperparameter wie folgt definieren:
runs = [
{"dropout_rate": 0.001, "learning_rate": 0.001,"epochs": 20},
{"dropout_rate": 0.002, "learning_rate": 0.002,"epochs": 25},
{"dropout_rate": 0.003, "learning_rate": 0.003,"epochs": 30},
{"dropout_rate": 0.004, "learning_rate": 0.004,"epochs": 35},
{"dropout_rate": 0.005, "learning_rate": 0.005,"epochs": 40},
]
Nachdem die Hyperparameter definiert wurden, können wir eine for loop verwenden, um die verschiedenen Ausführungen der Pipeline zu übergeben:
for i, run in enumerate(runs):
job = vertex_ai.PipelineJob(
display_name=f"{EXPERIMENT_NAME}-pipeline-run-{i}",
template_path="gaming_pipeline.json",
pipeline_root=PIPELINE_URI,
parameter_values={
"train_uri": TRAIN_URI,
"label_uri": LABEL_URI,
"model_uri": MODEL_URI,
**run,
},
)
job.submit(experiment=EXPERIMENT_NAME)
Schritt 5: Vertex AI SDK verwenden, um Tests anzusehen
Mit dem Vertex AI SDK können Sie den Status von Pipelineausführungen überwachen. Sie können damit auch Parameter und Messwerte der Pipelineausführungen im Vertex AI-Test zurückgeben. Verwenden Sie den folgenden Code, um die Parameter für Ihre Ausführungen und den aktuellen Status zu sehen.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
Mit dem folgenden Code können Sie Updates zum Status Ihrer Pipelineausführungen erhalten.
#check on current status
while True:
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
if all(
pipeline_state != "COMPLETE" for pipeline_state in pipeline_experiments_df.state
):
print("Pipeline runs are still running...")
if any(
pipeline_state == "FAILED"
for pipeline_state in pipeline_experiments_df.state
):
print("At least one Pipeline run failed")
break
else:
print("Pipeline experiment runs have completed")
break
time.sleep(60)
Sie können auch bestimmte Pipelinejobs mit dem run_name aufrufen.
# Call the pipeline runs based on the experiment run name
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
job = vertex_ai.PipelineJob.get(pipeline_experiments_df.run_name[0])
print(job.resource_name)
print(job._dashboard_uri())
Schließlich können Sie den Status Ihrer Ausführungen in festgelegten Intervallen (z. B. alle 60 Sekunden) aktualisieren, um zu sehen, wie sich der Status von RUNNING zu FAILED oder COMPLETE ändert.
# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
7. Leistungsstärkste Ausführung ermitteln
Wir haben jetzt die Ergebnisse unserer Pipelineausführungen. Sie fragen sich vielleicht, was Sie aus den Ergebnissen lernen können. Die Ausgabe Ihrer Tests sollte fünf Zeilen enthalten, eine für jede Ausführung der Pipeline. Sie sieht in etwa so aus:
Sowohl MAE als auch RMSE sind Maße für den durchschnittlichen Vorhersagefehler des Modells. Ein niedrigerer Wert für beide Messwerte ist in den meisten Fällen wünschenswert. Anhand der Ausgabe von Vertex AI Experiments können wir sehen, dass unsere erfolgreichste Ausführung in Bezug auf beide Messwerte die letzte Ausführung mit einer dropout_rate von 0,001, einer learning_rate von 0,001 und einer Gesamtzahl von epochs von 20 war. Basierend auf diesem Test werden diese Modellparameter letztendlich in der Produktion verwendet, da sie die beste Modellleistung erzielen.
Damit haben Sie das Lab abgeschlossen.
🎉 Das wars! 🎉
Sie haben gelernt, wie Sie Vertex AI für Folgendes verwenden:
- Benutzerdefiniertes Keras-Modell trainieren, um Spielerbewertungen vorherzusagen (z.B. Regression)
- Mit dem Kubeflow Pipelines SDK skalierbare ML-Pipelines erstellen
- Eine Pipeline mit fünf Schritten erstellen und ausführen, die Daten aus GCS aufnimmt, die Daten skaliert, das Modell trainiert, es auswertet und das resultierende Modell wieder in GCS speichert
- Vertex ML Metadata verwenden, um Modellartefakte wie Modelle und Modellmesswerte zu speichern
- Vertex AI Experiments verwenden, um die Ergebnisse der verschiedenen Pipelineausführungen zu vergleichen
Weitere Informationen zu den verschiedenen Bereichen von Vertex finden Sie in der Dokumentation.
8. Bereinigen
Damit Ihnen keine Kosten in Rechnung gestellt werden, sollten Sie die in diesem Lab erstellten Ressourcen löschen.
Schritt 1: Notebookinstanz beenden oder löschen
Wenn Sie das in diesem Lab erstellte Notebook weiterhin verwenden möchten, sollten Sie es bei Nichtnutzung deaktivieren. Wählen Sie in der Notebook-Benutzeroberfläche in der Cloud Console das Notebook aus und klicken Sie dann auf Beenden. Wenn Sie die Instanz vollständig löschen möchten, wählen Sie Löschen aus:
Schritt 2: Cloud Storage-Bucket löschen
Wenn Sie den Storage-Bucket löschen möchten, rufen Sie im Navigationsmenü der Cloud Console „Storage“ auf, wählen Sie Ihren Bucket aus und klicken Sie auf „Löschen“:
