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

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

1. ภาพรวม

ในชั้นเรียนนี้ คุณจะใช้ Vertex AI เพื่อเรียกใช้งานการฝึกแบบหลายเวิร์กเกอร์สําหรับโมเดล TensorFlow

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

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

แก้ไขโค้ดของแอปพลิเคชันการฝึกอบรมสำหรับการฝึกอบรมผู้ปฏิบัติงานหลายคน
กำหนดค่าและเปิดใช้งานงานการฝึกแบบหลายเวิร์กเกอร์จาก UI ของ Vertex AI
กำหนดค่าและเปิดใช้งานงานการฝึกด้วยหลายเวิร์กเกอร์ด้วย 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 แล้ว cd เข้าไป

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 ของคอนเทนเนอร์การเรียนรู้เชิงลึก TensorFlow Enterprise 2.7 GPU คอนเทนเนอร์การเรียนรู้เชิงลึกบน 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 เนื่องจากไม่ได้ดาวน์โหลดชุดข้อมูล Cassava เป็นไฟล์หลายไฟล์ อย่างไรก็ตาม หากคุณไม่ได้ตั้งค่านโยบายเป็น 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 ของคอนโซลระบบคลาวด์

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

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

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

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

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

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

ข้ามขั้นตอนฮิวเปอร์พารามิเตอร์ H โดยคลิกต่อไปอีกครั้ง

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

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

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

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

Worker_pool_0

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

กำหนดค่าพูลผู้ปฏิบัติงาน 1 ดังนี้

Worker_pool_1

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

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

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

งานการฝึก

🎉 ยินดีด้วย 🎉

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

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

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

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

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

กลับไปที่อินสแตนซ์โน้ตบุ๊ก แล้วสร้างโน้ตบุ๊ก TensorFlow 2 จากตัวเปิดแอป โดยทำดังนี้

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 เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ

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