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 ตั้งแต่ต้นจนจบ ห้องทดลองนี้จะเน้นที่การฝึกอบรมและเวิร์กเบนค์
3. ภาพรวมกรณีการใช้งาน
ในชั้นเรียนนี้ คุณจะใช้การปรับแต่งไฮเปอร์พารามิเตอร์เพื่อค้นหาพารามิเตอร์ที่ดีที่สุดสําหรับโมเดลการจัดประเภทรูปภาพที่ฝึกในชุดข้อมูลม้าหรือมนุษย์จากชุดข้อมูล TensorFlow
การปรับแต่งไฮเปอร์พารามิเตอร์
การปรับแต่งไฮเปอร์พารามิเตอร์ด้วยการฝึก Vertex AI ทํางานโดยการเรียกใช้การทดลองใช้แอปพลิเคชันการฝึกหลายรายการด้วยค่าสําหรับไฮเปอร์พารามิเตอร์ที่เลือก ซึ่งตั้งค่าภายในขีดจํากัดที่คุณระบุ Vertex AI จะติดตามผลลัพธ์ของการทดลองใช้แต่ละครั้งและทำการปรับเปลี่ยนสำหรับการทดลองใช้ครั้งต่อๆ ไป
หากต้องการใช้การปรับแต่งไฮเปอร์พารามิเตอร์กับการฝึก Vertex AI คุณจะต้องทําการเปลี่ยนแปลง 2 อย่างในโค้ดการฝึก
- กำหนดอาร์กิวเมนต์บรรทัดคำสั่งในโมดูลการฝึกหลักสำหรับไฮเปอร์พารามิเตอร์แต่ละรายการที่คุณต้องการปรับแต่ง
- ใช้ค่าที่ส่งผ่านในอาร์กิวเมนต์เหล่านั้นเพื่อตั้งค่าไฮเปอร์พารามิเตอร์ที่เกี่ยวข้องในโค้ดของแอปพลิเคชัน
การฝึกอบรมแบบกระจาย
หากคุณมี GPU ตัวเดียว TensorFlow จะใช้ตัวเร่งนี้เพื่อเร่งการฝึกโมเดลโดยที่คุณไม่ต้องทำอะไรเพิ่มเติม อย่างไรก็ตาม หากต้องการเพิ่มประสิทธิภาพโดยใช้ GPU หลายตัว คุณจะต้องใช้ tf.distribute ซึ่งเป็นโมดูลของ TensorFlow สำหรับเรียกใช้การคํานวณในอุปกรณ์หลายเครื่อง
ห้องทดลองนี้ใช้ tf.distribute.MirroredStrategy ซึ่งคุณสามารถเพิ่มลงในแอปพลิเคชันการฝึกอบรมได้โดยทำการเปลี่ยนแปลงโค้ดเพียงไม่กี่บรรทัด กลยุทธ์นี้จะสร้างสำเนาของโมเดลใน GPU แต่ละตัวในเครื่อง การอัปเดตเส้นลาดต่อมาจะดำเนินการพร้อมกัน ซึ่งหมายความว่า GPU แต่ละรายการจะคำนวณการส่งต่อและย้อนกลับผ่านโมเดลในส่วนของข้อมูลอินพุตที่แตกต่างกัน จากนั้นระบบจะรวบรวมและหาค่าเฉลี่ยของอนุพันธ์ที่คำนวณจากแต่ละส่วนเหล่านี้ใน GPU ทั้งหมดในกระบวนการที่เรียกว่า all-reduce ระบบจะอัปเดตพารามิเตอร์โมเดลโดยใช้การไล่ระดับสีโดยเฉลี่ยเหล่านี้
คุณไม่จำเป็นต้องทราบรายละเอียดเพื่อทําแล็บนี้ให้เสร็จสมบูรณ์ แต่หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทํางานของการฝึกแบบกระจายใน TensorFlow โปรดดูวิดีโอด้านล่าง
4. ตั้งค่าสภาพแวดล้อม
คุณต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้โค้ดแล็บนี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้
ขั้นตอนที่ 2: เปิดใช้ Container Registry API
ไปที่ Container Registry แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะใช้ข้อมูลนี้เพื่อสร้างคอนเทนเนอร์สำหรับงานการฝึกที่กำหนดเอง
ขั้นตอนที่ 3: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API
ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench
จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench
เปิดใช้ Notebooks API หากยังไม่ได้เปิดใช้
เมื่อเปิดใช้แล้ว ให้คลิกโน้ตบุ๊กที่มีการจัดการ
จากนั้นเลือกสมุดบันทึกใหม่
ตั้งชื่อสมุดบันทึก แล้วคลิกการตั้งค่าขั้นสูง
ในส่วนการตั้งค่าขั้นสูง ให้เปิดใช้การปิดเครื่องเมื่อไม่มีการใช้งานและตั้งค่าจำนวนนาทีเป็น 60 ซึ่งหมายความว่าโน้ตบุ๊คจะปิดโดยอัตโนมัติเมื่อไม่มีการใช้งาน เพื่อไม่ให้คุณเสียค่าใช้จ่ายโดยไม่จำเป็น
ภายใต้ "ความปลอดภัย" เลือก "เปิดใช้เทอร์มินัล" หากยังไม่ได้เปิดใช้
คุณปล่อยการตั้งค่าขั้นสูงอื่นๆ ทั้งหมดไว้ตามเดิมได้
จากนั้นคลิกสร้าง อินสแตนซ์จะใช้เวลา 2-3 นาทีในการเตรียมใช้งาน
เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JupyterLab
ระบบจะขอให้คุณตรวจสอบสิทธิ์เมื่อใช้อินสแตนซ์ใหม่เป็นครั้งแรก ทําตามขั้นตอนใน UI
5. เขียนโค้ดการฝึก
ในการเริ่มต้น ให้เปิดหน้าต่างเทอร์มินัลในอินสแตนซ์โน้ตบุ๊กจากเมนู Launcher โดยทำดังนี้
สร้างไดเรกทอรีใหม่ชื่อ 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()
มาเจาะลึกโค้ดและตรวจสอบคอมโพเนนต์เฉพาะสำหรับการฝึกแบบกระจายและการปรับแต่งไฮเปอร์พารามิเตอร์กัน
การฝึกอบรมแบบกระจาย
- ในฟังก์ชัน
main()ระบบจะสร้างออบเจ็กต์MirroredStrategyถัดไป ให้ปิดการสร้างตัวแปรรูปแบบภายในขอบเขตของกลยุทธ์ ขั้นตอนนี้จะบอก TensorFlow ว่าควรมิเรอร์ตัวแปรใดใน GPU - ระบบจะปรับขนาดกลุ่มเป็น
num_replicas_in_syncการปรับขนาดกลุ่มเป็นแนวทางปฏิบัติแนะนำเมื่อใช้กลยุทธ์การทำงานแบบขนานของข้อมูลแบบซิงค์ใน TensorFlow ดูข้อมูลเพิ่มเติมได้ที่นี่
การปรับแต่งไฮเปอร์พารามิเตอร์
- สคริปต์จะนําเข้าไลบรารี
hypertuneเมื่อสร้างอิมเมจคอนเทนเนอร์ในภายหลัง เราจะต้องตรวจสอบว่าได้ติดตั้งไลบรารีนี้แล้ว - ฟังก์ชัน
get_args()จะกําหนดอาร์กิวเมนต์บรรทัดคําสั่งสําหรับไฮเปอร์พารามิเตอร์แต่ละรายการที่ต้องการปรับแต่ง ในตัวอย่างนี้ ฮิวเปอร์พารามิเตอร์ที่จะปรับแต่งคืออัตราการเรียนรู้ ค่าโมเมนตัมในเครื่องมือเพิ่มประสิทธิภาพ และจํานวนหน่วยในชั้นที่ซ่อนอยู่ล่าสุดของโมเดล แต่คุณก็ลองใช้ฮิวเปอร์พารามิเตอร์อื่นๆ ก็ได้ จากนั้นระบบจะใช้ค่าที่ส่งในอาร์กิวเมนต์เหล่านั้นเพื่อตั้งค่าไฮเปอร์พารามิเตอร์ที่เกี่ยวข้องในโค้ด (เช่น ตั้งค่าlearning_rate = args.learning_rate) - ที่ส่วนท้ายของฟังก์ชัน
main()ระบบจะใช้ไลบรารีhypertuneเพื่อกําหนดเมตริกที่คุณต้องการเพิ่มประสิทธิภาพ ใน TensorFlow เมธอดmodel.fitของ Keras จะแสดงออบเจ็กต์Historyแอตทริบิวต์History.historyคือระเบียนของค่าการสูญเสียในการฝึกและค่าเมตริกในแต่ละยุค หากคุณส่งข้อมูลการตรวจสอบไปยัง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. บรรจุโค้ดในคอนเทนเนอร์
ขั้นตอนแรกในการบรรจุโค้ดของคุณลงในคอนเทนเนอร์คือการสร้าง 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 ของคอนเทนเนอร์การเรียนรู้เชิงลึก TensorFlow Enterprise 2.7 GPU คอนเทนเนอร์การเรียนรู้เชิงลึกใน 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: สร้างงานการฝึกอบรมที่กำหนดเองด้วยการปรับแต่งไฮเปอร์พารามิเตอร์
เปิด Notebook ใหม่ของ TensorFlow 2 จากตัวเปิด
นําเข้า 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 ซึ่งเป็นพจนานุกรมที่ระบุพารามิเตอร์ที่คุณต้องการเพิ่มประสิทธิภาพ คีย์ของพจนานุกรมคือสตริงที่คุณกําหนดให้กับอาร์กิวเมนต์บรรทัดคําสั่งสําหรับไฮเปอร์พารามิเตอร์แต่ละรายการ และค่าของพจนานุกรมคือข้อกําหนดของพารามิเตอร์
สําหรับไฮเปอร์พารามิเตอร์แต่ละรายการ คุณต้องกําหนดประเภท รวมถึงขอบเขตของค่าที่บริการการปรับแต่งจะลองใช้ ไฮเปอร์พารามิเตอร์อาจเป็นประเภท 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} ด้วยที่เก็บข้อมูลที่คุณสร้างขึ้นก่อนหน้านี้
# 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: หากคุณใช้การทดลองใช้พร้อมกัน บริการจะจัดสรรคลัสเตอร์การประมวลผลการฝึกหลายรายการ การเพิ่มจํานวนการทดสอบแบบขนานจะลดเวลาในการทํางานของการปรับแต่งไฮเปอร์พารามิเตอร์ แต่อาจทําให้ประสิทธิภาพโดยรวมของงานลดลง เนื่องจากกลยุทธ์การปรับเริ่มต้นใช้ผลลัพธ์ของการทดสอบก่อนหน้านี้เพื่อกำหนดค่าในการทดสอบครั้งต่อๆ ไป
- search_algorithm: คุณตั้งค่าอัลกอริทึมการค้นหาเป็นตารางกริด แบบสุ่ม หรือค่าเริ่มต้น (ไม่มี) ได้ ตัวเลือกเริ่มต้นจะใช้การเพิ่มประสิทธิภาพแบบ Bayesian เพื่อค้นหาพื้นที่ของค่าไฮเปอร์พารามิเตอร์ที่เป็นไปได้ และเป็นอัลกอริทึมที่แนะนํา ดูข้อมูลเพิ่มเติมเกี่ยวกับอัลกอริทึมนี้ได้ที่นี่
เมื่องานเริ่มต้นขึ้นแล้ว คุณจะติดตามสถานะได้ใน UI ใต้แท็บ HYPERPARAMETER TUNING JobS
เมื่องานเสร็จสมบูรณ์แล้ว คุณสามารถดูและจัดเรียงผลลัพธ์ของการทดสอบเพื่อค้นหาชุดค่าผสมของค่าไฮเปอร์พารามิเตอร์ที่ดีที่สุด
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้
- เรียกใช้งานการปรับแต่งไฮเปอร์พารามิเตอร์ด้วยการฝึกแบบกระจาย
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex AI ได้ในเอกสารประกอบ
8. ล้างข้อมูล
เนื่องจากเรากำหนดค่าสมุดบันทึกให้หมดเวลาหลังจากไม่มีการใช้งาน 60 นาที เราจึงไม่ต้องกังวลเกี่ยวกับการปิดอินสแตนซ์ หากต้องการปิดอินสแตนซ์ด้วยตนเอง ให้คลิกปุ่ม "หยุด" ในส่วน Vertex AI Workbench ของคอนโซล หากคุณต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่ม ลบ
หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:
