การใช้ข้อมูลเมตา Vertex ML กับไปป์ไลน์

1. ภาพรวม

ในแล็บนี้ คุณจะได้เรียนรู้วิธีวิเคราะห์ข้อมูลเมตาจากการเรียกใช้ Vertex Pipelines ด้วย Vertex ML Metadata

สิ่งที่คุณจะได้เรียนรู้

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

ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่สร้างชุดข้อมูลใน Vertex AI รวมถึงฝึกและติดตั้งใช้งานโมเดล Scikit-learn ที่กำหนดเองในชุดข้อมูลนั้น
เขียนคอมโพเนนต์ไปป์ไลน์ที่กำหนดเองซึ่งสร้างอาร์ติแฟกต์และข้อมูลเมตา
เปรียบเทียบการเรียกใช้ Vertex Pipelines ทั้งใน Cloud Console และแบบเป็นโปรแกรม
ติดตามแหล่งที่มาของอาร์ติแฟกต์ที่สร้างขึ้นในไปป์ไลน์
ค้นหาข้อมูลเมตาของการเรียกใช้ไปป์ไลน์

ค่าใช้จ่ายทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $2

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

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

นอกจากบริการฝึกและติดตั้งใช้งานโมเดลแล้ว Vertex AI ยังมีผลิตภัณฑ์ MLOps ที่หลากหลาย ซึ่งรวมถึง Vertex Pipelines, ข้อมูลเมตา ML, การตรวจสอบโมเดล, Feature Store และอื่นๆ คุณดูข้อเสนอผลิตภัณฑ์ Vertex AI ทั้งหมดได้ในแผนภาพด้านล่าง

ภาพรวมผลิตภัณฑ์ Vertex

แล็บนี้มุ่งเน้นที่ Vertex Pipelines และ Vertex ML Metadata

หากมีข้อเสนอแนะเกี่ยวกับ Vertex AI โปรดดูหน้าการสนับสนุน

เหตุใดไปป์ไลน์ ML จึงมีประโยชน์

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

สรุป: ไปป์ไลน์ช่วยให้คุณทำงานอัตโนมัติและทำซ้ำเวิร์กโฟลว์ ML ได้

3. การตั้งค่าสภาพแวดล้อมระบบคลาวด์

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

เริ่มต้น Cloud Shell

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

ให้สิทธิ์ Cloud Shell

เปิดใช้งาน Cloud Shell

จากด้านขวาบนของ Cloud Console ให้คลิกปุ่มด้านล่างเพื่อเปิดใช้งาน Cloud Shell

เปิดใช้งาน Cloud Shell

หากไม่เคยเริ่มใช้ Cloud Shell มาก่อน คุณจะเห็นหน้าจอระดับกลาง (ด้านล่าง) ที่อธิบายว่า Cloud Shell คืออะไร ในกรณีนี้ ให้คลิกต่อไป (และคุณจะไม่เห็นหน้าจอนี้อีก) หน้าจอแบบครั้งเดียวจะมีลักษณะดังนี้

การตั้งค่า Cloud Shell

การจัดสรรและเชื่อมต่อกับ Cloud Shell จะใช้เวลาไม่นาน

Cloud Shell init

เครื่องเสมือนนี้มีเครื่องมือพัฒนาซอฟต์แวร์ทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก คุณสามารถทำงานในโค้ดแล็บนี้ได้โดยใช้เพียงเบราว์เซอร์หรือ Chromebook

เมื่อเชื่อมต่อกับ Cloud Shell แล้ว คุณควรเห็นว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์ของคุณแล้ว

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว

gcloud auth list

เอาต์พุตของคำสั่ง

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ

gcloud config list project

เอาต์พุตของคำสั่ง

[core]
project = <PROJECT_ID>

หากไม่ได้ตั้งค่าไว้ คุณตั้งค่าได้ด้วยคำสั่งนี้

gcloud config set project <PROJECT_ID>

เอาต์พุตของคำสั่ง

Updated property [core/project].

Cloud Shell มีตัวแปรสภาพแวดล้อม 2-3 ตัว ซึ่งรวมถึง GOOGLE_CLOUD_PROJECT ซึ่งมีชื่อของโปรเจ็กต์ Cloud ปัจจุบัน เราจะใช้ข้อมูลนี้ในที่ต่างๆ ตลอดทั้งแล็บนี้ คุณดูได้โดยเรียกใช้คำสั่งต่อไปนี้

echo $GOOGLE_CLOUD_PROJECT

เปิดใช้ API

ในขั้นตอนต่อๆ ไป คุณจะเห็นว่าบริการเหล่านี้จำเป็นต้องใช้ที่ใด (และเพราะเหตุใด) แต่ตอนนี้ ให้เรียกใช้คำสั่งนี้เพื่อให้โปรเจ็กต์เข้าถึงบริการ Compute Engine, Container Registry และ Vertex AI

gcloud services enable compute.googleapis.com         \
                       containerregistry.googleapis.com  \
                       aiplatform.googleapis.com

ซึ่งควรจะแสดงข้อความว่าดำเนินการสำเร็จคล้ายกับข้อความนี้

Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.

สร้าง Bucket ของ Cloud Storage

หากต้องการเรียกใช้งานการฝึกใน Vertex AI เราจะต้องมีที่เก็บข้อมูล Bucket เพื่อจัดเก็บชิ้นงานของโมเดลที่บันทึกไว้ Bucket ต้องอยู่ในระดับภูมิภาค เราใช้ us-central ที่นี่ แต่คุณจะใช้ภูมิภาคอื่นก็ได้ (เพียงแค่แทนที่ในทั้งแล็บนี้) หากมีที่เก็บข้อมูลอยู่แล้ว ให้ข้ามขั้นตอนนี้

เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell เพื่อสร้าง Bucket

BUCKET_NAME=gs://$GOOGLE_CLOUD_PROJECT-bucket
gsutil mb -l us-central1 $BUCKET_NAME

จากนั้นเราจะให้สิทธิ์เข้าถึง Bucket นี้แก่บัญชีบริการของ Compute ซึ่งจะช่วยให้มั่นใจได้ว่า Vertex Pipelines มีสิทธิ์ที่จำเป็นในการเขียนไฟล์ลงใน Bucket นี้ เรียกใช้คำสั่งต่อไปนี้เพื่อเพิ่มสิทธิ์นี้

gcloud projects describe $GOOGLE_CLOUD_PROJECT > project-info.txt
PROJECT_NUM=$(cat project-info.txt | sed -nre 's:.*projectNumber\: (.*):\1:p')
SVC_ACCOUNT="${PROJECT_NUM//\'/}-compute@developer.gserviceaccount.com"
gcloud projects add-iam-policy-binding $GOOGLE_CLOUD_PROJECT --member serviceAccount:$SVC_ACCOUNT --role roles/storage.objectAdmin

สร้างอินสแตนซ์ Vertex AI Workbench

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

เมนู Vertex AI

จากนั้นภายใน Notebook ที่ผู้ใช้จัดการ ให้คลิก Notebook ใหม่

สร้าง Notebook ใหม่

จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.3 (พร้อม LTS) ที่ไม่มี GPU:

อินสแตนซ์ TFE

ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง

เปิด Notebook

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

เปิด Notebook

4. การตั้งค่า Vertex Pipelines

เราจะต้องติดตั้งไลบรารีเพิ่มเติมบางรายการเพื่อใช้ Vertex Pipelines ดังนี้

Kubeflow Pipelines: นี่คือ SDK ที่เราจะใช้สร้างไปป์ไลน์ Vertex Pipelines รองรับการเรียกใช้ไปป์ไลน์ที่สร้างด้วยทั้ง Kubeflow Pipelines หรือ TFX
Vertex AI SDK: SDK นี้จะเพิ่มประสิทธิภาพประสบการณ์การใช้งานสำหรับการเรียก Vertex AI API เราจะใช้ไฟล์นี้เพื่อเรียกใช้ไปป์ไลน์ใน Vertex AI

สร้าง Notebook Python และติดตั้งไลบรารี

ก่อนอื่น ให้สร้างสมุดบันทึกจากเมนู Launcher ในอินสแตนซ์ Notebook โดยเลือก Python 3 ดังนี้

สร้าง Notebook Python3

หากต้องการติดตั้งทั้ง 2 บริการที่เราจะใช้ในแล็บนี้ ให้ตั้งค่าสถานะผู้ใช้ในเซลล์ Notebook ก่อน

USER_FLAG = "--user"

จากนั้นเรียกใช้คำสั่งต่อไปนี้จาก Notebook

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0
!pip3 install {USER_FLAG} kfp==1.8.9

หลังจากติดตั้งแพ็กเกจเหล่านี้แล้ว คุณจะต้องรีสตาร์ทเคอร์เนล

import os

if not os.getenv("IS_TESTING"):
    # Automatically restart kernel after installs
    import IPython

    app = IPython.Application.instance()
    app.kernel.do_shutdown(True)

จากนั้นตรวจสอบว่าคุณได้ติดตั้ง KFP SDK เวอร์ชันอย่างถูกต้อง โดยควรมีค่า >=1.8 ดังนี้

!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"

จากนั้นยืนยันว่า SDK ของ Vertex AI เป็นเวอร์ชัน >= 1.6.2 โดยทำดังนี้

!pip list | grep aiplatform

ตั้งค่ารหัสโปรเจ็กต์และที่เก็บข้อมูล

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

หากไม่ทราบรหัสโปรเจ็กต์ คุณอาจดูได้โดยเรียกใช้คำสั่งต่อไปนี้

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)

หรือตั้งค่าได้ที่นี่

if PROJECT_ID == "" or PROJECT_ID is None:
    PROJECT_ID = "your-project-id"  # @param {type:"string"}

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

BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"

นำเข้าไลบรารี

เพิ่มข้อมูลต่อไปนี้เพื่อนำเข้าไลบรารีที่เราจะใช้ตลอดทั้งโค้ดแล็บนี้

import matplotlib.pyplot as plt
import pandas as pd

from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline, component, Artifact, Dataset, Input, Metrics, Model, Output, InputPath, OutputPath

from google.cloud import aiplatform

# We'll use this namespace for metadata querying
from google.cloud import aiplatform_v1

กำหนดค่าคงที่

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

PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"

PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT

หลังจากเรียกใช้โค้ดด้านบนแล้ว คุณควรเห็นไดเรกทอรีรากของไปป์ไลน์ที่พิมพ์ออกมา นี่คือตำแหน่ง Cloud Storage ที่จะเขียนอาร์ติแฟกต์จากไปป์ไลน์ โดยจะอยู่ในรูปแบบ gs://YOUR-BUCKET-NAME/pipeline_root/

5. การสร้างไปป์ไลน์ 3 ขั้นตอนด้วยคอมโพเนนต์ที่กำหนดเอง

ห้องทดลองนี้มุ่งเน้นที่การทำความเข้าใจข้อมูลเมตาจากการเรียกใช้ไปป์ไลน์ หากต้องการทำเช่นนั้น เราจะต้องมีไปป์ไลน์ที่จะเรียกใช้ใน Vertex Pipelines ซึ่งเป็นจุดเริ่มต้นของเรา ในที่นี้ เราจะกำหนดไปป์ไลน์ 3 ขั้นตอนด้วยคอมโพเนนต์ที่กำหนดเองต่อไปนี้

get_dataframe: ดึงข้อมูลจากตาราง BigQuery และแปลงเป็น Pandas DataFrame
train_sklearn_model: ใช้ Pandas DataFrame เพื่อฝึกและส่งออกโมเดล Scikit Learn พร้อมกับเมตริกบางอย่าง
deploy_model: นำโมเดล Scikit Learn ที่ส่งออกมาใช้งานกับปลายทางใน Vertex AI

ในไปป์ไลน์นี้ เราจะใช้ชุดข้อมูลถั่วแห้งของ UCI Machine Learning จาก KOKLU, M. และ OZKAN, I.A. (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques."In Computers and Electronics in Agriculture, 174, 105507. DOI

นี่คือชุดข้อมูลแบบตาราง และในไปป์ไลน์ เราจะใช้ชุดข้อมูลเพื่อฝึก ประเมิน และติดตั้งใช้งานโมเดล Scikit-learn ที่จัดประเภทถั่วเป็น 1 ใน 7 ประเภทตามลักษณะของถั่ว มาเริ่มเขียนโค้ดกันเลย

สร้างคอมโพเนนต์ที่อิงตามฟังก์ชัน Python

เมื่อใช้ KFP SDK เราจะสร้างคอมโพเนนต์ตามฟังก์ชัน Python ได้ เราจะใช้ข้อมูลดังกล่าวสำหรับคอมโพเนนต์ 3 รายการในไปป์ไลน์นี้

ดาวน์โหลดข้อมูล BigQuery และแปลงเป็น CSV

ก่อนอื่น เราจะสร้างคอมโพเนนต์ get_dataframe ดังนี้

@component(
    packages_to_install=["google-cloud-bigquery", "pandas", "pyarrow", "db-dtypes"],
    base_image="python:3.9",
    output_component_file="create_dataset.yaml"
)
def get_dataframe(
    bq_table: str,
    output_data_path: OutputPath("Dataset")
):
    from google.cloud import bigquery
    import pandas as pd
    import os

    project_number = os.environ["CLOUD_ML_PROJECT_ID"]
    bqclient = bigquery.Client(project=project_number)
    table = bigquery.TableReference.from_string(
        bq_table
    )
    rows = bqclient.list_rows(
        table
    )
    dataframe = rows.to_dataframe(
        create_bqstorage_client=True,
    )
    dataframe = dataframe.sample(frac=1, random_state=2)
    dataframe.to_csv(output_data_path)

มาดูรายละเอียดสิ่งที่เกิดขึ้นในคอมโพเนนต์นี้กัน

ตัวตกแต่ง @component จะคอมไพล์ฟังก์ชันนี้เป็นคอมโพเนนต์เมื่อไปป์ไลน์ทำงาน คุณจะใช้สิ่งนี้ทุกครั้งที่เขียนคอมโพเนนต์ที่กำหนดเอง
พารามิเตอร์ base_image จะระบุอิมเมจคอนเทนเนอร์ที่คอมโพเนนต์นี้จะใช้
คอมโพเนนต์นี้จะใช้ไลบรารี Python บางรายการ ซึ่งเราจะระบุผ่านพารามิเตอร์ packages_to_install
พารามิเตอร์ output_component_file เป็นพารามิเตอร์ที่ไม่บังคับ และระบุไฟล์ YAML ที่จะเขียนคอมโพเนนต์ที่คอมไพล์แล้ว หลังจากเรียกใช้เซลล์แล้ว คุณจะเห็นว่าระบบเขียนไฟล์ลงในอินสแตนซ์ Notebook หากต้องการแชร์คอมโพเนนต์นี้กับผู้อื่น คุณสามารถส่งไฟล์ YAML ที่สร้างขึ้นให้บุคคลดังกล่าวและให้โหลดไฟล์ด้วยคำสั่งต่อไปนี้

# This is optional, it shows how to load a component from a yaml file
# dataset_component = kfp.components.load_component_from_file('./create_dataset.yaml')

จากนั้นคอมโพเนนต์นี้จะใช้ไลบรารีไคลเอ็นต์ Python ของ BigQuery เพื่อดาวน์โหลดข้อมูลจาก BigQuery ลงใน Pandas DataFrame แล้วสร้างอาร์ติแฟกต์เอาต์พุตของข้อมูลนั้นเป็นไฟล์ CSV ระบบจะส่งค่านี้เป็นอินพุตไปยังคอมโพเนนต์ถัดไป

สร้างคอมโพเนนต์เพื่อฝึกโมเดล Scikit-learn

ในคอมโพเนนต์นี้ เราจะใช้ CSV ที่สร้างไว้ก่อนหน้านี้เพื่อฝึกโมเดลต้นไม้ตัดสินใจของ Scikit-learn คอมโพเนนต์นี้จะส่งออกโมเดล Scikit ที่ได้ พร้อมกับMetricsอาร์ติแฟกต์ที่มีความแม่นยำ เฟรมเวิร์ก และขนาดของชุดข้อมูลที่ใช้ฝึกโมเดล

@component(
    packages_to_install=["sklearn", "pandas", "joblib", "db-dtypes"],
    base_image="python:3.9",
    output_component_file="beans_model_component.yaml",
)
def sklearn_train(
    dataset: Input[Dataset],
    metrics: Output[Metrics],
    model: Output[Model]
):
    from sklearn.tree import DecisionTreeClassifier
    from sklearn.metrics import roc_curve
    from sklearn.model_selection import train_test_split
    from joblib import dump

    import pandas as pd
    df = pd.read_csv(dataset.path)
    labels = df.pop("Class").tolist()
    data = df.values.tolist()
    x_train, x_test, y_train, y_test = train_test_split(data, labels)

    skmodel = DecisionTreeClassifier()
    skmodel.fit(x_train,y_train)
    score = skmodel.score(x_test,y_test)
    print('accuracy is:',score)

    metrics.log_metric("accuracy",(score * 100.0))
    metrics.log_metric("framework", "Scikit Learn")
    metrics.log_metric("dataset_size", len(df))
    dump(skmodel, model.path + ".joblib")

กำหนดคอมโพเนนต์เพื่ออัปโหลดและติดตั้งใช้งานโมเดลใน Vertex AI

สุดท้าย คอมโพเนนต์สุดท้ายจะนำโมเดลที่ฝึกแล้วจากขั้นตอนก่อนหน้า อัปโหลดไปยัง Vertex AI และติดตั้งใช้งานไปยังปลายทาง

@component(
    packages_to_install=["google-cloud-aiplatform"],
    base_image="python:3.9",
    output_component_file="beans_deploy_component.yaml",
)
def deploy_model(
    model: Input[Model],
    project: str,
    region: str,
    vertex_endpoint: Output[Artifact],
    vertex_model: Output[Model]
):
    from google.cloud import aiplatform

    aiplatform.init(project=project, location=region)

    deployed_model = aiplatform.Model.upload(
        display_name="beans-model-pipeline",
        artifact_uri = model.uri.replace("model", ""),
        serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest"
    )
    endpoint = deployed_model.deploy(machine_type="n1-standard-4")

    # Save data to the output params
    vertex_endpoint.uri = endpoint.resource_name
    vertex_model.uri = deployed_model.resource_name

ในที่นี้เราใช้ Vertex AI SDK เพื่ออัปโหลดโมเดลโดยใช้คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าสำหรับการคาดการณ์ จากนั้นจะทำให้โมเดลใช้งานได้ในปลายทางและแสดง URI ของทั้งโมเดลและทรัพยากรปลายทาง ในภายหลังของ Codelab นี้ คุณจะได้ดูข้อมูลเพิ่มเติมเกี่ยวกับความหมายของการส่งคืนข้อมูลนี้เป็นอาร์ติแฟกต์

กำหนดและคอมไพล์ไปป์ไลน์

เมื่อกำหนดคอมโพเนนต์ทั้ง 3 แล้ว ขั้นตอนถัดไปคือการสร้างคำจำกัดความของไปป์ไลน์ ซึ่งอธิบายถึงวิธีที่อาร์ติแฟกต์อินพุตและเอาต์พุตไหลผ่านระหว่างขั้นตอนต่างๆ ดังนี้

@pipeline(
    # Default pipeline root. You can override it when submitting the pipeline.
    pipeline_root=PIPELINE_ROOT,
    # A name for the pipeline.
    name="mlmd-pipeline",
)
def pipeline(
    bq_table: str = "",
    output_data_path: str = "data.csv",
    project: str = PROJECT_ID,
    region: str = REGION
):
    dataset_task = get_dataframe(bq_table)

    model_task = sklearn_train(
        dataset_task.output
    )

    deploy_task = deploy_model(
        model=model_task.outputs["model"],
        project=project,
        region=region
    )

คำสั่งต่อไปนี้จะสร้างไฟล์ JSON ที่คุณจะใช้เพื่อเรียกใช้ไปป์ไลน์

compiler.Compiler().compile(
    pipeline_func=pipeline, package_path="mlmd_pipeline.json"
)

เริ่มการเรียกใช้ไปป์ไลน์ 2 รายการ

จากนั้นเราจะเริ่มเรียกใช้ไปป์ไลน์2 ครั้ง ก่อนอื่นเรามากำหนดการประทับเวลาที่จะใช้สำหรับรหัสงานของไปป์ไลน์กัน

from datetime import datetime

TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")

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

run1 = aiplatform.PipelineJob(
    display_name="mlmd-pipeline",
    template_path="mlmd_pipeline.json",
    job_id="mlmd-pipeline-small-{0}".format(TIMESTAMP),
    parameter_values={"bq_table": "sara-vertex-demos.beans_demo.small_dataset"},
    enable_caching=True,
)

จากนั้นสร้างการเรียกใช้ไปป์ไลน์อีกรายการโดยใช้ชุดข้อมูลเดียวกันในเวอร์ชันที่ใหญ่ขึ้น

run2 = aiplatform.PipelineJob(
    display_name="mlmd-pipeline",
    template_path="mlmd_pipeline.json",
    job_id="mlmd-pipeline-large-{0}".format(TIMESTAMP),
    parameter_values={"bq_table": "sara-vertex-demos.beans_demo.large_dataset"},
    enable_caching=True,
)

สุดท้าย ให้เริ่มการดำเนินการไปป์ไลน์สำหรับการเรียกใช้ทั้ง 2 รายการ วิธีที่ดีที่สุดคือการทำเช่นนี้ในเซลล์ Notebook 2 เซลล์แยกกันเพื่อให้คุณเห็นเอาต์พุตสำหรับการเรียกใช้แต่ละครั้ง

run1.submit()

จากนั้นเริ่มการทดสอบครั้งที่ 2 โดยใช้คำสั่งต่อไปนี้

run2.submit()

หลังจากเรียกใช้เซลล์นี้ คุณจะเห็นลิงก์เพื่อดูไปป์ไลน์แต่ละรายการในคอนโซล Vertex AI เปิดลิงก์ดังกล่าวเพื่อดูรายละเอียดเพิ่มเติมเกี่ยวกับไปป์ไลน์

URL ของการเรียกใช้ไปป์ไลน์

เมื่อการดำเนินการเสร็จสิ้น (ไปป์ไลน์นี้ใช้เวลาประมาณ 10-15 นาทีต่อการเรียกใช้) คุณจะเห็นผลลัพธ์คล้ายกับตัวอย่างต่อไปนี้

ไปป์ไลน์ sklearn ที่เสร็จสมบูรณ์

ตอนนี้คุณมีไปป์ไลน์ที่ทำงานเสร็จสมบูรณ์ 2 รายการแล้ว คุณจึงพร้อมที่จะดูอาร์ติแฟกต์ เมตริก และที่มาของไปป์ไลน์อย่างละเอียด

6. ทำความเข้าใจอาร์ติแฟกต์และที่มาของไปป์ไลน์

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

การคลิกอาร์ติแฟกต์จะแสดงรายละเอียดเพิ่มเติม รวมถึง URI ของอาร์ติแฟกต์ เช่น การคลิกอาร์ติแฟกต์ vertex_endpoint จะแสดง URI ที่คุณจะเห็นปลายทางที่ทําให้ใช้งานได้ในคอนโซล Vertex AI

รายละเอียดอาร์ติแฟกต์ของอุปกรณ์ปลายทาง

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

เมตริกโมเดล

อาร์ติแฟกต์ทุกรายการมีแหล่งที่มาซึ่งอธิบายอาร์ติแฟกต์อื่นๆ ที่เชื่อมต่ออยู่ คลิกอาร์ติแฟกต์ vertex_endpoint ของไปป์ไลน์อีกครั้ง แล้วคลิกปุ่มดูที่มา

แสดงที่มา

การดำเนินการนี้จะเปิดแท็บใหม่ที่คุณจะเห็นอาร์ติแฟกต์ทั้งหมดที่เชื่อมต่อกับอาร์ติแฟกต์ที่คุณเลือก กราฟแหล่งที่มาจะมีลักษณะดังนี้

กราฟแหล่งที่มาของปลายทาง

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

7. การเปรียบเทียบการเรียกใช้ไปป์ไลน์

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

การเปรียบเทียบการเรียกใช้ใน UI ของ Pipelines

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

เปรียบเทียบการทดสอบ

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

เมตริกการเปรียบเทียบ

คุณสามารถใช้ฟังก์ชันการทำงานของ UI นี้เพื่อเปรียบเทียบการเรียกใช้มากกว่า 2 รายการ และแม้แต่การเรียกใช้จากไปป์ไลน์ต่างๆ

การเปรียบเทียบการเรียกใช้ด้วย Vertex AI SDK

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

คุณใช้เมธอด aiplatform.get_pipeline_df() เพื่อเข้าถึงข้อมูลเมตาของการเรียกใช้ได้ ในที่นี้ เราจะรับข้อมูลเมตาสำหรับการเรียกใช้ 2 ครั้งล่าสุดของไปป์ไลน์เดียวกันและโหลดลงใน Pandas DataFrame พารามิเตอร์ pipeline ในที่นี้หมายถึงชื่อที่เราตั้งให้ไปป์ไลน์ในการกำหนดไปป์ไลน์

df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df

เมื่อพิมพ์ DataFrame คุณจะเห็นข้อมูลดังนี้

DataFrame ของเมตริกไปป์ไลน์

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

เรียกใช้คำสั่งต่อไปนี้ในเซลล์สมุดบันทึกใหม่

plt.plot(df["metric.dataset_size"], df["metric.accuracy"],label="Accuracy")
plt.title("Accuracy and dataset size")
plt.legend(loc=4)
plt.show()

คุณควรเห็นข้อความคล้ายกับข้อความต่อไปนี้

กราฟข้อมูลเมตาของ Matplotlib

8. การค้นหาเมตริกไปป์ไลน์

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

การรับอาร์ติแฟกต์ของโมเดลทั้งหมด

หากต้องการค้นหาอาร์ติแฟกต์ด้วยวิธีนี้ เราจะสร้างMetadataServiceClientดังนี้

API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
metadata_client = aiplatform_v1.MetadataServiceClient(
  client_options={
      "api_endpoint": API_ENDPOINT
  }
)

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

MODEL_FILTER="schema_title = \"system.Model\""
artifact_request = aiplatform_v1.ListArtifactsRequest(
    parent="projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
    filter=MODEL_FILTER
)
model_artifacts = metadata_client.list_artifacts(artifact_request)

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

การกรองออบเจ็กต์และการแสดงใน DataFrame

หากเราสามารถแสดงภาพการค้นหาอาร์ติแฟกต์ที่ได้ง่ายขึ้นก็จะดีมาก จากนั้น มาดูอาร์ติแฟกต์ทั้งหมดที่สร้างขึ้นหลังจากวันที่ 10 สิงหาคม 2021 ที่มีสถานะเป็น LIVE กัน หลังจากเรียกใช้คำขอนี้แล้ว เราจะแสดงผลลัพธ์ใน Pandas DataFrame ก่อนอื่น ให้ดำเนินการคำขอโดยใช้คำสั่งต่อไปนี้

LIVE_FILTER = "create_time > \"2021-08-10T00:00:00-00:00\" AND state = LIVE"
artifact_req = {
    "parent": "projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
    "filter": LIVE_FILTER
}
live_artifacts = metadata_client.list_artifacts(artifact_req)

จากนั้นแสดงผลลัพธ์ใน DataFrame

data = {'uri': [], 'createTime': [], 'type': []}

for i in live_artifacts:
    data['uri'].append(i.uri)
    data['createTime'].append(i.create_time)
    data['type'].append(i.schema_title)

df = pd.DataFrame.from_dict(data)
df

คุณจะเห็นข้อความคล้ายกับข้อความต่อไปนี้

DataFrame ของอาร์ติแฟกต์ที่กรองแล้ว

นอกจากนี้ คุณยังกรองอาร์ติแฟกต์ตามเกณฑ์อื่นๆ นอกเหนือจากที่ลองใช้ที่นี่ได้ด้วย

เพียงเท่านี้คุณก็ทำแล็บเสร็จแล้ว

🎉 ยินดีด้วย 🎉

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

ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่สร้างชุดข้อมูลใน Vertex AI รวมถึงฝึกและติดตั้งใช้งานโมเดล Scikit-learn ที่กำหนดเองในชุดข้อมูลนั้น
เขียนคอมโพเนนต์ไปป์ไลน์ที่กำหนดเองซึ่งสร้างอาร์ติแฟกต์และข้อมูลเมตา
เปรียบเทียบการเรียกใช้ Vertex Pipelines ทั้งใน Cloud Console และแบบเป็นโปรแกรม
ติดตามแหล่งที่มาของอาร์ติแฟกต์ที่สร้างขึ้นในไปป์ไลน์
ค้นหาข้อมูลเมตาของการเรียกใช้ไปป์ไลน์

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

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

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

หยุดหรือลบอินสแตนซ์ Notebooks

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

หยุดอินสแตนซ์

ลบปลายทาง Vertex AI

หากต้องการลบปลายทางที่คุณติดตั้งใช้งาน ให้ไปที่ส่วนปลายทางของคอนโซล Vertex AI แล้วคลิกไอคอนลบ

ลบปลายทาง

ลบที่เก็บข้อมูล Cloud Storage

หากต้องการลบ Storage Bucket ให้ใช้เมนูการนำทางใน Cloud Console โดยไปที่ Storage เลือก Bucket แล้วคลิกลบ

ลบพื้นที่เก็บข้อมูล