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

1. ภาพรวม

ในห้องทดลองนี้ คุณจะได้เรียนรู้วิธีสร้างและเรียกใช้ไปป์ไลน์ ML ด้วยไปป์ไลน์ Vertex

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

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

  • ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่รองรับการปรับขนาด
  • สร้างและเรียกใช้ไปป์ไลน์บทนำ 3 ขั้นตอนที่นำการป้อนข้อความ
  • สร้างและเรียกใช้ไปป์ไลน์ที่จะฝึก ประเมิน และทำให้โมเดลการจัดประเภท AutoML ใช้งานได้
  • ใช้คอมโพเนนต์ที่สร้างไว้ล่วงหน้าสำหรับการโต้ตอบกับบริการ Vertex AI ซึ่งจัดหาให้ผ่านไลบรารี google_cloud_pipeline_components
  • กำหนดเวลางานไปป์ไลน์ด้วย Cloud Scheduler

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

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

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

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

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

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

ทำไมไปป์ไลน์ ML ถึงมีประโยชน์

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

tl;dr: ไปป์ไลน์จะช่วยให้คุณทำให้เวิร์กโฟลว์ ML เป็นอัตโนมัติและจำลองเวิร์กโฟลว์ ML

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

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

ขั้นตอนที่ 1: เริ่มต้น 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 ซึ่งจะช่วยเพิ่มประสิทธิภาพของเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก งานส่วนใหญ่ใน Codelab นี้สามารถทำได้โดยใช้เบราว์เซอร์หรือ Chromebook เท่านั้น

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

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

gcloud auth list

คุณควรเห็นข้อมูลดังนี้ในเอาต์พุตคำสั่ง

เอาต์พุต Cloud Shell

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

gcloud config list project

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

[core]
project = <PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

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

Updated property [core/project].

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

echo $GOOGLE_CLOUD_PROJECT

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

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

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

ซึ่งจะสร้างข้อความที่ประสบผลสำเร็จที่คล้ายกับข้อความต่อไปนี้

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

ขั้นตอนที่ 3: สร้างที่เก็บข้อมูล Cloud Storage

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

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

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

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

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

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

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

เมนู Vertex AI

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

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

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

อินสแตนซ์ TFE

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

ขั้นตอนที่ 5: เปิดสมุดบันทึก

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

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

4. การตั้งค่าไปป์ไลน์ Vertex

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

  • ไปป์ไลน์ Kubernetes: นี่คือ SDK ที่เราจะใช้สร้างไปป์ไลน์ Vertex Pipelines รองรับการเรียกใช้ไปป์ไลน์ที่สร้างด้วย Kubeflow Pipelines หรือ TFX
  • คอมโพเนนต์ไปป์ไลน์ของ Google Cloud: ไลบรารีนี้มีคอมโพเนนต์ที่สร้างไว้ล่วงหน้าเพื่อช่วยให้โต้ตอบกับบริการ Vertex AI ได้ง่ายขึ้นจากขั้นตอนของไปป์ไลน์

ขั้นตอนที่ 1: สร้างสมุดบันทึก Python และติดตั้งไลบรารี

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

สร้างสมุดบันทึก Python3

คุณเข้าถึงเมนู Launcher ได้โดยคลิกเครื่องหมาย + ที่ด้านซ้ายบนของอินสแตนซ์สมุดบันทึก

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

USER_FLAG = "--user"

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

!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0 --upgrade
!pip3 install {USER_FLAG} kfp==1.8.9 google-cloud-pipeline-components==0.2.0

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

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__))"
!python3 -c "import google_cloud_pipeline_components; print('google_cloud_pipeline_components version: {}'.format(google_cloud_pipeline_components.__version__))"

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

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

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

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"

ขั้นตอนที่ 3: นำเข้าไลบรารี

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

import kfp

from kfp.v2 import compiler, dsl
from kfp.v2.dsl import component, pipeline, Artifact, ClassificationMetrics, Input, Output, Model, Metrics

from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
from typing import NamedTuple

ขั้นตอนที่ 4: ระบุค่าคงที่

สิ่งสุดท้ายที่เราต้องทำก่อนสร้างไปป์ไลน์คือการกำหนดตัวแปรคงที่ 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. การสร้างไปป์ไลน์แรก

เพื่อทำความคุ้นเคยกับวิธีการทำงานของไปป์ไลน์ Vertex ก่อนอื่นเราจะสร้างไปป์ไลน์สั้นๆ โดยใช้ KFP SDK ไปป์ไลน์นี้ไม่ได้ช่วยทำอะไรเกี่ยวกับ ML เลย (ไม่ต้องกังวล เราจะไปถึงที่นั่น!) เราใช้ไปป์ไลน์เพื่อสอนคุณ

  • วิธีสร้างคอมโพเนนต์ที่กำหนดเองใน KFP SDK
  • วิธีเรียกใช้และตรวจสอบไปป์ไลน์ใน Vertex Pipelines

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

  • product_name: คอมโพเนนต์นี้จะป้อนข้อมูลชื่อผลิตภัณฑ์ (หรือคำนามใดๆ ก็ตามที่คุณต้องการจริงๆ) และแสดงผลสตริงนั้นเป็นเอาต์พุต
  • emoji: คอมโพเนนต์นี้จะมีข้อความอธิบายของอีโมจิและแปลงเป็นอีโมจิ ตัวอย่างเช่น รหัสข้อความสำหรับ ✨ คือ "ประกาย" คอมโพเนนต์นี้ใช้ไลบรารีอีโมจิเพื่อแสดงวิธีจัดการทรัพยากร Dependency ภายนอกในไปป์ไลน์
  • build_sentence: คอมโพเนนต์สุดท้ายนี้จะใช้เอาต์พุตจาก 2 รายการก่อนหน้าเพื่อสร้างประโยคที่ใช้อีโมจิ เช่น ผลลัพธ์ที่ได้อาจเป็น "Vertex Pipelines คือ ✨"

มาเริ่มเขียนโค้ดกันเลย

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

การใช้ KFP SDK ช่วยให้เราสร้างคอมโพเนนต์ตามฟังก์ชัน Python ได้ เราจะใช้ข้อมูลดังกล่าวสําหรับ 3 คอมโพเนนต์ในไปป์ไลน์แรก ก่อนอื่นเราจะสร้างคอมโพเนนต์ product_name ซึ่งจะใช้สตริงเป็นอินพุตและแสดงผลสตริงนั้น เพิ่มข้อมูลต่อไปนี้ลงในสมุดบันทึก

@component(base_image="python:3.9", output_component_file="first-component.yaml")
def product_name(text: str) -> str:
    return text

มาดูรายละเอียดไวยากรณ์กันที่นี่

  • มัณฑนากร @component จะรวมฟังก์ชันนี้ไปยังคอมโพเนนต์เมื่อเรียกใช้ไปป์ไลน์ คุณจะใช้ค่านี้ทุกครั้งที่เขียนคอมโพเนนต์ที่กำหนดเอง
  • พารามิเตอร์ base_image ระบุอิมเมจคอนเทนเนอร์ที่คอมโพเนนต์นี้จะใช้
  • คุณจะใช้พารามิเตอร์ output_component_file หรือไม่ก็ได้ และระบุไฟล์ yaml ที่ใช้เขียนคอมโพเนนต์ที่คอมไพล์แล้ว หลังจากเรียกใช้เซลล์ คุณควรเห็นไฟล์นั้นเขียนอยู่บนอินสแตนซ์สมุดบันทึก หากคุณต้องการแชร์คอมโพเนนต์นี้กับผู้อื่น คุณสามารถส่งไฟล์ yaml ที่สร้างขึ้นให้กับบุคคลนั้นและให้โหลดโดยใช้ข้อมูลต่อไปนี้
product_name_component = kfp.components.load_component_from_file('./first-component.yaml')
  • -> str ที่อยู่หลังคำจำกัดความของฟังก์ชันจะระบุประเภทเอาต์พุตสำหรับคอมโพเนนต์นี้

ขั้นตอนที่ 2: สร้างคอมโพเนนต์เพิ่มเติม 2 รายการ

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

@component(packages_to_install=["emoji"])
def emoji(
    text: str,
) -> NamedTuple(
    "Outputs",
    [
        ("emoji_text", str),  # Return parameters
        ("emoji", str),
    ],
):
    import emoji

    emoji_text = text
    emoji_str = emoji.emojize(':' + emoji_text + ':', language='alias')
    print("output one: {}; output_two: {}".format(emoji_text, emoji_str))
    return (emoji_text, emoji_str)

คอมโพเนนต์นี้ซับซ้อนกว่าอย่างก่อนหน้านี้เล็กน้อย มาดูรายละเอียดกันว่ามีอะไรใหม่บ้าง

  • พารามิเตอร์ packages_to_install จะบอกคอมโพเนนต์ของไลบรารีภายนอกสำหรับคอนเทนเนอร์นี้ ในกรณีนี้ เราใช้ไลบรารีที่ชื่อว่าอีโมจิ
  • คอมโพเนนต์นี้แสดงผล NamedTuple ที่เรียกว่า Outputs โปรดสังเกตว่าแต่ละสตริงใน Tuple นี้มีคีย์: emoji_text และ emoji เราจะใช้ข้อมูลเหล่านี้ในคอมโพเนนต์ถัดไปเพื่อเข้าถึงเอาต์พุต

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

@component
def build_sentence(
    product: str,
    emoji: str,
    emojitext: str
) -> str:
    print("We completed the pipeline, hooray!")
    end_str = product + " is "
    if len(emoji) > 0:
        end_str += emoji
    else:
        end_str += emojitext
    return(end_str)

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

ขั้นตอนที่ 3: รวมคอมโพเนนต์เข้าด้วยกันเป็นไปป์ไลน์

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

เราจะกำหนดฟังก์ชัน intro_pipeline ในบล็อกโค้ดถัดไป นี่คือจุดที่เราระบุอินพุตของขั้นตอนเริ่มต้นในไปป์ไลน์ และวิธีที่ขั้นตอนต่างๆ เชื่อมต่อกัน

  • product_task จะป้อนชื่อผลิตภัณฑ์เป็นการป้อนข้อมูล เรากำลังส่ง "Vertex Pipelines" แต่คุณเปลี่ยนค่านี้ได้ตามต้องการ
  • emoji_task จะใช้โค้ดข้อความสำหรับอีโมจิเป็นอินพุต คุณยังสามารถเปลี่ยนค่านี้ได้ตามต้องการ เช่น "party_face" หมายถึงอีโมจิ 🥳 โปรดทราบว่าเนื่องจากทั้งส่วนนี้และคอมโพเนนต์ product_task ไม่มีขั้นตอนที่ป้อนอินพุตให้ เราจึงระบุอินพุตสำหรับคอมโพเนนต์เหล่านี้ด้วยตนเองเมื่อเรากำหนดไปป์ไลน์ของเรา
  • ขั้นตอนสุดท้ายในไปป์ไลน์ของเรา - consumer_task มีพารามิเตอร์อินพุต 3 ตัว ได้แก่
    • เอาต์พุตของ product_task เนื่องจากขั้นตอนนี้สร้างเพียง 1 เอาต์พุต เราจึงอ้างอิงผ่าน product_task.output ได้
    • ผลลัพธ์ emoji จากขั้นตอน emoji_task ของเรา ดูคอมโพเนนต์ emoji ที่กำหนดไว้ด้านบนตำแหน่งที่เราตั้งชื่อพารามิเตอร์เอาต์พุต
    • ในทํานองเดียวกัน เอาต์พุตที่มีชื่อ emoji_text จากคอมโพเนนต์ emoji ในกรณีที่ไปป์ไลน์เป็นข้อความที่ไม่สอดคล้องกับอีโมจิ ระบบจะใช้ข้อความนี้ในการสร้างประโยค
@pipeline(
    name="hello-world",
    description="An intro pipeline",
    pipeline_root=PIPELINE_ROOT,
)

# You can change the `text` and `emoji_str` parameters here to update the pipeline output
def intro_pipeline(text: str = "Vertex Pipelines", emoji_str: str = "sparkles"):
    product_task = product_name(text)
    emoji_task = emoji(emoji_str)
    consumer_task = build_sentence(
        product_task.output,
        emoji_task.outputs["emoji"],
        emoji_task.outputs["emoji_text"],
    )

ขั้นตอนที่ 4: คอมไพล์และเรียกใช้ไปป์ไลน์

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

compiler.Compiler().compile(
    pipeline_func=intro_pipeline, package_path="intro_pipeline_job.json"
)

ถัดไป ให้สร้างตัวแปร TIMESTAMP เราจะใช้รหัสนี้ในรหัสงาน

from datetime import datetime

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

จากนั้นกำหนดงานไปป์ไลน์ ดังนี้

job = aiplatform.PipelineJob(
    display_name="hello-world-pipeline",
    template_path="intro_pipeline_job.json",
    job_id="hello-world-pipeline-{0}".format(TIMESTAMP),
    enable_caching=True
)

สุดท้าย เรียกใช้งานเพื่อสร้างการดำเนินการไปป์ไลน์ใหม่ ดังนี้

job.submit()

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

บันทึกงานของไปป์ไลน์

ไปที่ลิงก์นั้น ไปป์ไลน์ควรมีลักษณะดังนี้เมื่อเสร็จสมบูรณ์แล้ว

ไปป์ไลน์บทนำเสร็จสมบูรณ์

ไปป์ไลน์นี้จะใช้เวลาทำงาน 5-6 นาที เมื่อดำเนินการเสร็จแล้ว คุณสามารถคลิกคอมโพเนนต์ build-sentence เพื่อดูผลลัพธ์สุดท้าย

เอาต์พุตของไปป์ไลน์บทนำ

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

6. การสร้างไปป์ไลน์ ML แบบต้นทางถึงปลายทาง

ได้เวลาสร้างไปป์ไลน์ ML แรกแล้ว ในไปป์ไลน์นี้ เราจะใช้ชุดข้อมูล Dry Beans ของแมชชีนเลิร์นนิง UCI จาก KOKLU, M. และ OZKAN, I.A, (2020), "Multiclass Classification of Dry Beans Using Computer Vision and Machine Learning Techniques."zippy Inในเมนูคอมพิวเตอร์และอิเล็กทรอนิกส์ในการเกษตร, 174, 105507. DOI

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

ไปป์ไลน์นี้จะทำสิ่งต่อไปนี้

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

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

ขั้นตอนที่ 1: คอมโพเนนต์ที่กำหนดเองสำหรับการประเมินโมเดล

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

  • รับเมตริกการประเมินจากโมเดลการจัดประเภท AutoML ที่ฝึก
  • แยกวิเคราะห์เมตริกและแสดงผลใน UI ไปป์ไลน์ Vertex
  • เปรียบเทียบเมตริกกับเกณฑ์เพื่อระบุว่าควรทำให้โมเดลใช้งานได้หรือไม่

ก่อนที่จะกำหนดคอมโพเนนต์ เรามาทำความเข้าใจพารามิเตอร์อินพุตและเอาต์พุตกันก่อน อินพุตนี้จะนำข้อมูลเมตาบางส่วนในโปรเจ็กต์ที่อยู่ในระบบคลาวด์, โมเดลที่ผ่านการฝึกที่ได้ (เราจะกำหนดคอมโพเนนต์นี้ในภายหลัง), เมตริกการประเมินของโมเดล และ thresholds_dict_str thresholds_dict_str คือสิ่งที่เราจะกำหนดเมื่อเรียกใช้ไปป์ไลน์ ในกรณีของโมเดลการจัดประเภทนี้ นี่จะเป็นพื้นที่ใต้ค่าเส้นโค้ง ROC ที่เราควรทำให้โมเดลใช้งานได้ ตัวอย่างเช่น หากเราส่ง 0.95 หมายความว่าเราต้องการให้ไปป์ไลน์ของเราทำให้โมเดลใช้งานได้ก็ต่อเมื่อเมตริกนี้สูงกว่า 95%

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

@component(
    base_image="gcr.io/deeplearning-platform-release/tf2-cpu.2-3:latest",
    output_component_file="tabular_eval_component.yaml",
    packages_to_install=["google-cloud-aiplatform"],
)
def classification_model_eval_metrics(
    project: str,
    location: str,  # "us-central1",
    api_endpoint: str,  # "us-central1-aiplatform.googleapis.com",
    thresholds_dict_str: str,
    model: Input[Artifact],
    metrics: Output[Metrics],
    metricsc: Output[ClassificationMetrics],
) -> NamedTuple("Outputs", [("dep_decision", str)]):  # Return parameter.

    import json
    import logging

    from google.cloud import aiplatform as aip

    # Fetch model eval info
    def get_eval_info(client, model_name):
        from google.protobuf.json_format import MessageToDict

        response = client.list_model_evaluations(parent=model_name)
        metrics_list = []
        metrics_string_list = []
        for evaluation in response:
            print("model_evaluation")
            print(" name:", evaluation.name)
            print(" metrics_schema_uri:", evaluation.metrics_schema_uri)
            metrics = MessageToDict(evaluation._pb.metrics)
            for metric in metrics.keys():
                logging.info("metric: %s, value: %s", metric, metrics[metric])
            metrics_str = json.dumps(metrics)
            metrics_list.append(metrics)
            metrics_string_list.append(metrics_str)

        return (
            evaluation.name,
            metrics_list,
            metrics_string_list,
        )

    # Use the given metrics threshold(s) to determine whether the model is
    # accurate enough to deploy.
    def classification_thresholds_check(metrics_dict, thresholds_dict):
        for k, v in thresholds_dict.items():
            logging.info("k {}, v {}".format(k, v))
            if k in ["auRoc", "auPrc"]:  # higher is better
                if metrics_dict[k] < v:  # if under threshold, don't deploy
                    logging.info("{} < {}; returning False".format(metrics_dict[k], v))
                    return False
        logging.info("threshold checks passed.")
        return True

    def log_metrics(metrics_list, metricsc):
        test_confusion_matrix = metrics_list[0]["confusionMatrix"]
        logging.info("rows: %s", test_confusion_matrix["rows"])

        # log the ROC curve
        fpr = []
        tpr = []
        thresholds = []
        for item in metrics_list[0]["confidenceMetrics"]:
            fpr.append(item.get("falsePositiveRate", 0.0))
            tpr.append(item.get("recall", 0.0))
            thresholds.append(item.get("confidenceThreshold", 0.0))
        print(f"fpr: {fpr}")
        print(f"tpr: {tpr}")
        print(f"thresholds: {thresholds}")
        metricsc.log_roc_curve(fpr, tpr, thresholds)

        # log the confusion matrix
        annotations = []
        for item in test_confusion_matrix["annotationSpecs"]:
            annotations.append(item["displayName"])
        logging.info("confusion matrix annotations: %s", annotations)
        metricsc.log_confusion_matrix(
            annotations,
            test_confusion_matrix["rows"],
        )

        # log textual metrics info as well
        for metric in metrics_list[0].keys():
            if metric != "confidenceMetrics":
                val_string = json.dumps(metrics_list[0][metric])
                metrics.log_metric(metric, val_string)
        # metrics.metadata["model_type"] = "AutoML Tabular classification"

    logging.getLogger().setLevel(logging.INFO)
    aip.init(project=project)
    # extract the model resource name from the input Model Artifact
    model_resource_path = model.metadata["resourceName"]
    logging.info("model path: %s", model_resource_path)

    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    client = aip.gapic.ModelServiceClient(client_options=client_options)
    eval_name, metrics_list, metrics_str_list = get_eval_info(
        client, model_resource_path
    )
    logging.info("got evaluation name: %s", eval_name)
    logging.info("got metrics list: %s", metrics_list)
    log_metrics(metrics_list, metricsc)

    thresholds_dict = json.loads(thresholds_dict_str)
    deploy = classification_thresholds_check(metrics_list[0], thresholds_dict)
    if deploy:
        dep_decision = "true"
    else:
        dep_decision = "false"
    logging.info("deployment decision is %s", dep_decision)

    return (dep_decision,)

ขั้นตอนที่ 2: การเพิ่มคอมโพเนนต์สำเร็จรูปของ Google Cloud

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

import time
DISPLAY_NAME = 'automl-beans{}'.format(str(int(time.time())))
print(DISPLAY_NAME)

จากนั้นคัดลอกข้อมูลต่อไปนี้ลงในเซลล์ใหม่ในสมุดบันทึก

@pipeline(name="automl-tab-beans-training-v2",
                  pipeline_root=PIPELINE_ROOT)
def pipeline(
    bq_source: str = "bq://aju-dev-demos.beans.beans1",
    display_name: str = DISPLAY_NAME,
    project: str = PROJECT_ID,
    gcp_region: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    thresholds_dict_str: str = '{"auRoc": 0.95}',
):
    dataset_create_op = gcc_aip.TabularDatasetCreateOp(
        project=project, display_name=display_name, bq_source=bq_source
    )

    training_op = gcc_aip.AutoMLTabularTrainingJobRunOp(
        project=project,
        display_name=display_name,
        optimization_prediction_type="classification",
        budget_milli_node_hours=1000,
        column_transformations=[
            {"numeric": {"column_name": "Area"}},
            {"numeric": {"column_name": "Perimeter"}},
            {"numeric": {"column_name": "MajorAxisLength"}},
            {"numeric": {"column_name": "MinorAxisLength"}},
            {"numeric": {"column_name": "AspectRation"}},
            {"numeric": {"column_name": "Eccentricity"}},
            {"numeric": {"column_name": "ConvexArea"}},
            {"numeric": {"column_name": "EquivDiameter"}},
            {"numeric": {"column_name": "Extent"}},
            {"numeric": {"column_name": "Solidity"}},
            {"numeric": {"column_name": "roundness"}},
            {"numeric": {"column_name": "Compactness"}},
            {"numeric": {"column_name": "ShapeFactor1"}},
            {"numeric": {"column_name": "ShapeFactor2"}},
            {"numeric": {"column_name": "ShapeFactor3"}},
            {"numeric": {"column_name": "ShapeFactor4"}},
            {"categorical": {"column_name": "Class"}},
        ],
        dataset=dataset_create_op.outputs["dataset"],
        target_column="Class",
    )
    model_eval_task = classification_model_eval_metrics(
        project,
        gcp_region,
        api_endpoint,
        thresholds_dict_str,
        training_op.outputs["model"],
    )

    with dsl.Condition(
        model_eval_task.outputs["dep_decision"] == "true",
        name="deploy_decision",
    ):

        endpoint_op = gcc_aip.EndpointCreateOp(
            project=project,
            location=gcp_region,
            display_name="train-automl-beans",
        )

        gcc_aip.ModelDeployOp(
            model=training_op.outputs["model"],
            endpoint=endpoint_op.outputs["endpoint"],
            dedicated_resources_min_replica_count=1,
            dedicated_resources_max_replica_count=1,
            dedicated_resources_machine_type="n1-standard-4",
        )

ดูว่าเกิดอะไรขึ้นในโค้ดนี้

  • อันดับแรก เรากำหนดพารามิเตอร์อินพุตที่ไปป์ไลน์นี้ใช้ เช่นเดียวกับในไปป์ไลน์ก่อนหน้านี้ เราจำเป็นต้องตั้งค่ารายการเหล่านี้ด้วยตนเองเนื่องจากไม่ได้ขึ้นอยู่กับเอาต์พุตของขั้นตอนอื่นๆ ในไปป์ไลน์
  • ไปป์ไลน์ที่เหลือจะใช้คอมโพเนนต์ที่สร้างไว้ล่วงหน้า 2-3 รายการที่โต้ตอบกับบริการ Vertex AI ดังนี้
    • TabularDatasetCreateOp สร้างชุดข้อมูลแบบตารางใน Vertex AI ที่ระบุแหล่งที่มาของชุดข้อมูลใน Cloud Storage หรือ BigQuery ในไปป์ไลน์นี้ เราจะส่งข้อมูลผ่าน URL ของตาราง BigQuery
    • AutoMLTabularTrainingJobRunOp เริ่มต้นงานการฝึก AutoML สำหรับชุดข้อมูลแบบตาราง เราส่งพารามิเตอร์การกำหนดค่า 2-3 รายการไปยังคอมโพเนนต์นี้ ซึ่งรวมถึงประเภทโมเดล (ในกรณีนี้คือการจัดประเภท) ข้อมูลบางส่วนในคอลัมน์ ระยะเวลาที่เราต้องการเรียกใช้การฝึก และตัวชี้ไปยังชุดข้อมูล โปรดทราบว่าในการส่งผ่านชุดข้อมูลไปยังคอมโพเนนต์นี้ เรากำลังจะให้เอาต์พุตของคอมโพเนนต์ก่อนหน้าผ่านทาง dataset_create_op.outputs["dataset"]
    • EndpointCreateOp สร้างปลายทางใน Vertex AI ระบบจะส่งปลายทางที่สร้างขึ้นจากขั้นตอนนี้เป็นอินพุตไปยังคอมโพเนนต์ถัดไป
    • ModelDeployOp ทำให้โมเดลที่ระบุใช้งานได้กับปลายทางใน Vertex AI ในกรณีนี้เราใช้ปลายทางที่สร้างขึ้นจากขั้นตอนก่อนหน้า ทั้งนี้จะมีตัวเลือกการกำหนดค่าเพิ่มเติมให้ใช้งาน แต่ในที่นี้เราจะระบุประเภทและโมเดลเครื่องปลายทางที่ต้องการนำไปใช้ด้วย เรากำลังส่งผ่านโมเดลด้วยการเข้าถึงเอาต์พุตของขั้นตอนการฝึกในไปป์ไลน์ของเรา
  • ไปป์ไลน์นี้ยังใช้ประโยชน์จากตรรกะตามเงื่อนไข ซึ่งเป็นฟีเจอร์ของไปป์ไลน์ Vertex ที่ให้คุณกำหนดเงื่อนไขพร้อมกับสาขาต่างๆ โดยอิงตามผลลัพธ์ของเงื่อนไขนั้นได้ด้วย อย่าลืมว่าเมื่อเรากำหนดไปป์ไลน์แล้ว เราจะส่งผ่านพารามิเตอร์ thresholds_dict_str นี่คือเกณฑ์ความแม่นยำที่เราใช้เพื่อตัดสินใจว่าจะทำให้โมเดลของเราใช้งานได้ที่ปลายทางหรือไม่ โดยเราจะใช้คลาส Condition จาก KFP SDK เพื่อนำมาใช้ เงื่อนไขที่เราส่งคือเอาต์พุตของคอมโพเนนต์การประเมินที่กำหนดเองซึ่งเรากำหนดไว้ก่อนหน้านี้ใน Codelab นี้ หากเงื่อนไขนี้เป็นจริง ไปป์ไลน์จะดำเนินการกับคอมโพเนนต์ deploy_op ต่อไป หากความแม่นยำไม่ถึงเกณฑ์ที่กำหนดไว้ล่วงหน้า ไปป์ไลน์จะหยุดที่นี่และจะไม่ทำให้โมเดลใช้งานได้

