สร้างต้นแบบสู่เวอร์ชันที่ใช้งานจริง: การฝึกอบรมแบบกระจายใน Vertex AI

1. ภาพรวม

ในแล็บนี้ คุณจะได้ใช้ Vertex AI เพื่อเรียกใช้การฝึกแบบกระจายใน Vertex AI Training โดยใช้ TensorFlow

แล็บนี้เป็นส่วนหนึ่งของวิดีโอซีรีส์ต้นแบบสู่การผลิต โปรดทำแล็บก่อนหน้าให้เสร็จก่อนที่จะลองใช้แล็บนี้ คุณดูชุดวิดีโอประกอบเพื่อดูข้อมูลเพิ่มเติมได้

.

สิ่งที่คุณจะได้เรียนรู้

โดยคุณจะได้เรียนรู้วิธีต่อไปนี้

  • เรียกใช้การฝึกแบบกระจายในเครื่องเดียวที่มี GPU หลายตัว
  • เรียกใช้การฝึกแบบกระจายในหลายเครื่อง

ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $2

2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI

แล็บนี้ใช้ผลิตภัณฑ์ AI ใหม่ล่าสุดที่พร้อมให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้จะรวมทั้ง 2 อย่างไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย

Vertex AI มีผลิตภัณฑ์มากมายที่แตกต่างกันเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร Lab นี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ Training และ Workbench

ภาพรวมผลิตภัณฑ์ Vertex

3. ภาพรวมการฝึกแบบกระจาย

หากมี GPU เดียว TensorFlow จะใช้ตัวเร่งนี้เพื่อเพิ่มความเร็วในการฝึกโมเดลโดยที่คุณไม่ต้องดำเนินการใดๆ เพิ่มเติม อย่างไรก็ตาม หากต้องการเพิ่มประสิทธิภาพจากการใช้ GPU หลายตัว คุณจะต้องใช้ tf.distribute ซึ่งเป็นโมดูลของ TensorFlow สำหรับการเรียกใช้การคำนวณในอุปกรณ์หลายเครื่อง

ส่วนแรกของแล็บนี้ใช้ tf.distribute.MirroredStrategy ซึ่งคุณสามารถเพิ่มลงในแอปพลิเคชันการฝึกได้โดยเปลี่ยนโค้ดเพียงเล็กน้อย กลยุทธ์นี้จะสร้างสำเนาของโมเดลในแต่ละ GPU บนเครื่องของคุณ การอัปเดตกราเดียนต์ครั้งต่อๆ ไปจะเกิดขึ้นแบบซิงโครนัส ซึ่งหมายความว่า GPU แต่ละตัวจะคำนวณการส่งต่อและการส่งย้อนกลับผ่านโมเดลในอินพุตข้อมูลที่แตกต่างกัน จากนั้นระบบจะรวบรวมการไล่ระดับสีที่คำนวณแล้วจากแต่ละชิ้นส่วนเหล่านี้ใน GPU ทั้งหมด และหาค่าเฉลี่ยในกระบวนการที่เรียกว่า all-reduce ระบบจะอัปเดตพารามิเตอร์ของโมเดลโดยใช้การไล่ระดับสีเฉลี่ยเหล่านี้

ส่วนที่ไม่บังคับที่ท้ายแล็บจะใช้ tf.distribute.MultiWorkerMirroredStrategy ซึ่งคล้ายกับ MirroredStrategy ยกเว้นว่าใช้ได้ในหลายเครื่อง เครื่องแต่ละเครื่องอาจมี GPU หลายตัวด้วย เช่น MirroredStrategy, MultiWorkerMirroredStrategy เป็นกลยุทธ์การขนานข้อมูลแบบซิงโครนัสที่คุณใช้ได้โดยมีการเปลี่ยนแปลงโค้ดเพียงเล็กน้อย ความแตกต่างหลักเมื่อเปลี่ยนจาก Data Parallelism แบบซิงโครนัสในเครื่องเดียวเป็นหลายเครื่องคือตอนนี้ต้องซิงค์การไล่ระดับสีที่ส่วนท้ายของแต่ละขั้นตอนใน GPU ทั้งหมดในเครื่องเดียวและในเครื่องทั้งหมดในคลัสเตอร์

คุณไม่จำเป็นต้องทราบรายละเอียดเพื่อทำแล็บนี้ให้เสร็จสมบูรณ์ แต่หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทำงานของการฝึกแบบกระจายใน TensorFlow โปรดดูวิดีโอด้านล่าง

4. ตั้งค่าสภาพแวดล้อม

ทำตามขั้นตอนในแล็บการฝึกโมเดลที่กำหนดเองด้วย Vertex AI เพื่อตั้งค่าสภาพแวดล้อม

5. การฝึกแบบหลาย GPU ในเครื่องเดียว

คุณจะส่งงานการฝึกแบบกระจายไปยัง Vertex AI โดยใส่โค้ดของแอปพลิเคชันการฝึกในคอนเทนเนอร์ Docker และพุชคอนเทนเนอร์นี้ไปยัง Google Artifact Registry เมื่อใช้วิธีนี้ คุณจะฝึกโมเดลที่สร้างด้วยเฟรมเวิร์กใดก็ได้

