เกี่ยวกับ Codelab นี้
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 ที่ไฮไลต์ด้านล่าง
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 รายการที่เจาะจงสำหรับบริการการปรับแต่งไฮเปอร์พารามิเตอร์
- สคริปต์จะนําเข้าไลบรารี
hypertune
- ฟังก์ชัน
get_args()
จะกําหนดอาร์กิวเมนต์บรรทัดคําสั่งสําหรับไฮเปอร์พารามิเตอร์แต่ละรายการที่ต้องการปรับแต่ง ในตัวอย่างนี้ ไฮเปอร์พารามิเตอร์ที่จะปรับแต่งคืออัตราการเรียนรู้ ค่าโมเมนตัมในเครื่องมือเพิ่มประสิทธิภาพ และจำนวนหน่วยในเลเยอร์ที่ซ่อนอยู่สุดท้ายของโมเดล แต่คุณสามารถทดลองกับผู้อื่นได้ จากนั้นระบบจะใช้ค่าที่ส่งในอาร์กิวเมนต์เหล่านั้นเพื่อตั้งค่าไฮเปอร์พารามิเตอร์ที่เกี่ยวข้องในโค้ด - ที่ส่วนท้ายของฟังก์ชัน
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
นําเข้า 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 เพื่อค้นหาพื้นที่ของค่าไฮเปอร์พารามิเตอร์ที่เป็นไปได้ และเป็นอัลกอริทึมที่แนะนํา ดูข้อมูลเพิ่มเติมเกี่ยวกับอัลกอริทึมนี้ได้ที่นี่
คุณจะดูความคืบหน้าของงานได้ในคอนโซล
เมื่อการทดสอบเสร็จสิ้น คุณจะดูผลลัพธ์ของการทดสอบแต่ละรายการและชุดค่าที่มีประสิทธิภาพดีที่สุดได้
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้
- เรียกใช้งานการปรับแต่งไฮเปอร์พารามิเตอร์อัตโนมัติ
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ในเอกสารประกอบ
6 ล้างข้อมูล
เนื่องจากเราได้กำหนดค่าโน้ตบุ๊คให้หมดเวลาหลังจากไม่มีการใช้งานเป็นเวลา 60 นาที เราจึงไม่ต้องกังวลเกี่ยวกับการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่ม "หยุด" ในส่วน Vertex AI Workbench ของคอนโซล หากต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม "ลบ"
หากต้องการลบที่เก็บข้อมูล ให้ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