1. סקירה כללית
בשיעור ה-Lab הזה תשתמשו ב-Vertex AI כדי להריץ משימת אימון מבוזרת ב-Vertex AI Training באמצעות TensorFlow.
שיעור ה-Lab הזה הוא חלק מסדרת הסרטונים Prototype to Production. חשוב להשלים את המעבדות הקודמות לפני שמנסים את המעבדה הזו. כדאי לצפות בסדרת הסרטונים הנלווית כדי לקבל מידע נוסף:
.
מה לומדים
במאמר הזה נסביר איך:
- הרצת אימון מבוזר במכונה אחת עם כמה GPU
- הרצת אימון מבוזר בכמה מכונות
העלות הכוללת של הרצת ה-Lab הזה ב-Google Cloud היא בערך 2$.
2. מבוא ל-Vertex AI
בשיעור ה-Lab הזה נעשה שימוש במוצר ה-AI החדש ביותר שזמין ב-Google Cloud. Vertex AI משלב את מוצרי ה-ML ב-Google Cloud לחוויית פיתוח חלקה. בעבר, היה אפשר לגשת למודלים שאומנו באמצעות AutoML ולמודלים בהתאמה אישית דרך שירותים נפרדים. המוצר החדש משלב את שניהם ב-API אחד, יחד עם מוצרים חדשים אחרים. אפשר גם להעביר פרויקטים קיימים אל Vertex AI.
Vertex AI כולל מוצרים רבים ושונים לתמיכה בתהליכי עבודה של למידת מכונה מקצה לקצה. בשיעור ה-Lab הזה נתמקד במוצרים שמודגשים בהמשך: Training ו-Workbench
3. סקירה כללית על אימון מבוזר
אם יש לכם GPU אחד, TensorFlow ישתמש במאיץ הזה כדי להאיץ את אימון המודל בלי שתצטרכו לעשות שום דבר נוסף. עם זאת, אם רוצים לקבל דחיפה נוספת מהשימוש בכמה יחידות GPU, צריך להשתמש ב-tf.distribute, שהוא המודול של TensorFlow להפעלת חישוב בכמה מכשירים.
בחלק הראשון של ה-Lab הזה נעשה שימוש ב-tf.distribute.MirroredStrategy, שאפשר להוסיף לאפליקציות האימון שלכם בכמה שינויים קלים בקוד. בגישה הזו נוצר עותק של המודל בכל GPU במחשב. העדכונים הבאים של הגרדיאנט יתבצעו באופן סינכרוני. כלומר, כל GPU מחשב את המעברים קדימה ואחורה במודל על פרוסה שונה של נתוני הקלט. הגרדיאנטים המחושבים מכל אחד מהפלחים האלה מצטברים בכל יחידות ה-GPU ומחושב להם ממוצע בתהליך שנקרא all-reduce. פרמטרים של המודל מתעדכנים באמצעות הגרדיאנטים הממוצעים האלה.
בחלק האופציונלי בסוף ה-Lab נעשה שימוש ב-tf.distribute.MultiWorkerMirroredStrategy, שדומה ל-MirroredStrategy אבל פועל בכמה מכונות. יכול להיות שלכל אחד מהמחשבים האלה יש כמה יחידות GPU. לדוגמה, MirroredStrategy היא שיטת מקביליות נתונים סינכרונית שאפשר להשתמש בה עם כמה שינויים קלים בקוד.MultiWorkerMirroredStrategy ההבדל העיקרי בין מקביליות נתונים סינכרונית במכונה אחת לבין מקביליות נתונים סינכרונית במכונות רבות הוא שבסוף כל שלב צריך לסנכרן את הגרדיאנטים בין כל המעבדים הגרפיים במכונה ובין כל המכונות באשכול.
לא צריך להכיר את הפרטים כדי להשלים את שיעור ה-Lab הזה, אבל אם אתם רוצים ללמוד עוד על האופן שבו אימון מבוזר פועל ב-TensorFlow, אתם יכולים לצפות בסרטון הבא:
4. הגדרת הסביבה
כדי להגדיר את הסביבה, צריך לבצע את השלבים בשיעור ה-Lab בנושא אימון מודלים בהתאמה אישית באמצעות Vertex AI.
5. אימון במכונה אחת עם כמה GPU
כדי לשלוח את משימת האימון המבוזרת ל-Vertex AI, צריך להכניס את קוד אפליקציית האימון לקונטיינר Docker ולדחוף את הקונטיינר הזה ל-Google Artifact Registry. באמצעות הגישה הזו, אפשר לאמן מודל שנבנה עם כל מסגרת.
כדי להתחיל, בתפריט Launcher של מחברת Workbench שיצרתם במעבדות הקודמות, פותחים חלון טרמינל.
שלב 1: כותבים קוד לאימון
יוצרים ספרייה חדשה בשם flowers-multi-gpu ועוברים אליה באמצעות הפקודה cd:
mkdir flowers-multi-gpu
cd flowers-multi-gpu
מריצים את הפקודה הבאה כדי ליצור ספרייה לקוד ההדרכה וקובץ Python שבו מוסיפים את הקוד שבהמשך.
mkdir trainer
touch trainer/task.py
עכשיו אמורים להיות לכם הקבצים הבאים בספרייה flowers-multi-gpu/:
+ trainer/
+ task.py
לאחר מכן, פותחים את הקובץ task.py שיצרתם ומעתיקים את הקוד שבהמשך.
תצטרכו להחליף את {your-gcs-bucket} ב-BUCKET_ROOT בקטגוריה של Cloud Storage שבה שמרתם את קבוצת הנתונים של הפרחים במעבדה 1.
import tensorflow as tf
import numpy as np
import os
## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'
# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32
IMG_HEIGHT = 180
IMG_WIDTH = 180
DATA_DIR = f'{BUCKET_ROOT}/flower_photos'
def create_datasets(data_dir, batch_size):
'''Creates train and validation datasets.'''
train_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
validation_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)
return train_dataset, validation_dataset
def create_model():
'''Creates model.'''
model = tf.keras.Sequential([
tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
])
return model
def main():
# Create distribution strategy
strategy = tf.distribute.MirroredStrategy()
# Get data
GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
# Wrap model creation and compilation within scope of strategy
with strategy.scope():
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
history = model.fit(
train_dataset,
validation_data=validation_dataset,
epochs=EPOCHS
)
model.save(f'{BUCKET_ROOT}/model_output')
if __name__ == "__main__":
main()
לפני שיוצרים את הקונטיינר, כדאי לעיין בקוד. יש כמה רכיבים שספציפיים לשימוש באימון מבוזר.
- האובייקט
MirroredStrategyנוצר בפונקציהmain(). בשלב הבא, עוטפים את יצירת משתני המודל בהיקף של שיטת הבידינג. בשלב הזה מגדירים ל-TensorFlow אילו משתנים לשכפל במעבדי ה-GPU. - גודל האצווה גדל פי
num_replicas_in_sync. הגדלת גודל האצווה היא שיטה מומלצת כשמשתמשים בשיטות מקביליות סינכרוניות של נתונים ב-TensorFlow. מידע נוסף זמין כאן.
שלב 2: יצירת Dockerfile
כדי להוסיף את הקוד למאגר, צריך ליצור קובץ Dockerfile. ב-Dockerfile, צריך לכלול את כל הפקודות שנדרשות להרצת האימג'. הסקריפט יתקין את כל הספריות הנדרשות ויגדיר את נקודת הכניסה לקוד האימון.
בטרמינל, יוצרים קובץ Dockerfile ריק בספריית הבסיס של הספרייה flowers:
touch Dockerfile
עכשיו אמורים להיות לכם הקבצים הבאים בספרייה flowers-multi-gpu/:
+ Dockerfile
+ trainer/
+ task.py
פותחים את Dockerfile ומעתיקים לתוכו את הקוד הבא:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]
שלב 3: בניית מאגר התגים
במסוף, מריצים את הפקודה הבאה כדי להגדיר משתנה סביבה לפרויקט. חשוב להחליף את your-cloud-project במזהה הפרויקט:
PROJECT_ID='your-cloud-project'
יוצרים מאגר ב-Artifact Registry. נשתמש במאגר שיצרנו במעבדה הראשונה.
REPO_NAME='flower-app'
מגדירים משתנה עם ה-URI של קובץ אימג' של קונטיינר ב-Artifact Registry:
IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:single_machine
הגדרת Docker
gcloud auth configure-docker \
us-central1-docker.pkg.dev
לאחר מכן, בונים את הקונטיינר על ידי הרצת הפקודה הבאה מתיקיית השורש של flowers-multi-gpu:
docker build ./ -t $IMAGE_URI
לבסוף, מעלים אותו ל-Artifact Registry:
docker push $IMAGE_URI
אחרי שמעבירים את הקונטיינר אל Artifact Registry, אפשר להתחיל את משימת האימון.
שלב 4: מריצים את העבודה באמצעות ה-SDK
בסעיף הזה נסביר איך להגדיר ולהפעיל את משימת האימון המבוזרת באמצעות Vertex AI Python SDK.
במרכז האפליקציות, יוצרים מחברת TensorFlow 2.
מייבאים את Vertex AI SDK.
from google.cloud import aiplatform
לאחר מכן מגדירים CustomContainerTrainingJob.
צריך להחליף את {PROJECT_ID} ב-container_uri ואת {YOUR_BUCKET} ב-staging_bucket.
job = aiplatform.CustomContainerTrainingJob(display_name='flowers-multi-gpu',
container_uri='us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:single_machine',
staging_bucket='gs://{YOUR_BUCKET}')
אחרי שמגדירים את העבודה, אפשר להריץ אותה. תגדירו את מספר המאיצים ל-2. אם נשתמש רק ב-GPU אחד, זה לא ייחשב לאימון מבוזר. אימון מבוזר במכונה אחת הוא מצב שבו משתמשים בשני מאיצים או יותר.
my_custom_job.run(replica_count=1,
machine_type='n1-standard-4',
accelerator_type='NVIDIA_TESLA_V100',
accelerator_count=2)
במסוף תוכלו לראות את התקדמות העבודה.
6. [אופציונלי] אימון של כמה עובדים
אחרי שניסיתם אימון מבוזר במכונה אחת עם כמה מעבדים גרפיים, אתם יכולים לשדרג את כישורי האימון המבוזר שלכם ולבצע אימון בכמה מכונות. כדי להקטין את העלויות, לא נוסיף מעבדי GPU למכונות האלה, אבל אתם יכולים להוסיף מעבדי GPU אם אתם רוצים להתנסות.
פותחים חלון טרמינל חדש במופע של ה-notebook:
שלב 1: כותבים קוד לאימון
יוצרים ספרייה חדשה בשם flowers-multi-machine ועוברים אליה באמצעות הפקודה cd:
mkdir flowers-multi-machine
cd flowers-multi-machine
מריצים את הפקודה הבאה כדי ליצור ספרייה לקוד ההדרכה וקובץ Python שבו מוסיפים את הקוד שבהמשך.
mkdir trainer
touch trainer/task.py
עכשיו אמורים להיות לכם הקבצים הבאים בספרייה flowers-multi-machine/:
+ trainer/
+ task.py
לאחר מכן, פותחים את הקובץ task.py שיצרתם ומעתיקים את הקוד שבהמשך.
תצטרכו להחליף את {your-gcs-bucket} ב-BUCKET_ROOT בקטגוריה של Cloud Storage שבה שמרתם את קבוצת הנתונים של הפרחים במעבדה 1.
import tensorflow as tf
import numpy as np
import os
## Replace {your-gcs-bucket} !!
BUCKET_ROOT='/gcs/{your-gcs-bucket}'
# Define variables
NUM_CLASSES = 5
EPOCHS=10
BATCH_SIZE = 32
IMG_HEIGHT = 180
IMG_WIDTH = 180
DATA_DIR = f'{BUCKET_ROOT}/flower_photos'
SAVE_MODEL_DIR = f'{BUCKET_ROOT}/multi-machine-output'
def create_datasets(data_dir, batch_size):
'''Creates train and validation datasets.'''
train_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
validation_dataset = tf.keras.utils.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=123,
image_size=(IMG_HEIGHT, IMG_WIDTH),
batch_size=batch_size)
train_dataset = train_dataset.cache().shuffle(1000).prefetch(buffer_size=tf.data.AUTOTUNE)
validation_dataset = validation_dataset.cache().prefetch(buffer_size=tf.data.AUTOTUNE)
return train_dataset, validation_dataset
def create_model():
'''Creates model.'''
model = tf.keras.Sequential([
tf.keras.layers.Resizing(IMG_HEIGHT, IMG_WIDTH),
tf.keras.layers.Rescaling(1./255, input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)),
tf.keras.layers.Conv2D(16, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(32, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Conv2D(64, 3, padding='same', activation='relu'),
tf.keras.layers.MaxPooling2D(),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
])
return model
def _is_chief(task_type, task_id):
'''Helper function. Determines if machine is chief.'''
return task_type == 'chief'
def _get_temp_dir(dirpath, task_id):
'''Helper function. Gets temporary directory for saving model.'''
base_dirpath = 'workertemp_' + str(task_id)
temp_dir = os.path.join(dirpath, base_dirpath)
tf.io.gfile.makedirs(temp_dir)
return temp_dir
def write_filepath(filepath, task_type, task_id):
'''Helper function. Gets filepath to save model.'''
dirpath = os.path.dirname(filepath)
base = os.path.basename(filepath)
if not _is_chief(task_type, task_id):
dirpath = _get_temp_dir(dirpath, task_id)
return os.path.join(dirpath, base)
def main():
# Create distribution strategy
strategy = tf.distribute.MultiWorkerMirroredStrategy()
# Get data
GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
# Wrap variable creation within strategy scope
with strategy.scope():
model = create_model()
model.compile(optimizer=tf.keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=['accuracy'])
history = model.fit(
train_dataset,
validation_data=validation_dataset,
epochs=EPOCHS
)
# Determine type and task of the machine from
# the strategy cluster resolver
task_type, task_id = (strategy.cluster_resolver.task_type,
strategy.cluster_resolver.task_id)
# Based on the type and task, write to the desired model path
write_model_path = write_filepath(SAVE_MODEL_DIR, task_type, task_id)
model.save(write_model_path)
if __name__ == "__main__":
main()
לפני שיוצרים את הקונטיינר, כדאי לעיין בקוד. יש כמה רכיבים בקוד שנדרשים כדי שאפליקציית האימון תפעל עם MultiWorkerMirroredStrategy.
- האובייקט
MultiWorkerMirroredStrategyנוצר בפונקציהmain(). בשלב הבא, עוטפים את יצירת משתני המודל בהיקף של שיטת הבידינג. השלב הזה חשוב מאוד כי הוא קובע ב-TensorFlow אילו משתנים יש לשכפל בכל הרפליקות. - גודל האצווה גדל פי
num_replicas_in_sync. הגדלת גודל האצווה היא שיטה מומלצת כשמשתמשים בשיטות מקביליות סינכרוניות של נתונים ב-TensorFlow. - שמירת המודל במקרה של כמה עובדים היא קצת יותר מורכבת, כי היעד צריך להיות שונה לכל אחד מהעובדים. התהליך המרכזי ישמור את המודל בספריית המודלים הרצויה, ותהליכים אחרים ישמרו את המודל בספריות זמניות. חשוב שהספריות הזמניות האלה יהיו ייחודיות כדי למנוע ממספר עובדים לכתוב לאותו מיקום. השמירה יכולה לכלול פעולות משותפות, כלומר כל העובדים צריכים לשמור ולא רק המנהל. הפונקציות
_is_chief(), _get_temp_dir(), write_filepath(), וגם הפונקציהmain()כוללות קוד boilerplate שעוזר לשמור את המודל.
שלב 2: יצירת Dockerfile
כדי להוסיף את הקוד למאגר, צריך ליצור קובץ Dockerfile. ב-Dockerfile, צריך לכלול את כל הפקודות שנדרשות להרצת האימג'. הסקריפט יתקין את כל הספריות הנדרשות ויגדיר את נקודת הכניסה לקוד האימון.
בטרמינל, יוצרים קובץ Dockerfile ריק בספריית הבסיס של הספרייה flowers:
touch Dockerfile
עכשיו אמורים להיות לכם הקבצים הבאים בספרייה flowers-multi-machine/:
+ Dockerfile
+ trainer/
+ task.py
פותחים את Dockerfile ומעתיקים לתוכו את הקוד הבא:
FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-8
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.task"]
שלב 3: בניית מאגר התגים
במסוף, מריצים את הפקודה הבאה כדי להגדיר משתנה סביבה לפרויקט. חשוב להחליף את your-cloud-project במזהה הפרויקט:
PROJECT_ID='your-cloud-project'
יוצרים מאגר ב-Artifact Registry. נשתמש במאגר שיצרנו במעבדה הראשונה.
REPO_NAME='flower-app'
מגדירים משתנה עם ה-URI של קובץ אימג' של קונטיינר ב-Google Artifact Registry:
IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_distributed:multi_machine
הגדרת Docker
gcloud auth configure-docker \
us-central1-docker.pkg.dev
לאחר מכן, בונים את הקונטיינר על ידי הרצת הפקודה הבאה מתיקיית השורש של flowers-multi-machine:
docker build ./ -t $IMAGE_URI
לבסוף, מעלים אותו ל-Artifact Registry:
docker push $IMAGE_URI
אחרי שמעבירים את הקונטיינר אל Artifact Registry, אפשר להתחיל את משימת האימון.
שלב 4: מריצים את העבודה באמצעות ה-SDK
בסעיף הזה נסביר איך להגדיר ולהפעיל את משימת האימון המבוזרת באמצעות Vertex AI Python SDK.
במרכז האפליקציות, יוצרים מחברת TensorFlow 2.
מייבאים את Vertex AI SDK.
from google.cloud import aiplatform
לאחר מכן מגדירים את worker_pool_specs.
Vertex AI מספק 4 מאגרי עובדים כדי לכסות את הסוגים השונים של משימות למידת מכונה.
מאגר העובדים 0 מגדיר את העובד הראשי, העובד הראשי, המתזמן או ה'מאסטר'. ב-MultiWorkerMirroredStrategy, כל המכונות מוגדרות כעובדות, שהן המכונות הפיזיות שבהן מבוצע החישוב המשוכפל. בנוסף לכך שכל מכונה היא worker, צריך להיות worker אחד שמבצע עבודה נוספת, כמו שמירת נקודות ביקורת וכתיבת קובצי סיכום ל-TensorBoard. המכונה הזו נקראת 'הבוס'. תמיד יש רק עובד ראשי אחד, לכן מספר העובדים במאגר העובדים 0 תמיד יהיה 1.
במאגר העובדים 1 מגדירים את העובדים הנוספים עבור האשכול.
המילון הראשון ברשימה worker_pool_specs מייצג את מאגר העובדים 0, והמילון השני מייצג את מאגר העובדים 1. בדוגמה הזו, שתי ההגדרות זהות. עם זאת, אם רוצים לאמן את המודל ב-3 מכונות, צריך להוסיף עוד עובדים למאגר העובדים 1 על ידי הגדרת הערך replica_count ל-2. אם רוצים להוסיף מעבדי GPU, צריך להוסיף את הארגומנטים accelerator_type ו-accelerator_count ל-machine_spec לשני מאגרי העובדים. שימו לב שאם אתם רוצים להשתמש במעבדי GPU עם MultiWorkerMirroredStrategy, לכל מכונה באשכול צריך להיות מספר זהה של מעבדי GPU. אחרת, העבודה תיכשל.
צריך להחליף את {PROJECT_ID} ב-image_uri.
# The spec of the worker pools including machine type and Docker image
# Be sure to replace PROJECT_ID in the "image_uri" with your project.
worker_pool_specs=[
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-4",
},
"container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
},
{
"replica_count": 1,
"machine_spec": {
"machine_type": "n1-standard-4",
},
"container_spec": {"image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_distributed:multi_machine"}
}
]
לאחר מכן יוצרים ומריצים CustomJob, ומחליפים את {YOUR_BUCKET} ב-staging_bucket בקטגוריה בפרויקט שלכם לצורך הכנה.
my_custom_job = aiplatform.CustomJob(display_name='flowers-multi-worker',
worker_pool_specs=worker_pool_specs,
staging_bucket='gs://{YOUR_BUCKET}')
my_custom_job.run()
במסוף תוכלו לראות את התקדמות העבודה.
🎉 איזה כיף! 🎉
למדתם איך להשתמש ב-Vertex AI כדי:
- הרצה של משימות אימון מבוזרות באמצעות TensorFlow
מידע נוסף על החלקים השונים של Vertex זמין בתיעוד.
7. הסרת המשאבים
הגדרנו את מחברת ה-Jupyter כך שתפסיק לפעול אחרי 60 דקות של חוסר פעילות, ולכן אין צורך לדאוג להשבתת המופע. כדי לכבות את המופע באופן ידני, לוחצים על הלחצן Stop (עצירה) בקטע Vertex AI Workbench במסוף. כדי למחוק את ה-Notebook לגמרי, לוחצים על לחצן המחיקה.
כדי למחוק את קטגוריית האחסון, בתפריט הניווט ב-Cloud Console, עוברים אל Storage, בוחרים את הקטגוריה ולוחצים על Delete:
