ใช้การทดลองให้เกิดประโยชน์สูงสุด: จัดการการทดสอบแมชชีนเลิร์นนิงด้วย Vertex AI

1. ภาพรวม

ในชั้นเรียนนี้ คุณจะใช้ Vertex AI เพื่อสร้างไปป์ไลน์ที่ฝึกโมเดล Keras ที่กําหนดเองใน TensorFlow จากนั้นเราจะใช้ฟังก์ชันการทำงานใหม่ที่พร้อมใช้งานในการทดสอบ Vertex AI เพื่อติดตามและเปรียบเทียบการเรียกใช้โมเดลเพื่อระบุชุดค่าผสมของไฮเปอร์พารามิเตอร์ที่ให้ประสิทธิภาพดีที่สุด

สิ่งที่คุณเรียนรู้

โดยคุณจะได้เรียนรู้วิธีต่อไปนี้

• ฝึกโมเดล Keras ที่กำหนดเองเพื่อคาดการณ์การให้คะแนนของผู้เล่น (เช่น การถดถอย)
• ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่ปรับขนาดได้
• สร้างและเรียกใช้ไปป์ไลน์ 5 ขั้นตอนที่นำเข้าข้อมูลจาก Cloud Storage, ปรับขนาดข้อมูล, ฝึกโมเดล, ประเมิน และบันทึกโมเดลที่ได้กลับไปยัง Cloud Storage
• ใช้ประโยชน์จาก Vertex ML Metadata เพื่อบันทึกอาร์ติแฟกต์ของโมเดล เช่น โมเดลและเมตริกของโมเดล
• ใช้ Vertex AI Experiments เพื่อเปรียบเทียบผลลัพธ์ของการเรียกใช้ไปป์ไลน์ต่างๆ

ต้นทุนทั้งหมดในการใช้งานห้องทดลองนี้ใน Google Cloud อยู่ที่ประมาณ $1

2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI

ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ทั่วทั้ง Google Cloud เข้าด้วยกันเพื่อมอบประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่นี้รวมทั้ง 2 รายการไว้ใน API เดียว พร้อมกับผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย

Vertex AI มีผลิตภัณฑ์หลายอย่างเพื่อรองรับเวิร์กโฟลว์ ML ตั้งแต่ต้นจนจบ ห้องทดลองนี้จะมุ่งเน้นที่ผลิตภัณฑ์ที่ไฮไลต์ไว้ด้านล่าง ได้แก่ การทดสอบ ไปป์ไลน์ ข้อมูลเมตา ML และ เวิร์กเบนค์

3. ภาพรวมกรณีการใช้งาน

เราจะใช้ชุดข้อมูลฟุตบอลยอดนิยมที่มาจากซีรีส์วิดีโอเกม FIFA ของ EA Sports ซึ่งรวมถึงการแข่งขันฟุตบอลกว่า 25,000 นัดและผู้เล่นกว่า 10,000 คนสำหรับฤดูกาล 2008-2016 ข้อมูลได้รับการประมวลผลล่วงหน้าแล้วเพื่อให้คุณเริ่มต้นใช้งานได้ง่ายขึ้น คุณจะใช้ชุดข้อมูลนี้ทั่วทั้งห้องทดลอง ซึ่งตอนนี้มีอยู่ในที่เก็บข้อมูล Cloud Storage สาธารณะ เราจะให้รายละเอียดเพิ่มเติมเกี่ยวกับวิธีเข้าถึงชุดข้อมูลในโค้ดแล็บในภายหลัง เป้าหมายสุดท้ายของเราคือการคาดคะเนคะแนนโดยรวมของผู้เล่นโดยอิงตามการกระทำต่างๆ ในเกม เช่น การแย่งบอลและลูกโทษ

เหตุใดเวอร์ชันทดลองของ Vertex AI จึงมีประโยชน์ต่อวิทยาศาสตร์ข้อมูล

วิทยาศาสตร์ข้อมูลเป็นศาสตร์ที่เน้นการทดลอง ผู้เชี่ยวชาญด้านนี้จึงเรียกว่านักวิทยาศาสตร์ นักวิทยาศาสตร์ข้อมูลที่ดีจะต้องยึดสมมติฐาน โดยใช้การลองผิดลองถูกเพื่อทดสอบสมมติฐานต่างๆ โดยหวังว่าการทำซ้ำซ้ำๆ หลายครั้งจะทำให้โมเดลมีประสิทธิภาพมากขึ้น

แม้ว่าทีมวิทยาศาสตร์ข้อมูลจะยอมรับการทดสอบ แต่มักประสบปัญหาในการติดตามงานและ "สูตรลับ" ที่ค้นพบผ่านการทดสอบ ปัญหานี้อาจเกิดขึ้นจากสาเหตุต่อไปนี้

• การติดตามงานการฝึกอบรมอาจทําให้ยุ่งยาก และทําให้คุณสับสนได้ง่ายว่าสิ่งใดใช้ได้ผลและไม่ได้ผล
• ปัญหานี้ยิ่งทวีความรุนแรงเมื่อคุณมองภาพรวมของทีมวิทยาการข้อมูล เนื่องจากสมาชิกบางคนอาจไม่ได้ติดตามการทดสอบหรือแชร์ผลลัพธ์กับผู้อื่น
• การบันทึกข้อมูลนั้นใช้เวลานานและทีมส่วนใหญ่ใช้ประโยชน์จากวิธีการแบบแมนวล (เช่น ชีตหรือเอกสาร) ซึ่งส่งผลให้มีข้อมูลที่ใช้ในการเรียนรู้ไม่สอดคล้องกันและขาดข้อมูล

สรุป: Vertex AI Experiments จะทํางานให้คุณ ช่วยให้คุณติดตามและเปรียบเทียบการทดสอบได้ง่ายขึ้น

ทำไมจึงต้องใช้การทดสอบ Vertex AI สำหรับเกม

ที่ผ่านมาวงการเกมเคยเป็นพื้นที่สำหรับแมชชีนเลิร์นนิงและการทดลองเกี่ยวกับ ML เกมไม่เพียงสร้างเหตุการณ์แบบเรียลไทม์หลายพันล้านรายการต่อวันเท่านั้น แต่ยังใช้ประโยชน์จากข้อมูลทั้งหมดนั้นด้วยการใช้ ML และการทดสอบ ML เพื่อปรับปรุงประสบการณ์ในเกม รักษาผู้เล่นไว้ และประเมินผู้เล่นแต่ละรายในแพลตฟอร์ม เราจึงคิดว่าชุดข้อมูลเกมเหมาะกับการฝึกฝนการทดสอบโดยรวมของเรา

4. ตั้งค่าสภาพแวดล้อม

คุณต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้โค้ดแล็บนี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 1: เปิดใช้ Compute Engine API

ไปที่ Compute Engine แล้วเลือกเปิดใช้หากยังไม่ได้เปิดใช้

ขั้นตอนที่ 2: เปิดใช้ Vertex AI API

ไปที่ส่วน Vertex AI ของ Cloud Console แล้วคลิกเปิดใช้ Vertex AI API

ขั้นตอนที่ 3: สร้างอินสแตนซ์ Vertex AI Workbench

จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench

เปิดใช้ Notebooks API หากยังไม่ได้เปิด

เมื่อเปิดใช้แล้ว ให้คลิกโน้ตบุ๊กที่มีการจัดการ

จากนั้นเลือกสมุดบันทึกใหม่

ตั้งชื่อสมุดบันทึก แล้วคลิกการตั้งค่าขั้นสูง

ในส่วนการตั้งค่าขั้นสูง ให้เปิดใช้การปิดเครื่องเมื่อไม่มีการใช้งานและตั้งค่าจำนวนนาทีเป็น 60 ซึ่งหมายความว่าสมุดบันทึกจะปิดโดยอัตโนมัติเมื่อไม่ได้ใช้งาน คุณจึงไม่จำเป็นต้องมีค่าใช้จ่ายที่ไม่จำเป็น

ขั้นตอนที่ 4: เปิดโน้ตบุ๊ก

เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab

ขั้นตอนที่ 5: ตรวจสอบสิทธิ์ (ครั้งแรกเท่านั้น)

ระบบจะขอให้คุณตรวจสอบสิทธิ์เมื่อใช้อินสแตนซ์ใหม่เป็นครั้งแรก ทําตามขั้นตอนใน UI

ขั้นตอนที่ 6: เลือกเคอร์เนลที่เหมาะสม

สมุดบันทึกที่มีการจัดการมีเคอร์เนลหลายรายการใน UI เดียว เลือกเคอร์เนลสําหรับ Tensorflow 2 (ในเครื่อง)

