Prototipe hingga Produksi: Penyesuaian hyperparameter

1. Ringkasan

Di lab ini, Anda akan menggunakan Vertex AI untuk menjalankan tugas penyesuaian hyperparameter pada Pelatihan Vertex AI.

Lab ini merupakan bagian dari seri video Prototipe hingga Produksi. Pastikan untuk menyelesaikan lab sebelumnya sebelum mencoba lab ini. Anda dapat menonton seri video yang disertakan untuk mempelajari lebih lanjut:

.

Yang Anda pelajari

Anda akan mempelajari cara:

  • Mengubah kode aplikasi pelatihan untuk penyesuaian hyperparameter otomatis.
  • Mengonfigurasi dan meluncurkan tugas penyelesaian hyperparameter dengan Vertex AI Python SDK

Total biaya untuk menjalankan lab ini di Google Cloud adalah sekitar $1.

2. Pengantar Vertex AI

Lab ini menggunakan penawaran produk AI terbaru yang tersedia di Google Cloud. Vertex AI mengintegrasikan penawaran ML di Google Cloud ke dalam pengalaman pengembangan yang lancar. Sebelumnya, model yang dilatih dengan AutoML dan model kustom dapat diakses melalui layanan terpisah. Penawaran baru ini menggabungkan kedua model ini menjadi satu API, beserta produk baru lainnya. Anda juga dapat memigrasikan project yang sudah ada ke Vertex AI.

Vertex AI mencakup banyak produk yang berbeda untuk mendukung alur kerja ML secara menyeluruh. Lab ini akan berfokus pada produk yang disorot di bawah: Pelatihan dan Workbench

Ringkasan produk Vertex

3. Menyiapkan lingkungan Anda

Selesaikan langkah-langkah di lab Melatih model kustom dengan Vertex AI untuk menyiapkan lingkungan Anda.

4. Menyimpan kode aplikasi pelatihan dalam container

Anda akan mengirim tugas pelatihan ke Vertex AI dengan menempatkan kode aplikasi dalam container Docker dan mengirim container ini ke Google Artifact Registry. Menggunakan pendekatan ini, Anda dapat melatih dan menyesuaikan model yang dibangun dengan framework apa pun.

Untuk memulai, dari menu Peluncur pada notebook Workbench yang telah Anda buat di lab sebelumnya, buka jendela terminal.

Membuka terminal di notebook

Langkah 1: Tulis kode pelatihan

Buat direktori baru bernama flowers-hptune dan cd ke dalamnya:

mkdir flowers-hptune
cd flowers-hptune

Jalankan perintah berikut guna membuat direktori untuk kode pelatihan dan file Python tempat Anda akan menambahkan kode di bawah.

mkdir trainer
touch trainer/task.py

Sekarang Anda akan memiliki kode berikut di direktori flowers-hptune/ Anda:

+ trainer/
    + task.py

Selanjutnya, buka file task.py yang baru saja Anda buat dan salin kode di bawah.

Anda harus mengganti {your-gcs-bucket} dalam BUCKET_ROOT dengan bucket Cloud Storage tempat Anda menyimpan set data bunga di Lab 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()

Sebelum Anda membangun container, mari pelajari lebih lanjut kode tersebut. Ada beberapa komponen yang spesifik untuk penggunaan layanan penyesuaian hyperparameter.

  1. Skrip ini akan mengimpor library hypertune.
  2. Fungsi get_args() menentukan argumen command line untuk setiap hyperparameter yang ingin Anda sesuaikan. Dalam contoh ini, hyperparameter yang akan disesuaikan adalah kecepatan pembelajaran, nilai momentum dalam pengoptimal, dan jumlah unit dalam lapisan tersembunyi terakhir dari model, tetapi jangan ragu untuk bereksperimen menggunakan yang lainnya. Nilai yang diteruskan dalam argumen tersebut kemudian akan digunakan untuk menetapkan hyperparameter yang sesuai dalam kode.
  3. Di bagian akhir fungsi main(), library hypertune digunakan untuk menentukan metrik yang ingin Anda optimalkan. Di TensorFlow, metode model.fit Keras akan menampilkan objek History. Atribut History.history adalah data nilai kerugian pelatihan dan nilai metrik pada iterasi pelatihan berturut-turut. Jika Anda meneruskan data validasi ke model.fit, atribut History.history juga akan menyertakan nilai metrik dan kerugian validasi. Misalnya, jika Anda melatih model untuk tiga iterasi pelatihan dengan data validasi dan memberikan accuracy sebagai metrik, atribut History.history akan terlihat mirip dengan kamus berikut.
{
 "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
 ]

Jika Anda ingin layanan penyesuaian hyperparameter menemukan nilai yang memaksimalkan akurasi validasi model, Anda perlu menentukan metrik sebagai entri terakhir (atau NUM_EPOCS - 1) dari daftar val_accuracy. Kemudian, teruskan metrik ini ke instance HyperTune. Anda dapat memilih string apa pun yang diinginkan untuk hyperparameter_metric_tag, tetapi Anda harus menggunakan string tersebut lagi saat memulai tugas penyesuaian hyperparameter.

Langkah 2: Buat Dockerfile

Untuk menyimpan kode dalam container, Anda harus membuat Dockerfile. Dalam Dockerfile, Anda akan menyertakan semua perintah yang diperlukan untuk menjalankan image. Tindakan ini akan menginstal semua library yang diperlukan dan menyiapkan titik entri untuk kode pelatihan.

Dari Terminal Anda, buat Dockerfile kosong dalam root direktori flowers-hptune Anda:

touch Dockerfile

Sekarang Anda akan memiliki kode berikut di direktori flowers-hptune/ Anda:

+ Dockerfile
+ trainer/
    + task.py

Buka Dockerfile dan salin kode berikut ke dalamnya. Anda akan melihat bahwa Dockerfile ini hampir sama dengan yang kita gunakan di lab pertama, hanya saja sekarang kita akan menginstal library 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"]

Langkah 3: Build container

Dari Terminal Anda, jalankan perintah berikut guna menentukan variabel env untuk project Anda, pastikan untuk mengganti your-cloud-project dengan ID project Anda:

PROJECT_ID='your-cloud-project'

Tentukan repositori di Artifact Registry. Kita akan menggunakan repositori yang kita buat di lab pertama.

REPO_NAME='flower-app'

Tentukan variabel dengan URI image container Anda di Google Artifact Registry:

IMAGE_URI=us-central1-docker.pkg.dev/$PROJECT_ID/$REPO_NAME/flower_image_hptune:latest

Mengonfigurasi Docker

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

Kemudian, bangun container dengan menjalankan perintah berikut dari root direktori flower-hptune Anda:

docker build ./ -t $IMAGE_URI

Terakhir, kirim ke Artifact Registry:

docker push $IMAGE_URI

Dengan container yang dikirim ke Artifact Registry, sekarang Anda siap untuk memulai tugas pelatihan.

5. Menjalankan tugas penyesuaian hyperparameter dengan SDK

Di bagian ini, Anda akan mempelajari cara mengonfigurasi dan mengirim tugas penyesuaian hyperparameter menggunakan Vertex Python API.

Dari Peluncur, buat notebook TensorFlow 2.

new_notebook

Impor Vertex AI SDK.

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

Untuk meluncurkan tugas penyesuaian hyperparameter, Anda harus terlebih dahulu menentukan worker_pool_specs, yang akan menentukan jenis mesin dan image Docker. Spesifikasi berikut menentukan satu mesin dengan dua GPU NVIDIA Tesla V100.

Anda harus mengganti {PROJECT_ID} di image_uri dengan project Anda.

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

Selanjutnya, tentukan parameter_spec, yang merupakan kamus untuk menentukan parameter yang ingin Anda optimalkan. Kunci kamus adalah string yang Anda tetapkan ke argumen command line untuk setiap hyperparameter, dan nilai kamus adalah spesifikasi parameternya.

Untuk setiap hyperparameter, Anda harus menentukan Jenis serta batas nilai yang akan dicoba oleh layanan penyesuaian. Hyperparameter dapat berupa jenis Ganda, Bilangan Bulat, Kategoris, atau Diskret. Jika memilih jenis Ganda atau Bilangan Bulat, Anda harus memberikan nilai minimum dan maksimum. Dan jika memilih Kategoris atau Diskret, Anda harus memberikan nilainya. Untuk jenis Ganda dan Bilangan Bulat, Anda juga harus memberikan nilai Penskalaan. Anda dapat mempelajari lebih lanjut cara memilih skala terbaik dalam video ini.

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

Spesifikasi akhir yang ditetapkan adalah metric_spec, yaitu kamus yang mewakili metrik yang akan dioptimalkan. Kunci kamus adalah hyperparameter_metric_tag yang Anda tetapkan dalam kode aplikasi pelatihan, dan nilainya adalah sasaran pengoptimalannya.

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

Setelah spesifikasi ditentukan, Anda akan membuat CustomJob, yaitu spesifikasi umum yang akan digunakan untuk menjalankan tugas Anda pada setiap uji coba penyesuaian hyperparameter.

Anda harus mengganti {YOUR_BUCKET} dengan bucket yang Anda buat sebelumnya.

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

Kemudian, buat dan jalankan 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()

Ada beberapa argumen yang perlu diperhatikan:

  • max_trial_count: Anda harus menetapkan batas maksimal terkait jumlah uji coba yang akan dijalankan oleh layanan tersebut. Lebih banyak uji coba umumnya memberikan hasil yang lebih baik, tetapi akan ada titik penurunan hasil, lalu uji coba tambahan yang dilakukan setelahnya memiliki sedikit hingga tanpa pengaruh pada metrik yang akan Anda optimalkan. Praktik terbaiknya adalah memulai dengan jumlah uji coba yang lebih sedikit dan memahami dampaknya terhadap hyperparameter yang Anda pilih sebelum meningkatkan skalanya.
  • paralel_trial_count: Jika Anda menggunakan uji coba paralel, layanan akan menyediakan beberapa cluster pemrosesan pelatihan. Peningkatan jumlah uji coba paralel akan mengurangi jumlah waktu yang diperlukan untuk menjalankan tugas penyesuaian hyperparameter; tetapi, cara ini dapat mengurangi efektivitas tugas secara keseluruhan. Hal ini karena strategi penyesuaian default menggunakan hasil uji coba sebelumnya untuk menentukan penetapan nilai dalam uji coba berikutnya.
  • search_algorithm: Anda dapat menetapkan algoritma penelusuran ke petak, acak, atau default (Tidak ada). Opsi default menerapkan pengoptimalan Bayesian untuk menelusuri ruang dari kemungkinan nilai hyperparameter dan merupakan algoritma yang direkomendasikan. Anda dapat mempelajari lebih lanjut algoritma ini di sini.

Di konsol, Anda dapat melihat progres tugas Anda.

hp_job

Setelah selesai, Anda dapat melihat hasil dari setiap uji coba dan kumpulan nilai mana yang berperforma terbaik.

hp_results

🎉 Selamat! 🎉

Anda telah mempelajari cara menggunakan Vertex AI untuk:

  • Menjalankan tugas penyesuaian hyperparameter otomatis

Untuk mempelajari lebih lanjut berbagai bagian Vertex, lihat dokumentasinya.

6. Pembersihan

Karena sebelumnya kita telah mengonfigurasi notebook agar kehabisan waktu setelah 60 menit tidak ada aktivitas, jangan khawatir untuk menonaktifkan instance-nya. Jika Anda ingin menonaktifkan instance secara manual, klik tombol Hentikan di bagian Vertex AI Workbench pada konsol. Jika Anda ingin menghapus notebook secara keseluruhan, klik tombol Hapus.

Hentikan instance

Untuk menghapus Bucket Penyimpanan, menggunakan menu Navigasi di Konsol Cloud, jelajahi Penyimpanan, pilih bucket Anda, lalu klik Hapus:

Hapus penyimpanan