1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้เรียนรู้วิธีใช้กิจวัตรการคาดการณ์ที่กำหนดเองใน Vertex AI เพื่อเขียนตรรกะการประมวลผลล่วงหน้าและการประมวลผลภายหลังที่กำหนดเอง แม้ว่าตัวอย่างนี้จะใช้สคีต-เลิร์น แต่กิจวัตรการคาดคะเนที่กำหนดเองจะทํางานร่วมกับเฟรมเวิร์ก ML อื่นๆ ของ Python ได้ เช่น XGBoost, PyTorch และ TensorFlow
สิ่งที่คุณเรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- เขียนตรรกะการคาดการณ์ที่กำหนดเองด้วยกิจวัตรการคาดการณ์ที่กำหนดเอง
- ทดสอบคอนเทนเนอร์และโมเดลการแสดงผลที่กำหนดเองในเครื่อง
- ทดสอบคอนเทนเนอร์การแสดงผลที่กำหนดเองในการคาดการณ์ของ Vertex AI
ค่าใช้จ่ายทั้งหมดในการเรียกใช้ห้องทดลองนี้ใน Google Cloud อยู่ที่ประมาณ $1 USD
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ทั่วทั้ง Google Cloud เข้าด้วยกันเพื่อมอบประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้รวมทั้ง 2 รายการไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย
Vertex AI มีผลิตภัณฑ์หลายอย่างเพื่อรองรับเวิร์กโฟลว์ ML ตั้งแต่ต้นจนจบ ห้องทดลองนี้จะเน้นที่การคาดคะเนและเวิร์กเบนค์
3. ภาพรวมกรณีการใช้งาน
กรณีการใช้งาน
ในชั้นเรียนนี้ คุณจะได้สร้างโมเดลการถดถอยแบบ Random Forest เพื่อคาดการณ์ราคาของเพชรตามแอตทริบิวต์ต่างๆ เช่น การตัด ความสะอาด และขนาด
คุณจะเขียนตรรกะการประมวลผลข้อมูลล่วงหน้าที่กําหนดเองเพื่อตรวจสอบว่าข้อมูล ณ เวลาแสดงอยู่ในรูปแบบที่โมเดลคาดไว้ นอกจากนี้ คุณยังเขียนตรรกะการประมวลผลผลลัพธ์ที่กำหนดเองเพื่อปัดเศษการคาดการณ์และแปลงเป็นสตริงได้ด้วย หากต้องการเขียนตรรกะนี้ คุณจะใช้กิจวัตรการคาดการณ์ที่กําหนดเอง
ข้อมูลเบื้องต้นเกี่ยวกับกิจวัตรการคาดการณ์ที่กำหนดเอง
คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าของ Vertex AI จะจัดการคำขอการคาดการณ์โดยดำเนินการคาดการณ์ของเฟรมเวิร์กแมชชีนเลิร์นนิง ก่อนใช้กิจวัตรการคาดการณ์ที่กําหนดเอง หากต้องการประมวลผลข้อมูลอินพุตก่อนทำการคาดการณ์ หรือประมวลผลผลลัพธ์ของการคาดการณ์ของโมเดลก่อนแสดงผล คุณจะต้องสร้างคอนเทนเนอร์ที่กําหนดเอง
การสร้างคอนเทนเนอร์การแสดงผลที่กำหนดเองจำเป็นต้องมีการเขียนเซิร์ฟเวอร์ HTTP ที่รวมโมเดลที่ฝึกไว้ แปลคำขอ HTTP เป็นอินพุตโมเดล และแปลงเอาต์พุตของโมเดลเป็นการตอบกลับ
เมื่อใช้กิจวัตรการคาดการณ์ที่กำหนดเอง Vertex AI จะจัดเตรียมคอมโพเนนต์ที่เกี่ยวข้องกับการแสดงให้คุณ เพื่อให้คุณมุ่งเน้นที่โมเดลและการเปลี่ยนรูปแบบข้อมูลได้
4. ตั้งค่าสภาพแวดล้อม
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 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
จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench
เปิดใช้ Notebooks API หากยังไม่ได้เปิดใช้
เมื่อเปิดใช้แล้ว ให้คลิกอินสแตนซ์ แล้วเลือกสร้างใหม่
ยอมรับตัวเลือกเริ่มต้น แล้วคลิกสร้าง
เมื่ออินสแตนซ์พร้อมแล้ว ให้คลิกเปิด JupyterLab เพื่อเปิดอินสแตนซ์
5. เขียนโค้ดการฝึก
ขั้นตอนที่ 1: สร้างที่เก็บข้อมูลระบบคลาวด์
คุณจะจัดเก็บโมเดลและอาร์ติแฟกต์การประมวลผลข้อมูลล่วงหน้าไว้ในที่เก็บข้อมูล 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 และเข้ารหัสลงในไดเรกทอรีดังกล่าว
mkdir cpr-codelab
cd cpr-codelab
ในโปรแกรมเรียกดูไฟล์ ให้ไปที่ไดเรกทอรี cpr-codelab ใหม่ จากนั้นใช้ตัวเปิดแอปเพื่อสร้างโน้ตบุ๊ก Python 3 ใหม่ชื่อ task.ipynb
ตอนนี้ไดเรกทอรี cpr-codelab ควรมีลักษณะดังนี้
+ cpr-codelab/
+ task.ipynb
วางรหัสต่อไปนี้ในสมุดบันทึก
ก่อนอื่น ให้เขียนไฟล์ 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
โมเดลที่คุณทำให้ใช้งานได้จะมีชุดทรัพยากร Dependency ที่ติดตั้งล่วงหน้าซึ่งต่างจากสภาพแวดล้อมสมุดบันทึกของคุณ คุณจึงควรแสดงรายการ Dependency ทั้งหมดของโมเดลใน requirements.txt แล้วใช้ pip เพื่อติดตั้ง Dependency เดียวกันทุกประการในโน้ตบุ๊ค หลังจากนั้น คุณจะทดสอบโมเดลในเครื่องก่อนนำไปใช้งานใน Vertex AI เพื่อตรวจสอบอีกครั้งว่าสภาพแวดล้อมตรงกัน
Pip ติดตั้งการอ้างอิงในโน้ตบุ๊ก
!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()
ตอนนี้ให้กําหนด column transform ของ sklearn เพื่อเข้ารหัสฟีเจอร์เชิงหมวดหมู่เป็น One Hot และปรับขนาดฟีเจอร์ที่เป็นตัวเลข
column_transform = make_column_transformer(
(preprocessing.OneHotEncoder(), [1,2,3]),
(preprocessing.StandardScaler(), [0,4,5,6,7,8]))
กําหนดโมเดล Random Forest
regr = RandomForestRegressor(max_depth=10, random_state=0)
ถัดไป ให้สร้างไปป์ไลน์ sklearn ซึ่งหมายความว่าข้อมูลที่ส่งไปยังไปป์ไลน์นี้จะได้รับการเข้ารหัส/ปรับขนาดก่อน จากนั้นจึงส่งไปยังโมเดล
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 และคัดลอกไปยังที่เก็บข้อมูล 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"}
ฟีเจอร์ clarity ในข้อมูลการฝึกของเราอยู่ในรูปแบบย่อเสมอ (เช่น "FL" แทน "Flawless") ในเวลาที่แสดงโฆษณา เราต้องการตรวจสอบว่าข้อมูลของฟีเจอร์นี้มีการย่อด้วย เนื่องจากโมเดลของเรารู้วิธีเข้ารหัสแบบฮอตเวิร์ก 1 รายการสำหรับ "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
6. สร้างคอนเทนเนอร์การแสดงผลที่กำหนดเองโดยใช้เซิร์ฟเวอร์โมเดล CPR
เมื่อฝึกโมเดลและบันทึกอาร์ติแฟกต์และการประมวลผลล่วงหน้าแล้ว ก็ถึงเวลาสร้างคอนเทนเนอร์การแสดงผลที่กำหนดเอง โดยปกติการสร้างคอนเทนเนอร์สำหรับแสดงผลจะต้องเขียนโค้ดเซิร์ฟเวอร์โมเดล อย่างไรก็ตาม Vertex AI Predictions จะสร้างเซิร์ฟเวอร์โมเดลและสร้างอิมเมจคอนเทนเนอร์ที่กำหนดเองให้คุณด้วยกิจวัตรการคาดการณ์ที่กำหนดเอง
คอนเทนเนอร์การแสดงผลที่กําหนดเองประกอบด้วยโค้ด 3 รายการต่อไปนี้
- เซิร์ฟเวอร์โมเดล (SDK จะสร้างและจัดเก็บใน
scr_dir/โดยอัตโนมัติ)- เซิร์ฟเวอร์ HTTP ที่โฮสต์โมเดล
- รับผิดชอบในการตั้งค่าเส้นทาง/พอร์ต/ฯลฯ
- ตัวแฮนเดิลคำขอ
- รับผิดชอบด้านการจัดการคําขอของเว็บเซิร์ฟเวอร์ เช่น การจัดรูปแบบข้อมูลใหม่ของเนื้อหาคําขอ และการจัดรูปแบบข้อมูลใหม่ของคําตอบ การตั้งค่าส่วนหัวการตอบกลับ ฯลฯ
- ในตัวอย่างนี้ คุณจะใช้ตัวแฮนเดิลเริ่มต้น
google.cloud.aiplatform.prediction.handler.PredictionHandlerที่มีให้ใน SDK
- ตัวทำนาย
- รับผิดชอบตรรกะ ML สําหรับการประมวลผลคําขอการคาดการณ์
องค์ประกอบแต่ละรายการเหล่านี้ปรับแต่งได้ตามข้อกําหนดของกรณีการใช้งาน ในตัวอย่างนี้ คุณจะใช้ตัวคาดการณ์เท่านั้น
ตัวคาดการณ์มีหน้าที่รับผิดชอบต่อตรรกะ ML สำหรับการประมวลผลคำขอการคาดการณ์ เช่น การประมวลผลล่วงหน้าและการประมวลผลภายหลังที่กำหนดเอง หากต้องการเขียนตรรกะการคาดการณ์ที่กําหนดเอง คุณจะต้องสร้างคลาสย่อยของอินเทอร์เฟซตัวคาดการณ์ Vertex AI
กิจวัตรการคาดการณ์ที่กําหนดเองรุ่นนี้มาพร้อมกับตัวคาดการณ์ XGBoost และ Sklearn ที่ใช้ซ้ำได้ แต่หากต้องการใช้เฟรมเวิร์กอื่น คุณก็สร้างเองได้โดยการแยกคลาสย่อยของตัวคาดการณ์พื้นฐาน
ดูตัวอย่างตัวทำนาย Sklearn ได้ที่ด้านล่าง นี่คือโค้ดทั้งหมดที่คุณจะต้องเขียนเพื่อสร้างเซิร์ฟเวอร์โมเดลที่กำหนดเองนี้
ในโน้ตบุ๊ค ให้วางโค้ดต่อไปนี้เพื่อกำหนดคลาสย่อยของ 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จะโหลดอาร์ติแฟกต์การประมวลผลข้อมูลก่อน ซึ่งในกรณีนี้คือพจนานุกรมที่แมปค่าความใสของเพชรกับตัวย่อ - เมธอด
preprocessใช้อาร์ติแฟกต์ดังกล่าวเพื่อให้แน่ใจว่าฟีเจอร์ความชัดเจนอยู่ในรูปแบบย่อเมื่อถึงเวลาแสดง หากไม่มี จะแปลงทั้งสตริงเป็นตัวย่อ - เมธอด
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
7. ทำให้โมเดลใช้งานได้กับ 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 เพื่อทำสิ่งต่อไปนี้
- เขียนตรรกะการประมวลผลล่วงหน้าและการประมวลผลภายหลังที่กำหนดเองด้วยกิจวัตรการคาดการณ์ที่กำหนดเอง
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex AI ได้ในเอกสารประกอบ
8. ล้างข้อมูล
หากต้องการใช้โน้ตบุ๊กที่สร้างในแท็บทดลองนี้ต่อไป เราขอแนะนำให้ปิดโน้ตบุ๊กเมื่อไม่ได้ใช้งาน เลือกสมุดบันทึกแล้วเลือกหยุดจาก UI ของ Workbench ในคอนโซล Google Cloud
หากต้องการลบสมุดบันทึกทั้งหมด ให้คลิกปุ่มลบที่ด้านขวาบน
หากต้องการลบปลายทางที่ติดตั้งใช้งาน ให้ไปที่ส่วน "ปลายทาง" ของคอนโซล คลิกปลายทางที่สร้าง แล้วเลือกยกเลิกการติดตั้งใช้งานโมเดลจากปลายทาง
หากต้องการลบอิมเมจคอนเทนเนอร์ ให้ไปที่ Artifact Registry เลือกที่เก็บที่คุณสร้างไว้ แล้วเลือกลบ
หากต้องการลบที่เก็บข้อมูล ให้ใช้เมนูการนำทางใน Cloud Console เพื่อไปยังพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ
