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 แบบครบวงจร ห้องทดลองนี้จะมุ่งเน้นไปที่การคาดการณ์และ Workbench
3. ภาพรวมกรณีการใช้งาน
ในห้องทดลองนี้ คุณจะได้สร้างโมเดลการถดถอยของป่าแบบสุ่มเพื่อคาดการณ์ราคาเพชรตามแอตทริบิวต์ต่างๆ เช่น สัดส่วน ความคมชัด และขนาด
คุณจะต้องเขียนตรรกะการประมวลผลล่วงหน้าที่กำหนดเองเพื่อตรวจสอบว่าข้อมูลขณะแสดงผลอยู่ในรูปแบบที่โมเดลคาดหวังหรือไม่ นอกจากนี้ คุณยังเขียนตรรกะการประมวลผลโพสต์ที่กำหนดเองเพื่อปัดเศษการคาดการณ์และแปลงเป็นสตริงได้ ในการเขียนตรรกะนี้ คุณจะต้องใช้กิจวัตรการคาดการณ์ที่กำหนดเอง
ข้อมูลเบื้องต้นเกี่ยวกับกิจวัตรการคาดการณ์ที่กำหนดเอง
คอนเทนเนอร์สำเร็จรูปของ Vertex AI จะจัดการคำขอการคาดการณ์โดยดำเนินการคาดคะเนของเฟรมเวิร์กแมชชีนเลิร์นนิง ก่อนที่จะใช้กิจวัตรการคาดการณ์ที่กำหนดเอง หากคุณต้องการประมวลผลอินพุตล่วงหน้าก่อนที่จะดำเนินการการคาดการณ์ หรือหลังประมวลผลการคาดการณ์ของโมเดลก่อนส่งคืนผลลัพธ์ คุณจะต้องสร้างคอนเทนเนอร์ที่กำหนดเอง
การสร้างคอนเทนเนอร์การแสดงผลที่กำหนดเองจำเป็นต้องมีการเขียนเซิร์ฟเวอร์ HTTP ที่รวมโมเดลที่ฝึกไว้ แปลคำขอ HTTP เป็นอินพุตโมเดล และแปลงเอาต์พุตของโมเดลเป็นการตอบกลับ
เมื่อใช้กิจวัตรการคาดการณ์ที่กำหนดเอง Vertex AI จะมอบคอมโพเนนต์ที่เกี่ยวข้องกับการแสดงผลให้กับคุณ เพื่อให้คุณมุ่งเน้นที่โมเดลและการเปลี่ยนรูปแบบข้อมูลได้
สิ่งที่คุณจะสร้าง
คุณจะตั้งค่าเครือข่าย VPC ชื่อ API ของ AOL ที่ประกอบด้วยซับเน็ต Workbench ที่ใช้ในการทำให้สมุดบันทึกที่ผู้ใช้จัดการใช้งานได้ และเข้าถึงการคาดการณ์ออนไลน์และปลายทางของโมเดลที่ทำให้ใช้งานได้ใน us-central1 ดังที่แสดงในรูปที่ 1 ด้านล่าง
Figure1
4. เปิดใช้ API ของบทแนะนำ
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือกเปิดใช้ หากยังไม่ได้เปิดใช้ ซึ่งคุณจะต้องใช้ในการสร้างอินสแตนซ์สมุดบันทึก
ขั้นตอนที่ 2: เปิดใช้ Artifact Registry API
ไปที่ Artifact Registry แล้วเลือกเปิดใช้ หากยังไม่ได้เปิด คุณจะใช้ค่านี้เพื่อสร้างคอนเทนเนอร์การแสดงผลที่กำหนดเอง
ขั้นตอนที่ 3: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API
ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench
เปิดใช้ API สำหรับสมุดบันทึก หากยังไม่ได้เปิดใช้
5. สร้าง Piml-vpc
บทแนะนำนี้ใช้ $variables เพื่อช่วยในการติดตั้งใช้งานการกำหนดค่า gcloud ใน Cloud Shell
ภายใน Cloud Shell ให้ดำเนินการต่อไปนี้
gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid
สร้าง SPM-vpc
ภายใน Cloud Shell ให้ดำเนินการต่อไปนี้
gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom
สร้างซับเน็ตของสมุดบันทึกที่จัดการโดยผู้ใช้
สร้างซับเน็ต Workbench ใน 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 ใช้ในบทแนะนำเพื่อดาวน์โหลดแพ็กเกจซอฟต์แวร์เนื่องจากสมุดบันทึกที่ผู้ใช้จัดการไม่มีที่อยู่ IP ภายนอก Cloud NAT มีความสามารถของ NAT ขาออก ซึ่งหมายความว่าโฮสต์อินเทอร์เน็ตจะไม่ได้รับอนุญาตให้เริ่มการสื่อสารกับสมุดบันทึกที่ผู้ใช้จัดการ ซึ่งทำให้มีความปลอดภัยมากยิ่งขึ้น
สร้างเราเตอร์ระบบคลาวด์ระดับภูมิภาค us-central1 ใน Cloud Shell
gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1
สร้างเกตเวย์ Cloud Nat ระดับภูมิภาคใน Cloud Shell ซึ่งก็คือ 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. สร้างสมุดบันทึกที่จัดการโดยผู้ใช้
สร้างบัญชีบริการที่จัดการโดยผู้ใช้ (สมุดบันทึก)
ในส่วนต่อไปนี้ คุณจะต้องสร้างบัญชีบริการที่มีการจัดการโดยผู้ใช้ซึ่งจะเชื่อมโยงกับ Vertex Workbench (สมุดบันทึก) ที่ใช้ในบทแนะนำ
ในบทแนะนำ บัญชีบริการจะใช้กฎต่อไปนี้
สร้างบัญชีบริการใน Cloud Shell
gcloud iam service-accounts create user-managed-notebook-sa \
--display-name="user-managed-notebook-sa"
ภายใน Cloud Shell ให้อัปเดตบัญชีบริการด้วยบทบาทผู้ดูแลระบบ Storage
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 ให้ระบุบัญชีบริการและจดบันทึกอีเมลที่จะใช้เมื่อสร้างสมุดบันทึกที่จัดการโดยผู้ใช้
gcloud iam service-accounts list
สร้างสมุดบันทึกที่จัดการโดยผู้ใช้
ในส่วนต่อไปนี้ ให้สร้างสมุดบันทึกที่จัดการโดยผู้ใช้ ซึ่งรวมบัญชีบริการที่สร้างไว้ก่อนหน้านี้ ซึ่งก็คือ user-managed-notebook-sa
ภายใน Cloud Shell ให้สร้างอินสแตนซ์ 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. เขียนโค้ดการฝึก
ขั้นตอนที่ 1: สร้างที่เก็บข้อมูลของ Cloud Storage
คุณจะต้องจัดเก็บโมเดลและประมวลผลอาร์ติแฟกต์ล่วงหน้าไปยังที่เก็บข้อมูล Cloud Storage หากมีที่เก็บข้อมูลในโปรเจ็กต์ที่ต้องการใช้อยู่แล้ว ให้ข้ามขั้นตอนนี้
จากตัวเรียกใช้งาน ให้เปิดเซสชันเทอร์มินัลใหม่
จากเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อกำหนดตัวแปร env สำหรับโปรเจ็กต์ของคุณ และแทนที่ 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 ใหม่ชื่อ Tasks
ตอนนี้ไดเรกทอรี cpr-codelab ควรมีลักษณะดังนี้
+ cpr-codelab/
+ task.ipynb
วางรหัสต่อไปนี้ในสมุดบันทึก
ก่อนอื่น ให้เขียนไฟล์ประมาณ .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 ที่ติดตั้งล่วงหน้าซึ่งต่างจากสภาพแวดล้อมสมุดบันทึกของคุณ ด้วยเหตุนี้ คุณจึงต้องแสดงรายการทรัพยากร Dependency ทั้งหมดสำหรับโมเดลใน "specific.txt" แล้วใช้ pip เพื่อติดตั้งทรัพยากร Dependency เดียวกันเหล่านั้นในสมุดบันทึก หลังจากนั้น คุณจะทดสอบโมเดลในเครื่องก่อนทำให้ใช้งานได้กับ Vertex AI เพื่อตรวจสอบอีกครั้งว่าสภาพแวดล้อมตรงกัน
Pip จะติดตั้งทรัพยากร Dependency ในสมุดบันทึก
!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 ด้วยที่เก็บข้อมูลที่คุณสร้างไว้ในขั้นตอนก่อนหน้า
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}"
โหลดข้อมูลจากไลบรารีของทะเล จากนั้นสร้างเฟรมข้อมูล 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()
ต่อไป ให้กำหนด คอลัมน์การเปลี่ยนแปลง ของ sklearn เป็น 1 เข้ารหัสคุณลักษณะหมวดหมู่ด้วยรูปแบบร้อนๆ และปรับขนาดฟีเจอร์เชิงตัวเลข
column_transform = make_column_transformer(
(preprocessing.OneHotEncoder(sparse=False), [1,2,3]),
(preprocessing.StandardScaler(), [0,4,5,6,7,8]))
นิยามโมเดลฟอเรสต์แบบสุ่ม
regr = RandomForestRegressor(max_depth=10, random_state=0)
ถัดไป ให้สร้างไปป์ไลน์ sklearn ซึ่งหมายความว่าระบบจะเข้ารหัส/ปรับขนาดข้อมูลที่ส่งไปยังไปป์ไลน์นี้ก่อน แล้วจึงส่งไปยังโมเดล
my_pipeline = make_pipeline(column_transform, regr)
ปรับไปป์ไลน์ให้ตรงกับข้อมูลการฝึก
my_pipeline.fit(x_train, y_train)
มาลองใช้โมเดลเพื่อให้แน่ใจว่าทำงานได้ตามที่คาดไว้ เรียกใช้เมธอดการคาดการณ์บนโมเดล โดยส่งในตัวอย่างทดสอบ
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
ตอนนี้เราสามารถบันทึกไปป์ไลน์ไปยังไดเรกทอรี model_artifacts และคัดลอกไปยังที่เก็บข้อมูล Cloud Storage ได้
joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
ขั้นตอนที่ 3: บันทึกอาร์ติแฟกต์ที่ประมวลผลล่วงหน้า
ถัดไปคุณจะต้องสร้างอาร์ติแฟกต์ที่ประมวลผลล่วงหน้า ระบบจะโหลดอาร์ติแฟกต์นี้ในคอนเทนเนอร์ที่กำหนดเองเมื่อเซิร์ฟเวอร์โมเดลเริ่มทำงาน อาร์ติแฟกต์ที่ประมวลผลล่วงหน้าอาจอยู่ในรูปแบบใดก็ได้ (เช่น ไฟล์แฝด) แต่ในกรณีนี้ คุณจะต้องเขียนพจนานุกรมลงในไฟล์ JSON
clarity_dict={"Flawless": "FL",
"Internally Flawless": "IF",
"Very Very Slightly Included": "VVS1",
"Very Slightly Included": "VS2",
"Slightly Included": "S12",
"Included": "I3"}
ฟีเจอร์ความชัดเจนในข้อมูลการฝึกอบรมของเราอยู่ในรูปแบบย่อเสมอ (เช่น "FL" แทนที่จะเป็น "ไร้ที่ติ") ขณะใช้งาน เราต้องการตรวจสอบว่าข้อมูลของสถานที่นี้เป็นตัวย่อเช่นกัน นั่นเป็นเพราะโมเดลของเรารู้วิธีเข้ารหัส "FL" ร้อนๆ แต่ไม่ใช่ "ไร้ที่ติ" คุณจะต้องเขียนตรรกะการประมวลผลล่วงหน้าที่กำหนดเองนี้ในภายหลัง แต่ตอนนี้ให้บันทึกตารางค้นหานี้ลงในไฟล์ 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 Predictions จะสร้างเซิร์ฟเวอร์โมเดลและสร้างอิมเมจคอนเทนเนอร์ที่กำหนดเองให้คุณด้วยกิจวัตรการคาดการณ์ที่กำหนดเอง
คอนเทนเนอร์ที่ใช้การแสดงผลที่กำหนดเองประกอบด้วยโค้ด 3 อย่างต่อไปนี้
- เซิร์ฟเวอร์โมเดล (SDK นี้จะสร้างขึ้นโดยอัตโนมัติและจัดเก็บไว้ใน scr_dir/)
- เซิร์ฟเวอร์ HTTP ที่โฮสต์โมเดล
- รับผิดชอบการตั้งค่าเส้นทาง/พอร์ต/ฯลฯ
- ซึ่งรับผิดชอบด้านการจัดการคำขอของเว็บเซิร์ฟเวอร์ เช่น การดีซีเรียลเนื้อหาของคำขอและการจัดลำดับการตอบกลับ การตั้งค่าส่วนหัวการตอบกลับ เป็นต้น
- ในตัวอย่างนี้ คุณจะใช้เครื่องจัดการเริ่มต้น google.cloud.aiplatform.prediction.handler.PredictionHandler ซึ่งมีอยู่ใน SDK
- รับผิดชอบตรรกะ ML สำหรับการประมวลผลคำขอการคาดการณ์
คอมโพเนนต์แต่ละอย่างเหล่านี้สามารถปรับแต่งได้ตามข้อกำหนดของกรณีการใช้งานของคุณ ในตัวอย่างนี้ คุณจะใช้ตัวคาดการณ์เท่านั้น
ตัวคาดการณ์มีหน้าที่รับผิดชอบต่อตรรกะ ML สำหรับการประมวลผลคำขอการคาดการณ์ เช่น การประมวลผลล่วงหน้าและการประมวลผลภายหลังที่กำหนดเอง หากต้องการเขียนตรรกะการคาดการณ์ที่กำหนดเอง คุณจะต้องคลาสย่อยของอินเทอร์เฟซ Vertex AI Predictor
กิจวัตรการคาดการณ์ที่กำหนดเองรุ่นนี้มาพร้อมกับตัวคาดการณ์ XGBoost และ Sklearn ที่ใช้ซ้ำได้ แต่หากต้องการใช้เฟรมเวิร์กอื่น คุณสามารถสร้างของตัวเองได้ด้วยการแยกประเภทย่อยของตัวคาดการณ์พื้นฐาน
ดูตัวอย่างเครื่องมือคาดการณ์ Sklearn ได้ที่ด้านล่าง นี่คือโค้ดทั้งหมดที่คุณจะต้องเขียนเพื่อสร้างเซิร์ฟเวอร์โมเดลที่กำหนดเองนี้
ในสมุดบันทึก ให้วางรหัสต่อไปนี้ด้านล่างเพื่อคลาสย่อย SklearnPredictor และเขียนลงในไฟล์ Python ใน src_dir/ โปรดทราบว่าในตัวอย่างนี้เราปรับแต่งเฉพาะเมธอดการโหลด กระบวนการล่วงหน้า และขั้นตอนหลังการประมวลผลเท่านั้น ไม่ได้ปรับแต่งเมธอดการคาดการณ์
%%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)]}
มาดูรายละเอียดเพิ่มเติมของแต่ละวิธีกัน
- วิธีโหลดจะโหลดในอาร์ติแฟกต์ก่อนการประมวลผล ซึ่งในกรณีนี้เป็นพจนานุกรมที่จับคู่ค่าความชัดเจนของเพชรกับตัวย่อ
- วิธีการประมวลผลล่วงหน้าจะใช้อาร์ติแฟกต์ดังกล่าวเพื่อให้แน่ใจว่าขณะให้บริการ ฟีเจอร์ความชัดเจนจะอยู่ในรูปแบบย่อ หากไม่เป็นเช่นนั้น เครื่องมือจะแปลงสตริงทั้งหมดเป็นอักษรย่อ
- เมธอด Postprocess จะแสดงผลค่าที่คาดการณ์เป็นสตริงที่มีเครื่องหมาย $ และปัดเศษค่า
ถัดไป ให้ใช้ 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