Vertex AI: Pelatihan Multi-Pekerja dan Pemelajaran Transfer 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 multipekerja
• Mengonfigurasi dan meluncurkan tugas pelatihan multi-pekerja dari UI Vertex AI
• Mengonfigurasi dan meluncurkan tugas pelatihan multi-worker dengan Vertex SDK

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

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. Jika Anda memiliki masukan, harap lihat halaman dukungan.

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

3. Ringkasan Kasus Penggunaan

Di lab ini, Anda akan menggunakan transfer learning untuk melatih model klasifikasi gambar pada set data ubi kayu dari TensorFlow Datasets. Arsitektur yang akan Anda gunakan adalah model ResNet50 dari library tf.keras.applications yang telah dilatih sebelumnya pada set data Imagenet.

Mengapa Pelatihan Terdistribusi?

Jika Anda memiliki satu GPU, TensorFlow akan menggunakan akselerator ini untuk mempercepat pelatihan model tanpa perlu melakukan upaya lain. Namun, jika Anda ingin mendapatkan peningkatan tambahan dari penggunaan beberapa GPU pada satu mesin atau beberapa mesin (masing-masing berpotensi memiliki beberapa GPU), 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, di beberapa mesin yang dapat menjalankan operasi TensorFlow.

Cara termudah untuk memulai pelatihan terdistribusi adalah dengan satu mesin dengan beberapa perangkat GPU. Strategi distribusi TensorFlow dari modul tf.distribute akan mengelola koordinasi distribusi data dan pembaruan gradien di semua GPU. Jika Anda telah menguasai pelatihan host tunggal dan ingin meningkatkan skala lebih jauh, menambahkan beberapa mesin ke cluster dapat membantu Anda mendapatkan peningkatan performa yang lebih besar. Anda dapat memanfaatkan cluster mesin yang hanya memiliki CPU, atau yang masing-masing memiliki satu atau beberapa GPU. Lab ini membahas kasus terakhir dan menunjukkan cara menggunakan MultiWorkerMirroredStrategy untuk mendistribusikan pelatihan model TensorFlow di beberapa mesin di 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. Update gradien berikutnya akan berlangsung secara sinkron. Artinya, setiap perangkat pekerja menghitung penerusan maju dan mundur melalui model pada bagian data input yang berbeda. Gradien yang dihitung dari setiap bagian tersebut kemudian digabungkan di semua perangkat pada satu mesin dan semua mesin dalam cluster, lalu dikurangi (biasanya rata-rata) dalam proses yang dikenal sebagai all-reduce. Kemudian, pengoptimal melakukan update parameter dengan gradien yang dikurangi ini sehingga perangkat tetap tersinkron. Untuk mempelajari lebih lanjut pelatihan terdistribusi dengan TensorFlow, tonton video di bawah ini:

4. Menyiapkan lingkungan Anda

Anda memerlukan project Google Cloud Platform dengan penagihan yang 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 tugas pelatihan kustom.

Langkah 3: Aktifkan Vertex AI API

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

Langkah 4: Buat instance Vertex AI Workbench

Dari bagian Vertex AI di Cloud Console Anda, klik Workbench:

Aktifkan Notebooks API jika belum diaktifkan.

Setelah diaktifkan, klik NOTEBOOK TERKELOLA:

Kemudian, pilih NOTEBOOK BARU.

Beri nama notebook Anda, lalu klik Setelan Lanjutan.

Di bagian Setelan Lanjutan, aktifkan penonaktifan tidak ada aktivitas dan setel jumlah menit ke 60. Artinya, notebook Anda akan otomatis dinonaktifkan saat tidak digunakan agar tidak menimbulkan biaya tambahan.

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

Anda dapat membiarkan semua setelan lanjutan lainnya 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. Menyimpan kode aplikasi pelatihan dalam container

Anda akan mengirim tugas pelatihan ini ke Vertex dengan menempatkan kode aplikasi pelatihan dalam container Docker dan mengirim container ini ke Google Container Registry. Menggunakan pendekatan ini, Anda dapat melatih model yang dibangun 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 untuk mem-build kode dalam container adalah 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:

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 TensorFlow Enterprise 2.7. Deep Learning Containers di Google Cloud dilengkapi dengan banyak ML umum dan framework data science yang diiinstal sebelumnya. Setelah mendownload image tersebut, Dockerfile ini akan menyiapkan titik entri untuk kode pelatihan. Anda belum membuat file ini – pada langkah berikutnya, Anda akan menambahkan kode untuk melatih dan menyetel model.

Langkah 2: Buat bucket Cloud Storage

Di 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 ID project dengan menjalankan gcloud config list --format 'value(core.project)' di terminal Anda

PROJECT_ID='your-cloud-project'

Selanjutnya, jalankan perintah berikut 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, jalankan perintah berikut guna membuat direktori untuk kode pelatihan dan file Python tempat Anda akan menambahkan kodenya:

mkdir trainer
touch trainer/task.py

Sekarang Anda akan memiliki kode berikut di direktori cassava/ Anda:

+ 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 membangun container, mari pelajari lebih lanjut kode tersebut, yang menggunakan MultiWorkerMirroredStrategy dari tf.distribute.Strategy API.

MultiWorkerMirroredStrategy dirancang untuk mendistribusikan pelatihan di beberapa mesin dalam cluster, yang masing-masing berpotensi 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 perlu di-shard, yang berarti setiap pekerja diberi subset dari seluruh 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 ubi kayu tidak didownload sebagai beberapa file. Namun, jika Anda tidak menyetel kebijakan ke DATA, kebijakan AUTO default akan berlaku 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 Anda dalam cakupan strategi. Langkah penting ini memberi tahu TensorFlow terkait variabel mana yang harus dicerminkan di seluruh replika.
3. Ukuran tumpukan ditingkatkan skalanya menurut num_replicas_in_sync. Hal ini memastikan bahwa setiap replika memproses jumlah contoh yang sama di setiap langkah. Penskalaan ukuran tumpukan adalah praktik terbaik saat menggunakan strategi paralelisme data sinkron di TensorFlow.
4. Proses menyimpan model Anda sedikit lebih rumit dalam kasus multipekerja karena tujuannya harus berbeda untuk setiap pekerja. Ketua pekerja akan menyimpan direktori model yang diinginkan, sedangkan pekerja lainnya akan menyimpan model ke direktori sementara. Direktori sementara ini harus unik untuk mencegah beberapa pekerja menulis ke lokasi yang sama. Proses menyimpan dapat mencakup operasi kolektif, yang artinya semua pekerja harus menyimpan, bukan hanya ketua. Fungsi _is_chief(), _get_temp_dir(), write_filepath(), serta fungsi main(), semuanya mencakup kode boilerplate yang membantu menyimpan model.

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

Langkah 4: Bangun 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 image container Anda di Google Container Registry:

IMAGE_URI="gcr.io/$PROJECT_ID/multiworker:cassava"

Konfigurasi Docker

gcloud auth configure-docker

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

docker build ./ -t $IMAGE_URI

Terakhir, teruskan ke Google Container Registry:

docker push $IMAGE_URI

Dengan container yang 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 yang telah dibangun sebelumnya.

Untuk memulai, buka bagian Pelatihan di bagian Vertex pada Konsol Cloud Anda:

Langkah 1: Konfigurasi tugas pelatihan

Klik Buat untuk memasukkan parameter ke tugas pelatihan Anda.

• Di bagian Set data, pilih Tidak ada set data terkelola
• Lalu, pilih Pelatihan kustom (lanjutan) sebagai metode pelatihan Anda dan klik Lanjutkan.
• Masukkan multiworker-cassava (atau apa pun nama model yang Anda inginkan) untuk Nama model
• Klik Lanjutkan

Dalam langkah setelan Container, pilih Container kustom:

Di kotak pertama (Image container), masukkan nilai variabel IMAGE_URI Anda dari bagian sebelumnya. Nilainya harus: gcr.io/your-cloud-project/multiworker:cassava, dengan ID project Anda. Biarkan kolom lainnya kosong dan klik Lanjutkan.

Lewati langkah Hyperparameter dengan mengklik Lanjutkan lagi.

Langkah 2: Konfigurasi cluster komputasi

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

Kumpulan pekerja 0 mengonfigurasi Utama, ketua, penjadwal, atau "master". Dalam MultiWorkerMirroredStrategy, semua mesin ditetapkan sebagai pekerja, yang merupakan mesin fisik tempat komputasi yang direplikasi dijalankan. Meskipun setiap mesin menjadi pekerja, perlu ada satu pekerja yang melakukan sedikit tugas tambahan, seperti menyimpan checkpoint dan menulis file ringkasan ke TensorBoard. Mesin ini dikenal sebagai ketua. Hanya ada satu ketua pekerja, jadi jumlah pekerja Anda untuk worker pool 0 akan selalu 1.

Di Compute and pricing, biarkan region yang dipilih seperti apa adanya dan konfigurasi Worker pool 0 sebagai 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 Anda.

Konfigurasi Worker pool 1 sebagai berikut:

Cluster kini dikonfigurasi untuk memiliki dua mesin khusus CPU. Saat kode aplikasi pelatihan dijalankan, MultiWorkerMirroredStrategy akan mendistribusikan pelatihan di kedua mesin.

MultiWorkerMirroredStrategy hanya memiliki jenis tugas ketua dan pekerja, jadi tidak perlu mengonfigurasi Worker Pool tambahan. Namun, jika menggunakan ParameterServerStrategy TensorFlow, Anda akan mengonfigurasi server parameter di worker pool 2. Jika ingin menambahkan evaluator ke cluster, Anda perlu mengonfigurasi mesin tersebut di kumpulan pekerja 3.

Klik Start training untuk memulai tugas penyesuaian hyperparameter. Di bagian Pelatihan konsol, pada tab PIPELINE PELATIHAN, Anda akan melihat tugas yang baru saja Anda luncurkan:

Tugas pelatihan akan memerlukan waktu sekitar 30-35 menit untuk diselesaikan.

🎉 Selamat! 🎉

Anda telah mempelajari cara menggunakan Vertex AI untuk:

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

Untuk mempelajari lebih lanjut berbagai bagian Vertex, lihat dokumentasinya.

7. [Opsional] Menggunakan Vertex SDK

Bagian sebelumnya menunjukkan cara meluncurkan tugas pelatihan melalui UI. Di bagian ini, Anda akan melihat cara alternatif untuk mengirim 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-worker, Anda harus menentukan spesifikasi kumpulan pekerja terlebih dahulu. Perhatikan bahwa penggunaan GPU dalam spesifikasi bersifat opsional dan Anda dapat menghapus accelerator_type dan accelerator_count jika menginginkan 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"}
      }
]

Selanjutnya, buat dan jalankan CustomJob. Anda harus mengganti {YOUR_BUCKET} dengan bucket dalam project Anda untuk staging. Anda dapat menggunakan bucket yang sama dengan yang Anda buat 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 konsol, pada tab TUGAS KUSTOM, Anda akan melihat tugas pelatihan Anda:

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

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