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

1. ภาพรวม

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

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

.

สิ่งที่ได้เรียนรู้

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

เปิดเทอร์มินัลในสมุดบันทึก

ขั้นตอนที่ 1: เขียนโค้ดการฝึกอบรม

สร้างไดเรกทอรีใหม่ชื่อ flowers-multi-gpu และเข้ารหัสลงในไดเรกทอรีดังกล่าว:

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 ที่คุณจัดเก็บชุดข้อมูลดอกไม้ใน Lab 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 ที่ว่างเปล่าในรูทของไดเรกทอรีดอกไม้ โดยทำดังนี้

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: สร้างคอนเทนเนอร์

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

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 ตัว จะไม่ถือว่าเป็นการฝึกแบบกระจาย การฝึกแบบกระจายในเครื่องเดียวคือเมื่อคุณใช้ Accelerator 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 หากต้องการ

เปิดหน้าต่างเทอร์มินัลใหม่ในอินสแตนซ์สมุดบันทึก

เปิดเทอร์มินัลในสมุดบันทึก

ขั้นตอนที่ 1: เขียนโค้ดการฝึกอบรม

สร้างไดเรกทอรีใหม่ชื่อ flowers-multi-machine และเข้ารหัสลงในไดเรกทอรีดังกล่าว:

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 ที่คุณจัดเก็บชุดข้อมูลดอกไม้ใน Lab 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()

มาดูโค้ดอย่างละเอียดกันก่อนที่จะสร้างคอนเทนเนอร์ มีคอมโพเนนต์ 2-3 รายการในโค้ดที่จำเป็นต่อการให้แอปพลิเคชันการฝึกทำงานกับ MultiWorkerMirroredStrategy

  • ระบบจะสร้างออบเจ็กต์ MultiWorkerMirroredStrategy ในฟังก์ชัน main() ต่อไป ให้คุณรวมการสร้างตัวแปรโมเดลภายในขอบเขตของกลยุทธ์ ขั้นตอนสำคัญนี้จะบอกให้ TensorFlow ทราบว่าควรมิเรอร์ตัวแปรใดในตัวจำลอง
  • ขนาดกลุ่มจะเพิ่มขึ้นโดย num_replicas_in_sync แนวทางปฏิบัติแนะนำในการปรับขนาดแบบกลุ่มเป็นแนวทางปฏิบัติแนะนำเมื่อใช้กลยุทธ์การทำงานพร้อมกันของข้อมูลพร้อมกันใน TensorFlow
  • การบันทึกโมเดลจะซับซ้อนขึ้นเล็กน้อยในกรณีของผู้ปฏิบัติงานหลายคน เนื่องจากปลายทางสำหรับผู้ปฏิบัติงานแต่ละคนต้องไม่เหมือนกัน หัวหน้าผู้ปฏิบัติงานจะบันทึกไปยังไดเรกทอรีโมเดลที่ต้องการ ในขณะที่ผู้ปฏิบัติงานคนอื่นๆ จะบันทึกโมเดลลงในไดเรกทอรีชั่วคราว ไดเรกทอรีชั่วคราวเหล่านี้จะต้องไม่ซ้ำกันเพื่อป้องกันไม่ให้ผู้ปฏิบัติงานหลายคนเขียนไปยังตำแหน่งเดียวกัน การบันทึกสามารถประกอบด้วยการดำเนินงานร่วม ซึ่งหมายความว่าผู้ปฏิบัติงานทุกคนต้องประหยัดได้ ไม่ใช่แค่หัวหน้าเท่านั้น ฟังก์ชัน _is_chief(), _get_temp_dir(), write_filepath() และฟังก์ชัน main() ทั้งหมดมีโค้ดสำเร็จรูปที่ช่วยบันทึกโมเดล

ขั้นตอนที่ 2: สร้าง Dockerfile

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

จากเทอร์มินัล ให้สร้าง Dockerfile ที่ว่างเปล่าในรูทของไดเรกทอรีดอกไม้ โดยทำดังนี้

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: สร้างคอนเทนเนอร์

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

new_notebook

นำเข้า Vertex AI SDK

from google.cloud import aiplatform

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

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

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

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

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

เนื่องจากเรากำหนดค่าให้สมุดบันทึกหมดเวลาหลังจากไม่มีการใช้งาน 60 นาที เราจึงไม่ต้องกังวลเกี่ยวกับการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่มหยุดในส่วน Vertex AI Workbench ของคอนโซล หากคุณต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม ลบ

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

หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:

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