1. Übersicht
In diesem Lab erstellen Sie mit Vertex AI eine Pipeline, die ein benutzerdefiniertes Keras-Modell in TensorFlow trainiert. Anschließend verwenden wir die neuen Funktionen in Vertex AI Experiments, um Modellläufe zu verfolgen und zu vergleichen, um zu ermitteln, welche Kombination von Hyperparametern 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 fünfstufige Pipeline erstellen und ausführen, die Daten aus Cloud Storage aufnimmt, skaliert, das Modell trainiert, bewertet und das resultierende Modell wieder in Cloud Storage speichert
- Vertex ML-Metadaten zum Speichern von Modellartefakten wie Modellen und Modellmesswerten verwenden
- Mit Vertex AI Experiments die Ergebnisse der verschiedenen Pipelineausführungen vergleichen
Die Gesamtkosten für das Lab in Google Cloud belaufen sich auf 1$.
2. Einführung in Vertex AI
In diesem Lab wird das neueste KI-Angebot von Google Cloud verwendet. Vertex AI integriert die ML-Angebote in Google Cloud für eine nahtlose Entwicklung. Bisher konnten auf mit AutoML trainierte Modelle und benutzerdefinierte Modelle über separate Dienste zugegriffen werden. Das neue Angebot kombiniert beide zusammen mit anderen neuen Produkten in 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 liegt der Schwerpunkt auf den unten aufgeführten Produkten: Tests, Pipelines, ML-Metadaten und Workbench.
3. Anwendungsfall – Übersicht
Wir verwenden ein beliebtes Fußball-Dataset aus der FIFA-Videospielreihe von EA Sports. Es umfasst über 25.000 Fußballspiele und mehr als 10.000 Spieler aus den Spielzeiten 2008–2016. Die Daten wurden vorab verarbeitet, damit Sie direkt loslegen können. Sie verwenden dieses Dataset im gesamten Lab, das sich jetzt in einem öffentlichen Cloud Storage-Bucket befindet. Wir werden später im Codelab weitere Informationen zum Zugriff auf das Dataset geben. Unser Endziel besteht darin, die Gesamtbewertung eines Spielers anhand verschiedener Spielaktionen wie Interceptions und Strafen vorherzusagen.
Warum ist Vertex AI Experiments für Data Science nützlich?
Data Science ist experimentell – schließlich werden die Experten auch als Wissenschaftler bezeichnet. Gute Data Scientists arbeiten hypothesengetrieben und testen verschiedene Hypothesen mit der Methode „Trial and Error“ in der Hoffnung, dass aufeinanderfolgende Iterationen zu einem leistungsfähigeren Modell führen.
Data Science-Teams haben zwar Tests eingeführt, haben aber oft Schwierigkeiten, den Überblick über ihre Arbeit und die „Geheimzutat“ zu behalten, die sie durch ihre Testbemühungen entdeckt haben. Das kann verschiedene Gründe haben:
- Die Nachverfolgung von Trainingsjobs kann umständlich werden, da Sie leicht aus den Augen verlieren, was funktioniert und was nicht
- Dieses Problem wird noch verschärft, wenn Sie sich ein Data-Science-Team ansehen, da nicht alle Mitglieder möglicherweise Tests verfolgen oder ihre Ergebnisse mit anderen teilen.
- Die Datenerfassung ist zeitaufwendig und die meisten Teams nutzen manuelle Methoden (z. B. Tabellen oder Dokumente), die zu inkonsistenten und unvollständigen Informationen führen, aus denen man lernen kann.
Zusammenfassung:Vertex AI Experiments übernimmt die Arbeit für Sie und hilft Ihnen, Ihre Tests einfacher zu verfolgen und zu vergleichen.
Warum Vertex AI Experiments für Gaming?
Gaming war schon immer ein Testfeld für maschinelles Lernen und ML-Experimente. In Spielen werden nicht nur Milliarden von Ereignissen in Echtzeit pro Tag generiert, sondern auch alle diese Daten genutzt. Mithilfe von ML und ML-Tests werden die In-Game-Funktionen verbessert, Spieler gebunden und die verschiedenen Spieler auf der Plattform bewertet. Daher haben wir uns für einen Gaming-Datensatz entschieden, der gut zu unserer Testübung passt.
4. 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.
Schritt 1: Compute Engine API aktivieren
Rufen Sie Compute Engine auf und wählen Sie Aktivieren aus, falls die Option noch nicht aktiviert ist.
Schritt 2: Vertex AI API aktivieren
Rufen Sie den Bereich „Vertex AI“ 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 einen Namen für das Notebook ein 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 Notebook wird also automatisch heruntergefahren, wenn es nicht verwendet wird, sodass keine unnötigen Kosten entstehen.
Schritt 4: Notizbuch öffnen
Wählen Sie nach dem Erstellen der Instanz JupyterLab öffnen aus.
Schritt 5: Authentifizieren (nur beim ersten Mal)
Wenn Sie zum ersten Mal eine neue Instanz verwenden, werden Sie zur Authentifizierung aufgefordert. Folgen Sie dazu der Anleitung auf der Benutzeroberfläche.
Schritt 6: Entsprechenden Kernel auswählen
Verwaltete Notebooks bieten mehrere Kernel in einer einzigen UI. Wählen Sie den Kernel für Tensorflow 2 (lokal) aus.
5. Erste Einrichtungsschritte in Ihrem Notizbuch
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 eines Cloud Storage-Buckets, das Kopieren des Gaming-Datasets aus einem öffentlichen Speicher-Bucket, 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
Anschließend müssen Sie den Notebook-Kernel neu starten, 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 möchten auch die Variable REGION festlegen, die für den Rest dieses Notebooks verwendet wird. Im Folgenden finden Sie die Regionen, die für Vertex AI unterstützt werden. Wir empfehlen, die Region auszuwählen, die Ihnen am nächsten ist.
- Amerika: us-central1
- Europa: europe-west4
- Asien-Pazifik: asia-east1
Verwenden Sie keinen Multi-Regional Storage-Bucket für das Training mit Vertex AI. 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 TIMESTAMP-Variable fest. Mit dieser Variablen werden Namenskonflikte zwischen Nutzern bei erstellten Ressourcen vermieden. Sie erstellen eine TIMESTAMP für jede Instanzsitzung und hängen sie 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 gespeichert, die mit Ihrem Dataset und Ihren Modellressourcen verknüpft sind.
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
Sie können dann den Zugriff auf Ihren Cloud Storage-Bucket prü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 einen beliebten Gaming-Datensatz aus dem erfolgreichen Videospiel FIFA von EA Sports. Wir haben die Vorverarbeitung für Sie durchgeführt. Sie müssen also nur das Dataset aus dem öffentlichen Speicher-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
Außerdem definieren wir zusätzliche Konstanten, auf die wir uns im Rest des Notebooks beziehen, 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 können wir mit Vertex AI unsere Trainingspipeline erstellen. Wir initialisieren das Vertex AI SDK, richten unseren Trainingsjob als Pipelinekomponente ein, erstellen unsere Pipeline, reichen unsere Pipelineausführungen ein 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 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
Bevor wir unsere Tests ausführen können, müssen wir unseren Trainingsjob als Pipelinekomponente definieren. Unsere Pipeline nimmt Trainingsdaten und Hyperparameter (z.B. DROPOUT_RATE, LEARNING_RATE, EPOCHS) als Eingaben und Modellmesswerte (z.B. MAE und RMSE) und ein Modellartefakt.
@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 Domain Specific Language (DSL) in KFP ein 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ührung(en) einreichen
Die meiste Arbeit ist schon getan, da wir die Komponente eingerichtet und die Pipeline definiert haben. Wir sind bereit, verschiedene Ausführungen der oben beschriebenen Pipeline einzureichen. Dazu müssen wir die Werte für unsere verschiedenen Hyperparameter so 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 mithilfe einer for loop die verschiedenen Ausführungen der Pipeline erfolgreich einspeisen:
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: Tests mit dem Vertex AI SDK ansehen
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-Experiment zurückgeben. Mit dem folgenden Code können Sie die Parameter und den aktuellen Status Ihrer Ausführungen sehen.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
Mit dem folgenden Code können Sie sich über den Status Ihrer Pipelineausführungen informieren.
#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 der 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())
Außerdem können Sie den Status Ihrer Läufe in festgelegten Intervallen (z. B. alle 60 Sekunden) aktualisieren, um zu sehen, ob er sich von RUNNING in 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
Super, 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 Modellvorhersagefehler. Daher ist in den meisten Fällen ein niedrigerer Wert für beide Messwerte wünschenswert. Anhand der Ausgabe von Vertex AI Experiments sehen wir, dass der letzte Durchlauf mit einem dropout_rate von 0,001, einem learning_rate von 0,001 und einer Gesamtzahl von epochs = 20 der erfolgreichste war. Auf Grundlage dieses Tests würden diese Modellparameter letztendlich in der Produktion verwendet, da sie die beste Modellleistung erzielen.
Damit ist das Lab abgeschlossen.
🎉 Glückwunsch! 🎉
Sie haben gelernt, wie Sie Vertex AI für Folgendes verwenden:
- Trainieren Sie ein benutzerdefiniertes Keras-Modell, um Spielerbewertungen vorherzusagen (z.B. Regression)
- Mit dem Kubeflow Pipelines SDK skalierbare ML-Pipelines erstellen
- Eine aus fünf Schritten bestehende Pipeline erstellen und ausführen, die Daten aus GCS aufnimmt, die Daten skaliert, das Modell trainiert, auswertet und das resultierende Modell wieder in GCS speichert
- Vertex ML-Metadaten verwenden, um Modellartefakte wie Modelle und Modellmesswerte zu speichern
- Mit Vertex AI Experiments die Ergebnisse der verschiedenen Pipelineausführungen vergleichen
Weitere Informationen zu den verschiedenen Bereichen von Vertex finden Sie in der Dokumentation.
8. Bereinigen
Damit Ihnen keine Kosten entstehen, sollten Sie die in diesem Lab erstellten Ressourcen löschen.
Schritt 1: 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:
Schritt 2: Cloud Storage-Bucket löschen
Wenn Sie den Speicher-Bucket löschen möchten, klicken Sie in der Cloud Console im Navigationsmenü auf „Speicher“, wählen Sie den Bucket aus und klicken Sie auf „Löschen“:
