Vertex AI:Menggunakan rutinitas prediksi kustom dengan Sklearn untuk melakukan pra-pemrosesan dan memposting data proses untuk prediksi

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 ML Python lainnya seperti XGBoost, PyTorch, dan TensorFlow.

Yang akan Anda pelajari

Menulis logika prediksi kustom dengan rutinitas prediksi kustom
Menguji container dan model penayangan kustom secara lokal
Menguji container inferensi kustom di Vertex AI Prediction

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 Prediksi dan Workbench.

3. Ringkasan Kasus Penggunaan

Di lab ini, Anda akan membuat model regresi random forest untuk memprediksi harga berlian berdasarkan atribut seperti potongan, kejernihan, dan ukuran.

Anda akan menulis logika praproses kustom untuk memeriksa apakah data pada waktu penayangan dalam format yang diharapkan oleh model. Anda juga akan menulis logika pasca-pemrosesan kustom untuk membulatkan prediksi dan mengonversinya menjadi string. Untuk menulis logika ini, Anda akan menggunakan rutinitas prediksi kustom.

Pengantar rutinitas prediksi kustom

Container bawaan Vertex AI menangani permintaan prediksi dengan melakukan operasi prediksi framework machine learning. Sebelum adanya rutinitas prediksi kustom, jika Anda ingin melakukan pra-pemrosesan input sebelum prediksi dilakukan, atau melakukan pascapemrosesan prediksi model sebelum menampilkan hasilnya, Anda harus membuat container kustom.

Membangun penampung penayangan kustom memerlukan penulisan server HTTP yang membungkus model terlatih, menerjemahkan permintaan HTTP menjadi input model, dan menerjemahkan output model menjadi respons.

Dengan rutinitas prediksi kustom, Vertex AI menyediakan komponen terkait penayangan untuk Anda, sehingga Anda dapat berfokus pada model dan transformasi data.

Yang akan Anda bangun

Anda akan menyiapkan jaringan VPC bernama aiml-vpc yang terdiri dari subnet workbench yang digunakan untuk men-deploy notebook yang dikelola pengguna dan mengakses endpoint model dan prediksi online yang di-deploy di us-central1 seperti yang diilustrasikan pada gambar 1 di bawah.

                                                                            Figure1

4. Aktifkan 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 container penayangan kustom.

Langkah 3: Aktifkan Vertex AI API

Buka bagian Vertex AI di Konsol Cloud Anda, lalu klik Aktifkan Vertex AI API.

Langkah 4: Buat instance Vertex AI Workbench

Aktifkan Notebooks API jika belum diaktifkan.

5. Buat aiml-vpc

Tutorial ini menggunakan $variables untuk membantu penerapan 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

Buat aiml-vpc

Di dalam Cloud Shell, lakukan hal berikut:

gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom

Buat 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 menyediakan kemampuan NAT keluar, yang berarti host internet tidak diizinkan untuk memulai komunikasi dengan notebook yang dikelola pengguna, sehingga lebih aman.

Di dalam Cloud Shell, buat Cloud Router 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. Buat notebook yang dikelola pengguna

Membuat akun layanan yang dikelola pengguna (Notebook)

Di bagian berikut, Anda akan membuat akun layanan yang dikelola pengguna yang akan dikaitkan dengan Vertex Workbench (Notebook) yang digunakan dalam tutorial.

Dalam tutorial ini, 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, buat daftar akun layanan dan catat alamat email yang akan digunakan saat membuat notebook yang dikelola pengguna.

gcloud iam service-accounts list

Buat Notebook yang dikelola pengguna

Di bagian berikut, buat notebook yang dikelola pengguna yang 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 praproses ke bucket Cloud Storage. Jika sudah memiliki bucket di project yang ingin digunakan, Anda dapat melewati langkah ini.

Dari peluncur, buka sesi terminal baru.

Dari terminal, 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}-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 file browser, buka direktori cpr-codelab baru, lalu gunakan peluncur untuk membuat notebook Python 3 baru bernama task.ipynb.

Direktori cpr-codelab Anda sekarang akan terlihat seperti:

+ 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 serangkaian dependensi yang telah diinstal sebelumnya yang berbeda dengan lingkungan notebook Anda. Oleh karena itu, Anda harus mencantumkan semua dependensi untuk model dalam requirements.txt, lalu menggunakan pip untuk menginstal dependensi yang sama persis di notebook. Selanjutnya, Anda akan menguji model secara lokal sebelum men-deploy ke Vertex AI untuk memeriksa kembali apakah lingkungan cocok.

Pip menginstal dependensi 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 artefak model dan praproses.

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:

+ cpr-codelab/
    + model_artifacts/
    + scr_dir/
        + requirements.txt
    + task.ipynb
    + requirements.txt

Setelah struktur direktori disiapkan, saatnya 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 pada 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 yang 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 untuk melakukan encoding one-hot pada fitur kategoris dan menskalakan fitur numerik

column_transform = make_column_transformer(
    (preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
    (preprocessing.StandardScaler(), [0,4,5,6,7,8]))

Tentukan model random forest

regr = RandomForestRegressor(max_depth=10, random_state=0)

Selanjutnya, buat pipeline sklearn. Artinya, data yang dimasukkan ke pipeline ini akan dienkode/diskala terlebih dahulu, lalu diteruskan ke model.

my_pipeline = make_pipeline(column_transform, regr)

Sesuaikan pipeline dengan data pelatihan

my_pipeline.fit(x_train, y_train)

Mari kita coba modelnya untuk memastikan model tersebut 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 praproses

Selanjutnya, Anda akan membuat artefak praproses. Artefak ini akan dimuat di container kustom saat server model dimulai. Artefak praproses Anda dapat berupa hampir semua bentuk (seperti file pickle), tetapi dalam kasus 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 kami selalu dalam bentuk singkatan (yaitu "FL" dan bukan "Sempurna"). Pada waktu penayangan, kita ingin memeriksa apakah data untuk fitur ini juga disingkat. Hal ini karena model kita tahu cara melakukan encoding one-hot "FL", tetapi tidak tahu cara melakukan encoding "Flawless". Anda akan menulis logika praproses kustom ini nanti. Namun, untuk saat ini, cukup simpan tabel penelusuran 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:

+ cpr-codelab/
    + model_artifacts/
        + model.joblib
        + preprocessor.json
    + scr_dir/
        + requirements.txt
    + task.ipynb
    + requirements.txt

8. Membangun container penayangan kustom menggunakan server model CPR

Setelah model dilatih dan artefak praproses disimpan, saatnya membuat container penayangan kustom. Biasanya, pembuatan container penayangan memerlukan penulisan kode server model. Namun, dengan rutin prediksi kustom, Vertex AI Prediction membuat server model dan membangun image container kustom untuk Anda.

Container penayangan kustom berisi 3 bagian kode berikut:

Server model (akan dibuat secara otomatis oleh SDK dan disimpan di scr_dir/)

Server HTTP yang menghosting model
Bertanggung jawab untuk menyiapkan rute/port/dll.

Handler Permintaan

Bertanggung jawab atas aspek server web dalam menangani permintaan, seperti melakukan deserialisasi isi permintaan, dan melakukan serialisasi respons, menyetel header respons, dll.
Dalam contoh ini, Anda akan menggunakan Handler default, google.cloud.aiplatform.prediction.handler.PredictionHandler yang disediakan di SDK.

Prediktor

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 menerapkan prediktor.

Prediktor bertanggung jawab atas logika ML untuk memproses permintaan prediksi, seperti pra-pemrosesan dan pasca-pemrosesan 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 lain, 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, tempel kode berikut di bawah untuk membuat subclass SklearnPredictor dan menulisnya ke file Python di src_dir/. Perhatikan bahwa dalam contoh ini, kita hanya menyesuaikan metode load, praproses, dan pascaproses, 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 dalam setiap metode ini.

Metode load memuat artefak praproses, yang dalam hal ini adalah pemetaan kamus nilai kejernihan berlian ke singkatannya.
Metode praproses menggunakan artefak tersebut untuk memastikan bahwa pada waktu penayangan, fitur kejelasan berada dalam format singkatnya. Jika tidak, string lengkap akan dikonversi menjadi singkatan.
Metode postprocess menampilkan nilai yang diprediksi sebagai string dengan tanda $ dan membulatkan nilai.

Selanjutnya, gunakan Vertex AI Python SDK untuk membuat 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 nama kejelasan yang disingkat, tetapi instance lainnya harus 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 menguji container secara lokal, kini saatnya mengirim image ke Artifact Registry dan mengupload model ke Vertex AI Model Registry.

Pertama, konfigurasi 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, upload modelnya.

model = aiplatform.Model.upload(local_model = local_model,
                                display_name=MODEL_DISPLAY_NAME,
                                artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)

Setelah 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.