5. ขั้นตอนการตั้งค่าเริ่มต้นในสมุดบันทึก

คุณจะต้องทําตามขั้นตอนเพิ่มเติมอีกหลายขั้นตอนเพื่อตั้งค่าสภาพแวดล้อมภายในโน้ตบุ๊กก่อนสร้างไปป์ไลน์ ขั้นตอนเหล่านี้รวมถึงการติดตั้งแพ็กเกจเพิ่มเติม การตั้งค่าตัวแปร การสร้างที่เก็บข้อมูลระบบคลาวด์ การคัดลอกชุดข้อมูลเกมจากที่เก็บข้อมูลสาธารณะ ตลอดจนการนําเข้าไลบรารีและกำหนดค่าคงที่เพิ่มเติม

ขั้นตอนที่ 1: ติดตั้งแพ็กเกจเพิ่มเติม

เราจำเป็นต้องติดตั้งทรัพยากร Dependency ของแพ็กเกจเพิ่มเติมซึ่งไม่ได้ติดตั้งในสภาพแวดล้อมสมุดบันทึกของคุณในปัจจุบัน ตัวอย่าง ได้แก่ KFP SDK

!pip3 install --user --force-reinstall 'google-cloud-aiplatform>=1.15' -q --no-warn-conflicts
!pip3 install --user kfp -q --no-warn-conflicts

จากนั้นให้รีสตาร์ทเคอร์เนลโน้ตบุ๊กเพื่อให้ใช้แพ็กเกจที่ดาวน์โหลดภายในโน้ตบุ๊กได้

# 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 ซึ่งใช้ในส่วนที่เหลือของสมุดบันทึกนี้ ด้านล่างนี้คือภูมิภาคที่รองรับ Vertex AI เราขอแนะนําให้คุณเลือกภูมิภาคที่ใกล้กับคุณมากที่สุด

• อเมริกา: us-central1
• ยุโรป: europe-west4
• เอเชียแปซิฟิก: asia-east1

โปรดอย่าใช้ที่เก็บข้อมูลแบบหลายภูมิภาคสำหรับการฝึกด้วย 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: สร้างที่เก็บข้อมูล Cloud Storage

คุณจะต้องระบุและใช้ประโยชน์จากที่เก็บข้อมูลการทดลองใช้ของ Cloud Storage ที่เก็บข้อมูลการทดลองใช้คือที่ที่ข้อมูลทั้งหมดที่เชื่อมโยงกับชุดข้อมูลและทรัพยากรของโมเดลจะเก็บรักษาไว้ในเซสชันต่างๆ

ตั้งชื่อที่เก็บข้อมูล Cloud Storage ด้านล่าง ชื่อที่เก็บข้อมูลต้องไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด ซึ่งรวมถึงชื่อภายนอกองค์กรด้วย

#set cloud storage bucket 
BUCKET_NAME = "[insert bucket name here]"  # @param {type:"string"}
BUCKET_URI = f"gs://{BUCKET_NAME}"

หากที่เก็บข้อมูลยังไม่มีอยู่ ให้เรียกใช้เซลล์ต่อไปนี้เพื่อสร้างที่เก็บข้อมูล Cloud Storage

! gsutil mb -l $REGION -p $PROJECT_ID $BUCKET_URI

จากนั้นคุณสามารถยืนยันสิทธิ์เข้าถึงที่เก็บข้อมูล Cloud Storage ได้โดยเรียกใช้เซลล์ต่อไปนี้

#verify access 
! gsutil ls -al $BUCKET_URI

ขั้นตอนที่ 4: คัดลอกชุดข้อมูลเกม

ดังที่ได้กล่าวไปก่อนหน้านี้ คุณจะใช้ชุดข้อมูลเกมยอดนิยมจากวิดีโอเกม FIFA สุดฮิตของ EA Sports เราได้ทําการประมวลผลข้อมูลเบื้องต้นให้คุณแล้ว คุณจึงต้องคัดลอกชุดข้อมูลจากที่เก็บข้อมูลสาธารณะและย้ายไปยังที่เก็บข้อมูลที่คุณสร้างขึ้น

# 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

นอกจากนี้ เราจะกำหนดค่าคงที่เพิ่มเติมที่จะอ้างอิงกลับไปตลอดทั้งโน้ตบุ๊ก เช่น เส้นทางไฟล์ไปยังข้อมูลการฝึก

#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) และอาร์ติแฟกต์ของโมเดล

หากต้องการดูตัวอย่างอื่นๆ เกี่ยวกับวิธีใช้ประโยชน์จากการทดสอบ Vertex AI นอกไปจากไปป์ไลน์และกับโมเดลประเภทอื่นๆ ดูตัวอย่างนี้ซึ่งจะอธิบายวิธีทดสอบโมเดลที่ฝึกในเครื่อง (ดูตัวอย่างการเปรียบเทียบโมเดลที่ฝึกในเครื่อง)

@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 ช่วยให้คุณตรวจสอบสถานะการเรียกใช้ไปป์ไลน์ได้ นอกจากนี้ คุณยังใช้เพื่อแสดงผลพารามิเตอร์และเมตริกของการเรียกใช้ไปป์ไลน์ในการทดสอบ Vertex AI ได้ด้วย ใช้โค้ดต่อไปนี้เพื่อดูพารามิเตอร์ที่เชื่อมโยงกับการเรียกใช้และสถานะปัจจุบันของการเรียกใช้

# see state/status of all the pipeline runs

vertex_ai.get_experiment_df(EXPERIMENT_NAME)

ปัจจุบัน Vertex AI SDK สําหรับ Python รองรับเมธอด get_experiment_df ที่ช่วยแสดงรายละเอียดเกี่ยวกับการเรียกใช้ ซึ่งสามารถจับคู่กับวิธีการอื่นๆ ของ Pipelinejob เพื่อดึงรายละเอียดเกี่ยวกับงานในไปป์ไลน์ที่เกี่ยวข้อง เมื่อส่งแล้ว การดำเนินการจะใช้เวลาประมาณ 5 นาที

คุณใช้ประโยชน์จากโค้ดด้านล่างเพื่อรับข้อมูลอัปเดตเกี่ยวกับสถานะการเรียกใช้ไปป์ไลน์ได้

#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 ว่าการเรียกใช้ที่ประสบความสําเร็จมากที่สุดในเมตริกทั้ง 2 รายการคือการเรียกใช้ครั้งสุดท้ายที่มี dropout_rate เป็น 0.001, learning_rate เป็น 0.001 และจํานวน epochs ทั้งหมดคือ 20 ผลการทดสอบนี้ชี้ว่าพารามิเตอร์รูปแบบเหล่านี้จะใช้ในเวอร์ชันที่ใช้งานจริงเนื่องจากให้ประสิทธิภาพรูปแบบที่ดีที่สุด

เท่านี้คุณก็ทําแล็บเสร็จแล้ว

🎉 ยินดีด้วย 🎉

คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้

• ฝึกโมเดล Keras ที่กําหนดเองเพื่อคาดการณ์คะแนนผู้เล่น (เช่น การถดถอย)
• ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่ปรับขนาดได้
• สร้างและเรียกใช้ไปป์ไลน์ 5 ขั้นตอนที่นำเข้าข้อมูลจาก GCS, ปรับขนาดข้อมูล, ฝึกโมเดล, ประเมิน และบันทึกโมเดลที่ได้กลับไปไว้ใน GCS
• ใช้ประโยชน์จาก Vertex ML Metadata เพื่อบันทึกอาร์ติแฟกต์ของโมเดล เช่น โมเดลและเมตริกของโมเดล
• ใช้การทดสอบ Vertex AI เพื่อเปรียบเทียบผลลัพธ์ของการเรียกใช้ไปป์ไลน์แบบต่างๆ

ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ในเอกสารประกอบ

8. ล้างข้อมูล

ขอแนะนำให้คุณลบทรัพยากรที่สร้างขึ้นทั่วทั้งห้องทดลองนี้เพื่อไม่ให้มีการเรียกเก็บเงิน

ขั้นตอนที่ 1: หยุดหรือลบอินสแตนซ์สมุดบันทึก

หากต้องการใช้โน้ตบุ๊กที่สร้างในแท็บทดลองนี้ต่อไป เราขอแนะนำให้ปิดโน้ตบุ๊กเมื่อไม่ได้ใช้งาน จาก UI ของโน้ตบุ๊กใน Cloud Console ให้เลือกโน้ตบุ๊ก แล้วเลือกหยุด หากต้องการลบอินสแตนซ์ทั้งหมด ให้เลือกลบ

ขั้นตอนที่ 2: ลบที่เก็บข้อมูล Cloud Storage

หากต้องการลบที่เก็บข้อมูล ให้ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