1. Ringkasan
Di lab ini, Anda akan menggunakan Vertex AI untuk melatih dan menayangkan model TensorFlow menggunakan kode dalam penampung kustom.
Meskipun kita menggunakan TensorFlow untuk kode model di sini, Anda dapat dengan mudah menggantinya dengan framework lain.
Yang Anda pelajari
Anda akan mempelajari cara:
- Mem-build dan mengemas kode pelatihan model di Vertex Workbench
- Mengirim tugas pelatihan model kustom ke Vertex AI
- Men-deploy model terlatih ke endpoint, dan menggunakan endpoint tersebut untuk mendapatkan prediksi
Total biaya untuk menjalankan lab ini di Google Cloud adalah sekitar $1.
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, Prediksi, dan Workbench.
3. 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 Vertex AI API
Buka bagian Vertex AI di Cloud Console Anda, lalu klik Aktifkan Vertex AI API.
Langkah 3: Aktifkan Container Registry API
Buka Container Registry dan pilih Aktifkan jika belum melakukannya. Anda akan menggunakannya untuk membuat container tugas pelatihan kustom.
Langkah 4: Buat instance Vertex AI Workbench
Dari bagian Vertex AI di Cloud Console Anda, klik Workbench:
Dari sana, di bagian Notebook yang dikelola pengguna, klik Notebook Baru:
Kemudian, pilih jenis instance TensorFlow Enterprise (dengan LTS) versi terbaru tanpa GPU:
Gunakan opsi default, lalu klik Create.
Model yang akan kita latih dan tayangkan di lab ini dibuat berdasarkan tutorial ini dari dokumen TensorFlow. Tutorial ini menggunakan set data Auto MPG dari Kaggle untuk memprediksi efisiensi bahan bakar kendaraan.
4. Menyimpan kode pelatihan dalam container
Kita akan mengirimkan tugas pelatihan ini ke Vertex dengan menempatkan kode pelatihan dalam container Docker dan mengirim container ini ke Google Container Registry. Dengan pendekatan ini, kita 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 mpg dan cd ke dalamnya:
mkdir mpg
cd mpg
Langkah 1: Buat Dockerfile
Langkah pertama kita dalam mem-build kode dalam container adalah membuat Dockerfile. Dalam Dockerfile, kita akan menyertakan semua perintah yang diperlukan untuk menjalankan image. Tindakan ini akan menginstal semua library yang kita gunakan 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-cpu.2-6
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.train"]
Dockerfile ini menggunakan image Docker Deep Learning Container TensorFlow Enterprise 2.3. Deep Learning Containers di Google Cloud dilengkapi dengan banyak ML umum dan framework data science yang diiinstal sebelumnya. Yang kami gunakan mencakup TF Enterprise 2.3, Pandas, Scikit-learn, dan lainnya. Setelah mendownload image tersebut, Dockerfile ini akan menyiapkan titik entri untuk kode pelatihan kita. Kita belum membuat file ini – pada langkah berikutnya, kita akan menambahkan kode untuk melatih dan mengekspor model.
Langkah 2: Buat bucket Cloud Storage
Dalam tugas pelatihan, kita akan mengekspor model TensorFlow terlatih ke Bucket Cloud Storage. Vertex akan menggunakannya untuk membaca aset model yang diekspor dan men-deploy model. 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. Flag -l (lokasi) penting karena harus berada di region yang sama dengan tempat Anda men-deploy endpoint model nanti dalam tutorial:
BUCKET_NAME="gs://${PROJECT_ID}-bucket"
gsutil mb -l us-central1 $BUCKET_NAME
Langkah 3: Tambahkan kode pelatihan model
Dari Terminal Anda, jalankan perintah berikut guna membuat direktori untuk kode pelatihan kita dan file Python tempat kita akan menambahkan kode:
mkdir trainer
touch trainer/train.py
Sekarang Anda akan memiliki kode berikut di direktori mpg/:
+ Dockerfile
+ trainer/
+ train.py
Selanjutnya, buka file train.py yang baru saja Anda buat dan salin kode di bawah (ini diadaptasi dari tutorial dalam dokumen TensorFlow).
Di awal file, perbarui variabel BUCKET dengan nama Bucket Penyimpanan yang Anda buat di langkah sebelumnya:
import numpy as np
import pandas as pd
import pathlib
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
print(tf.__version__)
"""## The Auto MPG dataset
The dataset is available from the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/).
### Get the data
First download the dataset.
"""
dataset_path = keras.utils.get_file("auto-mpg.data", "http://archive.ics.uci.edu/ml/machine-learning-databases/auto-mpg/auto-mpg.data")
dataset_path
"""Import it using pandas"""
column_names = ['MPG','Cylinders','Displacement','Horsepower','Weight',
'Acceleration', 'Model Year', 'Origin']
dataset = pd.read_csv(dataset_path, names=column_names,
na_values = "?", comment='\t',
sep=" ", skipinitialspace=True)
dataset.tail()
# TODO: replace `your-gcs-bucket` with the name of the Storage bucket you created earlier
BUCKET = 'gs://your-gcs-bucket'
"""### Clean the data
The dataset contains a few unknown values.
"""
dataset.isna().sum()
"""To keep this initial tutorial simple drop those rows."""
dataset = dataset.dropna()
"""The `"Origin"` column is really categorical, not numeric. So convert that to a one-hot:"""
dataset['Origin'] = dataset['Origin'].map({1: 'USA', 2: 'Europe', 3: 'Japan'})
dataset = pd.get_dummies(dataset, prefix='', prefix_sep='')
dataset.tail()
"""### Split the data into train and test
Now split the dataset into a training set and a test set.
We will use the test set in the final evaluation of our model.
"""
train_dataset = dataset.sample(frac=0.8,random_state=0)
test_dataset = dataset.drop(train_dataset.index)
"""### Inspect the data
Have a quick look at the joint distribution of a few pairs of columns from the training set.
Also look at the overall statistics:
"""
train_stats = train_dataset.describe()
train_stats.pop("MPG")
train_stats = train_stats.transpose()
train_stats
"""### Split features from labels
Separate the target value, or "label", from the features. This label is the value that you will train the model to predict.
"""
train_labels = train_dataset.pop('MPG')
test_labels = test_dataset.pop('MPG')
"""### Normalize the data
Look again at the `train_stats` block above and note how different the ranges of each feature are.
It is good practice to normalize features that use different scales and ranges. Although the model *might* converge without feature normalization, it makes training more difficult, and it makes the resulting model dependent on the choice of units used in the input.
Note: Although we intentionally generate these statistics from only the training dataset, these statistics will also be used to normalize the test dataset. We need to do that to project the test dataset into the same distribution that the model has been trained on.
"""
def norm(x):
return (x - train_stats['mean']) / train_stats['std']
normed_train_data = norm(train_dataset)
normed_test_data = norm(test_dataset)
"""This normalized data is what we will use to train the model.
Caution: The statistics used to normalize the inputs here (mean and standard deviation) need to be applied to any other data that is fed to the model, along with the one-hot encoding that we did earlier. That includes the test set as well as live data when the model is used in production.
## The model
### Build the model
Let's build our model. Here, we'll use a `Sequential` model with two densely connected hidden layers, and an output layer that returns a single, continuous value. The model building steps are wrapped in a function, `build_model`, since we'll create a second model, later on.
"""
def build_model():
model = keras.Sequential([
layers.Dense(64, activation='relu', input_shape=[len(train_dataset.keys())]),
layers.Dense(64, activation='relu'),
layers.Dense(1)
])
optimizer = tf.keras.optimizers.RMSprop(0.001)
model.compile(loss='mse',
optimizer=optimizer,
metrics=['mae', 'mse'])
return model
model = build_model()
"""### Inspect the model
Use the `.summary` method to print a simple description of the model
"""
model.summary()
"""Now try out the model. Take a batch of `10` examples from the training data and call `model.predict` on it.
It seems to be working, and it produces a result of the expected shape and type.
### Train the model
Train the model for 1000 epochs, and record the training and validation accuracy in the `history` object.
Visualize the model's training progress using the stats stored in the `history` object.
This graph shows little improvement, or even degradation in the validation error after about 100 epochs. Let's update the `model.fit` call to automatically stop training when the validation score doesn't improve. We'll use an *EarlyStopping callback* that tests a training condition for every epoch. If a set amount of epochs elapses without showing improvement, then automatically stop the training.
You can learn more about this callback [here](https://www.tensorflow.org/api_docs/python/tf/keras/callbacks/EarlyStopping).
"""
model = build_model()
EPOCHS = 1000
# The patience parameter is the amount of epochs to check for improvement
early_stop = keras.callbacks.EarlyStopping(monitor='val_loss', patience=10)
early_history = model.fit(normed_train_data, train_labels,
epochs=EPOCHS, validation_split = 0.2,
callbacks=[early_stop])
# Export model and save to GCS
model.save(BUCKET + '/mpg/model')
Langkah 4: Build dan uji container secara lokal
Dari Terminal, tentukan variabel dengan URI image container Anda di Google Container Registry:
IMAGE_URI="gcr.io/$PROJECT_ID/mpg:v1"
Kemudian, build container dengan menjalankan perintah berikut dari root direktori mpg Anda:
docker build ./ -t $IMAGE_URI
Jalankan penampung dalam instance notebook untuk memastikannya berfungsi dengan benar:
docker run $IMAGE_URI
Model akan selesai dilatih dalam 1-2 menit dengan akurasi validasi sekitar 72% (akurasi persisnya dapat bervariasi). Setelah Anda selesai menjalankan container secara lokal, kirim container tersebut ke Google Container Registry:
docker push $IMAGE_URI
Setelah container dikirim ke Container Registry, sekarang kita siap untuk memulai tugas pelatihan model kustom.
5. Menjalankan tugas pelatihan pada Vertex AI
Vertex AI memberi Anda dua opsi untuk melatih model:
- AutoML: Melatih model berkualitas tinggi dengan upaya dan keahlian ML minimal.
- Pelatihan kustom: Jalankan aplikasi pelatihan kustom di cloud menggunakan salah satu container bawaan Google Cloud atau gunakan container Anda sendiri.
Dalam lab ini, kita menggunakan pelatihan kustom melalui container kustom kami sendiri di Google Container Registry. Untuk memulai, buka bagian Models di bagian Vertex pada Konsol Cloud Anda:
Langkah 1: Memulai tugas pelatihan
Klik Buat untuk memasukkan parameter ke tugas pelatihan dan model yang di-deploy:
- Di bagian Set data, pilih Tidak ada set data terkelola
- Lalu, pilih Pelatihan kustom (lanjutan) sebagai metode pelatihan Anda dan klik Lanjutkan.
- Klik Lanjutkan
Pada langkah berikutnya, masukkan mpg (atau apa pun nama model yang Anda inginkan) untuk Nama model. Kemudian, pilih Penampung kustom:
Di kotak teks Container image, klik Browse, lalu temukan image Docker yang baru diupload ke Container Registry. Biarkan kolom lainnya kosong dan klik Lanjutkan.
Kita tidak akan menggunakan penyesuaian hyperparameter dalam tutorial ini, jadi biarkan kotak Aktifkan penyesuaian hyperparameter tidak dicentang dan klik Lanjutkan.
Di Compute and pricing, biarkan region yang dipilih apa adanya dan pilih n1-standard-4 sebagai jenis mesin Anda:
Biarkan kolom akselerator kosong, lalu pilih Lanjutkan. Karena model dalam demo ini dilatih dengan cepat, kita menggunakan jenis mesin yang lebih kecil.
Di bagian langkah Prediction container, pilih Pre-built container, lalu pilih TensorFlow 2.6.
Biarkan setelan default untuk penampung bawaan apa adanya. Di bagian Model directory, masukkan bucket GCS Anda dengan subdirektori mpg. Ini adalah jalur dalam skrip pelatihan model tempat Anda mengekspor model terlatih:
Vertex akan mencari di lokasi ini saat men-deploy model Anda. Sekarang Anda siap untuk melakukan pelatihan. Klik Start training untuk memulai tugas pelatihan. Di bagian Pelatihan konsol, Anda akan melihat sesuatu seperti ini:
6. Men-deploy endpoint model
Saat menyiapkan tugas pelatihan, kita menentukan tempat Vertex AI akan mencari aset model yang diekspor. Sebagai bagian dari pipeline pelatihan, Vertex akan membuat resource model berdasarkan jalur aset ini. Resource model itu sendiri bukanlah model yang di-deploy, tetapi setelah memiliki model, Anda siap untuk men-deploynya ke endpoint. Untuk mempelajari Model dan Endpoint di Vertex AI lebih lanjut, lihat dokumentasinya.
Pada langkah ini, kita akan membuat endpoint untuk model terlatih. Kita dapat menggunakannya untuk mendapatkan prediksi pada model melalui Vertex AI API.
Langkah 1: Deploy endpoint
Setelah tugas pelatihan selesai, Anda akan melihat model bernama mpg (atau nama apa pun yang Anda berikan) di bagian Model pada konsol:
Ketika tugas pelatihan Anda berjalan, Vertex membuat resource model untuk Anda. Untuk menggunakan model ini, Anda perlu men-deploy endpoint. Anda dapat memiliki banyak endpoint per model. Klik model, lalu klik Deploy to endpoint.
Pilih Buat endpoint baru dan beri nama, seperti v1. Biarkan Standar dipilih untuk Akses, lalu klik Lanjutkan.
Biarkan Traffic split tetap 100 dan masukkan 1 untuk Minimum number of compute nodes. Di bagian Machine type, pilih n1-standard-2 (atau jenis mesin apa pun yang Anda inginkan). Biarkan setelan default lainnya dipilih, lalu klik Lanjutkan. Kita tidak akan mengaktifkan pemantauan untuk model ini, jadi klik Deploy untuk memulai deployment endpoint.
Proses deploy endpoint akan memerlukan waktu 10-15 menit, dan Anda akan mendapatkan email saat proses deploy selesai. Setelah endpoint selesai di-deploy, Anda akan melihat hal berikut, yang menunjukkan satu endpoint yang di-deploy di bagian resource Model:
Langkah 2: Mendapatkan prediksi pada model yang di-deploy
Kita akan mendapatkan prediksi pada model terlatih dari notebook Python, menggunakan Vertex Python API. Kembali ke instance notebook Anda, dan buat notebook Python 3 dari Peluncur:
Di notebook Anda, jalankan perintah berikut dalam sel untuk menginstal Vertex AI SDK:
!pip3 install google-cloud-aiplatform --upgrade --user
Kemudian, tambahkan sel di notebook untuk mengimpor SDK dan membuat referensi ke endpoint yang baru saja Anda deploy:
from google.cloud import aiplatform
endpoint = aiplatform.Endpoint(
endpoint_name="projects/YOUR-PROJECT-NUMBER/locations/us-central1/endpoints/YOUR-ENDPOINT-ID"
)
Anda harus mengganti dua nilai dalam string endpoint_name di atas dengan nomor project dan endpoint Anda. Anda dapat menemukan nomor project dengan membuka dasbor project dan mendapatkan nilai Project Number.
Anda dapat menemukan ID endpoint di bagian endpoint pada konsol di sini:
Terakhir, buat prediksi ke endpoint Anda dengan menyalin dan menjalankan kode di bawah dalam sel baru:
test_mpg = [1.4838871833555929,
1.8659883497083019,
2.234620276849616,
1.0187816540094903,
-2.530890710602246,
-1.6046416850441676,
-0.4651483719733302,
-0.4952254087173721,
0.7746763768735953]
response = endpoint.predict([test_mpg])
print('API response: ', response)
print('Predicted MPG: ', response.predictions[0][0])
Contoh ini sudah memiliki nilai yang dinormalisasi, yang merupakan format yang diharapkan model kami.
Jalankan sel ini, dan Anda akan melihat output prediksi sekitar 16 mil per galon.
🎉 Selamat! 🎉
Anda telah mempelajari cara menggunakan Vertex AI untuk:
- Latih model dengan menyediakan kode pelatihan dalam container kustom. Anda telah menggunakan model TensorFlow dalam contoh ini, tetapi Anda dapat melatih model yang dibuat dengan framework apa pun menggunakan penampung kustom.
- Deploy model TensorFlow menggunakan penampung bawaan sebagai bagian dari alur kerja yang sama dengan yang Anda gunakan untuk pelatihan.
- Buat endpoint model dan buat prediksi.
Untuk mempelajari lebih lanjut berbagai bagian Vertex, lihat dokumentasinya.
7. Pembersihan
Jika Anda ingin terus menggunakan notebook yang dibuat di lab ini, sebaiknya nonaktifkan notebook saat tidak digunakan. Dari UI Workbench di Konsol Cloud, pilih notebook, lalu pilih Stop.
Jika Anda ingin menghapus notebook secara keseluruhan, klik tombol Hapus di kanan atas.
Untuk menghapus endpoint yang Anda deploy, buka bagian Endpoints di konsol Vertex AI, klik endpoint yang Anda buat, lalu pilih Undeploy model from endpoint:
Untuk menghapus Bucket Penyimpanan menggunakan menu Navigasi di Cloud Console, jelajahi Penyimpanan, pilih bucket Anda, lalu klik Hapus:
