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 container dan model penayangan kustom secara lokal
• Menguji penayangan container kustom di Vertex AI Predictions

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

Untuk mem-build penampung penayangan kustom, Anda harus menulis server HTTP yang menggabungkan model yang dilatih, 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.

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

Terima opsi default dan klik Create.

Saat instance siap, klik BUKA JUPYTERLAB untuk membuka instance.

5. Menulis kode pelatihan

Langkah 1: Buat bucket Cloud Storage

Anda akan menyimpan model dan artefak prapemrosesan 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 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: Melatih 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 kumpulan 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. Kemudian, Anda akan menguji model secara lokal sebelum men-deploy ke Vertex AI untuk memeriksa kembali apakah lingkungannya 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 model dan artefak prapemrosesan.

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 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 dataframe, satu dengan fitur dan satu lagi 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 mengenkode one hot 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/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 untuk memastikan model tersebut berfungsi seperti yang diharapkan. Panggil metode predict pada model, dengan meneruskan contoh 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 prapemrosesan

Selanjutnya, Anda akan membuat artefak prapemrosesan. Artefak ini akan dimuat di penampung kustom saat server model dimulai. Artefak prapemrosesan Anda dapat berupa hampir semua bentuk (seperti file pickle), 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 clarity dalam data pelatihan kami selalu dalam bentuk singkatan (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 tidak tahu "Flawless". 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:

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

6. 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 Predictions akan membuat server model dan mem-build image container kustom untuk Anda.

Penampung penayangan kustom berisi 3 bagian kode berikut:

1. Server model (ini akan dihasilkan secara otomatis oleh SDK dan disimpan di scr_dir/)
   • Server HTTP yang menghosting model
   • Bertanggung jawab untuk menyiapkan rute/port/dll.
2. Pemroses Permintaan
   • 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 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 prapemrosesan 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 membuat sendiri dengan membuat subclass prediktor dasar.

Anda dapat melihat contoh Prediktor Sklearn di bawah. Ini adalah semua kode yang perlu Anda tulis untuk mem-build 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 lanjut setiap metode ini.

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

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

Selanjutnya, gunakan Vertex AI Python SDK untuk membangun image. Dengan menggunakan rutinitas prediksi kustom, Dockerfile akan dibuat dan image akan di-build 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.

Dalam contoh ini, kita menggunakan model lokal dan artefak prapemrosesan, 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 penampung secara lokal, sekarang 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, upload 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 sehingga 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 prapemrosesan dan pascapemrosesan kustom dengan rutinitas prediksi kustom

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

8. Pembersihan

Jika Anda ingin terus menggunakan notebook yang dibuat di lab ini, sebaiknya nonaktifkan notebook saat tidak digunakan. Dari UI Workbench di Google Cloud Console, 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 Endpoint pada konsol, klik endpoint yang Anda buat, lalu pilih Batalkan deployment model dari 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: