1. Ringkasan
Di lab ini, Anda akan menggunakan Vertex AI untuk melatih dan menyalurkan model TensorFlow menggunakan kode dalam container 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:
- Membuat dan memasukkan kode pelatihan model ke dalam container di Vertex Workbench
- Mengirim tugas pelatihan model kustom ke Vertex AI
- Men-deploy model yang telah dilatih 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, dalam Notebooks 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 inferensi 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 mengirim tugas pelatihan 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 dibangun 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 meliputi 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 menggunakan ini 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 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 dalam direktori mpg/:
+ Dockerfile
+ trainer/
+ train.py
Selanjutnya, buka file train.py yang baru saja Anda buat, lalu salin kode di bawah (ini diadaptasi dari tutorial di 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: Bangun dan uji container secara lokal
Dari Terminal Anda, 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 container dalam instance notebook Anda untuk memastikannya berfungsi dengan benar:
docker run $IMAGE_URI
Model akan menyelesaikan pelatihan dalam 1-2 menit dengan akurasi validasi sekitar 72% (akurasi yang tepat dapat bervariasi). Setelah Anda selesai menjalankan container secara lokal, kirim container tersebut ke Google Container Registry:
docker push $IMAGE_URI
Dengan container yang 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: Latih model berkualitas tinggi dengan upaya dan keahlian ML minimal.
- Pelatihan kustom: Jalankan aplikasi pelatihan kustom Anda 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 guna memasukkan parameter untuk 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 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 penyesuaian Aktifkan hyperparameter tidak dicentang lalu klik Lanjutkan.
Di bagian 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 berlatih dengan cepat, kita menggunakan jenis mesin yang lebih kecil.
Pada langkah Prediction container, pilih Pre-built container, lalu pilih TensorFlow 2.6.
Biarkan setelan default untuk container yang telah dibangun sebelumnya sebagaimana adanya. Di bagian Direktori model, masukkan bucket GCS dengan subdirektori mpg. Ini adalah jalur dalam skrip pelatihan model tempat Anda mengekspor model yang telah dilatih:
Vertex akan terlihat di lokasi ini saat men-deploy model Anda. Sekarang Anda siap untuk pelatihan! Klik Start training untuk memulai tugas pelatihan. Di bagian Training pada konsol, Anda akan melihat sesuatu seperti ini:
6. Men-deploy endpoint model
Saat menyiapkan tugas pelatihan, kami menentukan lokasi Vertex AI harus mencari aset model yang diekspor. Sebagai bagian dari pipeline pelatihan kami, Vertex akan membuat resource model berdasarkan jalur aset ini. Resource model itu sendiri bukan model yang di-deploy, tetapi setelah memiliki model, Anda siap men-deploy-nya ke endpoint. Untuk mempelajari Model dan Endpoint di Vertex AI lebih lanjut, lihat dokumentasinya.
Pada langkah ini, kita akan membuat endpoint untuk model yang telah dilatih. Kita dapat menggunakan ini 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 model 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 Create new endpoint dan beri nama, seperti v1. Biarkan Standard dipilih untuk Akses, lalu klik Continue.
Biarkan Pembagian traffic di angka 100 dan masukkan 1 untuk Jumlah minimum node komputasi. Di bagian Machine type, pilih n1-standard-2 (atau jenis mesin apa pun yang Anda inginkan). Tetap pilih opsi default lainnya, lalu klik Continue. Kami tidak akan mengaktifkan pemantauan untuk model ini, jadi klik Deploy berikutnya 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 kode berikut, yang menunjukkan satu endpoint yang di-deploy pada resource Model:
Langkah 2: Dapatkan prediksi tentang 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 Anda untuk mengimpor SDK dan membuat referensi ke endpoint yang baru saja di-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 dan endpoint project Anda. Anda dapat menemukan nomor project dengan membuka dasbor project dan mendapatkan nilai Project Number.
Anda dapat menemukan ID endpoint di bagian endpoint konsol di sini:
Terakhir, buat prediksi ke endpoint dengan menyalin dan menjalankan kode di bawah ini 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 dinormalkan, yang merupakan format yang diharapkan oleh model kita.
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 dibangun dengan framework apa pun menggunakan container kustom.
- Deploy model TensorFlow menggunakan container yang telah dibangun sebelumnya sebagai bagian dari alur kerja yang sama yang Anda gunakan untuk pelatihan.
- Membuat endpoint model dan menghasilkan prediksi.
Untuk mempelajari lebih lanjut berbagai bagian Vertex, lihat dokumentasinya.
7. Pembersihan
Jika ingin terus menggunakan notebook yang Anda buat di lab ini, sebaiknya nonaktifkan notebook tersebut 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 telah di-deploy, buka bagian Endpoint 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:
