Vertex AI: Pelatihan Multi-Worker dan Transfer Learning dengan TensorFlow

1. Ringkasan

Di lab ini, Anda akan menggunakan Vertex AI untuk menjalankan tugas pelatihan multi-pekerja untuk model TensorFlow.

Yang Anda pelajari

Anda akan mempelajari cara:

• Mengubah kode aplikasi pelatihan untuk pelatihan multi-pekerja
• Mengonfigurasi dan meluncurkan tugas pelatihan multi-pekerja dari UI Vertex AI
• Mengonfigurasi dan meluncurkan tugas pelatihan multi-pekerja dengan Vertex SDK

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

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 Ringkasan Kasus Penggunaan

Di lab ini, Anda akan menggunakan pemelajaran transfer untuk melatih model klasifikasi gambar pada set data singkong dari Set Data TensorFlow. Arsitektur yang akan Anda gunakan adalah model ResNet50 dari library tf.keras.applications yang telah dilatih sebelumnya di set data Imagenet.

Mengapa Pelatihan Terdistribusi?

Jika Anda memiliki satu GPU, TensorFlow akan menggunakan akselerator ini untuk mempercepat pelatihan model tanpa perlu upaya ekstra dari Anda. Namun, jika Anda ingin mendapatkan peningkatan tambahan dari penggunaan beberapa GPU pada satu atau beberapa mesin (masing-masing dengan potensi beberapa GPU), maka Anda harus menggunakan tf.distribute, yang merupakan library TensorFlow untuk menjalankan komputasi di beberapa perangkat. Perangkat mengacu pada CPU atau akselerator, seperti GPU atau TPU, pada mesin tertentu yang dapat menjalankan operasi TensorFlow.

Cara termudah untuk memulai pelatihan terdistribusi adalah satu mesin dengan beberapa perangkat GPU. Strategi distribusi TensorFlow dari modul tf.distribute akan mengelola koordinasi distribusi data dan update gradien di semua GPU. Jika Anda telah menguasai pelatihan host tunggal dan ingin meningkatkan skala lebih lanjut, menambahkan beberapa mesin ke cluster dapat membantu Anda meningkatkan performa secara lebih baik. Anda dapat menggunakan cluster mesin dengan CPU saja, atau mesin yang memiliki satu atau beberapa GPU. Lab ini membahas kasus terakhir dan menunjukkan cara menggunakan MultiWorkerMirroredStrategy untuk mendistribusikan pelatihan model TensorFlow di beberapa mesin pada Vertex AI.

MultiWorkerMirroredStrategy adalah strategi paralelisme data sinkron yang dapat Anda gunakan hanya dengan beberapa perubahan kode. Salinan model dibuat di setiap perangkat dalam cluster Anda. Pembaruan gradien berikutnya akan terjadi secara sinkron. Ini berarti bahwa setiap perangkat pekerja menghitung maju dan mundur melewati model pada bagian data input yang berbeda. Gradien yang dihitung dari setiap potongan ini kemudian digabungkan ke semua perangkat di mesin dan semua mesin dalam cluster dan dikurangi (biasanya rata-rata) dalam proses yang dikenal sebagai pengurangan semua. Pengoptimal kemudian melakukan pembaruan parameter dengan gradien yang dikurangi ini sehingga perangkat tetap sinkron. Untuk mempelajari lebih lanjut pelatihan terdistribusi dengan TensorFlow, lihat video di bawah ini:

4. 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.

5. Mem-build kode aplikasi pelatihan dalam container

Anda akan mengirimkan tugas pelatihan ini ke Vertex dengan menempatkan kode aplikasi pelatihan Anda di container Docker dan mengirimkan penampung ini ke Google Container Registry. Dengan menggunakan pendekatan ini, Anda dapat melatih model yang dibuat dengan framework apa pun.

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

Buat direktori baru bernama cassava dan cd ke dalamnya:

mkdir cassava
cd cassava

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 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 /

# 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: Buat bucket Cloud Storage

Dalam tugas pelatihan ini, Anda akan mengekspor model TensorFlow terlatih ke Bucket Cloud Storage. 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'

Berikutnya, jalankan perintah berikut ini di Terminal untuk membuat bucket baru dalam project Anda.

BUCKET="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET

Langkah 3: 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 cassava/:

+ Dockerfile
+ trainer/
    + task.py

Selanjutnya, buka file task.py yang baru saja Anda buat dan salin kode di bawah. Anda harus mengganti {your-gcs-bucket} dengan nama bucket Cloud Storage yang baru saja Anda buat.

import tensorflow as tf
import tensorflow_datasets as tfds
import os

PER_REPLICA_BATCH_SIZE = 64
EPOCHS = 2

# TODO: replace {your-gcs-bucket} with the name of the Storage bucket you created earlier
BUCKET = 'gs://{your-gcs-bucket}/mwms'

def preprocess_data(image, label):
  '''Resizes and scales images.'''

  image = tf.image.resize(image, (300,300))
  return tf.cast(image, tf.float32) / 255., label

def create_dataset(batch_size):
  '''Loads Cassava dataset and preprocesses data.'''

  data, info = tfds.load(name='cassava', as_supervised=True, with_info=True)
  number_of_classes = info.features['label'].num_classes
  train_data = data['train'].map(preprocess_data,
                                 num_parallel_calls=tf.data.experimental.AUTOTUNE)
  train_data  = train_data.shuffle(1000)
  train_data  = train_data.batch(batch_size)
  train_data  = train_data.prefetch(tf.data.experimental.AUTOTUNE)

  # Set AutoShardPolicy
  options = tf.data.Options()
  options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.DATA
  train_data = train_data.with_options(options)

  return train_data, number_of_classes

def create_model(number_of_classes):
  '''Creates and compiles pretrained ResNet50 model.'''

  base_model = tf.keras.applications.ResNet50(weights='imagenet', include_top=False)
  x = base_model.output
  x = tf.keras.layers.GlobalAveragePooling2D()(x)
  x = tf.keras.layers.Dense(1016, activation='relu')(x)
  predictions = tf.keras.layers.Dense(number_of_classes, activation='softmax')(x)
  model = tf.keras.Model(inputs=base_model.input, outputs=predictions)

  model.compile(
      loss='sparse_categorical_crossentropy',
      optimizer=tf.keras.optimizers.Adam(0.0001),
      metrics=['accuracy'])

  return model

def _is_chief(task_type, task_id):
  '''Helper function. Determines if machine is chief.'''

  return task_type == 'chief'

def _get_temp_dir(dirpath, task_id):
  '''Helper function. Gets temporary directory for saving model.'''

  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir

def write_filepath(filepath, task_type, task_id):
  '''Helper function. Gets filepath to save model.'''

  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)

def main():
  # Create strategy
  strategy = tf.distribute.MultiWorkerMirroredStrategy()

  # Get data
  global_batch_size = PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync
  train_data, number_of_classes = create_dataset(global_batch_size)

  # Wrap variable creation within strategy scope
  with strategy.scope():
    model = create_model(number_of_classes)

  model.fit(train_data, epochs=EPOCHS)

  # Determine type and task of the machine from
  # the strategy cluster resolver
  task_type, task_id = (strategy.cluster_resolver.task_type,
                        strategy.cluster_resolver.task_id)

  # Based on the type and task, write to the desired model path
  write_model_path = write_filepath(BUCKET, task_type, task_id)
  model.save(write_model_path)

if __name__ == "__main__":
    main()

Sebelum Anda membuat container, mari kita lihat lebih dalam kodenya, yang menggunakan MultiWorkerMirroredStrategy dari tf.distribute.Strategy API.

MultiWorkerMirroredStrategy dirancang untuk mendistribusikan pelatihan di beberapa mesin dalam sebuah cluster, yang masing-masing memiliki beberapa GPU. Jika Anda hanya ingin mendistribusikan pelatihan di beberapa GPU pada satu perangkat, lihat MirroredStrategy.

Ada beberapa komponen dalam kode yang diperlukan agar kode Anda berfungsi dengan MultiWorkerMirroredStrategy.

1. Data harus di-sharding, yang berarti bahwa setiap pekerja diberi subset dari keseluruhan set data. Oleh karena itu, pada setiap langkah, ukuran batch global elemen set data yang tidak tumpang-tindih akan diproses oleh setiap pekerja. Sharding ini terjadi secara otomatis dengan tf.data.experimental.AutoShardPolicy, yang dapat disetel ke FILE atau DATA. Dalam contoh ini, fungsi create_dataset() menetapkan AutoShardPolicy ke DATA karena set data singkong tidak didownload sebagai beberapa file. Namun, jika Anda tidak menetapkan kebijakan ke DATA, kebijakan AUTO default akan diterapkan dan hasil akhirnya akan sama. Anda dapat mempelajari lebih lanjut sharding set data dengan MultiWorkerMirroredStrategy di sini.
2. Dalam fungsi main(), objek MultiWorkerMirroredStrategy dibuat. Selanjutnya, gabungkan pembuatan variabel model dalam cakupan strategi. Langkah penting ini memberi tahu TensorFlow variabel mana yang harus dicerminkan di seluruh replika.
3. Ukuran batch ditingkatkan menurut num_replicas_in_sync. Hal ini memastikan bahwa setiap replika memproses jumlah contoh yang sama pada setiap langkah. Penskalaan ukuran batch adalah praktik terbaik saat menggunakan strategi paralelisme data sinkron di TensorFlow.
4. Menyimpan model Anda sedikit lebih rumit dalam kasus multi-pekerja karena tujuan harus berbeda untuk setiap pekerja. Pekerja utama akan menyimpan model ke direktori model yang diinginkan, sementara pekerja lain akan menyimpan model ke direktori sementara. Direktori sementara ini harus unik agar tidak ada pekerja yang menulis ke lokasi yang sama. Tabungan dapat berisi operasi kolektif, yang berarti bahwa semua pekerja harus menabung dan bukan hanya kepala suku. Fungsi _is_chief(), _get_temp_dir(), write_filepath(), serta fungsi main(), semuanya menyertakan kode boilerplate yang membantu menyimpan model.

Perlu diperhatikan bahwa jika Anda telah menggunakan MultiWorkerMirroredStrategy di lingkungan yang berbeda, Anda mungkin telah menyiapkan variabel lingkungan TF_CONFIG. Vertex AI menetapkan TF_CONFIG secara otomatis, sehingga Anda tidak perlu menentukan variabel ini di setiap mesin dalam cluster.

Langkah 4: 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/multiworker:cassava"

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

docker build ./ -t $IMAGE_URI

Terakhir, kirim ke Google Container Registry:

docker push $IMAGE_URI

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

6. Menjalankan tugas pelatihan multi-pekerja di Vertex AI

Lab ini menggunakan pelatihan kustom melalui container kustom di Google Container Registry, tetapi Anda juga dapat menjalankan tugas pelatihan dengan container standar.

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

Langkah 1: Konfigurasikan tugas pelatihan

Klik Buat untuk memasukkan parameter untuk tugas pelatihan Anda.

