Vertex AI: Penyelarasan Hyperparameter

1. Ringkasan

Di lab ini, Anda akan menggunakan Vertex AI untuk menjalankan tugas penyesuaian hyperparameter untuk model TensorFlow. Meskipun lab ini menggunakan TensorFlow untuk kode model, konsepnya juga berlaku untuk framework ML lainnya.

Yang Anda pelajari

Anda akan mempelajari cara:

• Mengubah kode aplikasi pelatihan untuk penyelarasan hiperparameter otomatis
• Mengonfigurasi dan meluncurkan tugas penyesuaian hyperparameter dari UI Vertex AI
• Mengonfigurasi dan meluncurkan tugas penyesuaian hyperparameter dengan Vertex AI Python SDK

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

2. Pengantar AI Vertex

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 keduanya menjadi satu API, bersama dengan produk baru lainnya. Anda juga dapat memigrasikan project yang ada ke Vertex AI. Jika Anda memiliki masukan, lihat halaman dukungan.

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

3 Menyiapkan lingkungan Anda

Anda memerlukan project Google Cloud Platform dengan penagihan diaktifkan untuk menjalankan codelab ini. Untuk membuat project, ikuti petunjuk di sini.

Langkah 1: Aktifkan Compute Engine API

Buka Compute Engine dan pilih Aktifkan jika belum diaktifkan. Anda akan memerlukan ini untuk membuat instance notebook.

Langkah 2: Aktifkan Container Registry API

Buka Container Registry dan pilih Aktifkan jika belum melakukannya. Anda akan menggunakannya untuk membuat container untuk tugas pelatihan kustom.

Langkah 3: Aktifkan Vertex AI API

Buka bagian Vertex AI Cloud Console Anda, lalu klik Aktifkan Vertex AI API.

Langkah 4: Buat instance Workbench Vertex AI

Dari bagian Vertex AI di Cloud Console, klik Workbench:

Aktifkan Notebooks API jika belum diaktifkan.

Setelah diaktifkan, klik KELOLA CATATAN TERKELOLA:

Kemudian, pilih Notebook BARU.

Beri nama pada notebook Anda, lalu klik Setelan Lanjutan.

Di bagian Setelan Lanjutan, aktifkan penonaktifan saat tidak ada aktivitas dan tetapkan jumlah menit ke 60. Artinya, notebook Anda akan otomatis dinonaktifkan saat tidak digunakan sehingga tidak menimbulkan biaya yang tidak perlu.

Di bagian Keamanan, pilih "Aktifkan terminal" jika belum diaktifkan.

Anda dapat membiarkan semua setelan lanjutan lainnya seperti apa adanya.

Selanjutnya, klik Buat. Instance akan memerlukan waktu beberapa menit untuk disediakan.

Setelah instance dibuat, pilih Buka JupyterLab.

Saat pertama kali menggunakan instance baru, Anda akan diminta untuk mengautentikasi. Ikuti langkah-langkah di UI untuk melakukannya.

4. Mem-build kode aplikasi pelatihan dalam container

Model yang akan Anda pelatihan dan sesuaikan di lab ini adalah model klasifikasi gambar yang dilatih di set data kuda atau manusia dari Set Data TensorFlow.

Anda akan mengirimkan tugas penyesuaian hyperparameter ini ke Vertex AI dengan menempatkan kode aplikasi pelatihan Anda dalam container Docker dan mengirim penampung ini ke Google Container Registry. Dengan pendekatan ini, Anda dapat menyesuaikan hyperparameter untuk model yang dibuat dengan framework apa pun.

Untuk memulai, dari menu Peluncur, buka jendela Terminal di instance notebook Anda:

Buat direktori baru bernama horses_or_humans dan cd ke dalamnya:

mkdir horses_or_humans
cd horses_or_humans

Langkah 1: Buat Dockerfile

Langkah pertama dalam container kode Anda adalah membuat Dockerfile. Dalam Dockerfile, Anda akan menyertakan semua perintah yang diperlukan untuk menjalankan gambar. Tindakan ini akan menginstal semua library yang diperlukan, termasuk library Cloud ML Hypertune, dan menyiapkan titik entri untuk kode pelatihan.

Dari Terminal Anda, buat Dockerfile kosong:

touch Dockerfile

Buka Dockerfile dan salin kode berikut ke dalamnya:

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 ini menggunakan image Docker GPU Deep Learning Container Enterprise 2.7. Deep Learning Containers di Google Cloud dilengkapi dengan banyak ML umum dan framework ilmu data yang telah terinstal. Setelah mendownload gambar tersebut, Dockerfile ini akan menyiapkan entrypoint untuk kode pelatihan. Anda belum membuat file ini. Pada langkah berikutnya, Anda akan menambahkan kode untuk melatih dan menyesuaikan model.

Langkah 2: Tambahkan kode pelatihan model

Dari Terminal Anda, jalankan perintah berikut guna membuat direktori untuk kode pelatihan dan file Python tempat Anda akan menambahkan kode:

mkdir trainer
touch trainer/task.py

Sekarang Anda akan memiliki yang berikut di direktori horses_or_humans/:

+ Dockerfile
+ trainer/
    + task.py

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

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()

Sebelum Anda membuat container, mari kita lihat lebih dalam kodenya. Ada beberapa komponen yang dikhususkan untuk menggunakan layanan penyempurnaan hyperparameter.

1. Skrip mengimpor library hypertune. Perlu diketahui bahwa Dockerfile dari Langkah 1 menyertakan petunjuk untuk menginstal library ini di pip.
2. Fungsi get_args() menentukan argumen command line untuk setiap hyperparameter yang ingin Anda sesuaikan. Dalam contoh ini, hyperparameter yang akan disesuaikan adalah kecepatan pemelajaran, nilai momentum dalam pengoptimal, dan jumlah unit dalam lapisan tersembunyi terakhir dari model, tetapi jangan ragu untuk bereksperimen dengan yang lain. Nilai yang diteruskan dalam argumen tersebut kemudian digunakan untuk menetapkan hyperparameter yang sesuai dalam kode.
3. Di akhir fungsi main(), library hypertune digunakan untuk menentukan metrik yang ingin Anda optimalkan. Di TensorFlow, metode model.fit keras menampilkan objek History. Atribut History.history adalah data nilai kerugian pelatihan dan nilai metrik pada iterasi pelatihan. Jika Anda meneruskan data validasi ke model.fit, atribut History.history juga akan menyertakan nilai kehilangan dan metrik 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 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 3: Build container

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

Anda bisa mendapatkan project ID dengan menjalankan gcloud config list --format 'value(core.project)' di terminal Anda

PROJECT_ID='your-cloud-project'

Tentukan variabel dengan URI gambar container Anda di Google Container Registry:

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

Kemudian, build container dengan menjalankan perintah berikut dari root direktori horses_or_humans Anda:

docker build ./ -t $IMAGE_URI

Terakhir, kirim ke Google Container Registry:

docker push $IMAGE_URI

Setelah container dikirimkan ke Container Registry, sekarang Anda siap untuk memulai tugas penyesuaian hyperparameter model kustom.

5. Menjalankan tugas penyesuaian hyperparameter di Vertex AI

Lab ini menggunakan pelatihan kustom melalui container kustom di Google Container Registry, tetapi Anda juga dapat menjalankan tugas penyesuaian hyperparameter dengan container Vertex AI Pre-built.

Untuk memulai, buka bagian Training di bagian Vertex pada Cloud Console Anda:

Langkah 1: Konfigurasikan tugas pelatihan

Klik Buat untuk memasukkan parameter untuk pekerjaan penyesuaian hyperparameter.

• Di bagian Set data, pilih Tidak ada set data terkelola
• Lalu pilih Pelatihan kustom (lanjutan) sebagai metode pelatihan Anda, lalu klik Lanjutkan.
• Masukkan horses-humans-hyptertune (atau apa pun nama model Anda) untuk Nama model
• Klik Lanjutkan

Pada langkah setelan Penampung, pilih Penampung khusus:

Pada kotak pertama (Gambar penampung), masukkan nilai variabel IMAGE_URI dari bagian sebelumnya. Seharusnya: gcr.io/your-cloud-project/horse-human:hypertune, dengan nama project Anda sendiri. Biarkan kolom lainnya kosong, lalu klik Lanjutkan.

Langkah 2: Konfigurasikan tugas penyesuaian hyperparameter

Pilih Aktifkan penyempurnaan hyperparameter.

Mengonfigurasi hiperparameter

Berikutnya, Anda harus menambahkan hyperparameter yang Anda tetapkan sebagai argumen command line dalam kode aplikasi pelatihan. Saat menambahkan hyperparameter, Anda harus memberikan namanya terlebih dahulu. Nama ini harus cocok dengan nama argumen yang Anda teruskan ke argparse.

Kemudian, Anda akan memilih Jenis serta batas untuk nilai yang akan dicoba oleh layanan penyesuaian. Jika memilih jenis Ganda atau Bilangan Bulat, Anda harus memberikan nilai minimum dan maksimum. Dan jika memilih Kategori atau Diskret, Anda harus memberikan nilai.

Untuk jenis Double dan Integer, Anda juga harus menyediakan nilai Scaling.

Setelah menambahkan hyperparameter learning_rate, tambahkan parameter untuk momentum dan num_units.

Konfigurasikan Metrik

Setelah menambahkan hiperparameter, selanjutnya Anda akan memberikan metrik yang ingin dioptimalkan serta sasaran. Ini harus sama dengan hyperparameter_metric_tag yang Anda tetapkan dalam aplikasi pelatihan.

Layanan penyempurnaan Vertex AI Hyperparameter akan menjalankan beberapa uji coba aplikasi pelatihan Anda dengan nilai yang dikonfigurasi di langkah-langkah sebelumnya. Anda harus menempatkan batas atas pada jumlah uji coba yang akan dijalankan oleh layanan tersebut. Uji coba lainnya umumnya memberikan hasil yang lebih baik, tetapi akan ada titik penurunan hasil yang setelah itu uji coba tambahan tidak akan terlalu berdampak atau tidak berdampak pada metrik yang ingin Anda optimalkan. Praktik terbaiknya adalah memulai dengan jumlah uji coba yang lebih sedikit dan memahami dampaknya terhadap hiperparameter yang Anda pilih sebelum meningkatkannya ke sejumlah besar uji coba.

Anda juga harus menetapkan batas atas jumlah uji coba paralel. Meningkatkan jumlah uji coba paralel akan mengurangi jumlah waktu yang diperlukan untuk menjalankan tugas penyesuaian hiperparameter; namun, hal ini dapat mengurangi efektivitas pekerjaan secara menyeluruh. Ini karena strategi penyempurnaan default menggunakan hasil uji coba sebelumnya untuk menentukan penetapan nilai dalam uji coba berikutnya. Jika Anda menjalankan terlalu banyak uji coba secara paralel, akan ada uji coba yang dimulai tanpa memanfaatkan hasil dari uji coba yang masih berjalan.

Untuk tujuan demonstrasi, Anda dapat menetapkan jumlah uji coba sebanyak 15 dan jumlah uji coba paralel maksimal 3. Anda dapat bereksperimen dengan jumlah yang berbeda, tetapi hal ini dapat menghasilkan waktu penyesuaian yang lebih lama dan biaya yang lebih tinggi.

Langkah terakhir adalah memilih Default sebagai algoritme penelusuran, yang akan menggunakan Google Vizier untuk melakukan pengoptimalan Bayesian untuk penyelarasan hiperparameter. Anda dapat mempelajari algoritme ini lebih lanjut di sini.

Klik Continue.

Langkah 3: Konfigurasikan komputasi

Di Compute dan harga, biarkan region yang dipilih apa adanya dan konfigurasikan Kumpulan pekerja 0 sebagai berikut.

Catatan: Menggunakan GPU bersifat opsional. Tugas penyesuaian hyperparameter hanya akan memakan waktu sedikit lebih lama untuk diselesaikan jika Anda tidak menggunakan GPU.

Klik Mulai pelatihan untuk memulai tugas penyesuaian hyperparameter. Di bagian Pelatihan konsol pada tab HYPERPARAMETER TUNING JOBS, Anda akan melihat tampilan seperti ini:

Tugas penyesuaian hyperparameter akan memakan waktu sekitar 30-40 menit.

Setelah selesai, Anda dapat mengklik nama tugas dan melihat hasil uji coba penyempurnaan.

🎉 Selamat! 🎉

Anda telah mempelajari cara menggunakan Vertex AI untuk:

• Meluncurkan tugas penyesuaian hyperparameter untuk kode pelatihan yang diberikan dalam penampung kustom. Anda menggunakan model TensorFlow dalam contoh ini, tetapi Anda dapat melatih model yang dibuat dengan framework apa pun menggunakan container kustom.

Untuk mempelajari lebih lanjut berbagai bagian Vertex, lihat dokumentasi.

6. [Opsional] Menggunakan Vertex SDK

Bagian sebelumnya menunjukkan cara meluncurkan tugas penyesuaian hyperparameter melalui UI. Di bagian ini, Anda akan melihat cara alternatif untuk mengirimkan tugas penyesuaian hyperparameter menggunakan Vertex Python API.

Dari Peluncur, buat notebook TensorFlow 2.

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 menentukan spesifikasi berikut terlebih dahulu. 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": "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)
}

Selanjutnya, buat CustomJob. Anda harus mengganti {YOUR_BUCKET} dengan bucket di project Anda untuk staging.

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

Kemudian, buat dan jalankan 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. Pembersihan

Karena kita mengonfigurasi notebook untuk kehabisan waktu setelah 60 menit tidak ada aktivitas, kita tidak perlu khawatir untuk menonaktifkan instance. Jika Anda ingin menonaktifkan instance secara manual, klik tombol Stop di bagian Vertex AI Workbench konsol. Jika Anda ingin menghapus keseluruhan catatan, klik tombol Hapus.

Untuk menghapus Bucket Storage, menggunakan menu Navigasi di Cloud Console, jelajahi Storage, pilih bucket Anda, lalu klik Delete: