1. Tổng quan
Trong lớp học lập trình này, bạn sẽ sử dụng Vertex AI để xây dựng một quy trình huấn luyện Mô hình Keras tuỳ chỉnh trong TensorFlow. Sau đó, chúng ta sẽ sử dụng chức năng mới có trong Thử nghiệm Vertex AI để theo dõi và so sánh các lần chạy mô hình nhằm xác định tổ hợp tham số siêu dữ liệu nào mang lại hiệu suất tốt nhất.
Kiến thức bạn sẽ học được
Bạn sẽ tìm hiểu cách:
- Huấn luyện Mô hình Keras tuỳ chỉnh để dự đoán điểm xếp hạng của người chơi (ví dụ: hồi quy)
- Sử dụng SDK quy trình Kubeflow để xây dựng quy trình học máy có thể mở rộng
- Tạo và chạy quy trình gồm 5 bước để nhập dữ liệu từ Cloud Storage, mở rộng quy mô dữ liệu, huấn luyện mô hình, đánh giá mô hình và lưu mô hình thu được trở lại Cloud Storage
- Tận dụng Siêu dữ liệu máy học của Vertex để lưu các cấu phần phần mềm của mô hình như Mô hình và Chỉ số mô hình
- Sử dụng tính năng Thử nghiệm của Vertex AI để so sánh kết quả của nhiều quy trình chạy
Tổng chi phí để chạy lớp học 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 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, các mô hình được huấn luyện bằng AutoML và mô hình tuỳ chỉnh có thể truy cập được 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. Lớp học này sẽ tập trung vào các sản phẩm được nêu dưới đây: Thử nghiệm, Quy trình, Siêu dữ liệu về công nghệ học máy và Workbench
3. Tổng quan về trường hợp sử dụng
Chúng ta sẽ sử dụng một tập dữ liệu bóng đá phổ biến lấy từ loạt trò chơi điện tử FIFA của EA Sports. Nó bao gồm hơn 25.000 trận đấu bóng đá và hơn 10.000 cầu thủ cho mùa giải 2008-2016. Dữ liệu đã được xử lý trước để bạn có thể bắt đầu dễ dàng hơn. Bạn sẽ sử dụng tập dữ liệu này trong suốt lớp học. Hiện tại, bạn có thể tìm thấy tập dữ liệu này trong một bộ chứa công khai trên Cloud Storage. Chúng tôi sẽ cung cấp thêm thông tin chi tiết về cách truy cập vào tập dữ liệu này trong phần sau của lớp học lập trình. Mục tiêu cuối cùng của chúng tôi là dự đoán điểm xếp hạng tổng thể của một cầu thủ dựa trên nhiều hành động trong trò chơi, chẳng hạn như chặn bóng và phạt góc.
Tại sao Thử nghiệm Vertex AI lại hữu ích cho Khoa học dữ liệu?
Khoa học dữ liệu mang tính chất thử nghiệm nên rốt cuộc thì họ được gọi là nhà khoa học. Nhà khoa học dữ liệu giỏi là những người dựa vào giả thuyết, sử dụng phương pháp thử và sai để kiểm tra nhiều giả thuyết với hy vọng các lần lặp lại liên tiếp sẽ tạo ra một mô hình hiệu quả hơn.
Mặc dù đã áp dụng phương pháp thử nghiệm, nhưng các nhóm khoa học dữ liệu thường gặp khó khăn trong việc theo dõi công việc của mình và "bí quyết" được phát hiện thông qua các nỗ lực thử nghiệm. Điều này xảy ra vì một vài lý do:
- Việc theo dõi công việc đào tạo có thể trở nên rườm rà, khiến bạn dễ dàng quên mất những hoạt động nào đang hoạt động hiệu quả so với những hoạt động chưa hiệu quả.
- Vấn đề này càng trở nên phức tạp hơn khi bạn xem xét một nhóm khoa học dữ liệu vì không phải tất cả thành viên đều theo dõi các thử nghiệm hoặc thậm chí chia sẻ kết quả của họ với người khác
- Việc thu thập dữ liệu tốn nhiều thời gian và hầu hết các nhóm đều sử dụng các phương pháp thủ công (ví dụ: trang tính hoặc tài liệu) dẫn đến thông tin không nhất quán và không đầy đủ để tìm hiểu
Tóm tắt: Vertex AI Experiments sẽ giúp bạn thực hiện công việc này, giúp bạn dễ dàng theo dõi và so sánh các thử nghiệm của mình
Tại sao nên sử dụng tính năng Thử nghiệm Vertex AI cho trò chơi?
Từ trước đến nay, trò chơi luôn là sân chơi cho các thử nghiệm về công nghệ học máy. Mỗi ngày, trò chơi không chỉ tạo ra hàng tỷ sự kiện theo thời gian thực mà còn tận dụng tất cả dữ liệu đó bằng cách tận dụng công nghệ học máy và các thử nghiệm học máy để cải thiện trải nghiệm trong trò chơi, giữ chân người chơi và đánh giá nhiều người chơi trên nền tảng của họ. Do đó, chúng tôi cho rằng tập dữ liệu trò chơi phù hợp với bài tập thử nghiệm tổng thể 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 Bật nếu bạn chưa bật.
Bước 2: Bật API Vertex AI
Chuyển đến mục Vertex AI trong Cloud Console rồi nhấp vào Bật API Vertex AI.
Bước 3: Tạo một phiên bản Vertex AI Workbench
Trong phần Vertex AI của Cloud Console, hãy nhấp vào Workbench (Bảng điều khiển):
Bật Notebooks API nếu bạn chưa bật.
Sau khi bật, hãy nhấp vào MANAGED NOTEBOOKS (SỔ ĐIỆN TỬ ĐƯỢC QUẢN LÝ):
Sau đó, chọn NOTEBOOK MỚI.
Đặt tên cho sổ tay rồi nhấp vào Cài đặt nâng cao.
Trong phần Cài đặt nâng cao, hãy bật tính năng tắt khi không hoạt động và đặt số phút thành 60. Điều này có nghĩa là sổ tay của bạn sẽ tự động tắt khi không được sử dụng, do đó bạn không phải chịu các chi phí không cần thiết.
Bước 4: Mở Sổ tay
Sau khi tạo thực thể, hãy chọn Open JupyterLab (Mở JupyterLab).
Bước 5: Xác thực (chỉ lần đầu tiên)
Trong lần đầu tiên sử dụng một thực thể mới, bạn sẽ được yêu cầu xác thực. Hãy làm theo các bước trong giao diện người dùng để thực hiện việc này.
Bước 6: Chọn Kernel thích hợp
Máy tính xách tay được quản lý cung cấp nhiều hạt nhân trong một giao diện người dùng. Chọn hạt nhân cho Tensorflow 2 (cục bộ).
5. Các bước thiết lập ban đầu trong Sổ tay
Bạn sẽ cần thực hiện thêm một loạt bước để thiết lập môi trường trong sổ tay trước khi xây dựng quy trình. Các bước này bao gồm: cài đặt mọi gói bổ sung, thiết lập biến, tạo bộ nhớ trên đám mây, sao chép tập dữ liệu trò chơi từ bộ nhớ công khai, nhập thư viện và xác định các hằng số bổ sung.
Bước 1: Cài đặt các gói bổ sung
Chúng ta sẽ cần cài đặt các phần phụ thuộc gói bổ sung hiện chưa được cài đặt trong môi trường máy tính xách tay của bạn. Ví dụ: SDK KFP.
!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts
Sau đó, bạn sẽ muốn khởi động lại Hạt nhân của sổ tay để có thể sử dụng các gói đã tải xuống trong sổ tay.
# Automatically restart kernel after installs
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
Bước 2: Đặt biến
Chúng ta muốn xác định PROJECT_ID. Nếu không biết Project_ID, bạn có thể lấy PROJECT_ID bằng gcloud.
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output = !gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
Nếu không, hãy đặt PROJECT_ID tại đây.
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
Chúng ta cũng sẽ muốn đặt biến REGION, biến này được sử dụng trong phần còn lại của sổ tay này. Dưới đây là các khu vực được hỗ trợ cho Vertex AI. Bạn nên chọn khu vực gần bạn nhất.
- Châu Mỹ: us-central1
- Châu Âu: europe-west4
- Châu Á – Thái Bình Dương: asia-east1
Vui lòng không sử dụng bộ chứa đa vùng để huấn luyện bằng Vertex AI. Không phải khu vực nào cũng hỗ trợ tất cả các dịch vụ của Vertex AI. Tìm hiểu thêm về các khu vực của Vertex AI.
#set your region
REGION = "us-central1" # @param {type: "string"}
Cuối cùng, chúng ta sẽ đặt biến TIMESTAMP. Biến này dùng để tránh xung đột tên giữa người dùng trên các tài nguyên đã tạo. Bạn tạo một TIMESTAMP cho mỗi phiên bản thể hiện và thêm biến này vào tên của các tài nguyên mà bạn tạo trong hướng dẫn này.
#set timestamp to avoid collisions between multiple users
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
Bước 3: Tạo một bộ chứa Cloud Storage
Bạn sẽ cần chỉ định và tận dụng bộ chứa dự trữ trên Cloud Storage. Bộ chứa dự trữ là nơi lưu giữ tất cả dữ liệu liên kết với tập dữ liệu và tài nguyên mô hình của bạn trên các phiên.
Đặt tên cho bộ chứa Cloud Storage của bạn ở bên dưới. Tên bộ chứa phải là duy nhất trên toàn cầu trên tất cả các dự án Google Cloud, bao gồm cả các dự án bên ngoài tổ chức của bạn.
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
Nếu bộ chứa của bạn KHÔNG tồn tại, bạn có thể chạy ô sau để tạo bộ chứa Cloud Storage.
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
Sau đó, bạn có thể xác minh quyền truy cập vào bộ chứa Cloud Storage bằng cách chạy ô sau.
#verify access
! gsutil ls -al $BUCKET_URI
Bước 4: Sao chép Tập dữ liệu trò chơi
Như đã đề cập trước đó, bạn sẽ sử dụng tập dữ liệu trò chơi phổ biến từ các trò chơi điện tử đình đám của EA Sports, FIFA. Chúng tôi đã hoàn tất bước xử lý trước cho bạn, do đó, bạn chỉ cần sao chép tập dữ liệu từ bộ chứa lưu trữ công khai rồi chuyển sang tập dữ liệu mà bạn đã tạo.
# copy the data over to your cloud storage bucket
DATASET_URI = "gs://cloud-samples-data/vertex-ai/structured_data/player_data"
!gsutil cp -r $DATASET_URI $BUCKET_URI
Bước 5: Nhập thư viện và xác định các hằng số bổ sung
Tiếp theo, chúng ta sẽ nhập các thư viện của mình cho Vertex AI, KFP, v.v.
import logging
import os
import time
logger = logging.getLogger("logger")
logging.basicConfig(level=logging.INFO)
import kfp.v2.compiler as compiler
# Pipeline Experiments
import kfp.v2.dsl as dsl
# Vertex AI
from google.cloud import aiplatform as vertex_ai
from kfp.v2.dsl import Artifact, Input, Metrics, Model, Output, component
from typing import NamedTuple
Chúng ta cũng sẽ xác định các hằng số bổ sung mà chúng ta sẽ tham chiếu lại trong suốt phần còn lại của sổ tay, chẳng hạn như(các) đường dẫn tệp đến dữ liệu huấn luyện.
#import libraries and define constants
# Experiments
TASK = "regression"
MODEL_TYPE = "tensorflow"
EXPERIMENT_NAME = f"{PROJECT_ID}-{TASK}-{MODEL_TYPE}-{TIMESTAMP}"
# Pipeline
PIPELINE_URI = f"{BUCKET_URI}/pipelines"
TRAIN_URI = f"{BUCKET_URI}/player_data/data.csv"
LABEL_URI = f"{BUCKET_URI}/player_data/labels.csv"
MODEL_URI = f"{BUCKET_URI}/model"
DISPLAY_NAME = "experiments-demo-gaming-data"
BQ_DATASET = "player_data"
BQ_LOCATION = "US"
VIEW_NAME = 'dataset_test'
PIPELINE_JSON_PKG_PATH = "experiments_demo_gaming_data.json"
PIPELINE_ROOT = f"gs://{BUCKET_URI}/pipeline_root"
6. Hãy xây dựng quy trình
Giờ đây, niềm vui đã bắt đầu và chúng ta có thể bắt đầu tận dụng Vertex AI để xây dựng quy trình đào tạo của mình. Chúng ta sẽ khởi chạy SDK Vertex AI, thiết lập công việc huấn luyện dưới dạng thành phần quy trình, tạo quy trình, gửi(các) lần chạy quy trình và tận dụng SDK Vertex AI để xem các thử nghiệm và theo dõi trạng thái của các thử nghiệm đó.
Bước 1: Khởi chạy SDK Vertex AI
Khởi chạy SDK Vertex AI, thiết lập PROJECT_ID và BUCKET_URI.
#initialize vertex AI SDK
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)
Bước 2: Thiết lập Công việc huấn luyện dưới dạng Thành phần quy trình
Để bắt đầu chạy các thử nghiệm, chúng ta cần chỉ định công việc huấn luyện bằng cách xác định công việc đó là một thành phần của quy trình. Quy trình của chúng ta sẽ lấy dữ liệu huấn luyện và các tham số siêu dữ liệu (ví dụ: DROPOUT_RATE, LEARNING_RATE, EPOCHS) làm chỉ số của mô hình đầu vào và đầu ra (ví dụ: MAE và RMSE) và một cấu phần phần mềm mô hình.
@component(
packages_to_install=[
"numpy==1.21.0",
"pandas==1.3.5",
"scikit-learn==1.0.2",
"tensorflow==2.9.0",
]
)
def custom_trainer(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
metrics: Output[Metrics],
model_metadata: Output[Model],
):
# import libraries
import logging
import uuid
from pathlib import Path as path
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Dropout
from tensorflow.keras.metrics import Metric
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error
import numpy as np
from math import sqrt
import os
import tempfile
# set variables and use gcsfuse to update prefixes
gs_prefix = "gs://"
gcsfuse_prefix = "/gcs/"
train_path = train_uri.replace(gs_prefix, gcsfuse_prefix)
label_path = label_uri.replace(gs_prefix, gcsfuse_prefix)
model_path = model_uri.replace(gs_prefix, gcsfuse_prefix)
def get_logger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
handler.setFormatter(
logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
)
logger.addHandler(handler)
return logger
def get_data(
train_path: str,
label_path: str
) -> (pd.DataFrame):
#load data into pandas dataframe
data_0 = pd.read_csv(train_path)
labels_0 = pd.read_csv(label_path)
#drop unnecessary leading columns
data = data_0.drop('Unnamed: 0', axis=1)
labels = labels_0.drop('Unnamed: 0', axis=1)
#save as numpy array for reshaping of data
labels = labels.values
data = data.values
# Split the data
labels = labels.reshape((labels.size,))
train_data, test_data, train_labels, test_labels = train_test_split(data, labels, test_size=0.2, shuffle=True, random_state=7)
#Convert data back to pandas dataframe for scaling
train_data = pd.DataFrame(train_data)
test_data = pd.DataFrame(test_data)
train_labels = pd.DataFrame(train_labels)
test_labels = pd.DataFrame(test_labels)
#Scale and normalize the training dataset
scaler = StandardScaler()
scaler.fit(train_data)
train_data = pd.DataFrame(scaler.transform(train_data), index=train_data.index, columns=train_data.columns)
test_data = pd.DataFrame(scaler.transform(test_data), index=test_data.index, columns=test_data.columns)
return train_data,train_labels, test_data, test_labels
""" Train your Keras model passing in the training data and values for learning rate, dropout rate,and the number of epochs """
def train_model(
learning_rate: float,
dropout_rate: float,
epochs: float,
train_data: pd.DataFrame,
train_labels: pd.DataFrame):
# Train tensorflow model
param = {"learning_rate": learning_rate, "dropout_rate": dropout_rate, "epochs": epochs}
model = Sequential()
model.add(Dense(500, input_dim=train_data.shape[1], activation= "relu"))
model.add(Dropout(param['dropout_rate']))
model.add(Dense(100, activation= "relu"))
model.add(Dense(50, activation= "relu"))
model.add(Dense(1))
model.compile(
tf.keras.optimizers.Adam(learning_rate= param['learning_rate']),
loss='mse',
metrics=[tf.keras.metrics.RootMeanSquaredError(),tf.keras.metrics.MeanAbsoluteError()])
model.fit(train_data, train_labels, epochs= param['epochs'])
return model
# Get Predictions
def get_predictions(model, test_data):
dtest = pd.DataFrame(test_data)
pred = model.predict(dtest)
return pred
# Evaluate predictions with MAE
def evaluate_model_mae(pred, test_labels):
mae = mean_absolute_error(test_labels, pred)
return mae
# Evaluate predictions with RMSE
def evaluate_model_rmse(pred, test_labels):
rmse = np.sqrt(np.mean((test_labels - pred)**2))
return rmse
#Save your trained model in GCS
def save_model(model, model_path):
model_id = str(uuid.uuid1())
model_path = f"{model_path}/{model_id}"
path(model_path).parent.mkdir(parents=True, exist_ok=True)
model.save(model_path + '/model_tensorflow')
# Main ----------------------------------------------
train_data, train_labels, test_data, test_labels = get_data(train_path, label_path)
model = train_model(learning_rate, dropout_rate, epochs, train_data,train_labels )
pred = get_predictions(model, test_data)
mae = evaluate_model_mae(pred, test_labels)
rmse = evaluate_model_rmse(pred, test_labels)
save_model(model, model_path)
# Metadata ------------------------------------------
#convert numpy array to pandas series
mae = pd.Series(mae)
rmse = pd.Series(rmse)
#log metrics and model artifacts with ML Metadata. Save metrics as a list.
metrics.log_metric("mae", mae.to_list())
metrics.log_metric("rmse", rmse.to_list())
model_metadata.uri = model_uri
Bước 3: Xây dựng quy trình
Bây giờ, chúng ta sẽ thiết lập quy trình làm việc bằng cách sử dụng Domain Specific Language (DSL) có trong KFP và biên dịch quy trình của chúng ta thành tệp JSON.
# define our workflow
@dsl.pipeline(name="gaming-custom-training-pipeline")
def pipeline(
train_uri: str,
label_uri: str,
dropout_rate: float,
learning_rate: float,
epochs: int,
model_uri: str,
):
custom_trainer(
train_uri,label_uri, dropout_rate,learning_rate,epochs, model_uri
)
#compile our pipeline
compiler.Compiler().compile(pipeline_func=pipeline, package_path="gaming_pipeline.json")
Bước 4: Gửi(các) lần chạy quy trình
Công việc khó khăn là thiết lập thành phần và xác định quy trình. Chúng ta đã sẵn sàng gửi nhiều lần chạy của quy trình mà chúng ta đã chỉ định ở trên. Để làm việc này, chúng ta cần xác định giá trị cho các tham số siêu dữ liệu như sau:
runs = [
{"dropout_rate": 0.001, "learning_rate": 0.001,"epochs": 20},
{"dropout_rate": 0.002, "learning_rate": 0.002,"epochs": 25},
{"dropout_rate": 0.003, "learning_rate": 0.003,"epochs": 30},
{"dropout_rate": 0.004, "learning_rate": 0.004,"epochs": 35},
{"dropout_rate": 0.005, "learning_rate": 0.005,"epochs": 40},
]
Sau khi xác định các tham số siêu dữ liệu, chúng ta có thể tận dụng for loop để cung cấp thành công các lần chạy khác nhau của quy trình:
for i, run in enumerate(runs):
job = vertex_ai.PipelineJob(
display_name=f"{EXPERIMENT_NAME}-pipeline-run-{i}",
template_path="gaming_pipeline.json",
pipeline_root=PIPELINE_URI,
parameter_values={
"train_uri": TRAIN_URI,
"label_uri": LABEL_URI,
"model_uri": MODEL_URI,
**run,
},
)
job.submit(experiment=EXPERIMENT_NAME)
Bước 5: Tận dụng SDK Vertex AI để xem thử nghiệm
Vertex AI SDK giúp bạn theo dõi trạng thái chạy quy trình. Bạn cũng có thể dùng hàm này để trả về các tham số và chỉ số của Quy trình chạy trong Thử nghiệm AI Vertex. Sử dụng mã sau để xem các tham số được liên kết với các lần chạy của bạn và trạng thái hiện tại của nó.
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
Bạn có thể tận dụng mã bên dưới để nhận thông tin cập nhật về trạng thái chạy quy trình.
#check on current status
while True:
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
if all(
pipeline_state != "COMPLETE" for pipeline_state in pipeline_experiments_df.state
):
print("Pipeline runs are still running...")
if any(
pipeline_state == "FAILED"
for pipeline_state in pipeline_experiments_df.state
):
print("At least one Pipeline run failed")
break
else:
print("Pipeline experiment runs have completed")
break
time.sleep(60)
Bạn cũng có thể gọi các công việc cụ thể trong quy trình bằng run_name.
# Call the pipeline runs based on the experiment run name
pipeline_experiments_df = vertex_ai.get_experiment_df(EXPERIMENT_NAME)
job = vertex_ai.PipelineJob.get(pipeline_experiments_df.run_name[0])
print(job.resource_name)
print(job._dashboard_uri())
Cuối cùng, bạn có thể làm mới trạng thái của các lần chạy theo khoảng thời gian đã đặt (chẳng hạn như 60 giây một lần) để xem các trạng thái thay đổi từ RUNNING thành FAILED hoặc COMPLETE.
# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
7. Xác định lượt chạy hoạt động hiệu quả nhất
Tuyệt vời, giờ đây chúng ta đã có kết quả của quá trình chạy quy trình. Bạn có thể tự hỏi: Tôi có thể học được gì từ kết quả này? Kết quả của các thử nghiệm phải chứa 5 hàng, mỗi hàng tương ứng với một lần chạy quy trình. Mã sẽ có dạng như sau:
Cả MAE và RMSE đều là các chỉ số đo lường sai số dự đoán trung bình của mô hình, vì vậy, trong hầu hết các trường hợp, bạn nên có giá trị thấp hơn cho cả hai chỉ số này. Dựa trên kết quả của Thử nghiệm Vertex AI, chúng ta có thể thấy rằng lần chạy thành công nhất trên cả hai chỉ số là lần chạy cuối cùng với dropout_rate là 0,001, learning_rate là 0,001 và tổng số epochs là 20. Dựa trên thử nghiệm này, các thông số mô hình này cuối cùng sẽ được dùng trong phiên bản chính thức để mang lại hiệu suất tốt nhất cho mô hình.
Vậy là bạn đã hoàn thành lớp học lập trình!
🎉 Xin chúc mừng! 🎉
Bạn đã tìm hiểu cách sử dụng Vertex AI để:
- Huấn luyện một Mô hình Keras tuỳ chỉnh để dự đoán điểm xếp hạng của người chơi (ví dụ: sự hồi quy)
- Sử dụng SDK quy trình Kubeflow để xây dựng các quy trình học máy có thể mở rộng
- Tạo và chạy quy trình 5 bước để nhập dữ liệu từ GCS, chia tỷ lệ dữ liệu, huấn luyện mô hình, đánh giá, rồi lưu mô hình thu được vào GCS
- Tận dụng Siêu dữ liệu máy học của Vertex để lưu các cấu phần phần mềm của mô hình như Mô hình và Chỉ số mô hình
- Sử dụng tính năng Thử nghiệm của Vertex AI để so sánh kết quả của nhiều quy trình chạy
Để tìm hiểu thêm về các phần khác nhau của Vertex, hãy xem tài liệu.
8. Dọn dẹp
Để không bị tính phí, bạn nên xoá các tài nguyên được tạo trong suốt lớp học này.
Bước 1: Dừng hoặc xoá thực thể của Sổ tay
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. Trên giao diện người dùng của Sổ tay trong Cloud Console, hãy chọn sổ tay rồi chọn Dừng. Nếu bạn muốn xoá hoàn toàn thực thể, hãy chọn Xoá:
Bước 2: Xoá bộ chứa trên Cloud Storage
Để 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á:
