1. Tổng quan
Trong lớp học 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 xử lý trước và xử lý sau 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 máy học 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ử vùng chứa phân phát tuỳ chỉnh và mô hình cục bộ
- Kiểm thử vùng chứa phân phát tuỳ chỉnh trên tính năng Dự đoán của Vertex AI
Tổng chi phí để chạy lớp học này trên Google Cloud là khoảng 1 đô la Mỹ.
2. Giới thiệu về Vertex AI
Lớp học này sử dụng sản phẩm AI mới nhất có trên Google Cloud. Vertex AI tích hợp các dịch vụ học máy trên Google Cloud vào một trải nghiệm phát triển liền mạch. Trước đây, bạn có thể truy cập vào các mô hình được huấn luyện bằng AutoML và mô hình tuỳ chỉnh thông qua các dịch vụ riêng biệt. Sản phẩm mới 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 để hỗ trợ quy trình làm việc toàn diện về máy học. Phòng thí nghiệm này sẽ tập trung vào tính năng 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 lớp học lập trình 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, độ trong suốt và kích thước.
Bạn sẽ viết logic xử lý trước 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 dự kiến hay không. Bạn cũng sẽ viết logic xử lý sau tuỳ chỉnh để làm tròn các kết quả 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ề quy trình dự đoán tuỳ chỉnh
Các vùng chứa tạo 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 học máy. Trước các quy trình dự đoán tuỳ chỉnh, nếu muốn xử lý trước dữ liệu đầu vào trước khi thực hiện dự đoán hoặc xử lý sau dự đoán của mô hình trước khi trả về kết quả, bạn cần tạo một vùng chứa tuỳ chỉnh.
Để tạo một vùng chứa phân phát tuỳ chỉnh, bạn cần viết một máy chủ HTTP bao bọc mô hình đã huấn luyện, dịch các yêu cầu HTTP thành dữ liệu đầu vào của mô hình và dịch 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 cho bạn các thành phần liên quan đến hoạt động phân phát để bạn có thể tập trung vào mô hình và các hoạt động chuyển đổi dữ liệu của mình.
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 dự án, hãy làm theo hướng dẫn tại đây.
Bước 1: Bật API Compute Engine
Chuyển đến Compute Engine rồi chọn Enable (Bật) nếu bạn chưa bật tính năng này. Bạn sẽ cần có gói này để tạo thực thể sổ tay.
Bước 2: Bật API Cấu phần phần mềm
Chuyển đến Artifact Registry (Cơ sở đăng ký cấu phần phần mềm) rồi chọn Enable (Bật) nếu bạn chưa bật. Bạn sẽ sử dụng mã này để tạo vùng chứa phân phát tuỳ chỉnh.
Bước 3: Bật Vertex AI API
Chuyển đến mục Vertex AI trong Cloud Console rồi nhấp vào Bật API Vertex AI.
Bước 4: Tạo một thực thể Vertex AI Workbench
Trong mục Vertex AI trên Cloud Console, hãy nhấp vào Workbench:
Bật Notebooks API nếu bạn chưa bật.
Sau khi bật, hãy nhấp vào SỰ KIỆN, rồi chọn TẠO MỚI.
Chấp nhận các tuỳ chọn mặc định rồi nhấp vào 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 xử lý trước vào một bộ chứa trên 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.
Trên trình chạy, hãy mở một phiên dòng lệnh mới.
Trên thiết bị đầu cuối, hãy chạy lệnh sau để xác định biến env cho dự án của bạn, nhớ thay thế your-cloud-project bằng mã nhận dạng của dự án:
PROJECT_ID='your-cloud-project'
Tiếp theo, hãy chạy đoạn mã sau trong Terminal để 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
Trên dòng lệnh, 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.
Lúc này, thư mục cpr-codelab của bạn sẽ có dạng như sau:
+ cpr-codelab/
+ task.ipynb
Trong sổ tay, hãy dán mã sau vào sổ tay.
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 bộ phần phụ thuộc được cài đặt sẵn khác với môi trường máy tính xách 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 đó 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 nhau hay không.
Pip cài đặt các phần phụ thuộc trong sổ tay.
!pip install -U --user -r requirements.txt
Xin lưu ý rằng bạn cần khởi động lại hạt nhân 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ấu phần phần mềm xử lý trước.
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
Bây giờ, thư mục cpr-codelab của bạn sẽ có dạng như sau:
+ cpr-codelab/
+ model_artifacts/
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
Giờ đây, khi cấu trúc thư mục đã được thiết lập, đã đến lúc huấn luyện 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. Hãy 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 đặc điểm 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 cùng 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 biến đổi cột sklearn thành một mã hoá nóng cho các tính năng phân loại và điều chỉnh tỷ lệ các tính năng dạ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 quy trình này trước tiên sẽ được mã hoá/điều chỉnh theo tỷ lệ, sau đó được truyền vào mô hình.
my_pipeline = make_pipeline(column_transform, regr)
Điều chỉnh quy trình cho phù hợp với 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 trên 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 cấu phần phần mềm xử lý trước
Tiếp theo, bạn sẽ tạo một cấu phần phần mềm xử lý trước. 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 xử lý trước 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 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 tôi 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 tôi muốn kiểm tra xem dữ liệu cho tính năng này có đượ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 xử lý trước tuỳ chỉnh này sau. Nhưng hiện tại, bạn chỉ cần lưu bảng tra cứu này vào một tệp json rồi ghi tệp đó 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}/
Lúc này, thư mục cpr-codelab cục bộ của bạn sẽ có dạng như sau:
+ cpr-codelab/
+ model_artifacts/
+ model.joblib
+ preprocessor.json
+ scr_dir/
+ requirements.txt
+ task.ipynb
+ requirements.txt
6. Tạo vùng chứa phân phát tuỳ chỉnh bằng máy chủ mô hình CPR
Giờ đây, khi mô hình đã được huấn luyện và cấu phần phần mềm xử lý trước đã được lưu, đã đến lúc tạo vùng chứa phân phát tuỳ chỉnh. Thông thường, việc tạo vùng chứa phân phát yêu cầu bạn 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, tính năng Dự đoán của Vertex AI sẽ tạo một máy chủ mô hình và xây dựng hình ảnh vùng chứa tuỳ chỉnh cho bạn.
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ạo tự động 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 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ý yêu cầu, chẳng hạn như huỷ chuyển đổi tuần tự nội dung yêu cầu và chuyển đổi tuần tự nội dung phản hồi, đặt 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.
- Bộ dự đoán
- Chịu trách nhiệm về logic ML để xử lý 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 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ý yêu cầu dự đoán, chẳng hạn như xử lý trước và xử lý sau tuỳ chỉnh. Để viết logic dự đoán tuỳ chỉnh, bạn sẽ lớp con giao diện Trình dự đoán Vertex AI.
Bản phát hành 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ể sử dụng lại, nhưng nếu cần sử dụng một khung khác, bạn có thể tạo quy trình dự đoán của riêng mình bằng cách phân lớp con 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 để tạo máy chủ mô hình tuỳ chỉnh này.
Trong sổ tay của bạn, hãy dán đoạn mã sau đây để tạo lớp con SklearnPredictor và ghi mã đó vào 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 phải 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 cùng tìm hiểu kỹ hơn về từng phương thức này.
- phương thức
loadtải trong cấu phần phần mềm xử lý trước, trong trường hợp này là một từ điển liên kết các giá trị độ trong của kim cương với các chữ viết tắt của chú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 làm rõ sẽ ở định dạng viết tắt. Nếu không, hàm 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 SDK Vertex AI Python để tạo hình ảnh. Bằng cách 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 tạo 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 ngắn gọn, 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ô 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 cho Vertex AI
Giờ đây, khi bạn đã kiểm thử vùng chứa trên thiết 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 Cấu phần phần mềm.
!gcloud artifacts repositories create {REPOSITORY} --repository-format=docker \
--location=us-central1 --description="Docker repository"
!gcloud auth configure-docker {REGION}-docker.pkg.dev --quiet
Sau đó, đẩ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. 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 tính năng 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 thông tin 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ý tuỳ chỉnh và logic hậu xử lý 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 này.
8. Dọn dẹp
Nếu muốn tiếp tục sử dụng sổ tay mà bạn đã tạo trong lớp học này, bạn nên tắt sổ tay khi không sử dụng. Trên giao diện người dùng Workbench trong Google Cloud Console, hãy chọn sổ tay rồi chọn Stop (Dừng).
Nếu bạn muốn xoá hoàn toàn sổ tay, hãy nhấp vào nút 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 Đ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, sau đó chọn 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 Cấu phần phần mềm, chọn kho lưu trữ bạn đã tạo rồi chọn Xoá
Để xoá Bộ nhớ, hãy sử dụng trình đơn Điều hướng trong Cloud Console, chuyển đến Bộ nhớ, chọn bộ nhớ của bạn rồi nhấp vào Xoá:
