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

1. ภาพรวม

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Notebooks_UI

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

new_notebook

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

create_notebook

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

idle_timeout

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

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

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

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

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

open_jupyterlab

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

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

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

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

launcher_terminal

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

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. ระบบจะสร้างออบเจ็กต์ MirroredStrategy ในฟังก์ชัน main() ต่อไป ให้คุณรวมการสร้างตัวแปรโมเดลภายในขอบเขตของกลยุทธ์ ขั้นตอนนี้จะบอก 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
 ]

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

6. โค้ด Containerize

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

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

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

ในงานการฝึกของเราจะส่งต่อเข้าไปในที่เก็บข้อมูลสำหรับการทดลองใช้

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

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

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

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

เปิดสมุดบันทึกใหม่ของ TensorFlow 2 จาก Launcher

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 เครื่องที่มี GPU NVIDIA Tesla V100 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 ซึ่งเป็นพจนานุกรมที่ระบุพารามิเตอร์ที่คุณต้องการเพิ่มประสิทธิภาพ คีย์พจนานุกรมคือสตริงที่คุณกำหนดให้อาร์กิวเมนต์บรรทัดคำสั่งสำหรับไฮเปอร์พารามิเตอร์แต่ละรายการ และค่าพจนานุกรมคือข้อมูลจำเพาะของพารามิเตอร์

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

# 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} ด้วยที่เก็บข้อมูลที่สร้างไว้ก่อนหน้านี้

# 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()

โดยมีอาร์กิวเมนต์ 2-3 ประการที่ควรทราบ ดังนี้

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

เมื่องานเริ่มต้นขึ้นแล้ว คุณจะติดตามสถานะได้ใน UI ใต้แท็บ HYPERPARAMETER TUNING JOBS

HP_job

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

HP_results

🎉 ยินดีด้วย 🎉

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

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

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

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

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

ลบ

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

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