1. Tổng quan
Trong phòng thí nghiệm này, bạn sẽ tìm hiểu cách sử dụng các quy trình dự đoán tuỳ chỉnh trên Vertex AI để viết logic tiền xử lý và hậu xử lý tuỳ chỉnh. Mặc dù mẫu này sử dụng scikit-learn, nhưng các quy trình dự đoán tuỳ chỉnh có thể hoạt động với các khung học máy Python khác như XGBoost, PyTorch và TensorFlow.
Kiến thức bạn sẽ học được
Bạn sẽ tìm hiểu cách:
- Viết logic dự đoán tuỳ chỉnh bằng các quy trình dự đoán tuỳ chỉnh
- Kiểm thử mô hình và vùng chứa phân phát tuỳ chỉnh cục bộ
- Kiểm thử vùng chứa phân phát tuỳ chỉnh trên Vertex AI Predictions
Tổng chi phí để chạy phòng thí nghiệm này trên Google Cloud là khoảng 1 USD.
2. Giới thiệu về Vertex AI
Phòng thí nghiệm này sử dụng sản phẩm AI mới nhất hiện có trên Google Cloud. Vertex AI tích hợp các sản phẩm học máy trên Google Cloud thành một trải nghiệm phát triển liền mạch. Trước đây, các mô hình được huấn luyện bằng AutoML và các mô hình tuỳ chỉnh có thể truy cập thông qua các dịch vụ riêng biệt. Sản phẩm mới này kết hợp cả hai thành một API duy nhất, cùng với các sản phẩm mới khác. Bạn cũng có thể di chuyển các dự án hiện có sang Vertex AI.
Vertex AI bao gồm nhiều sản phẩm khác nhau để hỗ trợ quy trình công việc học máy đầu cuối. Phòng thí nghiệm này sẽ tập trung vào Predictions (Dự đoán) và Workbench (Bàn làm việc).
3. Tổng quan về trường hợp sử dụng
Trường hợp sử dụng
Trong phòng thí nghiệm này, bạn sẽ xây dựng một mô hình hồi quy rừng ngẫu nhiên để dự đoán giá của một viên kim cương dựa trên các thuộc tính như kiểu cắt, độ tinh khiết và kích thước.
Bạn sẽ viết logic tiền xử lý tuỳ chỉnh để kiểm tra xem dữ liệu tại thời điểm phân phát có ở định dạng mà mô hình mong đợi hay không. Bạn cũng sẽ viết logic hậu xử lý tuỳ chỉnh để làm tròn các dự đoán và chuyển đổi chúng thành chuỗi. Để viết logic này, bạn sẽ sử dụng các quy trình dự đoán tuỳ chỉnh.
Giới thiệu về các quy trình dự đoán tuỳ chỉnh
Các vùng chứa dựng sẵn của Vertex AI xử lý các yêu cầu dự đoán bằng cách thực hiện thao tác dự đoán của khung máy học. Trước khi có các quy trình dự đoán tuỳ chỉnh, nếu muốn tiền xử lý dữ liệu đầu vào trước khi thực hiện dự đoán hoặc hậu xử lý dự đoán của mô hình trước khi trả về kết quả, bạn cần phải xây dựng một vùng chứa tuỳ chỉnh.
Việc xây dựng một vùng chứa phân phát tuỳ chỉnh đòi hỏi phải viết một máy chủ HTTP bao bọc mô hình đã huấn luyện, chuyển đổi các yêu cầu HTTP thành dữ liệu đầu vào của mô hình và chuyển đổi dữ liệu đầu ra của mô hình thành phản hồi.
Với các quy trình dự đoán tuỳ chỉnh, Vertex AI cung cấp các thành phần liên quan đến việc phân phát cho bạn để bạn có thể tập trung vào các mô hình và chuyển đổi dữ liệu.
4. Thiết lập môi trường
Bạn cần có một dự án trên Google Cloud Platform đã bật tính năng thanh toán để chạy lớp học lập trình này. Để tạo một dự án, hãy làm theo hướng dẫn tại đây.
Bước 1: Bật Compute Engine API
Chuyển đến Compute Engine rồi chọn Enable (Bật) nếu chưa bật. Bạn sẽ cần bật API này để tạo thực thể sổ tay.
Bước 2: Bật Artifact Registry API
Chuyển đến Artifact Registry rồi chọn Enable nếu chưa bật. Bạn sẽ sử dụng API này để tạo một vùng chứa phân phát tuỳ chỉnh.
Bước 3: Bật Vertex AI API
Chuyển đến phần Vertex AI của Cloud Console rồi nhấp vào Enable Vertex AI API (Bật Vertex AI API).
Bước 4: Tạo một thực thể Vertex AI Workbench
Trong phần Vertex AI của Cloud Console, hãy nhấp vào Workbench:
Bật Notebooks API nếu chưa bật.
Sau khi bật, hãy nhấp vào INSTANCES (THỰC THỂ), rồi chọn CREATE NEW (TẠO MỚI).
Chấp nhận các lựa chọn mặc định rồi nhấp vào Create (Tạo).
Khi thực thể đã sẵn sàng, hãy nhấp vào OPEN JUPYTERLAB (MỞ JUPYTERLAB) để mở thực thể.
5. Viết mã huấn luyện
Bước 1: Tạo một bộ chứa Cloud Storage
Bạn sẽ lưu trữ mô hình và các cấu phần phần mềm tiền xử lý vào một bộ chứa Cloud Storage. Nếu đã có một bộ chứa trong dự án mà bạn muốn sử dụng, bạn có thể bỏ qua bước này.
Từ trình chạy, hãy mở một phiên đầu cuối mới.
Từ đầu cuối, hãy chạy lệnh sau để xác định một biến môi trường cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã dự án:
PROJECT_ID='your-cloud-project'
Tiếp theo, hãy chạy lệnh sau trong đầu cuối để tạo một bộ chứa mới trong dự án.
BUCKET="gs://${PROJECT_ID}-cpr-bucket"
gsutil mb -l us-central1 $BUCKET
Bước 2: Huấn luyện mô hình
Từ đầu cuối, hãy tạo một thư mục mới có tên là cpr-codelab rồi chuyển vào thư mục đó.
mkdir cpr-codelab
cd cpr-codelab
Trong trình duyệt tệp, hãy chuyển đến thư mục cpr-codelab mới, sau đó sử dụng trình chạy để tạo một sổ tay Python 3 mới có tên là task.ipynb.
Thư mục cpr-codelab của bạn hiện sẽ có dạng như sau:
+ cpr-codelab/
+ task.ipynb
Trong sổ tay, hãy dán mã sau.
Trước tiên, hãy viết một tệp 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
Mô hình mà bạn triển khai sẽ có một tập hợp các phần phụ thuộc được cài đặt sẵn khác với môi trường sổ tay. Do đó, bạn nên liệt kê tất cả các phần phụ thuộc cho mô hình trong requirements.txt, sau đó sử dụng pip để cài đặt chính xác các phần phụ thuộc tương tự trong sổ tay. Sau đó, bạn sẽ kiểm thử mô hình cục bộ trước khi triển khai lên Vertex AI để kiểm tra kỹ xem các môi trường có khớp hay không.
Cài đặt các phần phụ thuộc trong sổ tay bằng pip.
!pip install -U --user -r requirements.txt
Xin lưu ý rằng bạn cần phải khởi động lại nhân hệ điều hành sau khi quá trình cài đặt pip hoàn tất.
Tiếp theo, hãy tạo các thư mục nơi bạn sẽ lưu trữ mô hình và các cấu phần phần mềm tiền xử lý.
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
Thư mục cpr-codelab của bạn hiện sẽ có dạng như sau:
+ cpr-codelab/
+ model_artifacts/
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
Bây giờ, khi cấu trúc thư mục đã được thiết lập, đã đến lúc huấn luyện một mô hình!
Trước tiên, hãy nhập các thư viện.
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)
Sau đó, hãy xác định các biến sau. Nhớ thay thế PROJECT_ID bằng mã dự án và BUCKET_NAME bằng bộ chứa mà bạn đã tạo ở bước trước.
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}"
Tải dữ liệu từ thư viện seaborn, sau đó tạo hai khung dữ liệu, một khung có các tính năng và khung còn lại có nhãn.
data = sns.load_dataset('diamonds', cache=True, data_home=None)
label = 'price'
y_train = data['price']
x_train = data.drop(columns=['price'])
Hãy xem dữ liệu huấn luyện. Bạn có thể thấy rằng mỗi hàng đại diện cho một viên kim cương.
x_train.head()
Và các nhãn, là giá tương ứng.
y_train.head()
Bây giờ, hãy xác định một biến đổi cột sklearn để mã hoá một lần các tính năng phân loại và điều chỉnh các tính năng số
column_transform = make_column_transformer(
(preprocessing.OneHotEncoder(), [1,2,3]),
(preprocessing.StandardScaler(), [0,4,5,6,7,8]))
Xác định mô hình rừng ngẫu nhiên
regr = RandomForestRegressor(max_depth=10, random_state=0)
Tiếp theo, hãy tạo một quy trình sklearn. Điều này có nghĩa là dữ liệu được đưa vào pipeline này sẽ được mã hoá/chuyển tỉ lệ trước, sau đó được truyền đến mô hình.
my_pipeline = make_pipeline(column_transform, regr)
Điều chỉnh quy trình trên dữ liệu huấn luyện
my_pipeline.fit(x_train, y_train)
Hãy thử mô hình để đảm bảo mô hình hoạt động như mong đợi. Gọi phương thức predict trên mô hình, truyền vào một mẫu kiểm thử.
my_pipeline.predict([[0.23, 'Ideal', 'E', 'SI2', 61.5, 55.0, 3.95, 3.98, 2.43]])
Bây giờ, chúng ta có thể lưu quy trình vào thư mục model_artifacts và sao chép quy trình đó vào bộ chứa Cloud Storage.
joblib.dump(my_pipeline, 'model_artifacts/model.joblib')
!gsutil cp model_artifacts/model.joblib {BUCKET_NAME}/{MODEL_ARTIFACT_DIR}/
Bước 3: Lưu một cấu phần phần mềm tiền xử lý
Tiếp theo, bạn sẽ tạo một cấu phần phần mềm tiền xử lý. Cấu phần phần mềm này sẽ được tải trong vùng chứa tuỳ chỉnh khi máy chủ mô hình khởi động. Cấu phần phần mềm tiền xử lý của bạn có thể ở hầu hết mọi dạng (chẳng hạn như tệp pickle), nhưng trong trường hợp này, bạn sẽ ghi một từ điển vào một tệp JSON.
clarity_dict={"Flawless": "FL",
"Internally Flawless": "IF",
"Very Very Slightly Included": "VVS1",
"Very Slightly Included": "VS2",
"Slightly Included": "S12",
"Included": "I3"}
Tính năng clarity trong dữ liệu huấn luyện của chúng ta luôn ở dạng viết tắt (tức là "FL" thay vì "Flawless"). Tại thời điểm phân phát, chúng ta muốn kiểm tra xem dữ liệu cho tính năng này cũng được viết tắt hay không. Lý do là mô hình của chúng ta biết cách mã hoá một lần "FL" nhưng không biết cách mã hoá "Flawless". Bạn sẽ viết logic tiền xử lý tuỳ chỉnh này sau. Nhưng hiện tại, chỉ cần lưu bảng tra cứu này vào một tệp json, sau đó ghi vào bộ chứa 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}/
Thư mục cpr-codelab cục bộ của bạn hiện sẽ có dạng như sau:
+ cpr-codelab/
+ model_artifacts/
+ model.joblib
+ preprocessor.json
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
6. Xây dựng một vùng chứa phân phát tuỳ chỉnh bằng máy chủ mô hình CPR
Bây giờ, khi mô hình đã được huấn luyện và cấu phần phần mềm tiền xử lý đã được lưu, đã đến lúc xây dựng vùng chứa phân phát tuỳ chỉnh. Thông thường, việc xây dựng một vùng chứa phân phát đòi hỏi phải viết mã máy chủ mô hình. Tuy nhiên, với các quy trình dự đoán tuỳ chỉnh, Vertex AI Predictions sẽ tạo một máy chủ mô hình và xây dựng một hình ảnh vùng chứa tuỳ chỉnh cho bạn.
Một vùng chứa phân phát tuỳ chỉnh chứa 3 đoạn mã sau:
- Máy chủ mô hình (máy chủ này sẽ được SDK tự động tạo và lưu trữ trong
scr_dir/)- Máy chủ HTTP lưu trữ mô hình
- Chịu trách nhiệm thiết lập các tuyến/cổng/v.v.
- Trình xử lý yêu cầu
- Chịu trách nhiệm về các khía cạnh của máy chủ web trong việc xử lý một yêu cầu, chẳng hạn như huỷ tuần tự hoá nội dung yêu cầu và tuần tự hoá phản hồi, thiết lập tiêu đề phản hồi, v.v.
- Trong ví dụ này, bạn sẽ sử dụng Trình xử lý mặc định,
google.cloud.aiplatform.prediction.handler.PredictionHandlerđược cung cấp trong SDK.
- Trình dự đoán
- Chịu trách nhiệm về logic học máy để xử lý một yêu cầu dự đoán.
Bạn có thể tuỳ chỉnh từng thành phần này dựa trên các yêu cầu của trường hợp sử dụng. Trong ví dụ này, bạn sẽ chỉ triển khai trình dự đoán.
Trình dự đoán chịu trách nhiệm về logic học máy để xử lý một yêu cầu dự đoán, chẳng hạn như tiền xử lý và hậu xử lý tuỳ chỉnh. Để viết logic dự đoán tuỳ chỉnh, bạn sẽ tạo lớp con cho giao diện Vertex AI Predictor.
Phiên bản quy trình dự đoán tuỳ chỉnh này đi kèm với các trình dự đoán XGBoost và Sklearn có thể dùng lại, nhưng nếu cần sử dụng một khung khác, bạn có thể tạo trình dự đoán của riêng mình bằng cách tạo lớp con cho trình dự đoán cơ sở.
Bạn có thể xem ví dụ về trình dự đoán Sklearn bên dưới. Đây là tất cả mã bạn cần viết để xây dựng máy chủ mô hình tuỳ chỉnh này.
Trong sổ tay, hãy dán mã sau đây để tạo lớp con cho SklearnPredictor và ghi vào một tệp Python trong src_dir/. Xin lưu ý rằng trong ví dụ này, chúng ta chỉ tuỳ chỉnh các phương thức load, preprocess và postprocess, chứ không tuỳ chỉnh phương thức 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)]}
Hãy xem xét kỹ hơn từng phương thức này.
- phương thức
loadtải cấu phần phần mềm tiền xử lý, trong trường hợp này là một từ điển ánh xạ các giá trị độ tinh khiết của kim cương với các từ viết tắt tương ứng. - phương thức
preprocesssử dụng cấu phần phần mềm đó để đảm bảo rằng tại thời điểm phân phát, tính năng độ tinh khiết ở định dạng viết tắt. Nếu không, phương thức này sẽ chuyển đổi chuỗi đầy đủ thành từ viết tắt. - phương thức
postprocesstrả về giá trị dự đoán dưới dạng một chuỗi có dấu $ và làm tròn giá trị.
Tiếp theo, hãy sử dụng Vertex AI Python SDK để xây dựng hình ảnh. Khi sử dụng các quy trình dự đoán tuỳ chỉnh, Dockerfile sẽ được tạo và hình ảnh sẽ được xây dựng cho bạn.
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"),
)
Viết một tệp kiểm thử có hai mẫu để dự đoán. Một trong các thực thể có tên độ tinh khiết viết tắt, nhưng thực thể còn lại cần được chuyển đổi trước.
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)
Kiểm thử vùng chứa cục bộ bằng cách triển khai một mô hình cục bộ.
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()
Bạn có thể xem kết quả dự đoán bằng:
predict_response.content
7. Triển khai mô hình lên Vertex AI
Bây giờ, khi bạn đã kiểm thử vùng chứa cục bộ, đã đến lúc đẩy hình ảnh lên Artifact Registry và tải mô hình lên Vertex AI Model Registry.
Trước tiên, hãy định cấu hình Docker để truy cập vào 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
Sau đó, hãy đẩy hình ảnh.
local_model.push_image()
Và tải mô hình lên.
model = aiplatform.Model.upload(local_model = local_model,
display_name=MODEL_DISPLAY_NAME,
artifact_uri=f"{BUCKET_NAME}/{MODEL_ARTIFACT_DIR}",)
Khi mô hình được tải lên, bạn sẽ thấy mô hình đó trong bảng điều khiển:
Tiếp theo, hãy triển khai mô hình để bạn có thể sử dụng mô hình đó cho các dự đoán trực tuyến. Các quy trình dự đoán tuỳ chỉnh cũng hoạt động với tính năng dự đoán hàng loạt, vì vậy, nếu trường hợp sử dụng của bạn không yêu cầu dự đoán trực tuyến, thì bạn không cần triển khai mô hình.
endpoint = model.deploy(machine_type="n1-standard-2")
Cuối cùng, hãy kiểm thử mô hình đã triển khai bằng cách nhận một dự đoán.
endpoint.predict(instances=[[0.23, 'Ideal', 'E', 'VS2', 61.5, 55.0, 3.95, 3.98, 2.43]])
🎉 Xin chúc mừng! 🎉
Bạn đã tìm hiểu cách sử dụng Vertex AI để:
- Viết logic tiền xử lý và hậu xử lý tuỳ chỉnh bằng các quy trình dự đoán tuỳ chỉnh
Để tìm hiểu thêm về các phần khác nhau của Vertex AI, hãy xem tài liệu.
8. Dọn dẹp
Nếu muốn tiếp tục sử dụng sổ tay mà bạn đã tạo trong phòng thí nghiệm này, bạn nên tắt sổ tay đó khi không sử dụng. Trong giao diện người dùng Workbench (Bàn làm việc) của Google Cloud Console, hãy chọn sổ tay rồi chọn Stop (Dừng).
Nếu muốn xoá hoàn toàn sổ tay, hãy nhấp vào nút Delete (Xoá) ở trên cùng bên phải.
Để xoá điểm cuối mà bạn đã triển khai, hãy chuyển đến phần Endpoints (Điểm cuối) của bảng điều khiển, nhấp vào điểm cuối mà bạn đã tạo, rồi chọn Undeploy model from endpoint (Huỷ triển khai mô hình khỏi điểm cuối):
Để xoá hình ảnh vùng chứa, hãy chuyển đến Artifact Registry, chọn kho lưu trữ mà bạn đã tạo, rồi chọn Delete (Xoá)
Để xoá bộ chứa Storage Bucket, hãy sử dụng trình đơn Navigation (Điều hướng) trong Cloud Console, duyệt đến Storage (Bộ nhớ), chọn bộ chứa của bạn rồi nhấp vào Delete:
