1. บทนำ
ในแล็บนี้ คุณจะได้เรียนรู้วิธีใช้กิจวัตรการคาดการณ์ที่กำหนดเองใน Vertex AI เพื่อเขียนตรรกะการประมวลผลก่อนและหลังที่กำหนดเอง แม้ว่าตัวอย่างนี้จะใช้ Scikit-learn แต่กิจวัตรการคาดการณ์ที่กำหนดเองก็ใช้ได้กับเฟรมเวิร์ก ML แบบ Python อื่นๆ เช่น XGBoost, PyTorch และ TensorFlow
สิ่งที่คุณจะได้เรียนรู้
- เขียนตรรกะการคาดการณ์ที่กำหนดเองด้วยกิจวัตรการคาดการณ์ที่กำหนดเอง
- ทดสอบคอนเทนเนอร์การแสดงผลและโมเดลที่กำหนดเองในเครื่อง
- ทดสอบคอนเทนเนอร์การแสดงผลที่กำหนดเองใน Vertex AI Predictions
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
แล็บนี้ใช้ผลิตภัณฑ์ AI ใหม่ล่าสุดที่พร้อมให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้จะรวมทั้ง 2 อย่างไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย
Vertex AI มีผลิตภัณฑ์มากมายที่แตกต่างกันเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นที่การคาดการณ์และเวิร์กเบนช์
3. ภาพรวมกรณีการใช้งาน
ในแล็บนี้ คุณจะได้สร้างโมเดลการถดถอยแบบสุ่มเพื่อคาดการณ์ราคาของเพชรตามแอตทริบิวต์ต่างๆ เช่น การเจียระไน ความใส และขนาด
คุณจะเขียนตรรกะการประมวลผลล่วงหน้าที่กำหนดเองเพื่อตรวจสอบว่าข้อมูล ณ เวลาที่ให้บริการอยู่ในรูปแบบที่โมเดลคาดไว้ นอกจากนี้ คุณยังต้องเขียนตรรกะการประมวลผลภายหลังที่กำหนดเองเพื่อปัดเศษการคาดการณ์และแปลงเป็นสตริง หากต้องการเขียนตรรกะนี้ คุณจะต้องใช้กิจวัตรการคาดการณ์ที่กำหนดเอง
ข้อมูลเบื้องต้นเกี่ยวกับกิจวัตรการคาดการณ์ที่กำหนดเอง
คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าของ Vertex AI จะจัดการคำขอการคาดการณ์โดยการดำเนินการคาดการณ์ของเฟรมเวิร์กแมชชีนเลิร์นนิง ก่อนที่จะมีกิจวัตรการคาดการณ์ที่กำหนดเอง หากต้องการประมวลผลอินพุตล่วงหน้าก่อนทำการคาดการณ์ หรือประมวลผลภายหลังการคาดการณ์ของโมเดลก่อนแสดงผลลัพธ์ คุณจะต้องสร้างคอนเทนเนอร์ที่กำหนดเอง
การสร้างคอนเทนเนอร์การแสดงผลที่กำหนดเองต้องเขียนเซิร์ฟเวอร์ HTTP ที่ห่อหุ้มโมเดลที่ฝึกแล้ว แปลคำขอ HTTP เป็นอินพุตของโมเดล และแปลเอาต์พุตของโมเดลเป็นการตอบกลับ
กิจวัตรการคาดการณ์ที่กำหนดเองช่วยให้ Vertex AI มีคอมโพเนนต์ที่เกี่ยวข้องกับการแสดงผลสำหรับคุณ เพื่อให้คุณมุ่งเน้นไปที่โมเดลและการเปลี่ยนรูปแบบข้อมูลได้
สิ่งที่คุณจะสร้าง
คุณจะตั้งค่าเครือข่าย VPC ที่ชื่อ aiml-vpc ซึ่งประกอบด้วยซับเน็ตเวิร์กเบนช์ที่ใช้ในการทำให้ใช้งานได้ Notebook ที่ผู้ใช้จัดการ และเข้าถึงการคาดการณ์ออนไลน์และปลายทางโมเดลที่ทำให้ใช้งานได้ใน us-central1 ดังแสดงในรูปที่ 1 ด้านล่าง
Figure1
4. เปิดใช้ API ของบทแนะนำ
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะต้องใช้ข้อมูลนี้เพื่อสร้างอินสแตนซ์ Notebook
ขั้นตอนที่ 2: เปิดใช้ Artifact Registry API
ไปที่ Artifact Registry แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้ คุณจะใช้สิ่งนี้เพื่อสร้างคอนเทนเนอร์การแสดงผลที่กำหนดเอง
ขั้นตอนที่ 3: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API
ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench
เปิดใช้ Notebooks API หากยังไม่ได้เปิด
5. สร้าง aiml-vpc
บทแนะนำนี้ใช้ $variables เพื่อช่วยในการติดตั้งใช้งานการกำหนดค่า gcloud ใน Cloud Shell
ใน Cloud Shell ให้ทำดังนี้
gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid
สร้าง aiml-vpc
ใน Cloud Shell ให้ทำดังนี้
gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom
สร้างซับเน็ตของ Notebook ที่ผู้ใช้จัดการ
สร้าง workbench-subnet ภายใน Cloud Shell
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
การกำหนดค่า Cloud Router และ NAT
ในบทแนะนำนี้จะใช้ Cloud NAT เพื่อดาวน์โหลดแพ็กเกจซอฟต์แวร์เนื่องจาก Notebook ที่ผู้ใช้จัดการไม่มีที่อยู่ IP ภายนอก Cloud NAT มีความสามารถ NAT ขาออก ซึ่งหมายความว่าโฮสต์อินเทอร์เน็ตไม่ได้รับอนุญาตให้เริ่มการสื่อสารกับ Notebook ที่ผู้ใช้จัดการ ทำให้มีความปลอดภัยมากขึ้น
สร้าง Cloud Router ระดับภูมิภาค us-central1 ภายใน Cloud Shell
gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1
สร้างเกตเวย์ Cloud NAT ระดับภูมิภาค us-central1 ภายใน Cloud Shell
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. สร้าง Notebook ที่ผู้ใช้จัดการ
สร้างบัญชีบริการที่มีการจัดการโดยผู้ใช้ (Notebook)
ในส่วนต่อไปนี้ คุณจะสร้างบัญชีบริการที่มีการจัดการโดยผู้ใช้ซึ่งจะเชื่อมโยงกับ Vertex Workbench (Notebook) ที่ใช้ในบทแนะนำ
ในบทแนะนำ บัญชีบริการจะมีกฎต่อไปนี้
สร้างบัญชีบริการภายใน Cloud Shell
gcloud iam service-accounts create user-managed-notebook-sa \
--display-name="user-managed-notebook-sa"
ใน Cloud Shell ให้อัปเดตบัญชีบริการด้วยบทบาทผู้ดูแลระบบพื้นที่เก็บข้อมูล
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"
ใน Cloud Shell ให้อัปเดตบัญชีบริการด้วยบทบาทผู้ใช้ Vertex AI
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"
ใน Cloud Shell ให้อัปเดตบัญชีบริการด้วยบทบาทผู้ดูแลระบบ Artifact Registry
gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"
ใน Cloud Shell ให้แสดงรายการบัญชีบริการและจดที่อยู่อีเมลที่จะใช้เมื่อสร้าง Notebook ที่ผู้ใช้จัดการ
gcloud iam service-accounts list
สร้าง Notebook ที่ผู้ใช้จัดการ
ในส่วนต่อไปนี้ ให้สร้าง Notebook ที่ผู้ใช้จัดการซึ่งรวมบัญชีบริการที่สร้างไว้ก่อนหน้านี้ นั่นคือ user-managed-notebook-sa
สร้างอินสแตนซ์ไคลเอ็นต์ส่วนตัวภายใน Cloud Shell
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. เขียนโค้ดการฝึก
ขั้นตอนที่ 1: สร้างที่เก็บข้อมูลระบบคลาวด์
คุณจะจัดเก็บโมเดลและอาร์ติแฟกต์การประมวลผลล่วงหน้าไว้ใน Bucket ของ Cloud Storage หากมีที่เก็บข้อมูลในโปรเจ็กต์ที่ต้องการใช้อยู่แล้ว คุณสามารถข้ามขั้นตอนนี้ได้
เปิดเซสชันเทอร์มินัลใหม่จาก Launcher
จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปรสภาพแวดล้อมสำหรับโปรเจ็กต์ของคุณ โดยอย่าลืมแทนที่ your-cloud-project ด้วยรหัสโปรเจ็กต์
PROJECT_ID='your-cloud-project'
จากนั้นเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อสร้างที่เก็บข้อมูลใหม่ในโปรเจ็กต์
BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET
ขั้นตอนที่ 2: ฝึกโมเดล
จากเทอร์มินัล ให้สร้างไดเรกทอรีใหม่ชื่อ cpr-codelab แล้วใช้คำสั่ง cd เพื่อเข้าไปในไดเรกทอรี
mkdir cpr-codelab
cd cpr-codelab
ในโปรแกรมเรียกดูไฟล์ ให้ไปที่ไดเรกทอรี cpr-codelab ใหม่ แล้วใช้ Launcher เพื่อสร้างสมุดบันทึก Python 3 ใหม่ชื่อ task.ipynb
ตอนนี้ไดเรกทอรี cpr-codelab ควรมีลักษณะดังนี้
+ cpr-codelab/
+ task.ipynb
วางโค้ดต่อไปนี้ใน Notebook
ก่อนอื่น ให้เขียนไฟล์ 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
โมเดลที่คุณทำให้ใช้งานได้จะมีชุดทรัพยากร Dependency ที่ติดตั้งไว้ล่วงหน้าแตกต่างจากสภาพแวดล้อมของ Notebook ด้วยเหตุนี้ คุณจึงควรแสดงรายการทรัพยากร Dependency ทั้งหมดสำหรับโมเดลใน requirements.txt แล้วใช้ pip เพื่อติดตั้งทรัพยากร Dependency เดียวกันใน Notebook จากนั้นคุณจะทดสอบโมเดลในเครื่องก่อนที่จะนำไปใช้งานใน Vertex AI เพื่อตรวจสอบอีกครั้งว่าสภาพแวดล้อมตรงกัน
Pip จะติดตั้งการอ้างอิงใน Notebook
!pip install -U --user -r requirements.txt
โปรดทราบว่าคุณจะต้องรีสตาร์ทเคอร์เนลหลังจากที่ pip ติดตั้งเสร็จสมบูรณ์
จากนั้นสร้างไดเรกทอรีที่จะจัดเก็บโมเดลและอาร์ติแฟกต์การประมวลผลล่วงหน้า
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
ตอนนี้ไดเรกทอรี cpr-codelab ควรมีลักษณะดังนี้
+ cpr-codelab/
+ model_artifacts/
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
เมื่อตั้งค่าโครงสร้างไดเรกทอรีแล้ว ก็ถึงเวลาฝึกโมเดล
ก่อนอื่น ให้นำเข้าไลบรารี
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)
จากนั้นกำหนดตัวแปรต่อไปนี้ อย่าลืมแทนที่ PROJECT_ID ด้วยรหัสโปรเจ็กต์และ BUCKET_NAME ด้วย Bucket ที่คุณสร้างในขั้นตอนก่อนหน้า
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}"
โหลดข้อมูลจากไลบรารี Seaborn แล้วสร้าง DataFrame 2 รายการ โดยรายการหนึ่งมีฟีเจอร์และอีกรายการหนึ่งมีป้ายกำกับ
data = sns.load_dataset('diamonds', cache=True, data_home=None)
label = 'price'
y_train = data['price']
x_train = data.drop(columns=['price'])
มาดูข้อมูลฝึกฝนกัน คุณจะเห็นว่าแต่ละแถวแสดงถึงเพชร
x_train.head()
และป้ายกำกับซึ่งเป็นราคาที่เกี่ยวข้อง
y_train.head()
ตอนนี้ให้กำหนด column transform ของ sklearn เพื่อเข้ารหัสฟีเจอร์เชิงหมวดหมู่แบบ One-Hot และปรับขนาดฟีเจอร์เชิงตัวเลข
column_transform = make_column_transformer(
(preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
(preprocessing.StandardScaler(), [0,4,5,6,7,8]))
กำหนดโมเดล Random Forest
regr = RandomForestRegressor(max_depth=10, random_state=0)
จากนั้นสร้าง sklearn pipeline ซึ่งหมายความว่าข้อมูลที่ป้อนไปยังไปป์ไลน์นี้จะได้รับการเข้ารหัส/ปรับขนาดก่อน จากนั้นจึงส่งไปยังโมเดล
my_pipeline = make_pipeline(column_transform, regr)
พอดีกับไปป์ไลน์ในข้อมูลฝึกฝน
my_pipeline.fit(x_train, y_train)
มาลองใช้โมเดลเพื่อตรวจสอบว่าทำงานได้ตามที่คาดไว้ เรียกใช้เมธอด predict ในโมเดลโดยส่งตัวอย่างทดสอบ
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
ตอนนี้เราสามารถบันทึกไปป์ไลน์ไปยังไดเรกทอรี model_artifacts และคัดลอกไปยัง Bucket ของ Cloud Storage ได้แล้ว
joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
ขั้นตอนที่ 3: บันทึกอาร์ติแฟกต์การประมวลผลล่วงหน้า
จากนั้นคุณจะสร้างอาร์ติแฟกต์การประมวลผลล่วงหน้า ระบบจะโหลดอาร์ติแฟกต์นี้ในคอนเทนเนอร์ที่กำหนดเองเมื่อเซิร์ฟเวอร์โมเดลเริ่มต้น อาร์ติแฟกต์การประมวลผลล่วงหน้าอาจอยู่ในรูปแบบใดก็ได้ (เช่น ไฟล์ Pickle) แต่ในกรณีนี้ คุณจะต้องเขียนพจนานุกรมลงในไฟล์ JSON
clarity_dict={"Flawless": "FL",
"Internally Flawless": "IF",
"Very Very Slightly Included": "VVS1",
"Very Slightly Included": "VS2",
"Slightly Included": "S12",
"Included": "I3"}
ฟีเจอร์ความชัดเจนในข้อมูลฝึกฝนของเราอยู่ในรูปแบบย่อเสมอ (เช่น "FL" แทน "Flawless") ในเวลาที่แสดง เราต้องการตรวจสอบว่าข้อมูลสำหรับฟีเจอร์นี้ก็ย่อด้วยเช่นกัน เนื่องจากโมเดลของเราทราบวิธีเข้ารหัสแบบ One-Hot สำหรับ "FL" แต่ไม่ทราบวิธีเข้ารหัสสำหรับ "Flawless" คุณจะเขียนตรรกะการประมวลผลล่วงหน้าที่กำหนดเองนี้ในภายหลัง แต่ตอนนี้ ให้บันทึกตารางการค้นหานี้ลงในไฟล์ JSON แล้วเขียนลงในที่เก็บข้อมูล 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}/
ตอนนี้ไดเรกทอรี cpr-codelab ในเครื่องควรมีลักษณะดังนี้
+ cpr-codelab/
+ model_artifacts/
+ model.joblib
+ preprocessor.json
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
8. สร้างคอนเทนเนอร์การแสดงผลที่กำหนดเองโดยใช้เซิร์ฟเวอร์โมเดล CPR
ตอนนี้โมเดลได้รับการฝึกแล้วและบันทึกอาร์ติแฟกต์การประมวลผลล่วงหน้าแล้ว ก็ถึงเวลาสร้างคอนเทนเนอร์การแสดงผลที่กำหนดเอง โดยปกติแล้ว การสร้างคอนเทนเนอร์ที่แสดงจะต้องเขียนโค้ดเซิร์ฟเวอร์โมเดล อย่างไรก็ตาม เมื่อใช้กิจวัตรการคาดการณ์ที่กำหนดเอง การคาดการณ์ของ Vertex AI จะสร้างเซิร์ฟเวอร์โมเดลและสร้างอิมเมจคอนเทนเนอร์ที่กำหนดเองให้คุณ
คอนเทนเนอร์การแสดงผลที่กำหนดเองมีโค้ด 3 ส่วนต่อไปนี้
- เซิร์ฟเวอร์โมเดล (SDK จะสร้างเซิร์ฟเวอร์นี้โดยอัตโนมัติและจัดเก็บไว้ใน scr_dir/)
- เซิร์ฟเวอร์ HTTP ที่โฮสต์โมเดล
- รับผิดชอบในการตั้งค่าเส้นทาง/พอร์ต/ฯลฯ
- รับผิดชอบด้านเว็บเซิร์ฟเวอร์ในการจัดการคำขอ เช่น การยกเลิกการซีเรียลไลซ์เนื้อหาคำขอ และการซีเรียลไลซ์การตอบกลับ การตั้งค่าส่วนหัวการตอบกลับ ฯลฯ
- ในตัวอย่างนี้ คุณจะใช้ตัวแฮนเดิลเริ่มต้น google.cloud.aiplatform.prediction.handler.PredictionHandler ที่มีให้ใน SDK
- รับผิดชอบตรรกะ ML สำหรับการประมวลผลคำขอการคาดการณ์
คุณปรับแต่งแต่ละองค์ประกอบเหล่านี้ได้ตามข้อกำหนดของกรณีการใช้งาน ในตัวอย่างนี้ คุณจะติดตั้งใช้งานเฉพาะตัวคาดการณ์
ตัวคาดการณ์มีหน้าที่รับผิดชอบตรรกะ ML สำหรับการประมวลผลคำขอการคาดการณ์ เช่น การประมวลผลล่วงหน้าและการประมวลผลภายหลังที่กำหนดเอง หากต้องการเขียนตรรกะการคาดการณ์ที่กำหนดเอง คุณจะต้องสร้างคลาสย่อยของอินเทอร์เฟซ Vertex AI Predictor
การเผยแพร่กิจวัตรการคาดการณ์ที่กำหนดเองนี้มาพร้อมกับตัวคาดการณ์ XGBoost และ Sklearn ที่นำกลับมาใช้ใหม่ได้ แต่หากต้องการใช้เฟรมเวิร์กอื่น คุณสามารถสร้างเฟรมเวิร์กของคุณเองได้โดยการสร้างคลาสย่อยของตัวคาดการณ์ฐาน
ดูตัวอย่าง Sklearn Predictor ได้ที่ด้านล่าง นี่คือโค้ดทั้งหมดที่คุณต้องเขียนเพื่อสร้างเซิร์ฟเวอร์โมเดลที่กำหนดเองนี้
ใน Notebook ให้วางโค้ดต่อไปนี้เพื่อสร้างคลาสย่อยของ SklearnPredictor และเขียนลงในไฟล์ Python ใน src_dir/ โปรดทราบว่าในตัวอย่างนี้ เราจะปรับแต่งเฉพาะเมธอด load, preprocess และ postprocess เท่านั้น ไม่ใช่เมธอด 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)]}
มาดูรายละเอียดของแต่ละวิธีกัน
- เมธอด load จะโหลดอาร์ติแฟกต์การประมวลผลล่วงหน้า ซึ่งในกรณีนี้คือพจนานุกรมที่แมปค่าความใสของเพชรกับตัวย่อ
- เมธอดการประมวลผลล่วงหน้าจะใช้อาร์ติแฟกต์ดังกล่าวเพื่อให้แน่ใจว่าฟีเจอร์ความชัดจะอยู่ในรูปแบบย่อเมื่อแสดง หากไม่ ระบบจะแปลงสตริงทั้งหมดเป็นตัวย่อ
- เมธอดหลังการประมวลผลจะแสดงผลค่าที่คาดการณ์เป็นสตริงที่มีเครื่องหมาย $ และปัดค่า
จากนั้นใช้ Vertex AI Python SDK เพื่อสร้างอิมเมจ เมื่อใช้กิจวัตรการคาดการณ์ที่กำหนดเอง ระบบจะสร้าง Dockerfile และสร้างอิมเมจให้คุณ
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"),
)
เขียนไฟล์ทดสอบที่มีตัวอย่าง 2 รายการสำหรับการคาดการณ์ อินสแตนซ์หนึ่งมีชื่อความชัดเจนแบบย่อ แต่อีกอินสแตนซ์หนึ่งต้องแปลงก่อน
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)
ทดสอบคอนเทนเนอร์ในเครื่องโดยการติดตั้งใช้งานโมเดลในเครื่อง
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()
คุณดูผลการคาดการณ์ได้โดยใช้
predict_response.content
9. ทำให้โมเดลใช้งานได้ใน Vertex AI
ตอนนี้คุณได้ทดสอบคอนเทนเนอร์ในเครื่องแล้ว ก็ถึงเวลาพุชอิมเมจไปยัง Artifact Registry และอัปโหลดโมเดลไปยัง Vertex AI Model Registry
ก่อนอื่น ให้กำหนดค่า Docker เพื่อเข้าถึง 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
จากนั้นดันรูปภาพ
local_model.push_image()
แล้วอัปโหลดโมเดล
model = aiplatform.Model.upload(local_model = local_model,
display_name=MODEL_DISPLAY_NAME,
artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
เมื่ออัปโหลดโมเดลแล้ว คุณควรเห็นโมเดลในคอนโซล
จากนั้น ให้ทําให้โมเดลใช้งานได้เพื่อให้คุณใช้โมเดลสําหรับการคาดการณ์ออนไลน์ได้ กิจวัตรการคาดการณ์ที่กำหนดเองใช้ได้กับการคาดการณ์แบบกลุ่มด้วย ดังนั้นหากกรณีการใช้งานของคุณไม่จำเป็นต้องมีการคาดการณ์ออนไลน์ คุณก็ไม่จำเป็นต้องทำให้โมเดลใช้งานได้
จากนั้นดันรูปภาพ
endpoint = model.deploy(machine_type="n1-standard-2")
สุดท้าย ให้ทดสอบโมเดลที่ใช้งานจริงโดยรับการคาดการณ์
endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้
- เขียนตรรกะการประมวลผลก่อนและหลังที่กำหนดเองด้วยกิจวัตรการคาดการณ์ที่กำหนดเอง
Cosmopup คิดว่า Codelab นั้นยอดเยี่ยม!!
สิ่งต่อไปที่ควรทำ
อ่านเพิ่มเติมและวิดีโอ
- Vertex AI คืออะไร
- เริ่มต้นใช้งาน Vertex AI
- โซลูชัน AI/ML ใดใน Vertex AI ที่เหมาะกับฉัน
- การสร้างระบบตอบคำถามด้วย Vertex AI