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

1. ภาพรวม

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

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

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

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

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

หากต้องการเรียกใช้งานการฝึกใน Vertex AI เราจะต้องมีที่เก็บข้อมูลเพื่อจัดเก็บชิ้นงานของโมเดลที่บันทึกไว้ 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

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

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

เมนู Vertex AI

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

สร้าง Notebook ใหม่

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

อินสแตนซ์ TFE

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

ขั้นตอนที่ 5: เปิด Notebook

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

เปิด Notebook

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

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

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

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

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

สร้าง Notebook Python3

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

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

USER_FLAG = "--user"

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

!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"}

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

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

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

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

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

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

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

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

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

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

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

@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 จะบอกคอมโพเนนต์ถึงทรัพยากร Dependency ของไลบรารีภายนอกสำหรับคอนเทนเนอร์นี้ ในกรณีนี้ เราจะใช้ไลบรารีที่ชื่อ emoji
  • คอมโพเนนต์นี้จะแสดงผล NamedTuple ที่ชื่อ Outputs โปรดสังเกตว่าสตริงแต่ละรายการในทูเพิลนี้มีคีย์ 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: นำคอมโพเนนต์ต่างๆ มารวมกันเป็นไปป์ไลน์

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

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

  • product_task รับชื่อสินค้าเป็นอินพุต ในที่นี้เราส่ง "Vertex Pipelines" แต่คุณสามารถเปลี่ยนเป็นอะไรก็ได้ตามต้องการ
  • emoji_task รับรหัสข้อความสำหรับอีโมจิเป็นอินพุต นอกจากนี้ คุณยังเปลี่ยนเป็นอะไรก็ได้ตามต้องการ เช่น "party_face" หมายถึงอีโมจิ 🥳 โปรดทราบว่าเนื่องจากทั้งคอมโพเนนต์นี้และคอมโพเนนต์ product_task ไม่มีขั้นตอนที่ป้อนข้อมูลลงในคอมโพเนนต์ เราจึงต้องระบุอินพุตสำหรับคอมโพเนนต์เหล่านี้ด้วยตนเองเมื่อกำหนดไปป์ไลน์
  • ขั้นตอนสุดท้ายในไปป์ไลน์ของเรา - consumer_task มีพารามิเตอร์อินพุต 3 รายการ ได้แก่
    • เอาต์พุตของ product_task เนื่องจากขั้นตอนนี้สร้างเอาต์พุตเพียงรายการเดียว เราจึงอ้างอิงได้ผ่าน 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 แรกแล้ว ในไปป์ไลน์นี้ เราจะใช้ชุดข้อมูลถั่วแห้งของ 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

นี่คือชุดข้อมูลแบบตาราง และในไปป์ไลน์ เราจะใช้ชุดข้อมูลเพื่อฝึก ประเมิน และทำให้ใช้งานได้โมเดล 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%

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

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

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

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

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

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

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

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

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

ขั้นตอนที่ 2: ลบอุปกรณ์ปลายทาง

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

ลบปลายทาง

จากนั้นคลิกเลิกใช้งานจากข้อความแจ้งต่อไปนี้

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

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

ลบโมเดล

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

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

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