ต้นแบบเป็นเวอร์ชันที่ใช้งานจริง: การปรับแต่งไฮเปอร์พารามิเตอร์

1. ภาพรวม

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

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

.

สิ่งที่คุณเรียนรู้

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

  • แก้ไขโค้ดแอปพลิเคชันการฝึกอบรมสำหรับการปรับแต่งไฮเปอร์พารามิเตอร์อัตโนมัติ
  • กำหนดค่าและเปิดใช้งานงานการปรับแต่งไฮเปอร์พารามิเตอร์ด้วย Vertex AI Python SDK

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

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

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

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

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

3. ตั้งค่าสภาพแวดล้อม

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

4. บรรจุโค้ดแอปพลิเคชันการฝึกอบรมลงในคอนเทนเนอร์

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

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

เปิดเทอร์มินัลในโน้ตบุ๊ก

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

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

mkdir flowers-hptune
cd flowers-hptune

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

mkdir trainer
touch trainer/task.py

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

+ trainer/
    + task.py

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

คุณจะต้องแทนที่ {your-gcs-bucket} ใน BUCKET_ROOT ด้วยที่เก็บข้อมูล Cloud Storage ที่คุณจัดเก็บชุดข้อมูลดอกไม้ไว้ในห้องทดลอง 1

import tensorflow as tf
import numpy as np
import os
import hypertune
import argparse

## 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 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 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(num_units, learning_rate, momentum):
  '''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(num_units, activation='relu'),
    tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
  ])

  model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=learning_rate, momentum=momentum),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(),
              metrics=['accuracy'])
  
  return model

def main():
  args = get_args()
  train_dataset, validation_dataset = create_datasets(DATA_DIR, BATCH_SIZE)
  model = create_model(args.num_units, args.learning_rate, args.momentum)
  history = model.fit(train_dataset, validation_data=validation_dataset, epochs=EPOCHS)

  # 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=EPOCHS)


if __name__ == "__main__":
    main()

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

  1. สคริปต์จะนําเข้าไลบรารี hypertune
  2. ฟังก์ชัน get_args() จะกําหนดอาร์กิวเมนต์บรรทัดคําสั่งสําหรับไฮเปอร์พารามิเตอร์แต่ละรายการที่ต้องการปรับแต่ง ในตัวอย่างนี้ ไฮเปอร์พารามิเตอร์ที่จะปรับแต่งคืออัตราการเรียนรู้ ค่าโมเมนตัมในเครื่องมือเพิ่มประสิทธิภาพ และจำนวนหน่วยในเลเยอร์ที่ซ่อนอยู่สุดท้ายของโมเดล แต่คุณสามารถทดลองกับผู้อื่นได้ จากนั้นระบบจะใช้ค่าที่ส่งในอาร์กิวเมนต์เหล่านั้นเพื่อตั้งค่าไฮเปอร์พารามิเตอร์ที่เกี่ยวข้องในโค้ด
  3. ที่ส่วนท้ายของฟังก์ชัน main() ระบบจะใช้ไลบรารี hypertune เพื่อกําหนดเมตริกที่คุณต้องการเพิ่มประสิทธิภาพ ใน TensorFlow เมธอดเครา model.fit จะแสดงออบเจ็กต์ History แอตทริบิวต์ History.history คือระเบียนของค่าการสูญเสียในการฝึกและค่าเมตริกในแต่ละยุค หากคุณส่งข้อมูลการตรวจสอบไปยัง model.fit แอตทริบิวต์ History.history จะรวมการสูญเสียการตรวจสอบและค่าเมตริกด้วย ตัวอย่างเช่น หากคุณฝึกโมเดลเป็นเวลา 3 อีพอคด้วยข้อมูลที่ใช้ตรวจสอบและระบุ 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 แต่จะต้องใช้สตริงนั้นอีกครั้งในภายหลังเมื่อเริ่มงานการปรับแต่งไฮเปอร์พารามิเตอร์

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

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

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

touch Dockerfile

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

+ Dockerfile
+ trainer/
    + task.py

เปิด Dockerfile แล้วคัดลอกข้อมูลต่อไปนี้ลงไป คุณจะเห็นว่าไฟล์นี้แทบจะเหมือนกับ Dockerfile ที่เราใช้ในห้องทดลองแรก ยกเว้นตอนนี้เรากำลังติดตั้งไลบรารี cloudml-hypertune

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

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

ขั้นตอนที่ 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_hptune:latest

กำหนดค่า Docker

gcloud auth configure-docker \
    us-central1-docker.pkg.dev

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

docker build ./ -t $IMAGE_URI

สุดท้าย ให้พุชไปยัง Artifact Registry โดยทำดังนี้

docker push $IMAGE_URI

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

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

ในส่วนนี้ คุณจะได้ดูวิธีกำหนดค่าและส่งงานการปรับแต่งไฮเปอร์พารามิเตอร์โดยใช้ Vertex Python API

สร้างสมุดบันทึก TensorFlow 2 จาก Launcher

new_notebook

นําเข้า Vertex AI 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": 1
    },
    "replica_count": 1,
    "container_spec": {
        "image_uri": "us-central1-docker.pkg.dev/{PROJECT_ID}/flower-app/flower_image_hptune:latest"
    }
}]

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

สําหรับไฮเปอร์พารามิเตอร์แต่ละรายการ คุณต้องกําหนดประเภท รวมถึงขอบเขตของค่าที่บริการการปรับแต่งจะลองใช้ ไฮเปอร์พารามิเตอร์อาจเป็นประเภท Double, Integer, Categorical หรือ Discrete หากเลือกประเภท 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 ที่คุณตั้งไว้ในโค้ดแอปพลิเคชันการฝึก และค่าคือเป้าหมายการเพิ่มประสิทธิภาพ

# Dictionary representing metric 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 ซึ่งเป็นข้อกําหนดทั่วไปที่จะใช้ในการเรียกใช้งานในการทดสอบการปรับแต่ง Hyperparameter แต่ละครั้ง

คุณจะต้องแทนที่ {YOUR_BUCKET} ด้วยที่เก็บข้อมูลที่คุณสร้างขึ้นก่อนหน้านี้

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

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

hp_job = aiplatform.HyperparameterTuningJob(
    display_name='flowers-hptune-job',
    custom_job=my_custom_job,
    metric_spec=metric_spec,
    parameter_spec=parameter_spec,
    max_trial_count=15,
    parallel_trial_count=3)

hp_job.run()

อาร์กิวเมนต์ที่ควรทราบมีดังนี้

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

คุณจะดูความคืบหน้าของงานได้ในคอนโซล

hp_job

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

hp_results

🎉 ยินดีด้วย 🎉

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

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

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

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

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

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

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

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