Vertex AI: Menggunakan rutinitas prediksi kustom dengan Sklearn untuk melakukan prapemrosesan dan pascapemrosesan data untuk prediksi

1. Ringkasan

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 Anda pelajari

Anda akan mempelajari cara:

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

Total biaya untuk menjalankan lab ini di Google Cloud adalah sekitar $1 USD.

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

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 pascapemrosesan 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 pasca-pemrosesan 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.

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 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 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 INSTANCES, lalu pilih CREATE NEW.

Setujui opsi default, lalu klik Buat.

Setelah instance siap, klik OPEN JUPYTERLAB untuk membuka instance.

5. 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 Anda, jalankan perintah berikut guna menentukan variabel env untuk project Anda, pastikan untuk mengganti your-cloud-project dengan ID project Anda:

Anda bisa mendapatkan project ID dengan menjalankan gcloud config list --format 'value(core.project)' di terminal 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.0
numpy~=1.20
scikit-learn>=1.2.2
pandas
google-cloud-storage>=1.26.0,<2.0.0dev
google-cloud-aiplatform[prediction]>=1.16.0

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

Instal dependensi dengan pip 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 dataframe, 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(), [1,2,3]),
    (preprocessing.StandardScaler(), [0,4,5,6,7,8]))

Menentukan 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 predict 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 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 clarity dalam data pelatihan kami selalu dalam bentuk singkatan (yaitu "FL" dan bukan "Flawless"). Pada waktu penayangan, kita ingin memeriksa apakah data untuk fitur ini juga disingkat. Hal ini karena model kita tahu cara melakukan one-hot encoding "FL", tetapi tidak tahu cara melakukan one-hot 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

6. 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:

1. 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.
2. 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.
3. 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 XGBoost dan Sklearn predictor yang dapat digunakan kembali, tetapi jika Anda perlu menggunakan framework lain, Anda dapat membuatnya sendiri dengan membuat subclass predictor 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, 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, preprocess, dan postprocess, bukan metode predict.

%%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 singkatan masing-masing.
• Metode preprocess 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 prediksi sebagai string dengan tanda $ dan membulatkan nilai.

Perhatikan bahwa tujuan utama contoh ini adalah untuk menunjukkan cara menyesuaikan berbagai metode ini, bukan untuk membangun model atau pipeline penayangan yang realistis.

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.

Dalam contoh ini, kita menggunakan artefak model dan praproses lokal, tetapi Anda juga dapat menentukan jalur Cloud Storage sebagai artifact_uri. Dalam hal ini, Anda harus menyiapkan kredensial seperti yang ditunjukkan dalam contoh ini.

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

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

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 praproses dan pascaproses kustom dengan rutinitas prediksi kustom

Untuk mempelajari lebih lanjut berbagai bagian Vertex AI, lihat dokumentasinya.

8. Pembersihan

Jika Anda ingin terus menggunakan notebook yang Anda buat di lab ini, sebaiknya nonaktifkan notebook tersebut saat tidak digunakan. Dari UI Workbench di Konsol Google 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, klik endpoint yang Anda buat, lalu pilih Undeploy model from endpoint:

Untuk menghapus image container, buka Artifact Registry, pilih repositori yang Anda buat, lalu pilih Delete.

Untuk menghapus Bucket Penyimpanan, menggunakan menu Navigasi di Konsol Cloud, jelajahi Penyimpanan, pilih bucket Anda, lalu klik Hapus: