Vertex AI:Sử dụng các quy trình dự đoán tuỳ chỉnh với Sklearn để xử lý trước và sau xử lý dữ liệu cho thông tin dự đoán

1. Giới thiệu

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

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

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 ML 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 có nhiều sản phẩm để hỗ trợ quy trình làm việc ML toàn diện. Phòng thí nghiệm này sẽ tập trung vào Dự đoán và Workbench.

3. Tổng quan về trường hợp sử dụng

Trong lớp học 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ư vết cắt, độ trong 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 dự kiến hay không. Bạn cũng sẽ viết logic xử lý hậu kỳ tuỳ chỉnh để làm tròn các giá trị 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

Vùng chứa dựng sẵn 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 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ý kết quả dự đoán của mô hình trước khi trả về kết quả, bạn cần phải 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 đầu vào của mô hình và dịch đầu ra của mô hình thành các 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 việc phân phát, nhờ đó bạn có thể tập trung vào mô hình và các phép biến đổi dữ liệu.

Sản phẩm bạn sẽ tạo ra

Bạn sẽ thiết lập một mạng VPC có tên là aiml-vpc, bao gồm một mạng con workbench dùng để triển khai một sổ tay do người dùng quản lý và truy cập vào điểm cuối dự đoán và mô hình trực tuyến được triển khai trong us-central1 như minh hoạ trong hình 1 bên dưới.

                                                                            Figure1

4. Bật các API hướng dẫn

Bước 1: Bật Compute Engine API

Chuyển đến Compute Engine rồi chọn Bật nếu bạn chưa bật. Bạn sẽ cần thông tin 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 Bật nếu bạn chưa bật. Bạn sẽ dùng mã 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 mục Vertex AI trong Bảng điều khiển Cloud rồi nhấp vào Bật Vertex AI API.

Bước 4: Tạo một phiên bản Vertex AI Workbench

Bật API Sổ tay nếu bạn chưa bật.

5. Tạo aiml-vpc

Hướng dẫn này sử dụng $variables để hỗ trợ việc triển khai cấu hình gcloud trong Cloud Shell.

Trong Cloud Shell, hãy thực hiện các bước sau:

gcloud config list project
gcloud config set project [YOUR-PROJECT-NAME]
projectid=YOUR-PROJECT-NAME
echo $projectid

Tạo aiml-vpc

Trong Cloud Shell, hãy thực hiện các bước sau:

gcloud compute networks create aiml-vpc --project=$projectid --subnet-mode=custom

Tạo mạng con sổ tay do người dùng quản lý

Trong Cloud Shell, hãy tạo workbench-subnet.

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

Cấu hình Cloud Router và NAT

Cloud NAT được dùng trong hướng dẫn để tải các gói phần mềm xuống vì sổ tay do người dùng quản lý không có địa chỉ IP ngoài. Cloud NAT cung cấp các chức năng NAT xuất cảnh, tức là các máy chủ lưu trữ trên Internet không được phép bắt đầu giao tiếp với một sổ tay do người dùng quản lý, giúp tăng cường tính bảo mật.

Trong Cloud Shell, hãy tạo bộ định tuyến đám mây theo khu vực, us-central1.

gcloud compute routers create cloud-router-us-central1-aiml-nat --network aiml-vpc --region us-central1

Trong Cloud Shell, hãy tạo cổng NAT đám mây theo khu vực, 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. Tạo sổ tay do người dùng quản lý

Tạo tài khoản dịch vụ do người dùng quản lý (Sổ tay)

Trong phần sau, bạn sẽ tạo một tài khoản dịch vụ do người dùng quản lý và được liên kết với Vertex Workbench (Notebook) dùng trong hướng dẫn.

Trong hướng dẫn này, tài khoản dịch vụ sẽ áp dụng các quy tắc sau:

Trong Cloud Shell, hãy tạo tài khoản dịch vụ.

gcloud iam service-accounts create user-managed-notebook-sa \
    --display-name="user-managed-notebook-sa"

Trong Cloud Shell, hãy cập nhật tài khoản dịch vụ bằng vai trò Quản trị viên bộ nhớ.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/storage.admin"

Trong Cloud Shell, hãy cập nhật tài khoản dịch vụ bằng vai trò Người dùng Vertex AI.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/aiplatform.user"

Trong Cloud Shell, hãy cập nhật tài khoản dịch vụ bằng vai trò Quản trị viên Artifact Registry.

gcloud projects add-iam-policy-binding $projectid --member="serviceAccount:user-managed-notebook-sa@$projectid.iam.gserviceaccount.com" --role="roles/artifactregistry.admin"

Trong Cloud Shell, hãy liệt kê tài khoản dịch vụ và ghi lại địa chỉ email sẽ được dùng khi tạo sổ tay do người dùng quản lý.

gcloud iam service-accounts list

Tạo Sổ tay do người dùng quản lý

Trong phần sau, hãy tạo một sổ tay do người dùng quản lý kết hợp với tài khoản dịch vụ đã tạo trước đó, user-managed-notebook-sa.

Tạo thực thể ứng dụng khách riêng tư trong 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. Viết mã huấn luyện

Bước 1: Tạo một bộ chứa bộ nhớ trên đám mây

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 thiết bị đầu cuối mới.

Trong cửa sổ dòng lệnh, 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 Terminal để tạo một nhóm mới trong dự án của bạ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 thiết bị đầu cuối, hãy tạo một thư mục mới có tên là cpr-codelab rồi chuyển đến 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 đó 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 đoạn mã sau.

Trước tiên, hãy viết tệp 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

Mô hình mà bạn triển khai sẽ có một bộ phần phụ thuộc khác được cài đặt sẵn so với môi trường sổ tay của bạn. 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 đó 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 đế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 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

Giờ đây, 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 của bạn và BUCKET_NAME bằng tên của nhó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 đối tượ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 đặc điểm phân loại và điều chỉnh các đặc điểm số

column_transform = make_column_transformer(
    (preprocessing.OneHotEncoder(sparse=False), [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 pipeline sklearn. Điều này có nghĩa là dữ liệu được cung cấp cho pipeline này trước tiên sẽ được mã hoá/chuyển tỉ lệ, 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 này để đảm bảo mô hình hoạt động như mong đợi. Gọi phương thức dự đoán 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. Bạn có thể sử dụng hầu hết mọi dạng của cấu phần phần mềm tiền xử lý (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 độ rõ nét trong dữ liệu huấn luyện của chúng tôi luôn ở dạng viết tắt (ví dụ: "FL" thay vì "Flawless"). Tại thời điểm phân phát, chúng tôi muốn kiểm tra để đảm bảo rằng dữ liệu cho tính năng này cũng được rút gọn. 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, bạn chỉ cần lưu bảng tra cứu này vào một tệp json rồi 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 trên máy 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

8. Tạo vùng chứa phân phát tuỳ chỉnh bằng máy chủ mô hình CPR

Giờ đây, sau khi mô hình được huấn luyện và lưu trữ cấu phần phần mềm tiền xử lý, đã đến lúc bạn cần tạo vùng chứa phân phát tuỳ chỉnh. Thông thường, việc tạo một vùng chứa phân phát đòi hỏi 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, Vertex AI Predictions sẽ tạo một máy chủ mô hình và tạo một 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 (SDK sẽ tự động tạo máy chủ này 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 đường/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, đặ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ó trong SDK.

Predictor

Chịu trách nhiệm về logic học máy để 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 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ý 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.

Bản phát hành này của các quy trình dự đoán tuỳ chỉnh đi kèm với các trình dự đoán XGBoost và Sklearn có thể dùng lại. Tuy nhiên, nếu cần sử dụng một khung khác, bạn có thể tạo khung của riêng mình bằng cách phân lớp phụ 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à toàn bộ 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 mã sau đây để phân lớp SklearnPredictor và ghi mã đó 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 tải, tiền xử lý và hậu xử lý, chứ không tuỳ chỉnh phương thức dự đoán.

%%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 tìm hiểu kỹ hơn về từng phương pháp này.

Phương thức tải sẽ tải vào 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 liên kết các giá trị độ trong của kim cương với các từ viết tắt của chúng.
Phương thức tiền xử lý sử dụng cấu phần phần mềm đó để đảm bảo rằng vào thời gian phân phát, tính năng rõ nét ở định dạng rút gọn. Nếu không, hàm này sẽ chuyển đổi toàn bộ chuỗi thành dạng viết tắt.
Phương thức xử lý hậu kỳ trả 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 dùng Vertex AI Python SDK để tạo hình ảnh. Khi sử dụng các quy trình dự đoán tuỳ chỉnh, Dockerfile sẽ được tạo và một 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ó 2 mẫu để dự đoán. Một trong các phiên bản có tên rõ ràng được viết tắt, nhưng phiên bản 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 cách:

predict_response.content

9. Triển khai mô hình trên Vertex AI

Giờ đây, sau khi kiểm thử vùng chứa cục bộ, bạn có thể chuyển hình ảnh sang 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()

Sau đó 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 tải mô hình 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 này 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.