1. Tổng quan
Trong phòng thí nghiệm này, bạn sẽ sử dụng Vertex AI để xây dựng một pipeline 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 Vertex AI Experiments để theo dõi và so sánh các lần chạy mô hình nhằm xác định 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ô 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 Kubeflow Pipelines SDK để 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 gồm 5 bước để tiếp nhận dữ liệu từ Cloud Storage, điều chỉnh tỷ lệ dữ liệu, huấn luyện mô hình, đánh giá mô hình và lưu mô hình kết quả trở lại Cloud Storage
- Tận dụng Siêu dữ liệu học máy của Vertex để lưu các cấu phần phần mềm mô hình như Mô hình và Chỉ số mô hình
- Sử dụng Thử nghiệm của Vertex AI để so sánh kết quả của nhiều lần chạy quy trình
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 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 học máy từ đầu đến cuối. Phòng thí nghiệm này sẽ tập trung vào các sản phẩm được nêu bật bên dưới: Thử nghiệm, Quy trình, Siêu dữ liệu 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 được lấy từ loạt trò chơi điện tử FIFA của EA Sports. Tập dữ liệu này bao gồm hơn 25.000 trận bóng đá và hơn 10.000 cầu thủ cho các mùa giải từ năm 2008 đến năm 2016. Dữ liệu đã được xử lý trước để bạn có thể dễ dàng bắt đầu. Bạn sẽ sử dụng tập dữ liệu này trong suốt phòng thí nghiệm. Tập dữ liệu này hiện có trong một bộ chứa Cloud Storage công khai. Chúng tôi sẽ cung cấp thêm thông tin chi tiết sau trong lớp học lập trình 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 ta 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ư đánh chặn và phạt đền.
Tại sao Thử nghiệm của Vertex AI lại hữu ích cho Khoa học dữ liệu?
Khoa học dữ liệu có bản chất là thử nghiệm – suy cho cùng thì họ cũng được gọi là nhà khoa học. Các nhà khoa học dữ liệu giỏi là những ngườ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 liên tiếp sẽ tạo ra một mô hình hoạt động hiệu quả hơn.
Mặc dù các nhóm khoa học dữ liệu đã áp dụng phương pháp thử nghiệm, nhưng họ thường gặp khó khăn trong việc theo dõi công việc và "bí quyết" được khám phá thông qua nỗ lực thử nghiệm. Điều này xảy ra vì một số lý do:
- Việc theo dõi các công việc huấn luyện có thể trở nên phức tạp, khiến bạn dễ dàng bỏ qua những gì đang hoạt động so với những gì không hoạt động
- Vấn đề này 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 thời gian và hầu hết các nhóm đều tận 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 đủ để học hỏi
tl;dr: Thử nghiệm của Vertex AI sẽ giúp bạn dễ dàng theo dõi và so sánh các thử nghiệm
Tại sao nên dùng Thử nghiệm của Vertex AI cho trò chơi?
Trong lịch sử, 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. 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 sử 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á 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 phù hợp với bài tập thử nghiệm tổng thể của chúng tôi.
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 Bật nếu bạn chưa bật.
Bước 2: Bật Vertex AI API
Chuyển đến phần Vertex AI của Bảng điều khiển Cloud 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 phần Vertex AI của Bảng điều khiển Cloud, 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 NOTEBOOKS ĐƯỢC QUẢN LÝ:
Sau đó, chọn NOTEBOOK MỚI.
Đặt tên cho sổ ghi chép 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ổ ghi chép sẽ tự động tắt khi không sử dụng để bạn không phải chịu chi phí không cần thiết.
Bước 4: Mở sổ ghi chép
Sau khi tạo thực thể, hãy chọn Mở JupyterLab.
Bước 5: Xác thực (chỉ lần đầu tiên)
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
Notebooks được quản lý cung cấp nhiều kernel trong một giao diện người dùng. Chọn kernel cho Tensorflow 2 (cục bộ).
5. Các bước thiết lập ban đầu trong sổ ghi chép
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ổ ghi chép 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, đặt biến, tạo bộ chứa Cloud Storage, sao chép tập dữ liệu trò chơi từ một bộ chứa lưu trữ 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 cần cài đặt các phần phụ thuộc của gói bổ sung hiện chưa được cài đặt trong môi trường sổ ghi chép. Ví dụ: KFP SDK.
!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 Kernel sổ ghi chép để có thể sử dụng các gói đã tải xuống trong sổ ghi chép.
# 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 muốn đặt biến REGION, được sử dụng trong suốt phần còn lại của sổ ghi chép 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 nhất với mình.
- 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. Không phải tất cả các khu vực đều hỗ trợ tất cả các dịch vụ Vertex AI. Tìm hiểu thêm về các khu vực 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 được 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 TIMESTAMP cho mỗi phiên bản phiê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 bộ chứa Cloud Storage
Bạn cần chỉ định và tận dụng một bộ chứa dàn dựng Cloud Storage. Bộ chứa dàn dựng 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 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 của Google Cloud, bao gồm 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 CHƯA 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ẽ tận dụng một tập dữ liệu trò chơi phổ biến từ trò chơi điện tử FIFA của EA Sports. Chúng tôi đã thực hiện công việ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 và di chuyển tập dữ liệu đó sang bộ chứa 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ẽ muốn nhập các thư viện 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ổ ghi chép, 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 của chúng ta
Bây giờ, chúng ta có thể bắt đầu và tận dụng Vertex AI để xây dựng quy trình huấn luyện. Chúng ta sẽ khởi chạy Vertex AI SDK, thiết lập công việc huấn luyện dưới dạng thành phần pipeline, xây dựng pipeline, gửi(các) lần chạy pipeline và tận dụng Vertex AI SDK để xem các thử nghiệm và theo dõi trạng thái của chúng.
Bước 1: Khởi chạy Vertex AI SDK
Khởi chạy Vertex AI SDK, đặt 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 quy trình. Quy trình của chúng ta sẽ nhận dữ liệu huấn luyện và siêu tham số (ví dụ: DROPOUT_RATE, LEARNING_RATE, EPOCHS) làm dữ liệu đầu vào và chỉ số mô hình đầ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 của chúng ta
Bây giờ, chúng ta sẽ thiết lập quy trình làm việc bằng Domain Specific Language (DSL) có trong KFP và biên dịch quy trình của chúng ta thành một 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
Chúng ta đã hoàn thành công việc 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 quy trình mà chúng ta đã chỉ định ở trên. Để thực hiện việc này, chúng ta cần xác định các 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},
]
Sau khi xác định các siêu tham số, chúng ta có thể tận dụng for loop để đưa 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 Vertex AI SDK để xem các thử nghiệm
Vertex AI SDK cho phép bạn theo dõi trạng thái của các lần chạy quy trình. Bạn cũng có thể sử dụng SDK này để trả về các tham số và chỉ số của Lần chạy quy trình trong Thử nghiệm của Vertex AI. Sử dụng mã sau để xem các tham số liên kết với các lần chạy và trạng thái hiện tại của các tham số đó.
# 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 của các lần 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 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 của các lần chạy theo các khoảng thời gian đã đặt (chẳng hạn như 60 giây một lần) để xem 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ần chạy hoạt động hiệu quả nhất
Tuyệt vời, giờ chúng ta đã có kết quả của các lần chạy quy trình. Bạn có thể đang thắc mắc, tôi có thể học được gì từ kết quả? Kết quả của các thử nghiệm phải chứa 5 hàng, một cho mỗi lần chạy quy trình. Kết quả sẽ có dạng như sau:
Cả MAE và RMSE đều là thước đo lỗi dự đoán mô hình trung bình, vì vậy, giá trị thấp hơn cho cả hai chỉ số là điều mong muốn trong hầu hết các trường hợp. Chúng ta có thể thấy dựa trên kết quả từ Thử nghiệm của Vertex AI rằng lần chạy thành công nhất của chúng ta 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 tham số mô hình này cuối cùng sẽ được sử dụng trong quá trình phát hành công khai vì chúng mang lại hiệu quả mô hình tốt nhất.
Vậy là bạn đã hoàn thành phòng thí nghiệm!
🎉 Xin chúc mừng! 🎉
Bạn đã học cách sử dụng Vertex AI để:
- 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 Kubeflow Pipelines SDK để 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 gồm 5 bước để tiếp nhận dữ liệu từ GCS, điều chỉnh tỷ lệ dữ liệu, huấn luyện mô hình, đánh giá mô hình và lưu mô hình kết quả trở lại GCS
- Tận dụng Siêu dữ liệu học máy của Vertex để lưu các cấu phần phần mềm mô hình như Mô hình và Chỉ số mô hình
- Sử dụng Thử nghiệm của Vertex AI để so sánh kết quả của nhiều lần chạy quy trình
Để 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 đã tạo trong suốt phòng thí nghiệm này.
Bước 1: Dừng hoặc xoá thực thể Notebooks
Nếu muốn tiếp tục sử dụng sổ ghi chép mà bạn đã tạo trong phòng thí nghiệm này, bạn nên tắt sổ ghi chép đó khi không sử dụng. Trong giao diện người dùng Notebooks của Bảng điều khiển Cloud, hãy chọn sổ ghi chép 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 Cloud Storage
Để xoá Bộ chứa lưu trữ, hãy sử dụng trình đơn Điều hướng trong Bảng điều khiển Cloud, duyệt đến Bộ nhớ, chọn bộ chứa rồi nhấp vào Xoá:
