1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้ดูวิธีวิเคราะห์ข้อมูลเมตาจากไปป์ไลน์ Vertex ที่ทํางานร่วมกับข้อมูลเมตา Vertex ML
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่สร้างชุดข้อมูลใน Vertex AI รวมถึงฝึกและทำให้โมเดล Scikit-learn ที่กำหนดเองใช้งานได้บนชุดข้อมูลนั้น
- เขียนคอมโพเนนต์ไปป์ไลน์แบบกำหนดเองที่สร้างอาร์ติแฟกต์และข้อมูลเมตา
- เปรียบเทียบการเรียกใช้ Vertex Pipelines ทั้งในคอนโซลระบบคลาวด์และแบบเป็นโปรแกรม
- ย้อนรอยสายสกุลของอาร์ติแฟกต์ที่ไปป์ไลน์สร้างขึ้น
- ค้นหาข้อมูลเมตาการเรียกใช้ไปป์ไลน์
ค่าใช้จ่ายรวมในการเรียกใช้ห้องทดลองนี้บน Google Cloud อยู่ที่ประมาณ $2
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
ห้องทดลองนี้ใช้ข้อเสนอผลิตภัณฑ์ AI ใหม่ล่าสุดที่มีให้บริการใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น ก่อนหน้านี้โมเดลที่ฝึกด้วย AutoML และโมเดลที่กำหนดเองจะเข้าถึงได้ผ่านบริการแยกต่างหาก ข้อเสนอใหม่จะรวมทั้ง 2 อย่างไว้ใน API เดียว รวมทั้งผลิตภัณฑ์ใหม่อื่นๆ นอกจากนี้ คุณยังย้ายข้อมูลโปรเจ็กต์ที่มีอยู่ไปยัง Vertex AI ได้ด้วย
นอกจากการฝึกโมเดลและบริการการติดตั้งใช้งานแล้ว Vertex AI ยังมีผลิตภัณฑ์ MLOps ต่างๆ เช่น Vertex Pipelines, ข้อมูลเมตาของ ML, การตรวจสอบโมเดล, Feature Store และอื่นๆ อีกมากมาย คุณดูข้อเสนอผลิตภัณฑ์ Vertex AI ทั้งหมดได้ในแผนภาพด้านล่าง
ห้องทดลองนี้มุ่งเน้นที่ไปป์ไลน์ Vertex และข้อมูลเมตา Vertex ML
หากมีความคิดเห็นเกี่ยวกับ Vertex AI โปรดดูหน้าการสนับสนุน
ทำไมไปป์ไลน์ ML ถึงมีประโยชน์
ก่อนที่จะเจาะลึกรายละเอียด เรามาทำความเข้าใจว่าทำไมคุณต้องการใช้ไปป์ไลน์ ลองจินตนาการว่าคุณกำลังสร้างเวิร์กโฟลว์ ML ที่มีการประมวลผลข้อมูล การฝึกโมเดล การปรับแต่งไฮเปอร์พารามิเตอร์ การประเมิน และการทำให้โมเดลใช้งานได้ แต่ละขั้นตอนเหล่านี้อาจมีทรัพยากร Dependency ที่แตกต่างกัน ซึ่งอาจใช้งานยากหากคุณมองว่าเวิร์กโฟลว์ทั้งหมดเป็นโมโนลิธ เมื่อเริ่มปรับขนาดกระบวนการ ML คุณอาจต้องการแชร์เวิร์กโฟลว์ ML กับคนอื่นๆ ในทีมเพื่อให้พวกเขาเรียกใช้และมีส่วนร่วมในโค้ดได้ หากไม่มีขั้นตอนที่เชื่อถือได้และทำซ้ำได้ ก็อาจกลายเป็นเรื่องยุ่งยากได้ เมื่อใช้ไปป์ไลน์ แต่ละขั้นตอนในกระบวนการ ML จะเป็นคอนเทนเนอร์ของตัวเอง ซึ่งจะช่วยให้คุณพัฒนาขั้นตอนต่างๆ ได้อย่างอิสระและติดตามอินพุตและเอาต์พุตจากแต่ละขั้นตอนในลักษณะที่ทำให้เกิดซ้ำได้ นอกจากนี้ คุณยังกำหนดเวลาหรือทริกเกอร์การเรียกใช้ไปป์ไลน์โดยอิงตามเหตุการณ์อื่นๆ ในสภาพแวดล้อมระบบคลาวด์ได้ด้วย เช่น การเริ่มต้นเรียกใช้ไปป์ไลน์เมื่อมีข้อมูลการฝึกใหม่
tl;dr: ไปป์ไลน์จะช่วยให้คุณทำให้เวิร์กโฟลว์ ML เป็นอัตโนมัติและจำลองเวิร์กโฟลว์ ML
3. การตั้งค่าสภาพแวดล้อมระบบคลาวด์
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
เริ่มต้น Cloud Shell
ในห้องทดลองนี้ คุณจะได้ทำงานในเซสชัน Cloud Shell ซึ่งเป็นล่ามคำสั่งที่เครื่องเสมือนทำงานในระบบคลาวด์ของ Google คุณสามารถเรียกใช้ส่วนนี้ในคอมพิวเตอร์ของคุณเองได้ง่ายๆ แต่การใช้ Cloud Shell จะทำให้ทุกคนเข้าถึงประสบการณ์ที่ทำซ้ำได้ในสภาพแวดล้อมที่สอดคล้องกัน หลังจากการทดลองแล้ว คุณสามารถลองดำเนินการในส่วนนี้อีกครั้งในคอมพิวเตอร์ของคุณเอง
เปิดใช้งาน Cloud Shell
จากด้านขวาบนของ Cloud Console ให้คลิกปุ่มด้านล่างเพื่อเปิดใช้งาน Cloud Shell
หากคุณไม่เคยเริ่มต้นใช้งาน Cloud Shell มาก่อน คุณจะเห็นหน้าจอตรงกลาง (ครึ่งหน้าล่าง) ซึ่งอธิบายว่านี่คืออะไร หากเป็นเช่นนั้น ให้คลิกดำเนินการต่อ (คุณจะไม่เห็นการดำเนินการนี้อีก) หน้าจอแบบครั้งเดียวมีลักษณะดังนี้
การจัดสรรและเชื่อมต่อกับ Cloud Shell ใช้เวลาเพียงไม่กี่นาที
เครื่องเสมือนนี้เต็มไปด้วยเครื่องมือการพัฒนาทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักขนาด 5 GB ที่ทำงานอย่างต่อเนื่องใน Google Cloud ซึ่งจะช่วยเพิ่มประสิทธิภาพของเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก งานส่วนใหญ่ใน Codelab นี้สามารถทำได้โดยใช้เบราว์เซอร์หรือ Chromebook เท่านั้น
เมื่อเชื่อมต่อกับ Cloud Shell คุณควรเห็นว่าได้รับการตรวจสอบสิทธิ์แล้ว และโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์แล้ว
เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว
gcloud auth list
เอาต์พุตจากคำสั่ง
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้เกี่ยวกับโปรเจ็กต์ของคุณ
gcloud config list project
เอาต์พุตจากคำสั่ง
[core] project = <PROJECT_ID>
หากไม่ใช่ ให้ตั้งคำสั่งด้วยคำสั่งนี้
gcloud config set project <PROJECT_ID>
เอาต์พุตจากคำสั่ง
Updated property [core/project].
Cloud Shell มีตัวแปรสภาพแวดล้อมบางรายการ รวมถึง GOOGLE_CLOUD_PROJECT ที่มีชื่อโปรเจ็กต์ Cloud ปัจจุบันของเรา เราจะใช้สิ่งนี้ในที่ต่างๆ ทั่วทั้งห้องทดลองนี้ ซึ่งสามารถดูได้โดยการเรียกใช้:
echo $GOOGLE_CLOUD_PROJECT
เปิดใช้ API
ในขั้นตอนต่อๆ มา คุณจะเห็นว่าต้องใช้บริการเหล่านี้ (และเพราะเหตุใด) แต่ตอนนี้ให้เรียกใช้คำสั่งนี้เพื่อให้สิทธิ์เข้าถึงบริการ Compute Engine, Container Registry และ Vertex AI
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
ซึ่งจะสร้างข้อความที่ประสบผลสำเร็จที่คล้ายกับข้อความต่อไปนี้
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
สร้างที่เก็บข้อมูล 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
สร้างอินสแตนซ์ Vertex AI Workbench
จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench ดังนี้
จากภายในสมุดบันทึกที่ผู้ใช้จัดการ ให้คลิกสมุดบันทึกใหม่
จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.3 (ที่มี LTS) ที่ไม่มี GPU ดังนี้
ใช้ตัวเลือกเริ่มต้นแล้วคลิกสร้าง
เปิดสมุดบันทึก
เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab:
4. การตั้งค่าไปป์ไลน์ Vertex
มีไลบรารีเพิ่มเติม 2-3 รายการที่เราต้องติดตั้งเพื่อใช้ Vertex Pipelines ดังนี้
- ไปป์ไลน์ Kubernetes: นี่คือ SDK ที่เราจะใช้สร้างไปป์ไลน์ Vertex Pipelines รองรับการเรียกใช้ไปป์ไลน์ที่สร้างด้วย Kubeflow Pipelines หรือ TFX
- Vertex AI SDK: SDK นี้ช่วยเพิ่มประสิทธิภาพให้ประสบการณ์การเรียกใช้ Vertex AI API เราจะใช้ข้อมูลดังกล่าวเพื่อเรียกใช้ไปป์ไลน์บน Vertex AI
สร้างสมุดบันทึก Python และติดตั้งไลบรารี
ขั้นแรก จากเมนู Launcher ในอินสแตนซ์สมุดบันทึก ให้สร้างสมุดบันทึกโดยเลือก Python 3 ดังนี้
ในการติดตั้งทั้ง 2 บริการที่เราจะใช้ในห้องทดลองนี้ ให้ตั้งค่าแฟล็กผู้ใช้ในเซลล์สมุดบันทึกก่อน ดังนี้
USER_FLAG = "--user"
จากนั้นเรียกใช้สิ่งต่อไปนี้จากสมุดบันทึก
!pip3 install {USER_FLAG} google-cloud-aiplatform==1.7.0
!pip3 install {USER_FLAG} kfp==1.8.9
หลังจากติดตั้งแพ็กเกจเหล่านี้ คุณจะต้องรีสตาร์ทเคอร์เนล:
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)
ต่อไป ตรวจสอบว่าคุณได้ติดตั้ง KFP SDK เวอร์ชันอย่างถูกต้อง ค่าควรเป็น >=1.8:
!python3 -c "import kfp; print('KFP SDK version: {}'.format(kfp.__version__))"
จากนั้นยืนยันว่า Vertex AI SDK เวอร์ชัน >= 1.6.2
!pip list | grep aiplatform
ตั้งค่ารหัสโปรเจ็กต์และที่เก็บข้อมูล
ในห้องทดลองนี้ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ที่อยู่ในระบบคลาวด์และที่เก็บข้อมูลที่คุณสร้างไว้ก่อนหน้านี้ ต่อไป เราจะสร้างตัวแปรสำหรับแต่ละตัวแปร
หากคุณไม่ทราบรหัสโปรเจ็กต์ คุณอาจรับรหัสดังกล่าวได้โดยเรียกใช้โค้ดต่อไปนี้
import os
PROJECT_ID = ""
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)
หรือไม่เช่นนั้น ให้ตั้งค่าที่นี่:
if PROJECT_ID == "" or PROJECT_ID is None:
PROJECT_ID = "your-project-id" # @param {type:"string"}
จากนั้นสร้างตัวแปรเพื่อจัดเก็บชื่อที่เก็บข้อมูล หากคุณสร้างแอปในห้องทดลองนี้ สิ่งต่อไปนี้จะทํางานได้ ไม่เช่นนั้น คุณจะต้องตั้งค่าด้วยตนเองดังนี้
BUCKET_NAME="gs://" + PROJECT_ID + "-bucket"
นำเข้าไลบรารี
เพิ่มรายการต่อไปนี้เพื่อนำเข้าไลบรารีที่เราจะใช้ใน Codelab นี้
import matplotlib.pyplot as plt
import pandas as pd
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline, component, Artifact, Dataset, Input, Metrics, Model, Output, InputPath, OutputPath
from google.cloud import aiplatform
# We'll use this namespace for metadata querying
from google.cloud import aiplatform_v1
ระบุค่าคงที่
สิ่งสุดท้ายที่เราต้องทำก่อนสร้างไปป์ไลน์คือการกำหนดตัวแปรคงที่ PIPELINE_ROOT คือเส้นทาง Cloud Storage ที่ระบบจะเขียนอาร์ติแฟกต์ที่ไปป์ไลน์ของเราสร้างขึ้น เราใช้ us-central1 เป็นภูมิภาคของส่วนนี้ แต่หากคุณใช้ภูมิภาคอื่นเมื่อสร้างที่เก็บข้อมูล ให้อัปเดตตัวแปร REGION ในโค้ดด้านล่าง
PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
REGION="us-central1"
PIPELINE_ROOT = f"{BUCKET_NAME}/pipeline_root/"
PIPELINE_ROOT
หลังจากเรียกใช้โค้ดข้างต้นแล้ว คุณควรจะเห็นไดเรกทอรีรากของไปป์ไลน์ที่พิมพ์ นี่คือตำแหน่งของ Cloud Storage ที่จะเขียนอาร์ติแฟกต์จากไปป์ไลน์ ซึ่งจะอยู่ในรูปแบบ gs://YOUR-BUCKET-NAME/pipeline_root/
5. การสร้างไปป์ไลน์แบบ 3 ขั้นตอนด้วยคอมโพเนนต์ที่กำหนดเอง
จุดประสงค์ของห้องทดลองนี้คือการทำความเข้าใจข้อมูลเมตาจากการเรียกใช้ไปป์ไลน์ เราต้องมีไปป์ไลน์ที่ทำงานบน Vertex Pipelines ซึ่งเป็นจุดที่จะเริ่มต้น ที่นี่ เราจะกำหนดไปป์ไลน์แบบ 3 ขั้นตอนด้วยคอมโพเนนต์ที่กำหนดเองต่อไปนี้
get_dataframe: ดึงข้อมูลจากตาราง BigQuery และแปลงข้อมูลเป็น Pandas DataFrametrain_sklearn_model: ใช้ Pandas DataFrame เพื่อฝึกและส่งออกโมเดล Scikit Learn รวมไปถึงเมตริกบางรายการdeploy_model: ทำให้โมเดล Scikit Learn ที่ส่งออกใช้งานได้ที่ปลายทางใน Vertex AI
ในไปป์ไลน์นี้ เราจะใช้ชุดข้อมูล 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
นี่คือชุดข้อมูลแบบตาราง และในไปป์ไลน์ของเรา เราจะใช้ชุดข้อมูลเพื่อฝึก ประเมิน และติดตั้งใช้งานโมเดล Scikit-learn ที่จำแนกถั่วเป็น 1 ใน 7 ประเภทตามลักษณะเฉพาะ มาเริ่มเขียนโค้ดกันเลย
สร้างคอมโพเนนต์ตามฟังก์ชัน Python
การใช้ KFP SDK ช่วยให้เราสร้างคอมโพเนนต์ตามฟังก์ชัน Python ได้ เราจะใช้ข้อมูลดังกล่าวสําหรับ 3 คอมโพเนนต์ในไปป์ไลน์นี้
ดาวน์โหลดข้อมูล BigQuery และแปลงเป็น CSV
ก่อนอื่น เราจะสร้างคอมโพเนนต์ get_dataframe
@component(
packages_to_install=["google-cloud-bigquery", "pandas", "pyarrow", "db-dtypes"],
base_image="python:3.9",
output_component_file="create_dataset.yaml"
)
def get_dataframe(
bq_table: str,
output_data_path: OutputPath("Dataset")
):
from google.cloud import bigquery
import pandas as pd
import os
project_number = os.environ["CLOUD_ML_PROJECT_ID"]
bqclient = bigquery.Client(project=project_number)
table = bigquery.TableReference.from_string(
bq_table
)
rows = bqclient.list_rows(
table
)
dataframe = rows.to_dataframe(
create_bqstorage_client=True,
)
dataframe = dataframe.sample(frac=1, random_state=2)
dataframe.to_csv(output_data_path)
มาดูรายละเอียดสิ่งที่เกิดขึ้นในคอมโพเนนต์นี้กัน
- มัณฑนากร
@componentจะรวมฟังก์ชันนี้ไปยังคอมโพเนนต์เมื่อเรียกใช้ไปป์ไลน์ คุณจะใช้ค่านี้ทุกครั้งที่เขียนคอมโพเนนต์ที่กำหนดเอง - พารามิเตอร์
base_imageระบุอิมเมจคอนเทนเนอร์ที่คอมโพเนนต์นี้จะใช้ - คอมโพเนนต์นี้จะใช้ไลบรารี Python บางรายการ ซึ่งเราระบุผ่านพารามิเตอร์
packages_to_install - คุณจะใช้พารามิเตอร์
output_component_fileหรือไม่ก็ได้ และระบุไฟล์ yaml ที่ใช้เขียนคอมโพเนนต์ที่คอมไพล์แล้ว หลังจากเรียกใช้เซลล์ คุณควรเห็นไฟล์นั้นเขียนอยู่บนอินสแตนซ์สมุดบันทึก หากคุณต้องการแชร์คอมโพเนนต์นี้กับผู้อื่น คุณสามารถส่งไฟล์ yaml ที่สร้างขึ้นให้กับบุคคลนั้นและให้โหลดโดยใช้ข้อมูลต่อไปนี้
# This is optional, it shows how to load a component from a yaml file
# dataset_component = kfp.components.load_component_from_file('./create_dataset.yaml')
- ถัดไป คอมโพเนนต์นี้จะใช้ไลบรารีของไคลเอ็นต์ Python ของ BigQuery เพื่อดาวน์โหลดข้อมูลของเราจาก BigQuery ไปยัง Pandas DataFrame แล้วสร้างอาร์ติแฟกต์เอาต์พุตของข้อมูลดังกล่าวเป็นไฟล์ CSV ข้อมูลนี้จะถูกส่งเป็นอินพุตไปยังคอมโพเนนต์ถัดไป
สร้างคอมโพเนนต์เพื่อฝึกโมเดล Scikit-learn
ในคอมโพเนนต์นี้ เราจะนำ CSV ที่เราสร้างไว้ก่อนหน้านี้มาใช้ฝึกโมเดลแผนผังการตัดสินใจของ Scikit-learn คอมโพเนนต์นี้จะส่งออกโมเดล Scikit ที่ได้ รวมถึงอาร์ติแฟกต์ Metrics ที่ประกอบด้วยความถูกต้อง เฟรมเวิร์ก และขนาดของชุดข้อมูลที่ใช้ฝึกของโมเดลของเรา ดังนี้
@component(
packages_to_install=["sklearn", "pandas", "joblib", "db-dtypes"],
base_image="python:3.9",
output_component_file="beans_model_component.yaml",
)
def sklearn_train(
dataset: Input[Dataset],
metrics: Output[Metrics],
model: Output[Model]
):
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from joblib import dump
import pandas as pd
df = pd.read_csv(dataset.path)
labels = df.pop("Class").tolist()
data = df.values.tolist()
x_train, x_test, y_train, y_test = train_test_split(data, labels)
skmodel = DecisionTreeClassifier()
skmodel.fit(x_train,y_train)
score = skmodel.score(x_test,y_test)
print('accuracy is:',score)
metrics.log_metric("accuracy",(score * 100.0))
metrics.log_metric("framework", "Scikit Learn")
metrics.log_metric("dataset_size", len(df))
dump(skmodel, model.path + ".joblib")
กำหนดคอมโพเนนต์เพื่ออัปโหลดและทำให้โมเดลใช้งานได้กับ Vertex AI
สุดท้าย คอมโพเนนต์สุดท้ายจะนำโมเดลที่ผ่านการฝึกจากขั้นตอนก่อนหน้า อัปโหลดไปยัง Vertex AI และทำให้ใช้งานได้ที่ปลายทาง
@component(
packages_to_install=["google-cloud-aiplatform"],
base_image="python:3.9",
output_component_file="beans_deploy_component.yaml",
)
def deploy_model(
model: Input[Model],
project: str,
region: str,
vertex_endpoint: Output[Artifact],
vertex_model: Output[Model]
):
from google.cloud import aiplatform
aiplatform.init(project=project, location=region)
deployed_model = aiplatform.Model.upload(
display_name="beans-model-pipeline",
artifact_uri = model.uri.replace("model", ""),
serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest"
)
endpoint = deployed_model.deploy(machine_type="n1-standard-4")
# Save data to the output params
vertex_endpoint.uri = endpoint.resource_name
vertex_model.uri = deployed_model.resource_name
ในที่นี้เราจะใช้ Vertex AI SDK เพื่ออัปโหลดโมเดลโดยใช้คอนเทนเนอร์ที่สร้างไว้ล่วงหน้าสำหรับการคาดการณ์ จากนั้นจะทำให้โมเดลใช้งานได้ที่ปลายทาง และแสดง URI ไปยังทั้งทรัพยากรของโมเดลและทรัพยากรปลายทาง ต่อไปใน Codelab นี้ คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับความหมายของการส่งคืนข้อมูลนี้เป็นอาร์ติแฟกต์
กำหนดและคอมไพล์ไปป์ไลน์
เมื่อเราได้กำหนดองค์ประกอบทั้ง 3 อย่างแล้ว ต่อไปเราจะสร้างคำจำกัดความไปป์ไลน์ ซึ่งอธิบายการไหลเวียนของอาร์ติแฟกต์อินพุตและเอาต์พุตระหว่างขั้นตอนดังนี้
@pipeline(
# Default pipeline root. You can override it when submitting the pipeline.
pipeline_root=PIPELINE_ROOT,
# A name for the pipeline.
name="mlmd-pipeline",
)
def pipeline(
bq_table: str = "",
output_data_path: str = "data.csv",
project: str = PROJECT_ID,
region: str = REGION
):
dataset_task = get_dataframe(bq_table)
model_task = sklearn_train(
dataset_task.output
)
deploy_task = deploy_model(
model=model_task.outputs["model"],
project=project,
region=region
)
รายการต่อไปนี้จะสร้างไฟล์ JSON ที่คุณจะใช้เรียกใช้ไปป์ไลน์
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="mlmd_pipeline.json"
)
เริ่มการเรียกใช้ไปป์ไลน์ 2 รายการ
ถัดไปเราจะเริ่มต้นไปป์ไลน์ของเรา 2 รัน ก่อนอื่น ให้คุณกำหนดการประทับเวลาที่จะใช้สำหรับรหัสงานไปป์ไลน์ของเรา ดังนี้
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
โปรดทราบว่าไปป์ไลน์ของเราต้องใช้พารามิเตอร์ 1 รายการเมื่อเรียกใช้ ซึ่งก็คือ bq_table ที่เราต้องการใช้สำหรับข้อมูลการฝึก การเรียกใช้ไปป์ไลน์นี้จะใช้ชุดข้อมูลถั่วเวอร์ชันที่เล็กลง:
run1 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-small-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.small_dataset"},
enable_caching=True,
)
ถัดไป ให้สร้างการเรียกใช้ไปป์ไลน์อีกรายการโดยใช้ชุดข้อมูลเดียวกันที่มีขนาดใหญ่ขึ้น
run2 = aiplatform.PipelineJob(
display_name="mlmd-pipeline",
template_path="mlmd_pipeline.json",
job_id="mlmd-pipeline-large-{0}".format(TIMESTAMP),
parameter_values={"bq_table": "sara-vertex-demos.beans_demo.large_dataset"},
enable_caching=True,
)
สุดท้าย เริ่มการดำเนินการไปป์ไลน์สำหรับทั้ง 2 การเรียกใช้ วิธีที่ดีที่สุดคือทำขั้นตอนนี้ในเซลล์สมุดบันทึก 2 เซลล์ เพื่อให้คุณดูเอาต์พุตของการเรียกใช้แต่ละครั้งได้
run1.submit()
จากนั้น เริ่มการวิ่งครั้งที่ 2 ดังนี้
run2.submit()
หลังจากเรียกใช้เซลล์นี้ คุณจะเห็นลิงก์เพื่อดูไปป์ไลน์แต่ละรายการในคอนโซล Vertex AI เปิดลิงก์นี้เพื่อดูรายละเอียดเพิ่มเติมเกี่ยวกับไปป์ไลน์ของคุณ
เมื่อดำเนินการเสร็จแล้ว (ไปป์ไลน์นี้จะใช้เวลาประมาณ 10-15 นาทีต่อการทำงาน) คุณจะเห็นข้อมูลต่อไปนี้
ตอนนี้คุณมีการเรียกใช้ไปป์ไลน์ที่เสร็จสมบูรณ์แล้ว 2 ครั้ง คุณก็พร้อมที่จะดูรายละเอียดเกี่ยวกับอาร์ติแฟกต์ของไปป์ไลน์ เมตริก และ Lineage แล้ว
6. ทำความเข้าใจอาร์ติแฟกต์และสายเลือดของไปป์ไลน์
ในกราฟไปป์ไลน์ คุณจะเห็นช่องเล็กๆ หลังแต่ละขั้นตอน รายการเหล่านี้คืออาร์ติแฟกต์หรือเอาต์พุตที่สร้างขึ้นจากขั้นตอนไปป์ไลน์ อาร์ติแฟกต์มีอยู่หลายประเภท ในไปป์ไลน์นี้ เรามีชุดข้อมูล เมตริก โมเดล และอาร์ติแฟกต์ปลายทาง คลิกแถบเลื่อนขยายอาร์ติแฟกต์ที่ด้านบนของ UI เพื่อดูรายละเอียดเพิ่มเติมเกี่ยวกับแต่ละรายการ
การคลิกที่อาร์ติแฟกต์จะแสดงรายละเอียดเพิ่มเติมรวมถึง URI ของรายการนั้น เช่น การคลิกอาร์ติแฟกต์ vertex_endpoint จะแสดง URI ซึ่งคุณจะเห็นปลายทางที่ทำให้ใช้งานได้ในคอนโซล Vertex AI ของคุณ
อาร์ติแฟกต์ Metrics ช่วยให้คุณส่งเมตริกที่กำหนดเองซึ่งเชื่อมโยงกับขั้นตอนไปป์ไลน์หนึ่งๆ ได้ ในคอมโพเนนต์ sklearn_train ของไปป์ไลน์ เราได้บันทึกเมตริกเกี่ยวกับความแม่นยำ เฟรมเวิร์ก และขนาดชุดข้อมูลของโมเดล คลิกที่อาร์ติแฟกต์เมตริกเพื่อดูรายละเอียดเหล่านั้น
อาร์ติแฟกต์ทุกรายการจะมี Lineage ซึ่งอธิบายอาร์ติแฟกต์อื่นๆ ที่อาร์ติแฟกต์เชื่อมต่ออยู่ คลิกอาร์ติแฟกต์ vertex_endpoint ของไปป์ไลน์อีกครั้ง แล้วคลิกปุ่มดูบรรทัด
ซึ่งจะเปิดแท็บใหม่ที่มีอาร์ติแฟกต์ทั้งหมดที่เชื่อมต่อกับอาร์ติแฟกต์ที่คุณเลือก กราฟเส้นสายของคุณจะมีลักษณะดังนี้
คอลัมน์นี้จะแสดงโมเดล เมตริก และชุดข้อมูลที่เชื่อมโยงกับปลายทางนี้ เหตุใดจึงมีประโยชน์ คุณอาจทำให้โมเดลใช้งานได้กับปลายทางหลายแห่ง หรือจำเป็นต้องทราบชุดข้อมูลเฉพาะที่ใช้ในการฝึกโมเดลที่ทำให้ใช้งานได้กับปลายทางที่คุณดู กราฟ Lineage ช่วยให้คุณเข้าใจอาร์ติแฟกต์แต่ละรายการในบริบทของระบบ ML อื่นๆ คุณยังเข้าถึง Lineage แบบเป็นโปรแกรมได้ด้วย ซึ่งเราจะเห็นภายหลังใน Codelab นี้
7. การเปรียบเทียบการเรียกใช้ไปป์ไลน์
อาจมีการเรียกใช้ไปป์ไลน์เดียวหลายครั้ง เช่น อาจมีพารามิเตอร์อินพุต ข้อมูลใหม่ หรือโดยคนในทีมที่แตกต่างกัน หากต้องการติดตามการเรียกใช้ไปป์ไลน์ จะมีวิธีเปรียบเทียบเมตริกตามเมตริกต่างๆ ได้เพื่อให้สะดวก ในส่วนนี้ เราจะมาดู 2 วิธีในการเปรียบเทียบการวิ่ง
การเปรียบเทียบการเรียกใช้ใน UI ไปป์ไลน์
ใน Cloud Console ให้ไปที่แดชบอร์ดไปป์ไลน์ การดำเนินการนี้จะแสดงภาพรวมของการเรียกใช้ไปป์ไลน์ทั้งหมดที่คุณดำเนินการ ตรวจสอบการเรียกใช้ 2 ครั้งล่าสุด แล้วคลิกปุ่มเปรียบเทียบที่ด้านบน
ซึ่งจะนำเราไปยังหน้าที่เราสามารถเปรียบเทียบพารามิเตอร์และเมตริกอินพุตสำหรับการเรียกใช้แต่ละครั้งที่ได้เลือกไว้ สำหรับการเรียกใช้ทั้ง 2 ครั้งนี้ ให้สังเกตตาราง BigQuery, ขนาดชุดข้อมูล และค่าความแม่นยำที่แตกต่างกัน
คุณใช้ฟังก์ชันการทำงานของ UI นี้เพื่อเปรียบเทียบการเรียกใช้มากกว่า 2 ครั้งได้ ทั้งยังเรียกใช้จากไปป์ไลน์ที่แตกต่างกันได้ด้วย
การเปรียบเทียบการเรียกใช้กับ Vertex AI SDK
เมื่อมีการดำเนินการไปป์ไลน์จำนวนมาก คุณอาจต้องการวิธีรับเมตริกการเปรียบเทียบเหล่านี้แบบเป็นโปรแกรมเพื่อเจาะลึกรายละเอียดของเมตริกและสร้างภาพ
คุณใช้เมธอด aiplatform.get_pipeline_df() เพื่อเข้าถึงข้อมูลเมตาการเรียกใช้ได้ ในส่วนนี้ เราจะได้รับข้อมูลเมตาสำหรับการเรียกใช้ไปป์ไลน์เดียวกัน 2 ครั้งล่าสุด และโหลดลงใน Pandas DataFrame พารามิเตอร์ pipeline ที่นี่หมายถึงชื่อที่เราตั้งให้กับไปป์ไลน์ในคำนิยามของไปป์ไลน์
df = aiplatform.get_pipeline_df(pipeline="mlmd-pipeline")
df
เมื่อพิมพ์ DataFrame คุณจะเห็นข้อมูลดังนี้
เราได้ดำเนินการกับไปป์ไลน์ของเราเพียง 2 ครั้งเท่านั้น แต่คุณสามารถจินตนาการจำนวนเมตริกของคุณได้เช่นกันเมื่อมีการดำเนินการมากขึ้น ถัดไป เราจะสร้างการแสดงภาพที่กำหนดเองด้วย matplotlib เพื่อดูความสัมพันธ์ระหว่างความถูกต้องของโมเดลของเราและปริมาณข้อมูลที่ใช้สำหรับการฝึก
เรียกใช้โค้ดต่อไปนี้ในเซลล์สมุดบันทึกใหม่
plt.plot(df["metric.dataset_size"], df["metric.accuracy"],label="Accuracy")
plt.title("Accuracy and dataset size")
plt.legend(loc=4)
plt.show()
คุณควรจะเห็นบางสิ่งเช่นนี้:
8. กำลังค้นหาเมตริกไปป์ไลน์
นอกจากการรับ DataFrame ของเมตริกไปป์ไลน์ทั้งหมด คุณอาจต้องการค้นหาอาร์ติแฟกต์ที่สร้างในระบบ ML โดยใช้โปรแกรม คุณสามารถสร้างแดชบอร์ดที่กำหนดเองหรือให้ผู้อื่นในองค์กรดูรายละเอียดเกี่ยวกับอาร์ติแฟกต์เฉพาะได้จากส่วนนั้น
กําลังรับอาร์ติแฟกต์โมเดลทั้งหมด
หากต้องการค้นหาอาร์ติแฟกต์ด้วยวิธีนี้ เราจะสร้าง MetadataServiceClient:
API_ENDPOINT = "{}-aiplatform.googleapis.com".format(REGION)
metadata_client = aiplatform_v1.MetadataServiceClient(
client_options={
"api_endpoint": API_ENDPOINT
}
)
ถัดไป เราจะส่งคำขอ list_artifacts ไปยังปลายทางนั้น และส่งตัวกรองที่ระบุอาร์ติแฟกต์ที่เราต้องการในการตอบกลับ ก่อนอื่น ต้องหาอาร์ติแฟกต์ทั้งหมดในโปรเจ็กต์ที่เป็นโมเดล โดยให้เรียกใช้คำสั่งต่อไปนี้ในสมุดบันทึก
MODEL_FILTER="schema_title = \"system.Model\""
artifact_request = aiplatform_v1.ListArtifactsRequest(
parent="projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
filter=MODEL_FILTER
)
model_artifacts = metadata_client.list_artifacts(artifact_request)
การตอบกลับ model_artifacts ที่ได้จะมีออบเจ็กต์ที่ทำซ้ำได้สำหรับอาร์ติแฟกต์โมเดลแต่ละรายการในโปรเจ็กต์ของคุณ รวมถึงข้อมูลเมตาที่เชื่อมโยงสำหรับแต่ละโมเดล
การกรองออบเจ็กต์และแสดงใน DataFrame
คงจะเป็นประโยชน์หากเราสามารถแสดงภาพของคำค้นหาอาร์ติแฟกต์ได้ได้ง่ายยิ่งขึ้น ถัดไป เราจะมาสร้างอาร์ติแฟกต์ทั้งหมดที่สร้างขึ้นหลังวันที่ 10 สิงหาคม 2021 โดยมีสถานะ LIVE หลังจากเรียกใช้คำขอนี้ เราจะแสดงผลลัพธ์ใน Pandas DataFrame ก่อนอื่น ให้ดำเนินการตามคำขอ
LIVE_FILTER = "create_time > \"2021-08-10T00:00:00-00:00\" AND state = LIVE"
artifact_req = {
"parent": "projects/{0}/locations/{1}/metadataStores/default".format(PROJECT_ID, REGION),
"filter": LIVE_FILTER
}
live_artifacts = metadata_client.list_artifacts(artifact_req)
จากนั้นแสดงผลลัพธ์ใน DataFrame โดยทำดังนี้
data = {'uri': [], 'createTime': [], 'type': []}
for i in live_artifacts:
data['uri'].append(i.uri)
data['createTime'].append(i.create_time)
data['type'].append(i.schema_title)
df = pd.DataFrame.from_dict(data)
df
คุณจะเห็นบางอย่างในลักษณะนี้
คุณกรองอาร์ติแฟกต์ตามเกณฑ์อื่นๆ เพิ่มเติมจากสิ่งที่ลองทำที่นี่ได้
เพียงเท่านี้คุณก็ใช้ห้องทดลองเสร็จแล้ว
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้แล้ว
- ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่สร้างชุดข้อมูลใน Vertex AI รวมถึงฝึกและทำให้โมเดล Scikit-learn ที่กำหนดเองใช้งานได้บนชุดข้อมูลนั้น
- เขียนคอมโพเนนต์ไปป์ไลน์แบบกำหนดเองที่สร้างอาร์ติแฟกต์และข้อมูลเมตา
- เปรียบเทียบการเรียกใช้ Vertex Pipelines ทั้งในคอนโซลระบบคลาวด์และแบบเป็นโปรแกรม
- ย้อนรอยสายสกุลของอาร์ติแฟกต์ที่ไปป์ไลน์สร้างขึ้น
- ค้นหาข้อมูลเมตาการเรียกใช้ไปป์ไลน์
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ในเอกสารประกอบ
9. ล้างข้อมูล
ขอแนะนำให้คุณลบทรัพยากรที่สร้างขึ้นทั่วทั้งห้องทดลองนี้เพื่อไม่ให้มีการเรียกเก็บเงิน
หยุดหรือลบอินสแตนซ์สมุดบันทึก
หากต้องการใช้สมุดบันทึกที่คุณสร้างไว้ในห้องทดลองนี้ต่อไป ขอแนะนำให้คุณปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน จาก UI ของสมุดบันทึกใน Cloud Console ให้เลือกสมุดบันทึก แล้วเลือกหยุด หากต้องการลบอินสแตนซ์ทั้งหมด ให้เลือกลบ โดยทำดังนี้
ลบปลายทาง Vertex AI
หากต้องการลบปลายทางที่ทำให้ใช้งานได้แล้ว ให้ไปที่ส่วนปลายทางของคอนโซล Vertex AI และคลิกไอคอนลบ
ลบที่เก็บข้อมูล Cloud Storage
หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:
