1. Pengantar
Di lab ini, Anda akan mempelajari cara menggunakan rutinitas prediksi kustom di Vertex AI untuk menulis logika prapemrosesan dan pascapemrosesan kustom. Meskipun contoh ini menggunakan Scikit-learn, rutinitas prediksi kustom dapat berfungsi dengan framework Python ML lainnya seperti XGBoost, PyTorch, dan TensorFlow.
Yang akan Anda pelajari
- Menulis logika prediksi kustom dengan rutinitas prediksi kustom
- Menguji penampung penayangan kustom dan membuat model secara lokal
- Menguji penampung penayangan kustom di Vertex AI Predictions
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.
Vertex AI mencakup banyak produk yang berbeda untuk mendukung alur kerja ML secara menyeluruh. Lab ini akan berfokus pada Predictions dan Workbench.
3. Ringkasan Kasus Penggunaan
Di lab ini, Anda akan membangun model regresi hutan acak untuk memprediksi harga berlian berdasarkan atribut seperti potongan, kejelasan, dan ukuran.
Anda akan menulis logika pra-pemrosesan kustom untuk memeriksa apakah data pada waktu inferensi memiliki format yang diharapkan oleh model. Anda juga akan menulis logika pascapemrosesan kustom untuk membulatkan prediksi dan mengonversinya menjadi string. Untuk menulis logika ini, Anda akan menggunakan rutinitas prediksi kustom.
Pengantar rutinitas prediksi kustom
Container yang telah dibangun sebelumnya Vertex AI menangani permintaan prediksi dengan menjalankan operasi prediksi framework machine learning. Sebelum rutinitas prediksi kustom, jika Anda ingin melakukan prapemrosesan input sebelum prediksi dilakukan, atau pascapemrosesan prediksi model sebelum menampilkan hasilnya, Anda harus membangun container kustom.
Pembuatan penampung penayangan kustom memerlukan penulisan server HTTP yang menggabungkan model terlatih, menerjemahkan permintaan HTTP menjadi input model, dan menerjemahkan output model menjadi respons.
Dengan rutinitas prediksi kustom, Vertex AI menyediakan komponen terkait inferensi untuk Anda, sehingga Anda dapat berfokus pada transformasi data dan model.
Yang akan Anda bangun
Anda akan menyiapkan jaringan VPC bernama destinationl-vpc yang terdiri dari subnet workbench yang digunakan untuk men-deploy notebook yang dikelola pengguna serta mengakses prediksi online dan endpoint model yang di-deploy di us-central1 yang diilustrasikan pada gambar 1 di bawah.
Figure1
4. Mengaktifkan API tutorial
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 Artifact Registry API
Buka Artifact Registry dan pilih Aktifkan jika belum diaktifkan. Anda akan menggunakannya untuk membuat penampung penayangan kustom.
Langkah 3: Aktifkan Vertex AI API
Buka bagian Vertex AI di Konsol Cloud Anda, lalu klik Enable Vertex AI API.
Langkah 4: Membuat instance Vertex AI Workbench
Aktifkan Notebooks API jika belum.
5. Membuat destinationl-vpc
Tutorial ini menggunakan $variables untuk membantu implementasi konfigurasi gcloud di Cloud Shell.
Di dalam Cloud Shell, lakukan hal berikut:
gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid
Membuat destinationl-vpc
Di dalam Cloud Shell, lakukan hal berikut:
gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom
Membuat subnet notebook yang dikelola pengguna
Di dalam Cloud Shell, buat workbench-subnet.
gcloud compute networks subnets create workbench-subnet --project=$projectid --range=172.16.10.0/28 --network=aiml-vpc --region=us-central1 --enable-private-ip-google-access
Konfigurasi Cloud Router dan NAT
Cloud NAT digunakan dalam tutorial untuk mendownload paket software karena notebook yang dikelola pengguna tidak memiliki alamat IP eksternal. Cloud NAT memberikan kemampuan NAT keluar, yang berarti host internet tidak diizinkan untuk memulai komunikasi dengan notebook yang dikelola pengguna, sehingga menjadikannya lebih aman.
Di dalam Cloud Shell, buat router cloud regional, us-central1.
gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1
Di dalam Cloud Shell, buat gateway cloud nat regional, us-central1.
gcloud compute routers nats create cloud-nat-us-central1 --router=cloud-router-us-central1-aiml-nat --auto-allocate-nat-external-ips --nat-all-subnet-ip-ranges --region us-central1
6. Membuat notebook yang dikelola pengguna
Membuat akun layanan terkelola pengguna (Notebook)
Di bagian berikut, Anda akan membuat akun layanan terkelola pengguna yang akan dikaitkan dengan Vertex Workbench (Notebook) yang digunakan dalam tutorial.
Dalam tutorial, akun layanan akan menerapkan aturan berikut:
Di dalam Cloud Shell, buat akun layanan.
gcloud iam service-accounts create user-managed-notebook-sa \
--display-name="user-managed-notebook-sa"
Di dalam Cloud Shell, perbarui akun layanan dengan peran Storage Admin.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"
Di dalam Cloud Shell, perbarui akun layanan dengan peran Vertex AI User.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"
Di dalam Cloud Shell, perbarui akun layanan dengan peran Artifact Registry Admin.
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"
Di dalam Cloud Shell, cantumkan akun layanan dan catat alamat email yang akan digunakan saat membuat notebook yang dikelola pengguna.
gcloud iam service-accounts list
Membuat Notebook yang dikelola pengguna
Di bagian berikut, buat notebook yang dikelola pengguna dengan menggabungkan akun layanan yang dibuat sebelumnya, user-managed-notebook-sa.
Di dalam Cloud Shell, buat instance private-client.
gcloud notebooks instances create workbench-tutorial \
--vm-image-project=deeplearning-platform-release \
--vm-image-family=common-cpu-notebooks \
--machine-type=n1-standard-4 \
--location=us-central1-a \
--shielded-secure-boot \
--subnet-region=us-central1 \
--subnet=workbench-subnet \
--no-public-ip --service-account=user-managed-notebook-sa@$projectid.iam.gserviceaccount.com
7. Menulis kode pelatihan
Langkah 1: Buat bucket Cloud Storage
Anda akan menyimpan artefak model dan pra-pemrosesan ke bucket Cloud Storage. Jika sudah memiliki bucket dalam project yang ingin digunakan, Anda dapat melewati langkah ini.
Dari peluncur, buka sesi terminal baru.
Dari terminal Anda, jalankan perintah berikut guna menentukan variabel env untuk project Anda, pastikan untuk mengganti project-cloud-Anda 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}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET
Langkah 2: Latih model
Dari terminal, buat direktori baru bernama cpr-codelab dan cd ke dalamnya.
mkdir cpr-codelab
cd cpr-codelab
Di {i>file browser<i}, navigasikan ke direktori cpr-codelab yang baru, lalu gunakan peluncur untuk membuat notebook Python 3 baru bernama task.ipynb.
Direktori cpr-codelab Anda sekarang akan terlihat seperti ini:
+ cpr-codelab/
+ task.ipynb
Di notebook, tempelkan kode berikut.
Pertama, tulis file requirements.txt.
%%writefile requirements.txt
fastapi
uvicorn==0.17.6
joblib~=1.1.1
numpy>=1.17.3, <1.24.0
scikit-learn~=1.0.0
pandas
google-cloud-storage>=2.2.1,<3.0.0dev
google-cloud-aiplatform[prediction]>=1.18.2
Model yang Anda deploy akan memiliki kumpulan dependensi bawaan yang berbeda dari lingkungan notebook Anda. Karena itu, Anda perlu mencantumkan semua dependensi untuk model di requirements.txt, lalu menggunakan pip untuk menginstal dependensi yang sama persis di notebook. Nantinya, Anda akan menguji model secara lokal sebelum men-deploy ke Vertex AI untuk memeriksa kembali apakah lingkungan tersebut cocok.
Pip menginstal dependensi tersebut di notebook.
!pip install -U --user -r requirements.txt
Perhatikan bahwa Anda harus memulai ulang kernel setelah penginstalan pip selesai.
Selanjutnya, buat direktori tempat Anda akan menyimpan model dan artefak pra-pemrosesan.
USER_SRC_DIR = "src_dir"
!mkdir $USER_SRC_DIR
!mkdir model_artifacts
# copy the requirements to the source dir
!cp requirements.txt $USER_SRC_DIR/requirements.txt
Direktori cpr-codelab Anda sekarang akan terlihat seperti ini:
+ cpr-codelab/
+ model_artifacts/
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
Setelah struktur direktori siap, saatnya untuk melatih model.
Pertama, impor library.
import seaborn as sns
import numpy as np
import pandas as pd
from sklearn import preprocessing
from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import make_pipeline
from sklearn.compose import make_column_transformer
import joblib
import logging
# set logging to see the docker container logs
logging.basicConfig(level=logging.INFO)
Kemudian, tentukan variabel berikut. Pastikan untuk mengganti PROJECT_ID dengan project id Anda dan BUCKET_NAME dengan bucket yang Anda buat di langkah sebelumnya.
REGION = "us-central1"
MODEL_ARTIFACT_DIR = "sklearn-model-artifacts"
REPOSITORY = "diamonds"
IMAGE = "sklearn-image"
MODEL_DISPLAY_NAME = "diamonds-cpr"
# Replace with your project
PROJECT_ID = "{PROJECT_ID}"
# Replace with your bucket
BUCKET_NAME = "gs://{BUCKET_NAME}"
Muat data dari library seaborn, lalu buat dua frame data, satu dengan fitur dan lainnya dengan label.
data = sns.load_dataset('diamonds', cache=True, data_home=None)
label = 'price'
y_train = data['price']
x_train = data.drop(columns=['price'])
Mari kita lihat data pelatihan. Anda dapat melihat bahwa setiap baris mewakili berlian.
x_train.head()
Dan label, yang merupakan harga yang sesuai.
y_train.head()
Sekarang, tentukan transformasi kolom sklearn menjadi satu enkode fitur kategorikal yang tepat dan skalakan fitur numerik
column_transform = make_column_transformer(
(preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
(preprocessing.StandardScaler(), [0,4,5,6,7,8]))
Menentukan model forest acak
regr = RandomForestRegressor(max_depth=10, random_state=0)
Selanjutnya, buat pipeline sklearn. Artinya, data yang dimasukkan ke pipeline ini akan dienkode/diskalakan terlebih dahulu, lalu diteruskan ke model.
my_pipeline = make_pipeline(column_transform, regr)
Menyesuaikan pipeline pada data pelatihan
my_pipeline.fit(x_train, y_train)
Mari kita coba model tersebut untuk memastikannya berfungsi seperti yang diharapkan. Panggil metode prediksi pada model, dengan meneruskan sampel pengujian.
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
Sekarang kita dapat menyimpan pipeline ke direktori model_artifacts, dan menyalinnya ke bucket Cloud Storage
joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
Langkah 3: Simpan artefak pra-pemrosesan
Selanjutnya, Anda akan membuat artefak pra-pemrosesan. Artefak ini akan dimuat di penampung kustom saat server model dimulai. Artefak pra-pemrosesan Anda dapat berupa hampir semua bentuk (seperti file acar), tetapi dalam hal ini Anda akan menulis kamus ke file JSON.
clarity_dict={"Flawless": "FL",
"Internally Flawless": "IF",
"Very Very Slightly Included": "VVS1",
"Very Slightly Included": "VS2",
"Slightly Included": "S12",
"Included": "I3"}
Fitur kejelasan dalam data pelatihan kita selalu dalam bentuk yang disingkat (yaitu "FL" bukan "Flawless"). Pada waktu penayangan, kami ingin memeriksa apakah data untuk fitur ini juga disingkat. Hal ini karena model kita tahu cara melakukan enkode hot "FL" tetapi bukan "Luar biasa". Anda akan menulis logika pra-pemrosesan kustom ini nanti. Namun untuk saat ini, cukup simpan tabel pencarian ini ke file JSON, lalu tulis ke bucket Cloud Storage.
import json
with open("model_artifacts/preprocessor.json", "w") as f:
json.dump(clarity_dict, f)
!gsutil cp model_artifacts/preprocessor.json {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
Direktori cpr-codelab lokal Anda sekarang akan terlihat seperti ini:
+ cpr-codelab/
+ model_artifacts/
+ model.joblib
+ preprocessor.json
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
8. Membuat penampung penayangan kustom menggunakan server model CPR
Setelah model dilatih dan artefak prapemrosesan disimpan, saatnya membuat penampung penayangan kustom. Biasanya, pembuatan penampung penayangan memerlukan penulisan kode server model. Namun, dengan rutinitas prediksi kustom, Vertex AI Prediction akan menghasilkan server model dan membuat image container kustom untuk Anda.
Penampung penayangan kustom berisi 3 bagian kode berikut:
- Server model (ini akan dihasilkan secara otomatis oleh SDK dan disimpan di scr_dir/)
- Server HTTP yang menghosting model
- Bertanggung jawab untuk menyiapkan rute/pelabuhan/dll.
- Bertanggung jawab atas aspek server web dalam menangani permintaan, seperti melakukan deserialisasi isi permintaan, dan menserialisasi respons, menyetel header respons, dll.
- Dalam contoh ini, Anda akan menggunakan Pengendali default, google.cloud.aiplatform.prediksi.handler.PredictionHandler yang disediakan di SDK.
- Bertanggung jawab atas logika ML untuk memproses permintaan prediksi.
Setiap komponen ini dapat disesuaikan berdasarkan persyaratan kasus penggunaan Anda. Dalam contoh ini, Anda hanya akan mengimplementasikan prediktor.
Prediktor bertanggung jawab atas logika ML untuk memproses permintaan prediksi, seperti pra-pemrosesan dan pascapemrosesan kustom. Untuk menulis logika prediksi kustom, Anda akan membuat subclass antarmuka Vertex AI Predictor.
Rilis rutinitas prediksi kustom ini dilengkapi dengan prediktor XGBoost dan Sklearn yang dapat digunakan kembali, tetapi jika Anda perlu menggunakan framework yang berbeda, Anda dapat membuatnya sendiri dengan membuat subclass prediktor dasar.
Anda dapat melihat contoh prediktor Sklearn di bawah. Ini adalah semua kode yang perlu Anda tulis untuk membangun server model kustom ini.
Di notebook Anda, tempelkan kode berikut di bawah untuk membuat subclass SklearnPredictor dan tulis ke file Python di src_dir/. Perhatikan bahwa dalam contoh ini kita hanya menyesuaikan metode pemuatan, prapemrosesan, dan pascaproses, dan bukan metode prediksi.
%%writefile $USER_SRC_DIR/predictor.py
import joblib
import numpy as np
import json
from google.cloud import storage
from google.cloud.aiplatform.prediction.sklearn.predictor import SklearnPredictor
class CprPredictor(SklearnPredictor):
def __init__(self):
return
def load(self, artifacts_uri: str) -> None:
"""Loads the sklearn pipeline and preprocessing artifact."""
super().load(artifacts_uri)
# open preprocessing artifact
with open("preprocessor.json", "rb") as f:
self._preprocessor = json.load(f)
def preprocess(self, prediction_input: np.ndarray) -> np.ndarray:
"""Performs preprocessing by checking if clarity feature is in abbreviated form."""
inputs = super().preprocess(prediction_input)
for sample in inputs:
if sample[3] not in self._preprocessor.values():
sample[3] = self._preprocessor[sample[3]]
return inputs
def postprocess(self, prediction_results: np.ndarray) -> dict:
"""Performs postprocessing by rounding predictions and converting to str."""
return {"predictions": [f"${value}" for value in np.round(prediction_results)]}
Mari kita pelajari lebih lanjut masing-masing metode ini.
- Metode pemuatan dimuat dalam artefak pra-pemrosesan, yang dalam hal ini adalah kamus yang memetakan nilai kejelasan berlian ke singkatannya.
- Metode praproses menggunakan artefak tersebut untuk memastikan bahwa pada waktu penayangan, fitur kejelasan dalam format yang disingkat. Jika tidak, kode ini akan mengubah string lengkap menjadi singkatannya.
- Metode pascaproses menampilkan nilai yang diprediksi sebagai string dengan tanda $ dan membulatkan nilai tersebut.
Selanjutnya, gunakan Vertex AI Python SDK untuk membangun image. Dengan menggunakan rutinitas prediksi kustom, Dockerfile akan dibuat dan image akan dibangun untuk Anda.
from google.cloud import aiplatform
aiplatform.init(project=PROJECT_ID, location=REGION)
import os
from google.cloud.aiplatform.prediction import LocalModel
from src_dir.predictor import CprPredictor # Should be path of variable $USER_SRC_DIR
local_model = LocalModel.build_cpr_model(
USER_SRC_DIR,
f"{REGION}-docker.pkg.dev/{PROJECT_ID}/{REPOSITORY}/{IMAGE}",
predictor=CprPredictor,
requirements_path=os.path.join(USER_SRC_DIR, "requirements.txt"),
)
Tulis file pengujian dengan dua sampel untuk prediksi. Salah satu instance memiliki singkatan nama kejelasan, tetapi yang lain perlu dikonversi terlebih dahulu.
import json
sample = {"instances": [
[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43],
[0.29, 'Premium', 'J', 'Internally Flawless', 52.5, 49.0, 4.00, 2.13, 3.11]]}
with open('instances.json', 'w') as fp:
json.dump(sample, fp)
Uji container secara lokal dengan men-deploy model lokal.
with local_model.deploy_to_local_endpoint(
artifact_uri = 'model_artifacts/', # local path to artifacts
) as local_endpoint:
predict_response = local_endpoint.predict(
request_file='instances.json',
headers={"Content-Type": "application/json"},
)
health_check_response = local_endpoint.run_health_check()
Anda dapat melihat hasil prediksi dengan:
predict_response.content
9. Men-deploy model ke Vertex AI
Setelah Anda menguji container secara lokal, kini saatnya mengirim image ke Artifact Registry dan mengupload model ke Vertex AI Model Registry.
Pertama, konfigurasikan Docker untuk mengakses Artifact Registry.
!gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
--location=us-central1 --description="Docker repository"
!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
Kemudian, kirim image.
local_model.push_image()
Lalu mengupload model.
model = aiplatform.Model.upload(local_model = local_model,
display_name=MODEL_DISPLAY_NAME,
artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
Saat model diupload, Anda akan melihatnya di konsol:
Selanjutnya, deploy model agar Anda dapat menggunakannya untuk prediksi online. Rutinitas prediksi kustom juga berfungsi dengan prediksi batch, jadi jika kasus penggunaan Anda tidak memerlukan prediksi online, Anda tidak perlu men-deploy model.
Kemudian, kirim image.
endpoint = model.deploy(machine_type="n1-standard-2")
Terakhir, uji model yang di-deploy dengan mendapatkan prediksi.
endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
🎉 Selamat! 🎉
Anda telah mempelajari cara menggunakan Vertex AI untuk:
- Menulis logika prapemrosesan dan pascapemrosesan kustom dengan rutinitas prediksi kustom
Cosmopup menganggap codelab tersebut luar biasa!!
Apa selanjutnya?
Bacaan lebih lanjut & Video
- Apa itu Vertex AI?
- Mulai menggunakan Vertex AI
- Manakah solusi AI/ML di Vertex AI yang tepat untuk saya?
- Membangun sistem penjawaban pertanyaan dengan Vertex AI