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

1. ภาพรวม

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

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

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

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

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

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

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

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

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

ห้องทดลองนี้มุ่งเน้นที่ Vertex Pipelines และ Vertex ML Metadata

หากมีความคิดเห็นเกี่ยวกับ Vertex AI โปรดดูหน้าการสนับสนุน

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

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

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

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

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

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

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.

สร้างที่เก็บข้อมูล Cloud Storage

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

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

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

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

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

จากตรงนั้น ให้คลิกโน้ตบุ๊กใหม่ภายในโน้ตบุ๊กที่จัดการโดยผู้ใช้

สร้างสมุดบันทึกใหม่

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

อินสแตนซ์ TFE

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

เปิดสมุดบันทึก

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

เปิดสมุดบันทึก

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

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

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

สร้างโน้ตบุ๊ก Python และติดตั้งไลบรารี

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

สร้างโน้ตบุ๊ก Python3

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

USER_FLAG = "--user"

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

!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__))"

จากนั้นตรวจสอบว่า Vertex AI SDK เป็นเวอร์ชัน >= 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"}

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

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

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

เพิ่มข้อมูลต่อไปนี้เพื่อนำเข้าไลบรารีที่เราจะใช้ใน Codelab นี้

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. and 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 2-3 รายการที่เราระบุผ่านพารามิเตอร์ packages_to_install
  • พารามิเตอร์ output_component_file ไม่บังคับ และระบุไฟล์ yaml เพื่อเขียนคอมโพเนนต์ที่คอมไพล์แล้ว หลังจากเรียกใช้เซลล์แล้ว คุณควรเห็นไฟล์นั้นเขียนลงในอินสแตนซ์โน้ตบุ๊ก หากต้องการแชร์คําสั่งนี้กับผู้อื่น คุณสามารถส่งไฟล์ 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 ของทั้งทรัพยากรโมเดลและปลายทาง ในโค้ดแล็บนี้ คุณจะได้ดูข้อมูลเพิ่มเติมเกี่ยวกับความหมายของการแสดงผลข้อมูลนี้ในรูปแบบอาร์ติแฟกต์

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

เมื่อกําหนดคอมโพเนนต์ 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")

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

run1.submit()

จากนั้นเริ่มการเรียกใช้ครั้งที่ 2 โดยทำดังนี้

run2.submit()

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

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

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

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

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

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

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

ขยายอาร์ติแฟกต์

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

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

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

เมตริกโมเดล

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

แสดงลำดับชั้น

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

กราฟลำดับชั้นของปลายทาง

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

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

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

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

ใน 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 ไปยังปลายทางนั้นและส่งตัวกรองที่ระบุรายการต่างๆ ที่เราต้องการในคําตอบ ก่อนอื่น ให้ดูอาร์ติแฟกต์ทั้งหมดในโปรเจ็กต์ที่เป็นโมเดล โดยให้เรียกใช้โค้ดต่อไปนี้ในสมุดบันทึก

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

คุณจะเห็นบางอย่างในลักษณะนี้

เฟรมข้อมูลของอาร์ติแฟกต์ที่กรอง

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

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

🎉 ยินดีด้วย 🎉

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

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

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

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

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

หยุดหรือลบอินสแตนซ์โน้ตบุ๊ก

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

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

ลบปลายทาง Vertex AI

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

ลบปลายทาง

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

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

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