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 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 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 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 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 di 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 tempat TensorFlow dapat menjalankan operasi.
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 pembaruan gradien di semua GPU. Jika Anda telah menguasai pelatihan satu host dan ingin melakukan penskalaan lebih lanjut, menambahkan beberapa mesin ke cluster dapat membantu Anda mendapatkan peningkatan performa yang lebih besar. Anda dapat menggunakan cluster mesin yang khusus 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 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. Kemudian, pengoptimal akan melakukan update parameter dengan gradien yang dikurangi ini sehingga perangkat tetap sinkron. Untuk mempelajari pelatihan terdistribusi dengan TensorFlow lebih lanjut, 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.
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 mengirimkan 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 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, jalankan perintah berikut untuk 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 mem-build penampung, 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.
- 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 ditetapkan keFILEatauDATA. Dalam contoh ini, fungsicreate_dataset()menetapkanAutoShardPolicykeDATAkarena set data singkong tidak didownload sebagai beberapa file. Namun, jika Anda tidak menetapkan kebijakan keDATA, kebijakanAUTOdefault akan diterapkan dan hasilnya akan sama. Anda dapat mempelajari lebih lanjut sharding set data denganMultiWorkerMirroredStrategydi sini. - Dalam fungsi
main(), objekMultiWorkerMirroredStrategydibuat. Selanjutnya, gabungkan pembuatan variabel model Anda dalam cakupan strategi. Langkah penting ini memberi tahu TensorFlow terkait variabel mana yang harus dicerminkan di seluruh replika. - 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. - 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 fungsimain(), 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:
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 pekerja utama, jadi jumlah pekerja Anda untuk kumpulan pekerja 0 akan selalu 1.
Di Compute and Pricing, biarkan region yang dipilih apa adanya dan konfigurasikan kumpulan Pekerja 0 sebagai berikut:
Kumpulan pekerja 1 adalah tempat Anda mengonfigurasi pekerja untuk cluster Anda.
Konfigurasi kumpulan Pekerja 1 sebagai berikut:
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:
🎉 Selamat! 🎉
Anda telah mempelajari cara menggunakan Vertex AI untuk:
- Meluncurkan tugas pelatihan multi-pekerja 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 multipekerja, Anda harus menentukan spesifikasi kumpulan pekerja terlebih dahulu. Perlu diperhatikan bahwa penggunaan GPU dalam spesifikasi sepenuhnya 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 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:
