אב טיפוס לייצור: הדרכה מבוזרת על Vertex AI

1. סקירה כללית

בשיעור ה-Lab הזה תשתמשו ב-Vertex AI כדי להריץ משימת אימון מבוזרת ב-Vertex AI Training באמצעות TensorFlow.

שיעור ה-Lab הזה הוא חלק מסדרת הסרטונים יצירת אב טיפוס. חשוב להשלים את הסדנאות הקודמות לפני שמנסים את הסדנה הזו. אפשר לצפות בסדרת הסרטונים המצורפת כדי לקבל מידע נוסף:

.

מה תלמדו

תלמדו איך:

  • אימון מבוזבז במכונה אחת עם כמה מעבדי GPU
  • להריץ אימון מבוזר במספר מכונות

העלות הכוללת להרצת שיעור ה-Lab הזה ב-Google Cloud היא כ-2$.

2. מבוא ל-Vertex AI

במעבדה הזו נעשה שימוש במוצרי ה-AI החדשים ביותר שזמינים ב-Google Cloud. Vertex AI משלבת את חבילות ה-ML ב-Google Cloud לחוויית פיתוח חלקה. בעבר, היה אפשר לגשת למודלים שהותאמו אישית ולמודלים שהותאמו באמצעות AutoML דרך שירותים נפרדים. המוצר החדש משלב את שניהם ב-API אחד, יחד עם מוצרים חדשים אחרים. תוכלו גם להעביר פרויקטים קיימים ל-Vertex AI.

Vertex AI כולל הרבה מוצרים שונים לתמיכה בתהליכי עבודה של למידת מכונה מקצה לקצה. שיעור ה-Lab הזה יתמקד במוצרים שמודגשים בהמשך: הדרכה וWorkbench

סקירה כללית על מוצרי Vertex

3. סקירה כללית על אימון מבוזבז

אם יש לכם GPU אחד, TensorFlow ישתמש במאיץ הזה כדי לזרז את אימון המודל בלי שתצטרכו לעשות שום דבר נוסף. עם זאת, אם רוצים לקבל שיפור נוסף משימוש בכמה מעבדי GPU, צריך להשתמש ב-tf.distribute, שהוא המודול של TensorFlow להרצת חישוב בכמה מכשירים.

בקטע הראשון של הסדנה הזו נעשה שימוש ב-tf.distribute.MirroredStrategy, שאפשר להוסיף לאפליקציות האימון שלכם רק באמצעות כמה שינויים בקוד. לפי האסטרטגיה הזו, נוצר עותק של המודל בכל יחידת GPU במחשב. עדכוני ההדרגתיות הבאים יתבצעו באופן סינכרוני. כלומר, כל GPU מחשב את החזרה והקדימה דרך המודל בחלק אחר של נתוני הקלט. לאחר מכן, הנגזרות המחושבות מכל אחד מהפלחים האלה נצברות בכל המעבדים הגרפיים ומחושב להן ממוצע בתהליך שנקרא all-reduce. הפרמטרים של המודל מתעדכנים באמצעות הממוצעים של ההדרגתיות האלו.

בקטע האופציונלי בסוף השיעור נעשה שימוש ב-tf.distribute.MultiWorkerMirroredStrategy, שדומה ל-MirroredStrategy, מלבד העובדה שהוא פועל במספר מכונות. יכול להיות שכל אחת מהמכונות האלה תכלול גם כמה יחידות GPU. בדומה ל-MirroredStrategy,‏ MultiWorkerMirroredStrategy היא אסטרטגיה של מקבילות נתונים סינכרונית שאפשר להשתמש בה עם כמה שינויים קוד בלבד. ההבדל העיקרי במעבר מביצוע מקבילי של נתונים באופן סינכרוני במכונה אחת למספר מכונות הוא שצריך לסנכרן עכשיו את הגרדיאנטים בסוף כל שלב בין כל המעבדים הגרפיים במכונה ובין כל המכונות באשכול.

אתם לא צריכים לדעת את הפרטים כדי להשלים את סדנת ה-Lab הזו, אבל אם אתם רוצים לקבל מידע נוסף על האופן שבו אימון מבוזבז פועל ב-TensorFlow, כדאי לצפות בסרטון הבא:

4. הגדרת הסביבה

כדי להגדיר את הסביבה, מבצעים את השלבים במאמר אימון מודלים מותאמים אישית באמצעות Vertex AI.

5. אימון על מכונה יחידה, מולטי GPU

כדי לשלוח את משימת האימון המבוזרת ל-Vertex AI, תצטרכו להעביר את קוד האפליקציה של האימון לקונטיינר Docker ולדחוף את הקונטיינר הזה ל-Google Artifact Registry. בעזרת הגישה הזו, אפשר לאמן מודל שנוצר בכל מסגרת.

כדי להתחיל, פותחים חלון טרמינל מתפריט Launcher של ה-notebook ב-Workbench שיצרתם בסדנאות הקודמות.

פתיחת מסוף ב-notebook

שלב 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()

לפני שיוצרים את מאגר התגים, נבחן לעומק את הקוד. יש כמה רכיבים ספציפיים לשימוש בהדרכה מבוזרת.

  • בפונקציה main(), נוצר האובייקט MirroredStrategy. בשלב הבא, צריך לתחום את יצירת משתני המודל בהיקף של האסטרטגיה. השלב הזה מורה ל-TensorFlow אילו משתנים צריך לשקף במעבדי ה-GPU.
  • גודל האצווה יגדל לפי הערך של num_replicas_in_sync. השיטה המומלצת היא שינוי גודל האצווה כשמשתמשים באסטרטגיות סינכרוניות של נתונים במקביל ב-TensorFlow. מידע נוסף זמין כאן.

שלב 2: יצירת קובץ Dockerfile

כדי לארוז את הקוד בקונטיינרים, צריך ליצור קובץ Dockerfile. בקובץ Dockerfile תכללו את כל הפקודות הנדרשות להרצת קובץ האימג'. הספריות הנדרשות יותקנו ותתבצע הגדרה של נקודת הכניסה לקוד האימון.

ב-Terminal, יוצרים קובץ Dockerfile ריק ברמה הבסיסית (root) של ספריית 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: יצירת הקונטיינר

ב-Terminal, מריצים את הפקודה הבאה כדי להגדיר משתנה סביבה לפרויקט. חשוב להחליף את 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.

במרכז האפליקציות, יוצרים notebook של TensorFlow 2.

new_notebook

מייבאים את 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 אחד, זה לא ייחשב כאימון מבוזבז. אימון מבוזבז במכונה אחת מתבצע כשמשתמשים ב-2 מואצים או יותר.

my_custom_job.run(replica_count=1,
                  machine_type='n1-standard-4',
                  accelerator_type='NVIDIA_TESLA_V100',
                  accelerator_count=2)

במסוף תוכלו לראות את ההתקדמות של המשימה.

multigpu_job

6. [אופציונלי] הכשרה למספר עובדים

עכשיו, אחרי שניסיתם אימון מבוזבז במכונה אחת עם כמה מעבדי GPU, אתם יכולים לשפר את כישורי האימון המבוזר שלכם ולהתחיל לאמן במספר מכונות. כדי להפחית את העלויות, לא נוסיף מעבדי GPU למכונות האלה, אבל תוכלו להתנסות על ידי הוספת מעבדי GPU.

פותחים חלון טרמינל חדש במכונה של ה-notebook:

פתיחת מסוף ב-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.

  • בפונקציה main(), נוצר האובייקט MultiWorkerMirroredStrategy. בשלב הבא, צריך לתחום את יצירת משתני המודל בהיקף של האסטרטגיה. השלב הזה חיוני כדי להורות ל-TensorFlow אילו משתנים צריך לשקף בין הרפליקות.
  • גודל האצווה יגדל לפי הערך של num_replicas_in_sync. השיטה המומלצת היא שינוי גודל האצווה כשמשתמשים באסטרטגיות סינכרוניות של נתונים במקביל ב-TensorFlow.
  • שמירת המודל מורכבת יותר במקרה של כמה עובדים, כי היעד צריך להיות שונה לכל אחד מהעובדים. העובד הראשי ישמור את המודל בספריית המודל הרצויה, והעובדים האחרים ישמרו את המודל בספריות זמניות. חשוב שהספריות הזמניות האלה יהיו ייחודיות כדי למנוע מכמה עובדים לכתוב באותו מיקום. שמירה יכולה לכלול פעולות קולקטיביות, כלומר כל העובדים צריכים לשמור ולא רק המנהל. הפונקציות _is_chief(),‏ _get_temp_dir(),‏ write_filepath() וגם הפונקציה main() כוללות קוד סטנדרטי שעוזר לשמור את המודל.

שלב 2: יצירת קובץ Dockerfile

כדי לארוז את הקוד בקונטיינרים, צריך ליצור קובץ Dockerfile. בקובץ Dockerfile תכללו את כל הפקודות הנדרשות להרצת קובץ האימג'. הספריות הנדרשות יותקנו ותתבצע הגדרה של נקודת הכניסה לקוד האימון.

ב-Terminal, יוצרים קובץ Dockerfile ריק ברמה הבסיסית (root) של ספריית 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: יצירת הקונטיינר

ב-Terminal, מריצים את הפקודה הבאה כדי להגדיר משתנה סביבה לפרויקט. חשוב להחליף את your-cloud-project במזהה הפרויקט:

PROJECT_ID='your-cloud-project'

יוצרים מאגר ב-Artifact Registry. נשתמש במאגר שיצרנו בשיעור ה-Lab הראשון.

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.

במרכז האפליקציות, יוצרים notebook של TensorFlow 2.

new_notebook

מייבאים את Vertex AI SDK.

from google.cloud import aiplatform

לאחר מכן, מגדירים את worker_pool_specs.

מערכת Vertex AI מספקת 4 מאגרי עובדים כדי לכסות את הסוגים השונים של משימות המכונה.

מאגר העובדים 0 מגדיר את המכונה הראשית, המכונה הראשית לניהול, המכונה לניהול תזמון או המכונה הראשית (master). ב-MultiWorkerMirroredStrategy, כל המכונות מוגדרות כמכונות עבודה, שהן המכונות הפיזיות שבהן מתבצע החישוב המשוכפל. בנוסף לכך שכל מכונה היא worker, צריך להיות עובד אחד שמבצע עבודה נוספת כמו שמירת נקודות ביקורת וכתיבת קובצי סיכום ב-TensorBoard. המכונה הזו נקראת 'הראשית'. תמיד יש רק עובד ראשי אחד, כך שמספר העובדים במאגר העובדים 0 יהיה תמיד 1.

מאגר עובדים 1 הוא המקום שבו מגדירים את העובדים הנוספים לאשכול.

המילון הראשון ברשימה worker_pool_specs מייצג את מאגר העובדים 0, והמילון השני מייצג את מאגר העובדים 1. בדוגמה הזו, שתי הגדרות ה-config זהות. עם זאת, אם רוצים לאמן ב-3 מכונות, צריך להגדיר את replica_count ל-2 כדי להוסיף עוד עובדים למאגר העובדים 1. אם רוצים להוסיף מעבדי 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()

במסוף תוכלו לראות את ההתקדמות של המשימה.

multi_worker_job

🎉 מזל טוב! 🎉

למדתם איך להשתמש ב-Vertex AI כדי:

  • הרצת משימות אימון מבוזרות באמצעות TensorFlow

כדי לקבל מידע נוסף על החלקים השונים ב-Vertex, אתם יכולים לעיין במסמכי העזרה.

7. הסרת המשאבים

בגלל שהגדרנו את ה-notebook להפסקה של הזמן הקצוב לתפוגה אחרי 60 דקות ללא פעילות, אנחנו לא צריכים לדאוג לכיבוי המכונה. כדי לכבות את המכונה באופן ידני, לוחצים על הלחצן Stop בקטע Vertex AI Workbench במסוף. אם אתה רוצה למחוק לגמרי את ה-notebook, לחץ על הלחצן 'מחיקה'.

הפסקת המכונה

כדי למחוק את קטגוריית האחסון, באמצעות תפריט הניווט במסוף Cloud, עוברים אל Storage (אחסון), בוחרים את הקטגוריה ולוחצים על סמל המחיקה:

מחיקת אחסון