หากต้องการเริ่มต้น ให้เปิดหน้าต่างเทอร์มินัลจากเมนู Launcher ของ Notebook Workbench ที่คุณสร้างไว้ใน Lab ก่อนหน้า

เปิดเทอร์มินัลใน 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 ด้วย Bucket ของ 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 คุณจะต้องใส่คำสั่งทั้งหมดที่จำเป็นในการเรียกใช้อิมเมจ โดยจะติดตั้งไลบรารีที่จำเป็นทั้งหมดและตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึก

จากเทอร์มินัล ให้สร้าง 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

สร้าง 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}')

เมื่อกำหนดงานแล้ว คุณจะเรียกใช้งานได้ คุณจะตั้งค่าจำนวน Accelerator เป็น 2 หากเราใช้ GPU เพียง 1 ตัว ระบบจะไม่ถือว่าเป็นการฝึกแบบกระจาย การฝึกแบบกระจายในเครื่องเดียวคือการใช้ตัวเร่งตั้งแต่ 2 ตัวขึ้นไป

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

คุณจะดูความคืบหน้าของงานได้ในคอนโซล

multigpu_job

6. [ไม่บังคับ] การฝึกแบบหลาย Worker

ตอนนี้คุณได้ลองการฝึกแบบกระจายบนเครื่องเดียวที่มี 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 ด้วย Bucket ของ 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
  • การบันทึกโมเดลในกรณีที่มี Worker หลายรายจะซับซ้อนกว่าเล็กน้อย เนื่องจากปลายทางต้องแตกต่างกันสำหรับ Worker แต่ละราย โดยหัวหน้าคนงานจะบันทึกลงในไดเรกทอรีโมเดลที่ต้องการ ส่วนคนงานอื่นๆ จะบันทึกโมเดลลงในไดเรกทอรีชั่วคราว ไดเรกทอรีชั่วคราวเหล่านี้ต้องไม่ซ้ำกันเพื่อป้องกันไม่ให้ Worker หลายคนเขียนไปยังตำแหน่งเดียวกัน การบันทึกอาจมีการดำเนินการร่วมกัน ซึ่งหมายความว่าคนงานทุกคนต้องบันทึก ไม่ใช่แค่หัวหน้า ฟังก์ชัน _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

สร้าง Notebook ของ TensorFlow 2 จากตัวเรียกใช้

new_notebook

นำเข้า Vertex AI SDK

from google.cloud import aiplatform

จากนั้นกำหนด worker_pool_specs

Vertex AI มีพูลผู้ปฏิบัติงาน 4 รายการเพื่อครอบคลุมงานประเภทต่างๆ ของเครื่อง

พูลผู้ปฏิบัติงาน 0 จะกำหนดค่า Primary, chief, scheduler หรือ "master" ใน MultiWorkerMirroredStrategy เครื่องทั้งหมดจะได้รับการกำหนดให้เป็นเครื่องปฏิบัติงาน ซึ่งเป็นเครื่องจริงที่ใช้ดำเนินการคำนวณที่จำลอง นอกจากเครื่องแต่ละเครื่องจะเป็น Worker แล้ว ยังต้องมี Worker หนึ่งเครื่องที่รับงานเพิ่มเติม เช่น การบันทึกจุดตรวจสอบและการเขียนไฟล์สรุปไปยัง TensorBoard เครื่องนี้เรียกว่า "หัวหน้า" มีผู้ปฏิบัติงานหลักเพียงคนเดียวเสมอ ดังนั้นจำนวนผู้ปฏิบัติงานสำหรับพูลผู้ปฏิบัติงาน 0 จะเป็น 1 เสมอ

พูลผู้ปฏิบัติงาน 1 คือที่ที่คุณกำหนดค่าผู้ปฏิบัติงานเพิ่มเติมสำหรับคลัสเตอร์

พจนานุกรมแรกในworker_pool_specsรายการแสดงถึงพูลผู้ปฏิบัติงาน 0 และพจนานุกรมที่สองแสดงถึงพูลผู้ปฏิบัติงาน 1 ในการกำหนดค่าตัวอย่างนี้ การกำหนดค่าทั้ง 2 รายการจะเหมือนกัน แต่หากต้องการฝึกโมเดลในเครื่อง 3 เครื่อง คุณจะต้องเพิ่ม Worker ลงใน Worker Pool 1 โดยตั้งค่า replica_count เป็น 2 หากต้องการเพิ่ม GPU คุณจะต้องเพิ่มอาร์กิวเมนต์ accelerator_type และ accelerator_count ลงใน machine_spec สำหรับทั้ง 2 กลุ่ม Worker โปรดทราบว่าหากต้องการใช้ 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 นาที จึงไม่ต้องกังวลเรื่องการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่มหยุดในส่วน Vertex AI Workbench ของคอนโซล หากต้องการลบ Notebook ทั้งหมด ให้คลิกปุ่มลบ

หยุดอินสแตนซ์

หากต้องการลบ Storage Bucket ให้ใช้เมนูการนำทางใน Cloud Console ไปที่ Storage เลือก Bucket แล้วคลิกลบ

ลบพื้นที่เก็บข้อมูล