Vertex AI: การปรับแต่งไฮเปอร์พารามิเตอร์แบบกระจาย

1. ภาพรวม

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

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

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

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

ต้นทุนทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $6 USD

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

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

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

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

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

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

การปรับแต่งไฮเปอร์พารามิเตอร์

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

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

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

การฝึกแบบกระจาย

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

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

เมนู Vertex AI

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

Notebook_api

เมื่อเปิดใช้แล้ว ให้คลิก MANAGED NOTEBOOKS

Notebooks_UI

จากนั้นเลือก NOTEBOOK ใหม่

new_notebook

ตั้งชื่อ Notebook แล้วคลิกการตั้งค่าขั้นสูง

create_notebook

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

idle_timeout

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

เปิดใช้เทอร์มินัล

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

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

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

open_jupyterlab

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

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

5. เขียนโค้ดการฝึก

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

launcher_terminal

สร้างไดเรกทอรีใหม่ชื่อ vertex-codelab แล้วใช้คำสั่ง cd เพื่อเข้าไปในไดเรกทอรีนั้น

mkdir vertex-codelab
cd vertex-codelab

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

mkdir trainer
touch trainer/task.py

ตอนนี้คุณควรมีรายการต่อไปนี้ในไดเรกทอรี vertex-codelab

+ trainer/
    + task.py

จากนั้นเปิดไฟล์ task.py ที่คุณเพิ่งสร้างขึ้น แล้ววางโค้ดทั้งหมดด้านล่าง

import tensorflow as tf
import tensorflow_datasets as tfds
import argparse
import hypertune
import os

NUM_EPOCHS = 10
BATCH_SIZE = 64

def get_args():
  '''Parses args. Must include all hyperparameters you want to tune.'''

  parser = argparse.ArgumentParser()
  parser.add_argument(
      '--learning_rate',
      required=True,
      type=float,
      help='learning rate')
  parser.add_argument(
      '--momentum',
      required=True,
      type=float,
      help='SGD momentum value')
  parser.add_argument(
      '--num_units',
      required=True,
      type=int,
      help='number of units in last hidden layer')
  args = parser.parse_args()
  return args


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

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


def create_dataset(batch_size):
  '''Loads Horses Or Humans dataset and preprocesses data.'''

  data, info = tfds.load(name='horses_or_humans', as_supervised=True, with_info=True)

  # Create train dataset
  train_data = data['train'].map(preprocess_data)
  train_data  = train_data.shuffle(1000)
  train_data  = train_data.batch(batch_size)

  # Create validation dataset
  validation_data = data['test'].map(preprocess_data)
  validation_data  = validation_data.batch(batch_size)

  return train_data, validation_data


def create_model(num_units, learning_rate, momentum):
  '''Defines and compiles model.'''

  inputs = tf.keras.Input(shape=(150, 150, 3))
  x = tf.keras.layers.Conv2D(16, (3, 3), activation='relu')(inputs)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Conv2D(32, (3, 3), activation='relu')(x)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu')(x)
  x = tf.keras.layers.MaxPooling2D((2, 2))(x)
  x = tf.keras.layers.Flatten()(x)
  x = tf.keras.layers.Dense(num_units, activation='relu')(x)
  outputs = tf.keras.layers.Dense(1, activation='sigmoid')(x)
  model = tf.keras.Model(inputs, outputs)
  model.compile(
      loss='binary_crossentropy',
      optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum),
      metrics=['accuracy'])
  return model


def main():
  args = get_args()

  # Create distribution strategy
  strategy = tf.distribute.MirroredStrategy()

  # Get data
  GLOBAL_BATCH_SIZE = BATCH_SIZE * strategy.num_replicas_in_sync
  train_data, validation_data = create_dataset(GLOBAL_BATCH_SIZE)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model(args.num_units, args.learning_rate, args.momentum)

  # Train model
  history = model.fit(train_data, epochs=NUM_EPOCHS, validation_data=validation_data)

  # Define metric
  hp_metric = history.history['val_accuracy'][-1]

  hpt = hypertune.HyperTune()
  hpt.report_hyperparameter_tuning_metric(
      hyperparameter_metric_tag='accuracy',
      metric_value=hp_metric,
      global_step=NUM_EPOCHS)


