1. ภาพรวม
ใน Lab นี้ คุณจะได้ใช้ Vertex AI เพื่อสร้างไปป์ไลน์ที่ฝึกโมเดล Keras ที่กำหนดเองใน TensorFlow จากนั้นเราจะใช้ฟังก์ชันการทำงานใหม่ที่มีใน Vertex AI Experiments เพื่อติดตามและเปรียบเทียบการทำงานของโมเดลเพื่อระบุการผสมผสานของไฮเปอร์พารามิเตอร์ที่ให้ประสิทธิภาพดีที่สุด
สิ่งที่คุณจะได้เรียนรู้
คุณจะได้เรียนรู้วิธีต่อไปนี้
- ฝึกโมเดล Keras ที่กำหนดเองเพื่อคาดการณ์การให้คะแนนผู้เล่น (เช่น การถดถอย)
- ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่ปรับขนาดได้
- สร้างและเรียกใช้ไปป์ไลน์ 5 ขั้นตอนที่รับข้อมูลจาก Cloud Storage, ปรับขนาดข้อมูล, ฝึกโมเดล, ประเมินโมเดล และบันทึกโมเดลที่ได้กลับไปใน Cloud Storage
- ใช้ประโยชน์จาก Vertex ML Metadata เพื่อบันทึกอาร์ติแฟกต์ของโมเดล เช่น โมเดลและเมตริกของโมเดล
- ใช้ Vertex AI Experiments เพื่อเปรียบเทียบผลลัพธ์ของการเรียกใช้ไปป์ไลน์ต่างๆ
ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $1
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
Lab นี้ใช้ผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้าด้วยกันเพื่อมอบประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้ โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองสามารถเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้รวมทั้ง 2 อย่างไว้ใน API เดียว พร้อมด้วยผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย
Vertex AI มีผลิตภัณฑ์ที่แตกต่างกันมากมายเพื่อรองรับเวิร์กโฟลว์ ML แบบครบวงจร Lab นี้จะเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ Experiments, Pipelines, ML Metadata, และ Workbench
3. ภาพรวมกรณีการใช้งาน
เราจะใช้ชุดข้อมูลฟุตบอลยอดนิยมจาก ซีรีส์วิดีโอเกม FIFA ของ EA Sports ซึ่งมีแมตช์ฟุตบอลมากกว่า 25,000 แมตช์และผู้เล่นมากกว่า 10,000 คนสำหรับฤดูกาล 2008-2016 เราได้ประมวลผลข้อมูลล่วงหน้าแล้วเพื่อให้คุณเริ่มต้นใช้งานได้ง่ายขึ้น คุณจะได้ใช้ชุดข้อมูลนี้ตลอดทั้ง Lab ซึ่งตอนนี้อยู่ใน Bucket ของ Cloud Storage ที่เผยแพร่ต่อสาธารณะ เราจะให้รายละเอียดเพิ่มเติมเกี่ยวกับวิธีเข้าถึงชุดข้อมูลใน Codelab นี้ เป้าหมายสุดท้ายของเราคือการคาดการณ์คะแนนโดยรวมของผู้เล่นตามการกระทำต่างๆ ในเกม เช่น การสกัดบอลและการทำฟาวล์
Vertex AI Experiments มีประโยชน์อย่างไรสำหรับวิทยาศาสตร์ข้อมูล
วิทยาศาสตร์ข้อมูลเป็นเรื่องของการทดลอง โดยนักวิทยาศาสตร์ข้อมูลจะทำการทดลองต่างๆ นักวิทยาศาสตร์ข้อมูลที่ดีจะขับเคลื่อนด้วยสมมติฐาน โดยใช้การลองผิดลองถูกเพื่อทดสอบสมมติฐานต่างๆ ด้วยความหวังว่าการทำซ้ำอย่างต่อเนื่องจะส่งผลให้ได้โมเดลที่มีประสิทธิภาพมากขึ้น
แม้ว่าทีมวิทยาศาสตร์ข้อมูลจะยอมรับการทดลอง แต่ทีมมักประสบปัญหาในการติดตามงานและ "เคล็ดลับ" ที่ค้นพบผ่านความพยายามในการทดลอง ซึ่งเกิดขึ้นจากสาเหตุหลายประการ ดังนี้
- การติดตามงานฝึกอาจยุ่งยาก ทำให้มองข้ามได้ง่ายว่าสิ่งใดใช้ได้ผลและสิ่งใดใช้ไม่ได้ผล
- ปัญหานี้จะซับซ้อนยิ่งขึ้นเมื่อคุณดูทีมวิทยาศาสตร์ข้อมูล เนื่องจากสมาชิกบางคนอาจไม่ได้ติดตามการทดลองหรือแม้แต่แชร์ผลลัพธ์กับผู้อื่น
- การเก็บรวบรวมข้อมูลต้องใช้เวลานาน และทีมส่วนใหญ่ใช้วิธีการแบบแมนนวล (เช่น ชีตหรือเอกสาร) ซึ่งส่งผลให้ข้อมูลที่ได้ไม่สอดคล้องกันและไม่สมบูรณ์
สรุป: Vertex AI Experiments จะช่วยคุณติดตามและเปรียบเทียบการทดลองได้ง่ายขึ้น
ทำไมต้องใช้ Vertex AI Experiments สำหรับเกม
ในอดีต เกมเป็นสนามเด็กเล่นสำหรับแมชชีนเลิร์นนิงและการทดลอง ML เกมไม่เพียงแต่สร้างเหตุการณ์แบบเรียลไทม์นับพันล้านรายการต่อวันเท่านั้น แต่ยังใช้ประโยชน์จากข้อมูลทั้งหมดนั้นด้วยการใช้ ML และการทดลอง ML เพื่อปรับปรุงประสบการณ์ในเกม รักษาผู้เล่น และประเมินผู้เล่นต่างๆ ในแพลตฟอร์ม ด้วยเหตุนี้ เราจึงคิดว่าชุดข้อมูลเกมเหมาะกับแบบฝึกหัดการทดลองโดยรวมของเรา
4. ตั้งค่าสภาพแวดล้อม
คุณต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตาม วิธีการที่นี่
ขั้นตอนที่ 1: เปิดใช้ Compute Engine API
ไปที่ Compute Engine แล้วเลือก เปิดใช้ หากยังไม่ได้เปิดใช้
ขั้นตอนที่ 2: เปิดใช้ Vertex AI API
ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิก Enable Vertex AI API
ขั้นตอนที่ 3: สร้างอินสแตนซ์ Vertex AI Workbench
จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench
เปิดใช้ Notebooks API หากยังไม่ได้เปิดใช้
เมื่อเปิดใช้แล้ว ให้คลิก MANAGED NOTEBOOKS:
จากนั้นเลือก NEW NOTEBOOK
ตั้งชื่อ Notebook แล้วคลิก Advanced Settings
ในส่วน Advanced Settings ให้เปิดใช้ Idle Shutdown และตั้งค่าจำนวนนาทีเป็น 60 ซึ่งหมายความว่า Notebook จะปิดโดยอัตโนมัติเมื่อไม่ได้ใช้งาน เพื่อไม่ให้คุณเสียค่าใช้จ่ายที่ไม่จำเป็น
ขั้นตอนที่ 4: เปิด Notebook
เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab
ขั้นตอนที่ 5: ตรวจสอบสิทธิ์ (ครั้งแรกเท่านั้น)
เมื่อใช้อินสแตนซ์ใหม่เป็นครั้งแรก ระบบจะขอให้คุณตรวจสอบสิทธิ์ โดยทำตามขั้นตอนใน UI
ขั้นตอนที่ 6: เลือกเคอร์เนลที่เหมาะสม
Managed-Notebooks มีเคอร์เนลหลายรายการใน UI เดียว เลือกเคอร์เนลสำหรับ TensorFlow 2 (ในเครื่อง)
5. ขั้นตอนการตั้งค่าเริ่มต้นใน Notebook
คุณจะต้องทำตามขั้นตอนเพิ่มเติมหลายขั้นตอนเพื่อตั้งค่าสภาพแวดล้อมภายใน Notebook ก่อนที่จะสร้างไปป์ไลน์ ขั้นตอนเหล่านี้รวมถึงการติดตั้งแพ็กเกจเพิ่มเติม การตั้งค่าตัวแปร การสร้าง Bucket ของ Cloud Storage การคัดลอกชุดข้อมูลเกมจาก Bucket ของ Storage ที่เผยแพร่ต่อสาธารณะ และการนำเข้าไลบรารีและการกำหนดค่าคงที่เพิ่มเติม
ขั้นตอนที่ 1: ติดตั้งแพ็กเกจเพิ่มเติม
เราจะต้องติดตั้งการขึ้นต่อกันของแพ็กเกจเพิ่มเติมที่ยังไม่ได้ติดตั้งในสภาพแวดล้อม Notebook ของคุณ ตัวอย่างเช่น KFP SDK
!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts
จากนั้นคุณจะต้องรีสตาร์ทเคอร์เนลของ Notebook เพื่อให้ใช้แพ็กเกจที่ดาวน์โหลดมาภายใน Notebook ได้
# 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)
ขั้นตอนที่ 2: ตั้งค่าตัวแปร
เราต้องการกำหนด PROJECT_ID หากไม่ทราบ Project_ID คุณอาจรับ PROJECT_ID ได้โดยใช้ 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)
หรือตั้งค่า PROJECT_ID ที่นี่
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
นอกจากนี้ เรายังต้องการตั้งค่าตัวแปร REGION ซึ่งใช้ตลอดทั้ง Notebook นี้ ด้านล่างนี้คือภูมิภาคที่รองรับสำหรับ Vertex AI เราขอแนะนำให้คุณเลือกภูมิภาคที่ใกล้กับคุณมากที่สุด
- อเมริกา: us-central1
- ยุโรป: europe-west4
- เอเชียแปซิฟิก: asia-east1
โปรดอย่าใช้ Bucket แบบหลายภูมิภาคสำหรับการฝึกด้วย Vertex AI เนื่องจากบางภูมิภาคไม่รองรับบริการทั้งหมดของ Vertex AI ดูข้อมูลเพิ่มเติมเกี่ยวกับภูมิภาค Vertex AI
#set your region
REGION = "us-central1" # @param {type: "string"}
สุดท้าย เราจะตั้งค่าตัวแปร TIMESTAMP ตัวแปรนี้ใช้เพื่อหลีกเลี่ยงชื่อที่ซ้ำกันระหว่างผู้ใช้ในทรัพยากรที่สร้างขึ้น โดยคุณจะสร้าง TIMESTAMP สำหรับเซสชันอินสแตนซ์แต่ละเซสชัน และต่อท้ายชื่อทรัพยากรที่คุณสร้างในบทแนะนำนี้
#set timestamp to avoid collisions between multiple users
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
ขั้นตอนที่ 3: สร้าง Bucket ของ Cloud Storage
คุณจะต้องระบุและใช้ประโยชน์จาก Bucket การจัดเตรียมของ Cloud Storage Bucket การจัดเตรียมคือที่ที่ระบบจะเก็บข้อมูลทั้งหมดที่เชื่อมโยงกับชุดข้อมูลและทรัพยากรของโมเดลไว้ในเซสชันต่างๆ
ตั้งชื่อ Bucket ของ Cloud Storage ด้านล่าง ชื่อ Bucket ต้องไม่ซ้ำกันทั่วโลกในโปรเจ็กต์ Google Cloud ทั้งหมด รวมถึงโปรเจ็กต์ภายนอกองค์กรของคุณ
#set cloud storage bucket
BUCKET_NAME = "[insert bucket name here]" # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"
หาก Bucket ยังไม่มีอยู่ ให้เรียกใช้เซลล์ต่อไปนี้เพื่อสร้าง Bucket ของ Cloud Storage
! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI
จากนั้นยืนยันการเข้าถึง Bucket ของ Cloud Storage โดยเรียกใช้เซลล์ต่อไปนี้
#verify access
! gsutil ls -al $BUCKET_URI
ขั้นตอนที่ 4: คัดลอกชุดข้อมูลเกมของเรา
ดังที่กล่าวไว้ก่อนหน้านี้ คุณจะได้ใช้ประโยชน์จากชุดข้อมูลเกมยอดนิยมจากวิดีโอเกมฮิตของ EA Sports อย่าง FIFA เราได้ดำเนินการประมวลผลล่วงหน้าให้คุณแล้ว ดังนั้นคุณเพียงแค่คัดลอกชุดข้อมูลจาก Bucket ของ Storage ที่เผยแพร่ต่อสาธารณะและย้ายไปยัง Bucket ที่คุณสร้างขึ้น
# 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
ขั้นตอนที่ 5: นำเข้าไลบรารีและกำหนดค่าคงที่เพิ่มเติม
จากนั้นเราจะนำเข้าไลบรารีสำหรับ Vertex AI, KFP และอื่นๆ
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
นอกจากนี้ เรายังจะกำหนดค่าคงที่เพิ่มเติมที่เราจะอ้างอิงตลอดทั้ง Notebook เช่น เส้นทางไฟล์ไปยังข้อมูลฝึกฝน
#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. มาสร้างไปป์ไลน์กัน
ตอนนี้เรามาเริ่มใช้ประโยชน์จาก Vertex AI เพื่อสร้างไปป์ไลน์การฝึกกันได้เลย เราจะเริ่มต้น Vertex AI SDK, ตั้งค่างานฝึกเป็นคอมโพเนนต์ไปป์ไลน์, สร้างไปป์ไลน์, ส่งการเรียกใช้ไปป์ไลน์ และใช้ประโยชน์จาก Vertex AI SDK เพื่อดูการทดลองและตรวจสอบสถานะ
ขั้นตอนที่ 1: เริ่มต้น Vertex AI SDK
เริ่มต้น Vertex AI SDK โดยตั้งค่า PROJECT_ID และ BUCKET_URI
#initialize vertex AI SDK
vertex_ai.init(project=PROJECT_ID, staging_bucket=BUCKET_URI)
ขั้นตอนที่ 2: ตั้งค่างานฝึกเป็นคอมโพเนนต์ไปป์ไลน์
หากต้องการเริ่มเรียกใช้การทดลอง เราจะต้องระบุงานฝึกโดยกำหนดให้เป็นคอมโพเนนต์ไปป์ไลน์ ไปป์ไลน์ของเราจะรับข้อมูลฝึกฝนและไฮเปอร์พารามิเตอร์ (เช่น DROPOUT_RATE, LEARNING_RATE, EPOCHS) เป็นอินพุต และส่งออกเมตริกของโมเดล (เช่น MAE และ RMSE) และอาร์ติแฟกต์ของโมเดล
@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
ขั้นตอนที่ 3: สร้างไปป์ไลน์
ตอนนี้เราจะตั้งค่าเวิร์กโฟลว์โดยใช้ Domain Specific Language (DSL) ที่มีใน KFP และคอมไพล์ไปป์ไลน์เป็นไฟล์ 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")
ขั้นตอนที่ 4: ส่งการเรียกใช้ไปป์ไลน์
เราได้ตั้งค่าคอมโพเนนต์และกำหนดไปป์ไลน์เรียบร้อยแล้ว ตอนนี้เราพร้อมที่จะส่งการเรียกใช้ไปป์ไลน์ต่างๆ ที่เราระบุไว้ข้างต้น ในการดำเนินการนี้ เราจะต้องกำหนดค่าสำหรับไฮเปอร์พารามิเตอร์ต่างๆ ดังนี้
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},
]
เมื่อกำหนดไฮเปอร์พารามิเตอร์แล้ว เราจะใช้ for loop เพื่อป้อนการเรียกใช้ไปป์ไลน์ต่างๆ ได้สำเร็จ
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)
ขั้นตอนที่ 5: ใช้ประโยชน์จาก Vertex AI SDK เพื่อดูการทดลอง
Vertex AI SDK ช่วยให้คุณตรวจสอบสถานะของการเรียกใช้ไปป์ไลน์ได้ นอกจากนี้ คุณยังใช้ SDK เพื่อแสดงผลพารามิเตอร์และเมตริกของการเรียกใช้ไปป์ไลน์ในการทดลอง Vertex AI ได้ด้วย ใช้โค้ดต่อไปนี้เพื่อดูพารามิเตอร์ที่เชื่อมโยงกับการเรียกใช้และสถานะปัจจุบัน
# see state/status of all the pipeline runs
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
คุณใช้โค้ดด้านล่างเพื่อรับข้อมูลอัปเดตเกี่ยวกับสถานะของการเรียกใช้ไปป์ไลน์ได้
#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)
นอกจากนี้ คุณยังเรียกงานไปป์ไลน์ที่เฉพาะเจาะจงได้โดยใช้ 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())
สุดท้าย คุณสามารถรีเฟรชสถานะของการเรียกใช้ตามช่วงเวลาที่กำหนด (เช่น ทุก 60 วินาที) เพื่อดูสถานะที่เปลี่ยนจาก RUNNING เป็น FAILED หรือ COMPLETE
# wait 60 seconds and view state again
import time
time.sleep(60)
vertex_ai.get_experiment_df(EXPERIMENT_NAME)
7. ระบุการเรียกใช้ที่มีประสิทธิภาพดีที่สุด
ยอดเยี่ยม ตอนนี้เราได้ผลลัพธ์ของการเรียกใช้ไปป์ไลน์แล้ว คุณอาจสงสัยว่าฉันจะได้เรียนรู้อะไรจากผลลัพธ์เหล่านี้ เอาต์พุตจากการทดลองควรมี 5 แถว ซึ่งแต่ละแถวแสดงผลลัพธ์ของการเรียกใช้ไปป์ไลน์ 1 ครั้ง โดยจะมีลักษณะคล้ายกับตัวอย่างต่อไปนี้
ทั้ง MAE และ RMSE เป็นการวัดข้อผิดพลาดในการคาดการณ์ของโมเดลโดยเฉลี่ย ดังนั้นค่าที่ต่ำกว่าสำหรับเมตริกทั้ง 2 รายการจึงเป็นที่ต้องการในกรณีส่วนใหญ่ จากเอาต์พุตของ Vertex AI Experiments เราจะเห็นว่าการเรียกใช้ที่ประสบความสำเร็จมากที่สุดในเมตริกทั้ง 2 รายการคือการเรียกใช้ครั้งสุดท้ายที่มี dropout_rate เป็น 0.001, learning_rate เป็น 0.001 และจำนวน epochs ทั้งหมดเป็น 20 จากการทดลองนี้ พารามิเตอร์ของโมเดลเหล่านี้จะถูกนำไปใช้จริงในท้ายที่สุด เนื่องจากให้ประสิทธิภาพของโมเดลดีที่สุด
เท่านี้คุณก็ทำ Lab นี้เสร็จแล้ว
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้
- ฝึกโมเดล Keras ที่กำหนดเองเพื่อคาดการณ์การให้คะแนนผู้เล่น (เช่น การถดถอย)
- ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่ปรับขนาดได้
- สร้างและเรียกใช้ไปป์ไลน์ 5 ขั้นตอนที่รับข้อมูลจาก GCS, ปรับขนาดข้อมูล, ฝึกโมเดล, ประเมินโมเดล และบันทึกโมเดลที่ได้กลับไปใน GCS
- ใช้ประโยชน์จาก Vertex ML Metadata เพื่อบันทึกอาร์ติแฟกต์ของโมเดล เช่น โมเดลและเมตริกของโมเดล
- ใช้ Vertex AI Experiments เพื่อเปรียบเทียบผลลัพธ์ของการเรียกใช้ไปป์ไลน์ต่างๆ
หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex โปรดดูที่เอกสารประกอบ
8. การทำความสะอาดข้อมูล
เราขอแนะนำให้คุณลบทรัพยากรที่สร้างขึ้นตลอดทั้ง Lab นี้เพื่อไม่ให้ระบบเรียกเก็บเงินจากคุณ
ขั้นตอนที่ 1: หยุดหรือลบอินสแตนซ์ Notebooks
หากต้องการใช้ Notebook ที่สร้างขึ้นใน Lab นี้ต่อไป เราขอแนะนำให้ปิด Notebook เมื่อไม่ได้ใช้งาน จาก UI ของ Notebooks ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด หากต้องการลบอินสแตนซ์ทั้งหมด ให้เลือกลบ:
ขั้นตอนที่ 2: ลบ Bucket ของ Cloud Storage
หากต้องการลบ Bucket ของ Storage ให้ไปที่ Storage โดยใช้เมนูการนำทางใน Cloud Console เลือก Bucket แล้วคลิกลบ
