หน้านี้ได้รับการแปลโดย Cloud Translation API

Vertex AI: การฝึกทำงานแบบหลายผู้ปฏิบัติงานและถ่ายทอดการเรียนรู้ด้วย TensorFlow

1. ภาพรวม

ในห้องทดลองนี้ คุณจะใช้ Vertex AI เพื่อเรียกใช้งานการฝึกแบบหลายผู้ปฏิบัติงานสำหรับโมเดล TensorFlow

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

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

แก้ไขโค้ดของแอปพลิเคชันการฝึกอบรมสำหรับการฝึกอบรมผู้ปฏิบัติงานหลายคน
กำหนดค่าและเปิดตัวงานการฝึกอบรมผู้ปฏิบัติงานหลายคนจาก Vertex AI UI
กำหนดค่าและเรียกใช้งานการฝึกอบรมผู้ปฏิบัติงานหลายคนด้วย Vertex SDK

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

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

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

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

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

3. ภาพรวมกรณีการใช้งาน

ในห้องทดลองนี้ คุณจะได้ใช้การเรียนรู้การโอนเพื่อฝึกโมเดลการจัดประเภทรูปภาพบนชุดข้อมูล Cassava จากชุดข้อมูล TensorFlow สถาปัตยกรรมที่คุณจะใช้เป็นโมเดล ResNet50 จากไลบรารี tf.keras.applications ที่ฝึกไว้แล้วในชุดข้อมูล Imagenet

ทำไมจึงต้องใช้การฝึกอบรมแบบกระจาย

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

วิธีที่ง่ายที่สุดในการเริ่มต้นใช้งานการฝึกแบบกระจายคือเครื่องเดียวที่มีอุปกรณ์ GPU หลายเครื่อง กลยุทธ์การจัดจำหน่าย TensorFlow จากโมดูล tf.distribute จะจัดการการประสานงานของการจัดจำหน่ายข้อมูลและการอัปเดตอนุพันธ์ใน GPU ทั้งหมด หากคุณมีความเชี่ยวชาญในการฝึกใช้โฮสต์เดียวและอยากขยายการใช้งานให้มากกว่านี้ การเพิ่มเครื่องหลายเครื่องลงในคลัสเตอร์จะช่วยเพิ่มประสิทธิภาพให้ดียิ่งขึ้น คุณสามารถใช้คลัสเตอร์ของเครื่องที่มีเพียง CPU หรือมี GPU อย่างน้อย 1 ตัวในแต่ละเครื่อง ห้องทดลองนี้กล่าวถึงกรณีหลังและสาธิตวิธีใช้ MultiWorkerMirroredStrategy เพื่อกระจายการฝึกโมเดล TensorFlow ในเครื่องหลายเครื่องบน Vertex AI

MultiWorkerMirroredStrategy เป็นกลยุทธ์การทำงานพร้อมกันของข้อมูลที่ใช้ได้เมื่อมีการเปลี่ยนแปลงโค้ดเพียงไม่กี่รายการ ระบบจะสร้างสำเนาของโมเดลบนอุปกรณ์แต่ละเครื่องในคลัสเตอร์ การอัปเดตการไล่ระดับสีที่ตามมาจะเกิดขึ้นแบบซิงโครนัส ซึ่งหมายความว่าอุปกรณ์ของผู้ปฏิบัติงานแต่ละเครื่องจะคำนวณการส่งต่อและย้อนกลับไปยังโมเดลในส่วนของข้อมูลอินพุตที่แตกต่างกัน จากนั้นระบบจะรวบรวม Gradient ที่คำนวณแล้วจากแต่ละส่วนเหล่านี้ในอุปกรณ์ทั้งหมดบนเครื่องและเครื่องทั้งหมดในคลัสเตอร์ และลด (โดยปกติจะเป็นค่าเฉลี่ย) ในกระบวนการที่เรียกว่า "All-Reduce" จากนั้นเครื่องมือเพิ่มประสิทธิภาพจะทำการอัปเดตพารามิเตอร์ด้วยลู่ลาดที่ลดลงเหล่านี้เพื่อให้อุปกรณ์ซิงค์กันอยู่เสมอ ดูข้อมูลเพิ่มเติมเกี่ยวกับการฝึกแบบกระจายด้วย TensorFlow ได้ที่วิดีโอด้านล่าง

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

คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 1: เปิดใช้ Compute Engine API

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

ขั้นตอนที่ 2: เปิดใช้ Container Registry API

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

ขั้นตอนที่ 3: เปิดใช้ Vertex AI API

ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API

แดชบอร์ด Vertex AI

ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench

จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench ดังนี้

เปิดใช้ Notebooks API หากยังไม่ได้เปิดใช้

Notebook_api

เมื่อเปิดใช้แล้ว ให้คลิกสมุดบันทึกที่มีการจัดการ

Notebooks_UI

จากนั้นเลือกสมุดบันทึกใหม่

new_notebook

ตั้งชื่อสมุดบันทึก แล้วคลิกการตั้งค่าขั้นสูง

create_notebook

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

idle_timeout

ในส่วนความปลอดภัย ให้เลือก "เปิดใช้เทอร์มินัล" หากยังไม่ได้เปิดใช้

enable_terminal

คุณปล่อยการตั้งค่าขั้นสูงอื่นๆ ทั้งหมดไว้ตามเดิมได้

จากนั้นคลิกสร้าง การจัดสรรอินสแตนซ์จะใช้เวลา 2-3 นาที

เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab

open_jupyterlab

ครั้งแรกที่คุณใช้อินสแตนซ์ใหม่ ระบบจะขอให้คุณตรวจสอบสิทธิ์ ทําตามขั้นตอนใน UI

ตรวจสอบสิทธิ์

5. สร้างคอนเทนเนอร์โค้ดแอปพลิเคชันการฝึก

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

ในการเริ่มต้น จากเมนู Launcher ให้เปิดหน้าต่างเทอร์มินัลในอินสแตนซ์สมุดบันทึก โดยทำดังนี้

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

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

mkdir cassava
cd cassava

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

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

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

touch Dockerfile

เปิด Dockerfile และคัดลอกไฟล์ต่อไปนี้ลงในไฟล์

FROM gcr.io/deeplearning-platform-release/tf2-gpu.2-7

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"]

Dockerfile นี้ใช้อิมเมจ Docker ของ Deep Learning สำหรับคอนเทนเนอร์ TensorFlow Enterprise 2.7 คอนเทนเนอร์การเรียนรู้เชิงลึกบน Google Cloud มาพร้อมกับเฟรมเวิร์ก ML และวิทยาศาสตร์ข้อมูลทั่วไปมากมายที่ติดตั้งไว้ล่วงหน้า หลังจากดาวน์โหลดอิมเมจดังกล่าว Dockerfile นี้จะตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึก คุณยังไม่ได้สร้างไฟล์เหล่านี้ ในขั้นตอนถัดไป คุณจะต้องเพิ่มโค้ดสำหรับการฝึกและปรับแต่งโมเดล

ขั้นตอนที่ 2: สร้างที่เก็บข้อมูล Cloud Storage

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

PROJECT_ID='your-cloud-project'

จากนั้นเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อสร้างที่เก็บข้อมูลใหม่ในโปรเจ็กต์

BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET

ขั้นตอนที่ 3: เพิ่มโค้ดการฝึกโมเดล

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

mkdir trainer
touch trainer/task.py

ตอนนี้คุณควรมีสิ่งต่อไปนี้ในไดเรกทอรี cassava/ ของคุณ

+ Dockerfile
+ trainer/
    + task.py

จากนั้นให้เปิดไฟล์ task.py ที่คุณเพิ่งสร้างและคัดลอกโค้ดด้านล่าง คุณจะต้องแทนที่ {your-gcs-bucket} ด้วยชื่อของที่เก็บข้อมูล Cloud Storage ที่คุณเพิ่งสร้างขึ้น

import tensorflow as tf
import tensorflow_datasets as tfds
import os


PER_REPLICA_BATCH_SIZE = 64
EPOCHS = 2

# TODO: replace {your-gcs-bucket} with the name of the Storage bucket you created earlier
BUCKET = 'gs://{your-gcs-bucket}/mwms'

def preprocess_data(image, label):
  '''Resizes and scales images.'''

  image = tf.image.resize(image, (300,300))
  return tf.cast(image, tf.float32) / 255., label


def create_dataset(batch_size):
  '''Loads Cassava dataset and preprocesses data.'''

  data, info = tfds.load(name='cassava', as_supervised=True, with_info=True)
  number_of_classes = info.features['label'].num_classes
  train_data = data['train'].map(preprocess_data,
                                 num_parallel_calls=tf.data.experimental.AUTOTUNE)
  train_data  = train_data.shuffle(1000)
  train_data  = train_data.batch(batch_size)
  train_data  = train_data.prefetch(tf.data.experimental.AUTOTUNE)

  # Set AutoShardPolicy
  options = tf.data.Options()
  options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.DATA
  train_data = train_data.with_options(options)

  return train_data, number_of_classes


def create_model(number_of_classes):
  '''Creates and compiles pretrained ResNet50 model.'''

  base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)
  x = base_model.output
  x = tf.keras.layers.GlobalAveragePooling2D()(x)
  x = tf.keras.layers.Dense(1016, activation='relu')(x)
  predictions = tf.keras.layers.Dense(number_of_classes, activation='softmax')(x)
  model = tf.keras.Model(inputs=base_model.input, outputs=predictions)

  model.compile(
      loss='sparse_categorical_crossentropy',
      optimizer=tf.keras.optimizers.Adam(0.0001),
      metrics=['accuracy'])

  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 strategy
  strategy = tf.distribute.MultiWorkerMirroredStrategy()

  # Get data
  global_batch_size = PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync
  train_data, number_of_classes = create_dataset(global_batch_size)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model(number_of_classes)

  model.fit(train_data, 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(BUCKET, task_type, task_id)
  model.save(write_model_path)

if __name__ == "__main__":
    main()

ก่อนที่จะสร้างคอนเทนเนอร์ เรามาดูรายละเอียดของโค้ดที่ใช้ MultiWorkerMirroredStrategy จาก tf.distribute.Strategy API กัน

โค้ดมีคอมโพเนนต์ 2-3 อย่างที่จําเป็นสําหรับให้โค้ดทํางานร่วมกับ MultiWorkerMirroredStrategy ได้

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

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

ขั้นตอนที่ 4: สร้างคอนเทนเนอร์

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

PROJECT_ID='your-cloud-project'

กําหนดตัวแปรด้วย URI ของอิมเมจคอนเทนเนอร์ใน Google Container Registry โดยทําดังนี้

IMAGE_URI="gcr.io/$PROJECT_ID/multiworker:cassava"

กำหนดค่า Docker

gcloud auth configure-docker

จากนั้นสร้างคอนเทนเนอร์โดยเรียกใช้คำสั่งต่อไปนี้จากรูทของไดเรกทอรี cassava

docker build ./ -t $IMAGE_URI

สุดท้าย ให้พุชไปยัง Google Container Registry ดังนี้

docker push $IMAGE_URI

เมื่อพุชคอนเทนเนอร์ไปยัง Container Registry แล้ว คุณก็พร้อมเริ่มงานการฝึกแล้ว

6. เรียกใช้งานการฝึกอบรมผู้ปฏิบัติงานหลายคนใน Vertex AI

ห้องทดลองนี้ใช้การฝึกที่กำหนดเองผ่านคอนเทนเนอร์ที่กำหนดเองใน Google Container Registry แต่คุณยังเรียกใช้งานการฝึกด้วยคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าได้

เริ่มต้นด้วยการไปที่ส่วนการฝึกในส่วน Vertex ของ Cloud Console โดยทำดังนี้

ขั้นตอนที่ 1: กำหนดค่างานการฝึก

คลิกสร้างเพื่อป้อนพารามิเตอร์สำหรับงานการฝึก

ในส่วนชุดข้อมูล ให้เลือกไม่มีชุดข้อมูลที่มีการจัดการ
จากนั้นเลือกการฝึกที่กำหนดเอง (ขั้นสูง) เป็นวิธีการฝึก แล้วคลิกต่อไป
ป้อน multiworker-cassava (หรือชื่อใดก็ได้ที่ต้องการตั้งให้โมเดล) สำหรับชื่อโมเดล
คลิกต่อไป

ในขั้นตอนการตั้งค่าคอนเทนเนอร์ ให้เลือกคอนเทนเนอร์ที่กำหนดเอง ดังนี้

ตัวเลือกคอนเทนเนอร์ที่กำหนดเอง

ในช่องแรก (รูปภาพคอนเทนเนอร์) ให้ป้อนค่าตัวแปร IMAGE_URI จากส่วนก่อนหน้า รหัสควรเป็น gcr.io/your-cloud-project/multiworker:cassava พร้อมรหัสโปรเจ็กต์ของคุณเอง เว้นช่องที่เหลือว่างไว้และคลิกดำเนินการต่อ

ข้ามขั้นตอน Hhyperparameters โดยคลิกดำเนินการต่ออีกครั้ง

ขั้นตอนที่ 2: กำหนดค่าคลัสเตอร์การประมวลผล

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

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

ในส่วนการประมวลผลและการกำหนดราคา ให้ปล่อยภูมิภาคที่เลือกไว้ตามเดิมและกำหนดค่า Worker Pool 0 ดังนี้

Worker_pool_0

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

กำหนดค่า Worker Pool 1 ดังนี้

Worker_pool_1

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

MultiWorkerMirroredStrategy มีเฉพาะประเภทงานของหัวหน้าและผู้ปฏิบัติงาน จึงไม่จำเป็นต้องกำหนดค่าพูลผู้ปฏิบัติงานเพิ่มเติม แต่หากใช้ ParameterServerStrategy ของ TensorFlow คุณจะต้องกำหนดค่าเซิร์ฟเวอร์พารามิเตอร์ในพูลผู้ปฏิบัติงาน 2 และหากต้องการเพิ่มผู้ประเมินลงในคลัสเตอร์ ให้กำหนดค่าเครื่องดังกล่าวในกลุ่มผู้ปฏิบัติงาน 3

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

งานการฝึก

🎉 ยินดีด้วย 🎉

คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว

เปิดใช้งานการฝึกอบรมผู้ปฏิบัติงานหลายคนสำหรับโค้ดการฝึกอบรมที่มีให้ในคอนเทนเนอร์ที่กำหนดเอง คุณใช้โมเดล TensorFlow ในตัวอย่างนี้ แต่สามารถฝึกโมเดลที่สร้างด้วยเฟรมเวิร์กใดก็ได้โดยใช้คอนเทนเนอร์ที่กำหนดเองหรือคอนเทนเนอร์ในตัว

ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ในเอกสารประกอบ

7. [ไม่บังคับ] ใช้ Vertex SDK

ส่วนก่อนหน้านี้แสดงวิธีการเปิดงานการฝึกผ่าน UI ในส่วนนี้ คุณจะเห็นวิธีอื่นในการส่งงานการฝึกโดยใช้ Vertex Python API

กลับไปที่อินสแตนซ์สมุดบันทึกแล้วสร้างสมุดบันทึก TensorFlow 2 จาก Launcher โดยใช้คำสั่งต่อไปนี้

new_notebook

นำเข้า Vertex AI SDK

from google.cloud import aiplatform

หากต้องการเรียกใช้งานการฝึกอบรมผู้ปฏิบัติงานหลายคน คุณต้องกำหนดข้อมูลจำเพาะของพูลผู้ปฏิบัติงานก่อน โปรดทราบว่าการใช้ GPU ในข้อมูลจำเพาะเป็นแบบไม่บังคับทั้งหมด และคุณนำ accelerator_type และ accelerator_count ออกได้หากต้องการคลัสเตอร์เฉพาะ CPU ตามที่แสดงในส่วนก่อนหน้า

# The spec of the worker pools including machine type and Docker image
# Be sure to replace {YOUR-PROJECT-ID} with your project ID.
worker_pool_specs=[
     {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      },
      {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      }
]

จากนั้นให้สร้างและเรียกใช้ CustomJob คุณจะต้องแทนที่ {YOUR_BUCKET} ด้วยที่เก็บข้อมูลในโปรเจ็กต์สำหรับการทดลองใช้ คุณจะใช้ที่เก็บข้อมูลเดียวกันกับที่สร้างไว้ก่อนหน้านี้ได้

# Replace YOUR_BUCKET
my_multiworker_job = aiplatform.CustomJob(display_name='multiworker-cassava-sdk',
                              worker_pool_specs=worker_pool_specs,
                              staging_bucket='gs://{YOUR_BUCKET}')

my_multiworker_job.run()

ในส่วนการฝึกอบรมของคอนโซลใต้แท็บงานที่กำหนดเอง คุณจะเห็นงานการฝึกดังนี้

งานที่กำหนดเอง

8. ล้างข้อมูล

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

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

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

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