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

1. ภาพรวม

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

สิ่งที่คุณจะได้เรียนรู้

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

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

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

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

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

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

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

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

คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 1: เปิดใช้ Compute Engine API

ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์ Notebook

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

เปิดใช้ Notebooks API หากยังไม่ได้เปิด

Notebook_api

เมื่อเปิดใช้แล้ว ให้คลิก MANAGED NOTEBOOKS

Notebooks_UI

จากนั้นเลือก NOTEBOOK ใหม่

new_notebook

ตั้งชื่อ Notebook แล้วคลิกการตั้งค่าขั้นสูง

create_notebook

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

idle_timeout

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

enable_terminal

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

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

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

open_jupyterlab

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

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

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

โมเดลที่คุณจะฝึกและปรับแต่งในแล็บนี้คือโมเดลการแยกประเภทรูปภาพที่ฝึกในชุดข้อมูลม้าหรือคนจาก TensorFlow Datasets

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

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

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

สร้างไดเรกทอรีใหม่ชื่อ horses_or_humans แล้วใช้คำสั่ง cd เพื่อเข้าไปในไดเรกทอรีดังกล่าว

mkdir horses_or_humans
cd horses_or_humans

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

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

สร้าง Dockerfile ที่ว่างเปล่าจากเทอร์มินัลโดยทำดังนี้

touch Dockerfile

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

ขั้นตอนที่ 2: เพิ่มโค้ดการฝึกโมเดล

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

mkdir trainer
touch trainer/task.py

ตอนนี้คุณควรมีรายการต่อไปนี้ในไดเรกทอรี horses_or_humans/

+ Dockerfile
+ trainer/
    + task.py

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

import tensorflow as tf
import tensorflow_datasets as tfds
import argparse
import hypertune

NUM_EPOCHS = 10


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():
  '''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(64)

  # Create validation dataset
  validation_data = data['test'].map(preprocess_data)
  validation_data  = validation_data.batch(64)

  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()
  train_data, validation_data = create_dataset()
  model = create_model(args.num_units, args.learning_rate, args.momentum)
  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()

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

สคริปต์จะนำเข้าไลบรารี hypertune โปรดทราบว่า Dockerfile จากขั้นตอนที่ 1 มีวิธีการติดตั้งไลบรารีนี้ด้วย pip
ฟังก์ชัน get_args() กําหนดอาร์กิวเมนต์บรรทัดคําสั่งสําหรับไฮเปอร์พารามิเตอร์แต่ละรายการที่ต้องการปรับ ในตัวอย่างนี้ ไฮเปอร์พารามิเตอร์ที่จะได้รับการปรับคืออัตราการเรียนรู้ ค่าโมเมนตัมในเครื่องมือเพิ่มประสิทธิภาพ และจำนวนหน่วยในเลเยอร์ที่ซ่อนสุดท้ายของโมเดล แต่คุณสามารถทดลองกับไฮเปอร์พารามิเตอร์อื่นๆ ได้ จากนั้นระบบจะใช้ค่าที่ส่งในอาร์กิวเมนต์เหล่านั้นเพื่อตั้งค่าไฮเปอร์พารามิเตอร์ที่เกี่ยวข้องในโค้ด
ที่ส่วนท้ายของฟังก์ชัน 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
 ]

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

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

จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปรสภาพแวดล้อมสำหรับโปรเจ็กต์ของคุณ โดยแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์

PROJECT_ID='your-cloud-project'

กำหนดตัวแปรด้วย URI ของอิมเมจคอนเทนเนอร์ใน Google Container Registry ดังนี้

IMAGE_URI="gcr.io/$PROJECT_ID/horse-human:hypertune"

กำหนดค่า Docker

gcloud auth configure-docker

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

docker build ./ -t $IMAGE_URI

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

docker push $IMAGE_URI

เมื่อพุชคอนเทนเนอร์ไปยัง Container Registry แล้ว คุณก็พร้อมที่จะเริ่มงานการปรับไฮเปอร์พารามิเตอร์ของโมเดลที่กำหนดเองแล้ว

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

แล็บนี้ใช้การฝึกที่กำหนดเองผ่านคอนเทนเนอร์ที่กำหนดเองใน Google Container Registry แต่คุณยังเรียกใช้ชื่องานการปรับไฮเปอร์พารามิเตอร์ด้วยคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าของ Vertex AI ได้ด้วย

หากต้องการเริ่มต้นใช้งาน ให้ไปที่ส่วนการฝึกในส่วน Vertex ของคอนโซล Cloud

ขั้นตอนที่ 1: กำหนดค่างานการฝึก

คลิกสร้างเพื่อป้อนพารามิเตอร์สำหรับงานการปรับแต่งไฮเปอร์พารามิเตอร์

ในส่วนชุดข้อมูล ให้เลือกไม่มีชุดข้อมูลที่มีการจัดการ
จากนั้นเลือกการฝึกแบบกำหนดเอง (ขั้นสูง) เป็นวิธีการฝึก แล้วคลิกต่อไป
ป้อน horses-humans-hyptertune (หรือชื่อโมเดลที่คุณต้องการ) สำหรับชื่อโมเดล
คลิกต่อไป

ในขั้นตอนการตั้งค่าคอนเทนเนอร์ ให้เลือกคอนเทนเนอร์ที่กำหนดเอง

ตัวเลือกคอนเทนเนอร์ที่กำหนดเอง

ในช่องแรก (อิมเมจคอนเทนเนอร์) ให้ป้อนค่าของตัวแปร IMAGE_URI จากส่วนก่อนหน้า โดยควรเป็น gcr.io/your-cloud-project/horse-human:hypertune พร้อมชื่อโปรเจ็กต์ของคุณเอง เว้นช่องที่เหลือว่างไว้ แล้วคลิกดำเนินการต่อ

ขั้นตอนที่ 2: กำหนดค่างานการปรับแต่งไฮเปอร์พารามิเตอร์

เลือกเปิดใช้การปรับแต่งไฮเปอร์พารามิเตอร์

ไฮเปอร์พารามิเตอร์

กำหนดค่าไฮเปอร์พารามิเตอร์

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

learning_rate_name

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

learning_rate_type learning_rate_name

สำหรับประเภท Double และ Integer คุณจะต้องระบุค่าการปรับขนาดด้วย

learning_rate_scale

หลังจากเพิ่มไฮเปอร์พารามิเตอร์ learning_rate แล้ว ให้เพิ่มพารามิเตอร์สำหรับ momentum และ num_units

momentum_config

numneruons_config

กำหนดค่าเมตริก

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

metric_config

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

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

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

trial_config

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

algorithm_config

คลิกต่อไป

ขั้นตอนที่ 3: กำหนดค่าการคำนวณ

ในส่วนการประมวลผลและราคา ให้ปล่อยภูมิภาคที่เลือกไว้ตามเดิม แล้วกำหนดค่ากลุ่ม Worker 0 ดังนี้

ประเภทเครื่อง

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

งาน Hyperparameter

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

เอาต์พุตไฮเปอร์พารามิเตอร์

🎉 ยินดีด้วย 🎉

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

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

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

6. [ไม่บังคับ] ใช้ Vertex SDK

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

สร้าง Notebook ของ TensorFlow 2 จากตัวเรียกใช้

new_notebook

นำเข้า Vertex AI SDK

from google.cloud import aiplatform
from google.cloud.aiplatform import hyperparameter_tuning as hpt

หากต้องการเปิดใช้งานงานการปรับแต่งไฮเปอร์พารามิเตอร์ คุณต้องกำหนดข้อกำหนดต่อไปนี้ก่อน คุณจะต้องแทนที่ {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": "gcr.io/{PROJECT_ID}/horse-human:hypertune"
    }
}]


# Dictionary 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'}

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

จากนั้นสร้าง CustomJob คุณจะต้องแทนที่ {YOUR_BUCKET} ด้วย Bucket ในโปรเจ็กต์สำหรับการจัดเตรียม

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

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

hp_job = aiplatform.HyperparameterTuningJob(
    display_name='horses-humans-sdk-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()

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

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

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

หากต้องการลบ Storage Bucket ให้ใช้เมนูการนำทางใน Cloud Console โดยไปที่ Storage เลือก Bucket แล้วคลิกลบ

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