ข้อมูลเบื้องต้นเกี่ยวกับ 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 (จุดสนใจของห้องทดลองนี้), Model Monitoring, Feature Store และอื่นๆ คุณดูข้อเสนอผลิตภัณฑ์ Vertex AI ทั้งหมดได้ในแผนภาพด้านล่าง

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

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

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

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

Cloud Shell init

เครื่องเสมือนนี้เต็มไปด้วยเครื่องมือการพัฒนาทั้งหมดที่คุณต้องการ ซึ่งจะมีไดเรกทอรีหลักขนาด 5 GB ถาวรและทำงานใน Google Cloud ซึ่งจะช่วยเพิ่มประสิทธิภาพเครือข่ายและการรับรองได้อย่างมีประสิทธิภาพ คุณทํางานส่วนใหญ่ในโค้ดแล็บนี้ได้โดยใช้เพียงเบราว์เซอร์หรือ 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 มีตัวแปรสภาพแวดล้อม 2-3 รายการ ซึ่งรวมถึง GOOGLE_CLOUD_PROJECT ที่มีชื่อโปรเจ็กต์ที่อยู่ในระบบคลาวด์ปัจจุบัน เราจะใช้คำนี้ในหลายๆ ที่ตลอดทั้งบทแนะนำนี้ คุณดูได้โดยเรียกใช้

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 ที่นี่ แต่คุณใช้ภูมิภาคอื่นได้ (เพียงแค่แทนที่ 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

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

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

เมนู Vertex AI

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

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

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

อินสแตนซ์ TFE

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

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

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

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

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

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

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

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

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

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

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

หากต้องการติดตั้งทั้ง 2 บริการที่เราจะใช้ในแล็บนี้ ให้ตั้งค่า Flag ผู้ใช้ในเซลล์โน้ตบุ๊กก่อน โดยทำดังนี้

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: ตั้งค่ารหัสโปรเจ็กต์และที่เก็บข้อมูล

ตลอดทั้งห้องทดลองนี้ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ 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"

ขั้นตอนที่ 3: นําเข้าคลัง

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

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 Pipelines เราจะสร้างไปป์ไลน์สั้นๆ โดยใช้ KFP SDK ก่อน ไปป์ไลน์นี้ไม่ได้ทําอะไรที่เกี่ยวกับ ML (ไม่ต้องกังวล เราจะอธิบายให้ฟัง) เราใช้ไปป์ไลน์นี้เพื่อสอนคุณเกี่ยวกับสิ่งต่อไปนี้

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

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

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

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

ขั้นตอนที่ 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 จะบอกคอมโพเนนต์เกี่ยวกับไลบรารีภายนอกที่ต้องนำมาใช้กับคอนเทนเนอร์นี้ ในกรณีนี้ เราใช้ไลบรารีชื่อ emoji
  • คอมโพเนนต์นี้แสดงผล 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 Pipeline แล้ว คุณก็พร้อมสร้างไปป์ไลน์ที่สร้างและนำโมเดล ML ไปใช้งานโดยใช้บริการอื่นๆ ของ Vertex AI มาเริ่มกันเลย

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

ได้เวลาสร้างไปป์ไลน์ ML แรกแล้ว ในไปป์ไลน์นี้ เราจะใช้ชุดข้อมูลถั่วแห้งของ 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

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

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

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

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

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

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

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

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

Model-endpoint

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

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

ดูลำดับวงศ์ตระกูล

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

รายละเอียดสายการผลิต

ขั้นตอนที่ 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 เพื่อไปที่พื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ

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