ขั้นตอนที่ 3: คอมไพล์และเรียกใช้ไปป์ไลน์ ML แบบต้นทางถึงปลายทาง

เมื่อกำหนดไปป์ไลน์ทั้งหมดแล้ว ก็ถึงเวลารวบรวมข้อมูล

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

จากนั้น ให้นิยามงานดังนี้

ml_pipeline_job = aiplatform.PipelineJob(
    display_name="automl-tab-beans-training",
    template_path="tab_classif_pipeline.json",
    pipeline_root=PIPELINE_ROOT,
    parameter_values={"project": PROJECT_ID, "display_name": DISPLAY_NAME},
    enable_caching=True
)

และสุดท้าย เรียกใช้งาน:

ml_pipeline_job.submit()

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

ไปป์ไลน์ AutoML ที่เสร็จสมบูรณ์แล้ว

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

ชุดข้อมูลไปป์ไลน์

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

การแสดงภาพเมตริก

หากต้องการดูโมเดลและปลายทางที่สร้างจากการเรียกใช้ไปป์ไลน์นี้ ให้ไปที่ส่วนโมเดล แล้วคลิกโมเดลที่ชื่อ automl-beans คุณควรเห็นการทำให้โมเดลนี้ใช้งานได้ที่ปลายทาง

จุดสิ้นสุดของโมเดล

นอกจากนี้ คุณยังเข้าถึงหน้านี้ได้โดยคลิกที่อาร์ติแฟกต์ปลายทางในกราฟไปป์ไลน์

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

ดูตระกูล

หน้านี้จะแสดงตำแหน่งทั้งหมดที่ใช้อาร์ติแฟกต์นี้

รายละเอียดของรายการ

ขั้นตอนที่ 4: การเปรียบเทียบเมตริกในการเรียกใช้ไปป์ไลน์

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

pipeline_df = aiplatform.get_pipeline_df(pipeline="automl-tab-beans-training-v2")
small_pipeline_df = pipeline_df.head(2)
small_pipeline_df

เพียงเท่านี้คุณก็ใช้ห้องทดลองเสร็จแล้ว

🎉 ยินดีด้วย 🎉

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

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

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

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

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

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

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

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

ขั้นตอนที่ 2: ลบปลายทาง

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

ลบปลายทาง

จากนั้นคลิกยกเลิกการทำให้ใช้งานได้จากข้อความแจ้งต่อไปนี้

ยกเลิกการทำให้โมเดลใช้งานได้

สุดท้าย ให้ไปที่ส่วนรุ่นของคอนโซล ค้นหาโมเดลนั้น และจากเมนู 3 จุดทางด้านขวา ให้คลิกลบโมเดล

ลบโมเดล

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

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

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