• Di bagian Set data, pilih Tidak ada set data terkelola
• Lalu pilih Pelatihan kustom (lanjutan) sebagai metode pelatihan Anda, lalu klik Lanjutkan.
• Masukkan multiworker-cassava (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. ID project harus: gcr.io/your-cloud-project/multiworker:cassava, dengan project ID Anda sendiri. Biarkan kolom lainnya kosong, lalu klik Lanjutkan.

Lewati langkah Hiperparameter dengan mengklik Lanjutkan lagi.

Langkah 2: Konfigurasikan cluster komputasi

Vertex AI menyediakan 4 kumpulan pekerja untuk mencakup berbagai jenis tugas mesin.

Kumpulan pekerja 0 mengonfigurasi setelan Utama, utama, penjadwal, atau "master". Di MultiWorkerMirroredStrategy, semua mesin ditetapkan sebagai pekerja, yang merupakan mesin fisik tempat komputasi yang direplikasi dieksekusi. Selain setiap mesin menjadi pekerja, harus ada satu pekerja yang melakukan beberapa pekerjaan tambahan seperti menyimpan checkpoint dan menulis file ringkasan ke TensorBoard. Mesin ini dikenal sebagai kepala mesin. Hanya ada satu pekerja kepala, jadi jumlah pekerja Anda untuk kumpulan pekerja 0 akan selalu 1.

Di Compute dan harga, biarkan region yang dipilih, lalu konfigurasikan Kumpulan pekerja 0 seperti berikut:

Anda dapat memilih untuk menambahkan GPU, tetapi perlu diingat bahwa untuk MultiWorkerMirroredStrategy, setiap mesin di cluster Anda harus memiliki jumlah GPU yang sama. Menambahkan GPU juga akan meningkatkan biaya tugas pelatihan.

Kumpulan pekerja 1 adalah tempat Anda mengonfigurasi pekerja untuk cluster.

Konfigurasikan Kumpulan pekerja 1 sebagai berikut:

Sekarang cluster telah dikonfigurasi untuk memiliki dua mesin khusus CPU. Saat kode aplikasi pelatihan dijalankan, MultiWorkerMirroredStrategy akan mendistribusikan pelatihan di kedua komputer.

MultiWorkerMirroredStrategy hanya memiliki jenis tugas utama dan pekerja, sehingga Anda tidak perlu mengonfigurasi Kumpulan Pekerja tambahan. Namun, jika akan menggunakan ParameterServerStrategy TensorFlow, Anda harus mengonfigurasi server parameter di kumpulan pekerja 2. Dan jika ingin menambahkan evaluator ke cluster, Anda akan mengonfigurasi mesin tersebut di kumpulan pekerja 3.

Klik Mulai pelatihan untuk memulai tugas penyesuaian hyperparameter. Di bagian Pelatihan pada konsol di tab PENJATAAN PELATIHAN, Anda akan melihat tugas yang baru diluncurkan:

Tugas pelatihan ini akan memerlukan waktu sekitar 30-35 menit.

🎉 Selamat! 🎉

Anda telah mempelajari cara menggunakan Vertex AI untuk:

• Meluncurkan tugas pelatihan multi-pekerja untuk kode pelatihan yang diberikan dalam container kustom. Anda menggunakan model TensorFlow dalam contoh ini, tetapi Anda dapat melatih model yang dibuat dengan framework apa pun menggunakan container kustom atau bawaan.

Untuk mempelajari lebih lanjut berbagai bagian Vertex, lihat dokumentasi.

7. [Opsional] Menggunakan Vertex SDK

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

Kembali ke instance notebook Anda, dan buat notebook TensorFlow 2 dari Peluncur:

Impor Vertex AI SDK.

from google.cloud import aiplatform

Untuk meluncurkan tugas pelatihan multi-pekerja, Anda harus terlebih dahulu menentukan spesifikasi kumpulan pekerja. Perhatikan bahwa penggunaan GPU dalam spesifikasi benar-benar opsional dan Anda dapat menghapus accelerator_type dan accelerator_count jika Anda ingin cluster khusus CPU seperti yang ditunjukkan di bagian sebelumnya.

# The spec of the worker pools including machine type and Docker image
# Be sure to replace {YOUR-PROJECT-ID} with your project ID.
worker_pool_specs=[
     {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      },
      {
        "replica_count": 1,
        "machine_spec": {
          "machine_type": "n1-standard-8", "accelerator_type": "NVIDIA_TESLA_V100", "accelerator_count": 1
        },
        "container_spec": {"image_uri": "gcr.io/{YOUR-PROJECT-ID}/multiworker:cassava"}
      }
]

Berikutnya, buat dan jalankan CustomJob. Anda harus mengganti {YOUR_BUCKET} dengan bucket di project Anda untuk staging. Anda dapat menggunakan bucket yang sama yang dibuat sebelumnya.

# Replace YOUR_BUCKET
my_multiworker_job = aiplatform.CustomJob(display_name='multiworker-cassava-sdk',
                              worker_pool_specs=worker_pool_specs,
                              staging_bucket='gs://{YOUR_BUCKET}')

my_multiworker_job.run()

Di bagian Pelatihan pada konsol di tab JOB KHUSUS, Anda akan melihat tugas pelatihan Anda:

8 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: