Vertex AI: Pelatihan Multi-Pekerja dan Pemelajaran Transfer dengan TensorFlow

1. Ringkasan

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

Yang Anda pelajari

Anda akan mempelajari cara:

  • Mengubah kode aplikasi pelatihan untuk pelatihan multipekerja
  • Mengonfigurasi dan meluncurkan tugas pelatihan multipekerja dari UI Vertex AI
  • Mengonfigurasi dan meluncurkan tugas pelatihan multipekerja 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

Ringkasan produk Vertex

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 dengan 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 atau beberapa mesin (masing-masing dengan kemungkinan 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, pada mesin tertentu tempat TensorFlow dapat menjalankan operasi.

Cara paling sederhana 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 jauh, menambahkan beberapa mesin ke cluster dapat membantu Anda mendapatkan peningkatan performa yang lebih baik. Anda dapat menggunakan cluster mesin yang khusus CPU, atau yang masing-masing memiliki satu atau beberapa GPU. Lab ini membahas kasus kedua 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. Ini berarti bahwa setiap perangkat pekerja menghitung penerusan maju dan mundur melalui model pada irisan data input yang berbeda. Gradien yang dihitung dari setiap irisan ini kemudian digabungkan di semua perangkat pada 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 menjaga 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 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.

Dasbor Vertex AI

Langkah 4: Buat instance Vertex AI Workbench

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

Menu Vertex AI

Aktifkan Notebooks API jika belum diaktifkan.

Notebook_api

Setelah diaktifkan, klik NOTEBOOK TERKELOLA:

Notebooks_UI

Kemudian, pilih NOTEBOOK BARU.

new_notebook

Beri nama notebook Anda, lalu klik Setelan Lanjutan.

create_notebook

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.

idle_timeout

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

enable_terminal

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.

open_jupyterlab

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

autentikasi

5. Menyimpan kode aplikasi pelatihan dalam container

Anda akan mengirim tugas pelatihan 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:

Membuka terminal di notebook

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

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 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 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 yang menggunakan MultiWorkerMirroredStrategy dari tf.distribute.Strategy API.

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

  1. Data perlu di-sharding, artinya setiap pekerja diberi subset dari seluruh set data. Oleh karena itu, pada setiap langkah, ukuran batch global yang berisi elemen set data yang tidak tumpang-tindih akan diproses oleh setiap pekerja. Sharding ini terjadi secara otomatis dengan tf.data.experimental.AutoShardPolicy, yang dapat ditetapkan 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 menyetel kebijakan ke DATA, kebijakan AUTO default akan berlaku dan hasil akhirnya akan sama. Anda dapat mempelajari sharding set data dengan MultiWorkerMirroredStrategy lebih lanjut 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 pada 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:

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 multipekerja pada 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:

Menu uCAIP

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 nama model yang Anda inginkan) untuk Nama model
  • Klik Lanjutkan

Dalam langkah setelan Container, pilih Container kustom:

Opsi 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 Hhyperparameter 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". Di 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 kumpulan pekerja 0 akan selalu 1.

Di bagian Compute and Pricing, biarkan region yang dipilih apa adanya dan konfigurasikan Kumpulan pekerja 0 sebagai berikut:

Worker_pool_0

Kumpulan pekerja 1 adalah tempat Anda mengonfigurasi worker untuk cluster.

Konfigurasi kumpulan Pekerja 1 sebagai berikut:

Worker_pool_1

Sekarang cluster dikonfigurasi agar 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, sehingga tidak perlu mengonfigurasi Kumpulan Pekerja tambahan. Namun, jika menggunakan ParameterServerStrategy TensorFlow, Anda akan mengonfigurasi server parameter di kumpulan pekerja 2. Dan jika ingin menambahkan evaluator ke cluster, Anda harus 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

🎉 Selamat! 🎉

Anda telah mempelajari cara menggunakan Vertex AI untuk:

  • Meluncurkan tugas pelatihan multipekerja 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 mengirimkan tugas pelatihan menggunakan Vertex Python API.

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

new_notebook

Impor Vertex AI SDK.

from google.cloud import aiplatform

Untuk meluncurkan tugas pelatihan multipekerja, Anda harus menentukan spesifikasi kumpulan pekerja terlebih dahulu. Perlu diperhatikan bahwa penggunaan GPU dalam spesifikasi ini sepenuhnya bersifat opsional. 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 untuk staging. Anda dapat menggunakan bucket yang sama dengan 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 konsol, pada tab TUGAS KUSTOM, Anda akan melihat tugas pelatihan Anda:

Tugas kustom

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.

Hentikan instance

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

Hapus penyimpanan