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

1. ภาพรวม

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

สิ่งที่ได้เรียนรู้

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

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

ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $1

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ขั้นตอนที่ 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. ขั้นตอนการตั้งค่าเริ่มต้นในสมุดบันทึก

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

ขั้นตอนที่ 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: คัดลอกชุดข้อมูลเกม

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

# 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 เพื่อบันทึกอาร์ติแฟกต์ของโมเดล เช่น โมเดลและเมตริกโมเดล
• ใช้การทดสอบ Vertex AI เพื่อเปรียบเทียบผลลัพธ์ของการเรียกใช้ไปป์ไลน์แบบต่างๆ

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

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

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

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

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

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

หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ: