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

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

เกี่ยวกับ Codelab นี้

subjectอัปเดตล่าสุดเมื่อ ส.ค. 25, 2022
account_circleเขียนโดย Nikita Namjoshi

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

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