if __name__ == "__main__":
    main()

มาดูโค้ดกันอย่างละเอียดและตรวจสอบคอมโพเนนต์เฉพาะสำหรับการฝึกแบบกระจายและการปรับไฮเปอร์พารามิเตอร์

การฝึกแบบกระจาย

  1. ในฟังก์ชัน main() ระบบจะสร้างออบเจ็กต์ MirroredStrategy จากนั้น คุณจะรวมการสร้างตัวแปรโมเดลไว้ภายในขอบเขตของกลยุทธ์ ขั้นตอนนี้จะบอก TensorFlow ว่าควรทำมิเรอร์ตัวแปรใดใน GPU
  2. num_replicas_in_sync จะเพิ่มขนาดกลุ่ม การปรับขนาดกลุ่มเป็นแนวทางปฏิบัติแนะนำเมื่อใช้กลยุทธ์การขนานข้อมูลแบบซิงโครนัสใน TensorFlow ดูข้อมูลเพิ่มเติมได้ที่นี่

การปรับแต่งไฮเปอร์พารามิเตอร์

  1. สคริปต์จะนำเข้าไลบรารี hypertune เมื่อสร้างอิมเมจคอนเทนเนอร์ในภายหลัง เราจะต้องตรวจสอบว่าได้ติดตั้งไลบรารีนี้แล้ว
  2. ฟังก์ชัน get_args() กําหนดอาร์กิวเมนต์บรรทัดคําสั่งสําหรับไฮเปอร์พารามิเตอร์แต่ละรายการที่ต้องการปรับ ในตัวอย่างนี้ ไฮเปอร์พารามิเตอร์ที่จะได้รับการปรับคืออัตราการเรียนรู้ ค่าโมเมนตัมในเครื่องมือเพิ่มประสิทธิภาพ และจำนวนหน่วยในเลเยอร์ที่ซ่อนสุดท้ายของโมเดล แต่คุณสามารถทดลองใช้พารามิเตอร์อื่นๆ ได้ จากนั้นระบบจะใช้ค่าที่ส่งในอาร์กิวเมนต์เหล่านั้นเพื่อตั้งค่าไฮเปอร์พารามิเตอร์ที่เกี่ยวข้องในโค้ด (เช่น ตั้งค่า learning_rate = args.learning_rate)
  3. ที่ส่วนท้ายของฟังก์ชัน main() จะใช้ไลบรารี hypertune เพื่อกำหนดเมตริกที่คุณต้องการเพิ่มประสิทธิภาพ ใน TensorFlow เมธอด model.fit ของ Keras จะแสดงผลออบเจ็กต์ History แอตทริบิวต์ History.history คือบันทึกค่าการสูญเสียการฝึกและค่าเมตริกใน Epoch ที่ต่อเนื่องกัน หากคุณส่งข้อมูลการตรวจสอบไปยัง model.fit แอตทริบิวต์ History.history จะรวมการสูญเสียการตรวจสอบและค่าเมตริกด้วย ตัวอย่างเช่น หากคุณฝึกโมเดลเป็นเวลา 3 Epoch ด้วยข้อมูลการตรวจสอบและระบุ accuracy เป็นเมตริก แอตทริบิวต์ History.history จะมีลักษณะคล้ายกับพจนานุกรมต่อไปนี้
{
 "accuracy": [
   0.7795261740684509,
   0.9471358060836792,
   0.9870933294296265
 ],
 "loss": [
   0.6340447664260864,
   0.16712145507335663,
   0.04546636343002319
 ],
 "val_accuracy": [
   0.3795261740684509,
   0.4471358060836792,
   0.4870933294296265
 ],
 "val_loss": [
   2.044623374938965,
   4.100203514099121,
   3.0728273391723633
 ]

หากต้องการให้บริการปรับแต่ง Hyperparameter ค้นพบค่าที่เพิ่มความแม่นยำในการตรวจสอบของโมเดลสูงสุด ให้กำหนดเมตริกเป็นรายการสุดท้าย (หรือ NUM_EPOCS - 1) ของval_accuracy list จากนั้นส่งเมตริกนี้ไปยังอินสแตนซ์ของ HyperTune คุณเลือกสตริงใดก็ได้สำหรับ hyperparameter_metric_tag แต่จะต้องใช้สตริงนั้นอีกครั้งในภายหลังเมื่อเริ่มงานการปรับแต่งไฮเปอร์พารามิเตอร์

6. สร้างคอนเทนเนอร์โค้ด

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

ขั้นตอนที่ 1: เขียน Dockerfile

จากเทอร์มินัล ให้ตรวจสอบว่าคุณอยู่ในไดเรกทอรี vertex-codelab แล้วสร้าง Dockerfile ว่างเปล่า

touch Dockerfile

ตอนนี้คุณควรมีรายการต่อไปนี้ในไดเรกทอรี vertex-codelab

+ Dockerfile
+ trainer/
    + task.py

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

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

WORKDIR /

# Installs hypertune library
RUN pip install cloudml-hypertune

# 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 ของ GPU สำหรับ TensorFlow Enterprise 2.7 ใน Deep Learning Container คอนเทนเนอร์การเรียนรู้เชิงลึกใน Google Cloud มาพร้อมกับเฟรมเวิร์ก ML และวิทยาศาสตร์ข้อมูลทั่วไปหลายรายการที่ติดตั้งไว้ล่วงหน้า หลังจากดาวน์โหลดอิมเมจนั้นแล้ว Dockerfile นี้จะตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึก

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

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

PROJECT_ID='your-cloud-project'

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

IMAGE_URI="gcr.io/$PROJECT_ID/horse-human-codelab:latest"

กำหนดค่า Docker

gcloud auth configure-docker

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

docker build ./ -t $IMAGE_URI

สุดท้าย ให้พุชไปยัง Google Container Registry โดยใช้คำสั่งต่อไปนี้

docker push $IMAGE_URI

ขั้นตอนที่ 3: สร้าง Bucket ของ Cloud Storage

ในงานการฝึก เราจะส่งเส้นทางไปยังที่เก็บข้อมูลชั่วคราว

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

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

7. เปิดใช้งานงานการปรับแต่งไฮเปอร์พารามิเตอร์

ขั้นตอนที่ 1: สร้างงานการฝึกที่กำหนดเองด้วยการปรับแต่งไฮเปอร์พารามิเตอร์

เปิด Notebook ของ TensorFlow 2 ใหม่จากตัวเรียกใช้

new_notebook

นำเข้า Vertex AI Python SDK

from google.cloud import aiplatform
from google.cloud.aiplatform import hyperparameter_tuning as hpt

หากต้องการเปิดใช้งานงานการปรับแต่งไฮเปอร์พารามิเตอร์ คุณต้องกำหนด worker_pool_specs ก่อน ซึ่งจะระบุประเภทเครื่องและอิมเมจ Docker ข้อกำหนดต่อไปนี้กำหนดเครื่อง 1 เครื่องที่มี NVIDIA Tesla V100 GPU 2 ตัว

คุณจะต้องแทนที่ {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 = [{
    "machine_spec": {
        "machine_type": "n1-standard-4",
        "accelerator_type": "NVIDIA_TESLA_V100",
        "accelerator_count": 2
    },
    "replica_count": 1,
    "container_spec": {
        "image_uri": "gcr.io/{PROJECT_ID}/horse-human-codelab:latest"
    }
}]

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

สำหรับไฮเปอร์พารามิเตอร์แต่ละรายการ คุณต้องกำหนดประเภทและขอบเขตของค่าที่บริการปรับแต่งจะลองใช้ ไฮเปอร์พารามิเตอร์อาจเป็นประเภท Double, Integer, Categorical หรือ Discrete หากเลือกประเภทเป็น Double หรือ Integer คุณจะต้องระบุค่าต่ำสุดและสูงสุด และหากเลือก "เชิงหมวดหมู่" หรือ "ไม่ต่อเนื่อง" คุณจะต้องระบุค่า สำหรับประเภท Double และ Integer คุณจะต้องระบุค่าการปรับขนาดด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีเลือกขนาดที่ดีที่สุดได้ในวิดีโอนี้

# Dictionary representing parameters to optimize.
# The dictionary key is the parameter_id, which is passed into your training
# job as a command line argument,
# And the dictionary value is the parameter specification of the metric.
parameter_spec = {
    "learning_rate": hpt.DoubleParameterSpec(min=0.001, max=1, scale="log"),
    "momentum": hpt.DoubleParameterSpec(min=0, max=1, scale="linear"),
    "num_units": hpt.DiscreteParameterSpec(values=[64, 128, 512], scale=None)
}

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

# Dicionary representing metrics to optimize.
# The dictionary key is the metric_id, which is reported by your training job,
# And the dictionary value is the optimization goal of the metric.
metric_spec={'accuracy':'maximize'}

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

คุณจะต้องแทนที่ {YOUR_BUCKET} ด้วย Bucket ที่คุณสร้างขึ้นก่อนหน้านี้

# Replace YOUR_BUCKET
my_custom_job = aiplatform.CustomJob(display_name='horses-humans',
                              worker_pool_specs=worker_pool_specs,
                              staging_bucket='gs://{YOUR_BUCKET}')

จากนั้นสร้างและเรียกใช้ HyperparameterTuningJob

hp_job = aiplatform.HyperparameterTuningJob(
    display_name='horses-humans',
    custom_job=my_custom_job,
    metric_spec=metric_spec,
    parameter_spec=parameter_spec,
    max_trial_count=6,
    parallel_trial_count=2,
    search_algorithm=None)

hp_job.run()

ข้อโต้แย้งบางประการที่ควรทราบมีดังนี้

  • max_trial_count: คุณจะต้องกำหนดขอบเขตบนของจำนวนการทดลองที่บริการจะเรียกใช้ โดยทั่วไปแล้วการทดลองใช้ที่มากขึ้นจะให้ผลลัพธ์ที่ดีกว่า แต่จะมีจุดที่ผลลัพธ์ลดลง หลังจากนั้นการทดลองใช้เพิ่มเติมจะไม่มีผลต่อเมตริกที่คุณพยายามเพิ่มประสิทธิภาพ แนวทางปฏิบัติแนะนำคือให้เริ่มด้วยการทดลองจำนวนน้อยๆ และดูว่าไฮเปอร์พารามิเตอร์ที่เลือกมีผลมากน้อยเพียงใดก่อนที่จะเพิ่มจำนวนการทดลอง
  • parallel_trial_count: หากใช้การทดลองแบบขนาน บริการจะจัดสรรคลัสเตอร์การประมวลผลการฝึกหลายรายการ การเพิ่มจำนวนการทดลองใช้แบบขนานจะช่วยลดระยะเวลาที่ใช้ในการเรียกใช้งานการปรับแต่ง Hyperparameter แต่ก็อาจลดประสิทธิภาพของงานโดยรวมได้ เนื่องจากกลยุทธ์การปรับแต่งเริ่มต้นใช้ผลลัพธ์ของการทดสอบก่อนหน้าเพื่อแจ้งการกำหนดค่าในการทดสอบครั้งต่อๆ ไป
  • search_algorithm: คุณตั้งค่าอัลกอริทึมการค้นหาเป็นตาราง กริด หรือค่าเริ่มต้น (ไม่มี) ได้ ตัวเลือกเริ่มต้นจะใช้การเพิ่มประสิทธิภาพแบบ Bayesian เพื่อค้นหาพื้นที่ของค่าไฮเปอร์พารามิเตอร์ที่เป็นไปได้ และเป็นอัลกอริทึมที่แนะนำ ดูข้อมูลเพิ่มเติมเกี่ยวกับอัลกอริทึมนี้ได้ที่นี่

เมื่อเริ่มงานแล้ว คุณจะติดตามสถานะได้ใน UI ภายใต้แท็บงานการปรับแต่งไฮเปอร์พารามิเตอร์

HP_job

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

HP_results

🎉 ยินดีด้วย 🎉

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

  • เรียกใช้งานการปรับแต่งไฮเปอร์พารามิเตอร์ด้วยการฝึกแบบกระจาย

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

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

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

ลบ

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

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