1. Tổng quan
Trong phòng thí nghiệm này, bạn sẽ sử dụng AI Vertex để 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 tôi sẽ sử dụng chức năng mới có trong Thử nghiệm AI trên đỉnh để theo dõi và so sánh các lần chạy mô hình, từ đó xác định xem tổ hợp siêu tham số 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ộ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 một quy trình 5 bước để nhập dữ liệu từ Cloud Storage, điều chỉnh quy mô dữ liệu, huấn luyện mô hình, đánh giá và lưu mô hình kết quả vào 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 phòng thí nghiệm này trên Google Cloud là khoảng 1 đô la.
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 giải pháp 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. Dịch vụ 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 có nhiều sản phẩm nhằm hỗ trợ quy trình học máy toàn diện. Phòng thí nghiệm này sẽ tập trung vào các sản phẩm được làm nổi bật dưới đây: Thử nghiệm, Đường dẫn, Siêu dữ liệu học máy và Bàn làm việc
3. Tổng quan về trường hợp sử dụng
Chúng tôi sẽ sử dụng một tập dữ liệu bóng đá phổ biến lấy nguồn từ EA Sports' Loạt trò chơi điện tử FIFA. 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 trên toàn bộ phòng thí nghiệm và hiện có thể tìm thấy tập dữ liệu này trong một bộ chứa công khai của Cloud Storage. Chúng ta sẽ cung cấp thêm thông tin chi tiết ở phần sau của lớp học lập trình này về cách truy cập vào tập dữ liệu. Mục tiêu cuối cùng của chúng tôi là dự đoán điểm xếp hạng chung của người chơi 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 đền.
Vì sao tính năng Thử nghiệm của Vertex AI lại hữu ích cho lĩnh vực 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. Các nhà khoa học dữ liệu giỏi dựa trên 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 rằng các lần lặp lại liên tiếp sẽ dẫn đến mô hình có hiệu suất cao hơn.
Mặc dù các nhóm khoa học dữ liệu đã ưa chuộng thử nghiệm, nhưng họ thường gặp khó khăn trong việc theo dõi công việc của họ và "bí quyết" mà các nhà xuất bản này phát hiện ra qua nỗ lực thử nghiệm của họ. Đ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 trở nên nghiêm trọng hơn khi bạn xem xét một nhóm khoa học dữ liệu vì không phải thành viên nào cũng có thể theo dõi các thí nghiệm hay thậm chí là 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 phương pháp thủ công (ví dụ: trang tính hoặc tài liệu). Do đó, thông tin cần tìm hiểu không nhất quán và không đầy đủ
tl;dr: Các tính năng thử nghiệm của Vertex AI hỗ trợ bạn, giúp bạn theo dõi và so sánh các thử nghiệm của mình dễ dàng hơn
Lý do nên thử nghiệm Vertex AI cho lĩnh vực trò chơi
Trước đây, ngành trò chơi là một sân chơi cho công nghệ học máy và các thử nghiệm học máy. Các trò chơi không chỉ tạo ra hàng tỷ sự kiện theo thời gian thực mỗi ngày, mà còn khai thác toàn bộ dữ liệu đó bằng cách tận dụng các thử nghiệm học máy và 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á những người chơi khác nhau 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 sẽ 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 một dự á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 bạn chưa bật tính năng này.
Bước 2: Bật Vertex AI API
Chuyển đến phần Vertex AI trong Cloud Console rồi nhấp vào Bật Vertex AI API.
Bước 3: 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 API Notebooks nếu chưa bật.
Sau khi bật, hãy nhấp vào SÁCH QUẢN LÝ SÁCH:
Sau đó, chọn SÁCH LƯU Ý MỚI.
Đặt tên cho sổ tay của bạn, sau đó nhấp vào Cài đặt nâng cao.
Trong phần Advanced Settings (Cài đặt nâng cao), hãy bật chế độ tắt ở trạng thái rảnh và đặt số phút là 60 phút. Đ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 phiên bản, hãy chọn Open JupyterLab.
Bước 5: Xác thực (chỉ lần đầu tiên)
Vào lần đầu tiên sử dụng một phiên bản 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
Sổ tay được quản lý cung cấp nhiều nhân trong một giao diện người dùng. Chọn 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 một loạt các bước bổ sung để 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 bất kỳ gói bổ sung nào, đặt biến, tạo bộ chứa bộ nhớ trên đám mây, sao chép tập dữ liệu trò chơi từ bộ chứa lưu trữ công cộng, 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 tôi sẽ cần cài đặt thêm các phần phụ thuộc của gói 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ụ như 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 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 của mình.
# 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 của mình, bạn có thể nhận 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 cần đặt biến REGION. Biến này được dùng xuyên suốt phần còn lại của sổ tay này. Dưới đây là các khu vực hỗ trợ 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 khu vực để huấn luyện bằng Vertex AI. Một số khu vực không hỗ trợ mọi dịch vụ Vertex AI. Tìm hiểu thêm về các vùng AI của Vertex.
#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 được dùng để tránh xung đột tên giữa người dùng trên các tài nguyên được tạo. Bạn sẽ tạo một TIMESTAMP cho mỗi phiên thực thể và thêm biến này vào tên của 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 một bộ chứa chạy thử của Cloud Storage. Bộ chứa thử nghiệm 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 qua các phiên hoạt động.
Đặt tên 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 cho mọi dự án trên Google Cloud, kể cả những 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 của mình 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, vì vậy, 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 đến trong 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 cùng 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 tôi sẽ khởi chạy Vertex AI SDK, thiết lập công việc huấn luyện thành một thành phần của quy trình, xây dựng quy trình, gửi(các) lần chạy quy trình và tận dụng Vertex AI SDK để 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 Vertex AI SDK
Khởi chạy Vertex AI SDK, đặt PROJECT_ID và BUCKET_URI của bạn.
#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 đào tạo của chúng tôi dưới dạng thành phần quy trình
Để bắt đầu chạy thử nghiệm, chúng ta sẽ cần chỉ định công việc huấn luyện của mình 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 tôi sẽ lấy dữ liệu huấn luyện và các siêu tham số (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 công việc bằng cách sử dụng Domain Specific Language (DSL) có trong KFP và biên dịch quy trình 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) quy trình 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 tôi đã sẵn sàng gửi nhiều lần chạy quy trình mà chúng tôi đã chỉ định ở trên. Để thực hiện điều này, chúng ta cần xác định giá trị cho các siêu tham số khác nhau 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},
]
Với các siêu tham số đã xác định, chúng ta có thể tận dụng for loop để cấp dữ liệu thành công trong nhiều lần chạy 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 Vertex AI SDK để xem các 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ã dưới đây để nhận thông tin cập nhật về trạng thái chạy của 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 quy trình cụ thể 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 chạy theo các 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 bài 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. Có thể bạn sẽ hỏi: Tôi có thể biết được điều gì từ những kết quả đó? Đầu ra từ các thử nghiệm của bạn phải chứa 5 hàng, mỗi hàng cho một quy trình. Mã sẽ có dạng như sau:
Cả MAE và RMSE đều là thước đo sai số dự đoán mô hình trung bình. Vì vậy, trong hầu hết các trường hợp, bạn nên đưa ra giá trị thấp hơn cho cả hai chỉ số. Dựa trên kết quả từ các Thử nghiệm AI của Vertex, 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 nếu 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 phòng thí nghiệm!
🎉 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 một 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 này.
8. Dọn dẹp
Để không bị tính phí, bạn nên xoá các tài nguyên đã tạo trong toàn bộ phòng thí nghiệm này.
Bước 1: Dừng hoặc xoá phiên bản 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 phiên bản, hãy chọn Xoá:
Bước 2: Xoá bộ chứa trong Cloud Storage
Để xoá Bộ chứa Storage, hãy sử dụng trình đơn Điều hướng trong Cloud Console, duyệt đến Bộ nhớ, chọn bộ chứa rồi nhấp vào Xoá:
