1. ภาพรวม
ในแล็บนี้ คุณจะได้เรียนรู้วิธีเรียกใช้ชื่องานการฝึกโมเดลที่กำหนดเองโดยใช้ SDK ไปป์ไลน์ Kubeflow ใน Vertex Pipelines
สิ่งที่คุณจะได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ใช้ SDK ไปป์ไลน์ Kubeflow เพื่อสร้างไปป์ไลน์ ML ที่ปรับขนาดได้
- สร้างและจัดคอนเทนเนอร์งานการฝึกโมเดล Scikit-learn แบบกำหนดเองที่ใช้ชุดข้อมูลที่จัดการของ Vertex AI และจะทำงานในการฝึก Vertex AI ภายในไปป์ไลน์
- เรียกใช้งานการคาดการณ์แบบกลุ่มภายใน Vertex Pipelines
- ใช้คอมโพเนนต์ที่สร้างไว้ล่วงหน้าเพื่อโต้ตอบกับบริการ Vertex AI ซึ่งมีให้ผ่านไลบรารี
google_cloud_pipeline_components
ต้นทุนทั้งหมดในการเรียกใช้ Lab นี้ใน Google Cloud อยู่ที่ประมาณ $5
2. ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI
แล็บนี้ใช้ Vertex AI ซึ่งเป็นแพลตฟอร์ม ML แบบจัดการตั้งแต่ต้นจนจบใน Google Cloud Vertex AI ผสานรวมข้อเสนอ ML ของ Google ใน Google Cloud เข้ากับประสบการณ์การพัฒนาที่ราบรื่น นอกจากบริการฝึกและทำให้โมเดลใช้งานได้แล้ว Vertex AI ยังมีผลิตภัณฑ์ MLOps ที่หลากหลาย ซึ่งรวมถึง Vertex Pipelines (จุดสนใจของแล็บนี้), Model Monitoring, Feature Store และอื่นๆ คุณดูข้อเสนอผลิตภัณฑ์ Vertex AI ทั้งหมดได้ในแผนภาพด้านล่าง
หากมีข้อเสนอแนะ โปรดดูหน้าการสนับสนุน
เหตุใดไปป์ไลน์ ML จึงมีประโยชน์
ก่อนจะไปลงรายละเอียด มาดูกันว่าทำไมคุณถึงควรใช้ไปป์ไลน์ ลองนึกภาพว่าคุณกำลังสร้างเวิร์กโฟลว์ ML ที่รวมถึงการประมวลผลข้อมูล การฝึกโมเดล การปรับไฮเปอร์พารามิเตอร์ การประเมิน และการติดตั้งใช้งานโมเดล แต่ละขั้นตอนเหล่านี้อาจมีทรัพยากรที่ต้องพึ่งพาแตกต่างกัน ซึ่งอาจจัดการได้ยากหากคุณถือว่าทั้งเวิร์กโฟลว์เป็นแบบโมโนลิธ เมื่อเริ่มขยายกระบวนการ ML คุณอาจต้องการแชร์เวิร์กโฟลว์ ML กับคนอื่นๆ ในทีมเพื่อให้ผู้อื่นสามารถดำเนินการและมีส่วนร่วมในการเขียนโค้ดได้ หากไม่มีกระบวนการที่เชื่อถือได้และทำซ้ำได้ การดำเนินการนี้อาจเป็นเรื่องยาก เมื่อใช้ไปป์ไลน์ แต่ละขั้นตอนในกระบวนการ ML จะเป็นคอนเทนเนอร์ของตัวเอง ซึ่งจะช่วยให้คุณพัฒนาขั้นตอนต่างๆ ได้อย่างอิสระ และติดตามอินพุตและเอาต์พุตจากแต่ละขั้นตอนในลักษณะที่ทำซ้ำได้ นอกจากนี้ คุณยังกำหนดเวลาหรือทริกเกอร์การเรียกใช้ไปป์ไลน์ตามเหตุการณ์อื่นๆ ในสภาพแวดล้อมระบบคลาวด์ได้ด้วย เช่น การเริ่มเรียกใช้ไปป์ไลน์เมื่อมีข้อมูลฝึกฝนใหม่
สรุป: ไปป์ไลน์ช่วยปรับปรุงและทำซ้ำเวิร์กโฟลว์ ML
3. การตั้งค่าสภาพแวดล้อมระบบคลาวด์
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เริ่ม Cloud Shell
ในแล็บนี้ คุณจะได้ทำงานในเซสชัน Cloud Shell ซึ่งเป็นตัวแปลคำสั่งที่โฮสต์โดยเครื่องเสมือนที่ทำงานในระบบคลาวด์ของ Google คุณสามารถเรียกใช้ส่วนนี้ในเครื่องคอมพิวเตอร์ของคุณเองได้อย่างง่ายดาย แต่การใช้ Cloud Shell จะช่วยให้ทุกคนเข้าถึงประสบการณ์ที่ทำซ้ำได้ในสภาพแวดล้อมที่สอดคล้องกัน หลังจากแล็บแล้ว คุณสามารถลองทำส่วนนี้อีกครั้งในคอมพิวเตอร์ของคุณเองได้
เปิดใช้งาน Cloud Shell
จากด้านขวาบนของ Cloud Console ให้คลิกปุ่มด้านล่างเพื่อเปิดใช้งาน Cloud Shell
หากไม่เคยเริ่มใช้ Cloud Shell มาก่อน คุณจะเห็นหน้าจอระดับกลาง (ครึ่งหน้าล่าง) ที่อธิบายว่า Cloud Shell คืออะไร ในกรณีนี้ ให้คลิกต่อไป (และคุณจะไม่เห็นหน้าจอนี้อีก) หน้าจอแบบครั้งเดียวจะมีลักษณะดังนี้
การจัดสรรและเชื่อมต่อกับ Cloud Shell จะใช้เวลาไม่นาน
เครื่องเสมือนนี้มีเครื่องมือพัฒนาซอฟต์แวร์ทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก คุณสามารถทำงานในโค้ดแล็บนี้ได้โดยใช้เพียงเบราว์เซอร์หรือ Chromebook
เมื่อเชื่อมต่อกับ Cloud Shell แล้ว คุณควรเห็นว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและโปรเจ็กต์ได้รับการตั้งค่าเป็นรหัสโปรเจ็กต์ของคุณแล้ว
เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว
gcloud auth list
คุณควรเห็นข้อความคล้ายกับตัวอย่างต่อไปนี้ในเอาต์พุตจากคำสั่ง
เรียกใช้คำสั่งต่อไปนี้ใน 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
ซึ่งควรจะแสดงข้อความว่าดำเนินการสำเร็จคล้ายกับข้อความนี้
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
จากนั้นใน Notebook ที่ผู้ใช้จัดการ ให้คลิก Notebook ใหม่
จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.3 (พร้อม LTS) ที่ไม่มี GPU:
ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง
ขั้นตอนที่ 5: เปิด Notebook
เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JupyterLab
4. การตั้งค่า Vertex Pipelines
เราจะต้องติดตั้งไลบรารีเพิ่มเติมบางรายการเพื่อใช้ Vertex Pipelines ดังนี้
- Kubeflow Pipelines: นี่คือ SDK ที่เราจะใช้สร้างไปป์ไลน์ Vertex Pipelines รองรับการเรียกใช้ไปป์ไลน์ที่สร้างด้วยทั้ง Kubeflow Pipelines หรือ TFX
- คอมโพเนนต์ไปป์ไลน์ของ Google Cloud: ไลบรารีนี้มีคอมโพเนนต์ที่สร้างไว้ล่วงหน้าซึ่งช่วยให้โต้ตอบกับบริการ Vertex AI จากขั้นตอนไปป์ไลน์ได้ง่ายขึ้น
ขั้นตอนที่ 1: สร้าง Notebook ของ Python และติดตั้งไลบรารี
ก่อนอื่น ให้สร้าง Notebook จากเมนู Launcher ในอินสแตนซ์ Notebook (เข้าถึงได้โดยคลิกไอคอน + ที่ด้านซ้ายบนของ Notebook) โดยเลือก Python 3 ดังนี้
คุณเข้าถึงเมนู 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 นี้
from kfp.v2 import compiler, dsl
from kfp.v2.dsl import pipeline
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
ขั้นตอนที่ 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. การกำหนดค่างานฝึกโมเดลที่กำหนดเอง
ก่อนที่จะตั้งค่าไปป์ไลน์ เราต้องเขียนโค้ดสำหรับงานฝึกโมเดลที่กำหนดเอง ในการฝึกโมเดล เราจะใช้ชุดข้อมูลถั่วแห้งของ 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
ขั้นตอนแรกของไปป์ไลน์จะสร้างชุดข้อมูลที่มีการจัดการใน Vertex AI โดยใช้ตาราง BigQuery ที่มีข้อมูลเวอร์ชันของถั่ว ระบบจะส่งชุดข้อมูลเป็นอินพุตไปยังงานการฝึกของเรา ในโค้ดการฝึก เราจะมีสิทธิ์เข้าถึงตัวแปรสภาพแวดล้อมเพื่อเข้าถึงชุดข้อมูลที่มีการจัดการนี้
วิธีตั้งค่างานการฝึกที่กำหนดเองมีดังนี้
- เขียนโมเดล Scikit-learn
DecisionTreeClassifierเพื่อจัดประเภทถั่วในข้อมูล - แพ็กเกจโค้ดการฝึกในคอนเทนเนอร์ Docker แล้วพุชไปยัง Container Registry
จากนั้นเราจะเริ่มงานการฝึก Vertex AI ได้โดยตรงจากไปป์ไลน์ มาเริ่มกันเลย
ขั้นตอนที่ 1: กำหนดโค้ดการฝึกในคอนเทนเนอร์ Docker
จากอินสแตนซ์ Notebooks ให้เปิด Launcher แล้วเลือก Terminal
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อตั้งค่าไดเรกทอรีที่คุณจะเพิ่มโค้ดที่อยู่ในคอนเทนเนอร์
mkdir traincontainer
cd traincontainer
touch Dockerfile
mkdir trainer
touch trainer/train.py
หลังจากเรียกใช้คำสั่งเหล่านั้นแล้ว คุณควรเห็นไดเรกทอรีชื่อ traincontainer/ ที่สร้างขึ้นทางด้านซ้าย (คุณอาจต้องคลิกไอคอนรีเฟรชเพื่อดู) คุณจะเห็นข้อมูลต่อไปนี้ในไดเรกทอรี traincontainer/
+ Dockerfile
+ trainer/
+ train.py
ขั้นตอนแรกในการทำโค้ดให้เป็นคอนเทนเนอร์คือการสร้าง Dockerfile ใน Dockerfile เราจะใส่คำสั่งทั้งหมดที่จำเป็นในการเรียกใช้อิมเมจ ซึ่งจะติดตั้งไลบรารีทั้งหมดที่เราใช้และตั้งค่าจุดแรกเข้าสำหรับโค้ดการฝึก เปิด Dockerfile ที่คุณเพิ่งสร้าง แล้วเพิ่มโค้ดต่อไปนี้
FROM gcr.io/deeplearning-platform-release/sklearn-cpu.0-23
WORKDIR /
# Copies the trainer code to the docker image.
COPY trainer /trainer
RUN pip install sklearn google-cloud-bigquery joblib pandas google-cloud-storage
# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]
หากต้องการบันทึกไฟล์ขณะแก้ไขในอินสแตนซ์ Notebook คุณสามารถใช้ ctrl+s ได้
จากนั้นเปิดtrain.pyไฟล์ เราจะเพิ่มโค้ดการฝึกที่นี่ คัดลอกข้อความต่อไปนี้ลงใน train.py ซึ่งจะดึงข้อมูลจากชุดข้อมูลที่มีการจัดการของเรา ใส่ลงใน Pandas DataFrame ฝึกโมเดล Scikit-learn และอัปโหลดโมเดลที่ฝึกแล้วไปยัง Cloud Storage
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import roc_curve
from sklearn.model_selection import train_test_split
from google.cloud import bigquery
from google.cloud import storage
from joblib import dump
import os
import pandas as pd
bqclient = bigquery.Client()
storage_client = storage.Client()
def download_table(bq_table_uri: str):
prefix = "bq://"
if bq_table_uri.startswith(prefix):
bq_table_uri = bq_table_uri[len(prefix):]
table = bigquery.TableReference.from_string(bq_table_uri)
rows = bqclient.list_rows(
table,
)
return rows.to_dataframe(create_bqstorage_client=False)
# These environment variables are from Vertex AI managed datasets
training_data_uri = os.environ["AIP_TRAINING_DATA_URI"]
test_data_uri = os.environ["AIP_TEST_DATA_URI"]
# Download data into Pandas DataFrames, split into train / test
df = download_table(training_data_uri)
test_df = download_table(test_data_uri)
labels = df.pop("Class").tolist()
data = df.values.tolist()
test_labels = test_df.pop("Class").tolist()
test_data = test_df.values.tolist()
# Define and train the Scikit model
skmodel = DecisionTreeClassifier()
skmodel.fit(data, labels)
score = skmodel.score(test_data, test_labels)
print('accuracy is:',score)
# Save the model to a local file
dump(skmodel, "model.joblib")
# Upload the saved model file to GCS
bucket = storage_client.get_bucket("YOUR_GCS_BUCKET")
model_directory = os.environ["AIP_MODEL_DIR"]
storage_path = os.path.join(model_directory, "model.joblib")
blob = storage.blob.Blob.from_string(storage_path, client=storage_client)
blob.upload_from_filename("model.joblib")
จากนั้นกลับไปที่ Notebook แล้วเรียกใช้คำสั่งต่อไปนี้เพื่อแทนที่ YOUR_GCS_BUCKET จากสคริปต์ด้านบนด้วยชื่อของ Bucket ใน Cloud Storage
BUCKET = BUCKET_NAME[5:] # Trim the 'gs://' before adding to train script
!sed -i -r 's@YOUR_GCS_BUCKET@'"$BUCKET"'@' traincontainer/trainer/train.py
หรือคุณจะดำเนินการด้วยตนเองก็ได้หากต้องการ หากทำเช่นนั้น โปรดอย่าใส่ gs:// ในชื่อที่เก็บข้อมูลเมื่ออัปเดตสคริปต์
ตอนนี้โค้ดการฝึกของเราอยู่ในคอนเทนเนอร์ Docker และเราพร้อมที่จะเรียกใช้การฝึกในระบบคลาวด์แล้ว
ขั้นตอนที่ 2: พุชคอนเทนเนอร์ไปยัง Container Registry
เมื่อโค้ดการฝึกเสร็จสมบูรณ์แล้ว เราก็พร้อมที่จะพุชโค้ดนี้ไปยัง Google Container Registry เมื่อกำหนดค่าคอมโพเนนต์การฝึกของไปป์ไลน์ในภายหลัง เราจะชี้ Vertex Pipelines ไปยังคอนเทนเนอร์นี้
กลับไปที่เทอร์มินัล และจากรูทของไดเรกทอรี traincontainer/ ให้กำหนดตัวแปรด้วย URI สำหรับอิมเมจคอนเทนเนอร์ใน Container Registry
PROJECT_ID=$(gcloud config get-value project)
IMAGE_URI="gcr.io/$PROJECT_ID/scikit:v1"
จากนั้นสร้างคอนเทนเนอร์โดยเรียกใช้คำสั่งต่อไปนี้
docker build ./ -t $IMAGE_URI
สุดท้าย ให้พุชคอนเทนเนอร์ไปยัง Container Registry โดยใช้คำสั่งต่อไปนี้
docker push $IMAGE_URI
ไปที่ส่วน Container Registry ของ Cloud Console เพื่อยืนยันว่าคอนเทนเนอร์ของคุณอยู่ที่นั่น โดยจะมีลักษณะดังนี้
6. การกำหนดค่างานการคาดการณ์แบบกลุ่ม
ขั้นตอนสุดท้ายของไปป์ไลน์จะเรียกใช้ชื่องานการคาดการณ์แบบกลุ่ม หากต้องการให้การดำเนินการนี้ทำงานได้ เราต้องระบุไฟล์ CSV ใน Cloud Storage ซึ่งมีตัวอย่างที่เราต้องการรับการคาดการณ์ เราจะสร้างไฟล์ CSV นี้ใน Notebook และคัดลอกไปยัง Cloud Storage โดยใช้เครื่องมือบรรทัดคำสั่ง gsutil
การคัดลอกตัวอย่างการคาดการณ์แบบกลุ่มไปยัง Cloud Storage
ไฟล์ต่อไปนี้มีตัวอย่าง 3 รายการจากแต่ละคลาสในชุดข้อมูลถั่ว ตัวอย่างด้านล่างไม่มีคอลัมน์ Class เนื่องจากเป็นสิ่งที่โมเดลจะคาดการณ์ เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไฟล์ CSV นี้ในสมุดบันทึกของคุณ
%%writefile batch_examples.csv
Area,Perimeter,MajorAxisLength,MinorAxisLength,AspectRation,Eccentricity,ConvexArea,EquivDiameter,Extent,Solidity,roundness,Compactness,ShapeFactor1,ShapeFactor2,ShapeFactor3,ShapeFactor4
23288,558.113,207.567738,143.085693,1.450653336,0.7244336162,23545,172.1952453,0.8045881703,0.9890847314,0.9395021523,0.8295857874,0.008913077034,0.002604069884,0.6882125787,0.9983578734
23689,575.638,205.9678003,146.7475015,1.403552348,0.7016945718,24018,173.6714472,0.7652721693,0.9863019402,0.8983750474,0.8431970773,0.00869465998,0.002711119968,0.7109813112,0.9978994889
23727,559.503,189.7993849,159.3717704,1.190922235,0.5430731512,24021,173.8106863,0.8037601626,0.9877607094,0.952462433,0.9157600082,0.007999299741,0.003470231343,0.8386163926,0.9987269085
31158,641.105,212.0669751,187.1929601,1.132879009,0.4699241567,31474,199.1773023,0.7813134733,0.989959967,0.9526231013,0.9392188582,0.0068061806,0.003267009878,0.8821320637,0.9993488983
32514,649.012,221.4454899,187.1344232,1.183349841,0.5346736437,32843,203.4652564,0.7849831,0.9899826447,0.9700068737,0.9188051492,0.00681077351,0.002994124691,0.8442029022,0.9989873701
33078,659.456,235.5600775,178.9312328,1.316483846,0.6503915309,33333,205.2223615,0.7877214708,0.9923499235,0.9558229607,0.8712102818,0.007121351881,0.002530662194,0.7590073551,0.9992209221
33680,683.09,256.203255,167.9334938,1.525623324,0.7552213942,34019,207.081404,0.80680321,0.9900349805,0.9070392732,0.8082699962,0.007606985006,0.002002710402,0.6533003868,0.9966903078
33954,716.75,277.3684803,156.3563259,1.773951126,0.825970469,34420,207.9220419,0.7994819873,0.9864613597,0.8305492781,0.7496238998,0.008168948587,0.001591181142,0.5619359911,0.996846984
36322,719.437,272.0582306,170.8914975,1.591993952,0.7780978465,36717,215.0502424,0.7718560075,0.9892420405,0.8818487005,0.7904566678,0.007490177594,0.001803782407,0.6248217437,0.9947124371
36675,742.917,285.8908964,166.8819538,1.713132487,0.8119506999,37613,216.0927123,0.7788277766,0.9750618137,0.8350248381,0.7558572692,0.0077952528,0.001569528272,0.5713202115,0.9787472145
37454,772.679,297.6274753,162.1493177,1.835514817,0.8385619338,38113,218.3756257,0.8016695205,0.9827093118,0.7883332637,0.7337213257,0.007946480356,0.001420623993,0.5383469838,0.9881438654
37789,766.378,313.5680678,154.3409867,2.031657789,0.8704771226,38251,219.3500608,0.7805870567,0.9879218844,0.8085170916,0.6995293312,0.008297866252,0.001225659709,0.4893412853,0.9941740339
47883,873.536,327.9986493,186.5201272,1.758516115,0.822571799,48753,246.9140116,0.7584464543,0.9821549443,0.7885506623,0.7527897207,0.006850002074,0.00135695419,0.5666923636,0.9965376533
49777,861.277,300.7570338,211.6168613,1.42123379,0.7105823885,50590,251.7499649,0.8019106536,0.9839296304,0.843243269,0.8370542883,0.00604208839,0.001829706116,0.7006598815,0.9958014989
49882,891.505,357.1890036,179.8346914,1.986207449,0.8640114945,51042,252.0153467,0.7260210171,0.9772736178,0.7886896753,0.7055518063,0.007160679276,0.001094585314,0.4978033513,0.9887407248
53249,919.923,325.3866286,208.9174205,1.557489212,0.7666552108,54195,260.3818974,0.6966846347,0.9825445152,0.7907120655,0.8002231025,0.00611066177,0.001545654241,0.6403570138,0.9973491406
61129,964.969,369.3481688,210.9473449,1.750902193,0.8208567513,61796,278.9836198,0.7501135067,0.9892064211,0.8249553283,0.7553404711,0.006042110436,0.001213219664,0.5705392272,0.9989583843
61918,960.372,353.1381442,224.0962377,1.575832543,0.7728529173,62627,280.7782864,0.7539207091,0.9886790043,0.8436218213,0.7950947556,0.005703319619,0.00140599258,0.6321756704,0.9962029945
141953,1402.05,524.2311633,346.3974998,1.513380332,0.7505863011,143704,425.1354762,0.7147107987,0.9878152313,0.9074598849,0.8109694843,0.003692991084,0.0009853172185,0.6576715044,0.9953071199
145285,1440.991,524.9567463,353.0769977,1.486805285,0.7400216694,146709,430.0960442,0.7860466375,0.9902937107,0.8792413513,0.8192980608,0.003613289371,0.001004269363,0.6712493125,0.9980170255
146153,1476.383,526.1933264,356.528288,1.475881001,0.7354662103,149267,431.3789276,0.7319360978,0.9791380546,0.8425962592,0.8198107159,0.003600290972,0.001003163512,0.6720896099,0.991924286
จากนั้นคัดลอกไฟล์ไปยัง Bucket ของ Cloud Storage โดยทำดังนี้
!gsutil cp batch_examples.csv $BUCKET_NAME
เราจะอ้างอิงไฟล์นี้ในขั้นตอนถัดไปเมื่อกำหนดไปป์ไลน์
7. การสร้างไปป์ไลน์ด้วยคอมโพเนนต์ที่สร้างไว้ล่วงหน้า
ตอนนี้โค้ดการฝึกของเราอยู่ในระบบคลาวด์แล้ว เราจึงพร้อมที่จะเรียกใช้จากไปป์ไลน์ ไปป์ไลน์ที่เราจะกำหนดจะใช้คอมโพเนนต์ที่สร้างไว้ล่วงหน้า 3 รายการจากไลบรารี google_cloud_pipeline_components ที่เราติดตั้งไว้ก่อนหน้านี้ คอมโพเนนต์ที่กำหนดไว้ล่วงหน้าเหล่านี้ช่วยลดความซับซ้อนของโค้ดที่เราต้องเขียนเพื่อตั้งค่าไปป์ไลน์ และจะช่วยให้เราใช้บริการ Vertex AI เช่น การฝึกโมเดลและการคาดการณ์แบบเป็นกลุ่มได้
ไปป์ไลน์ 3 ขั้นตอนของเราจะทำสิ่งต่อไปนี้
- สร้างชุดข้อมูลที่มีการจัดการใน Vertex AI
- เรียกใช้งานการฝึกใน Vertex AI โดยใช้คอนเทนเนอร์ที่กำหนดเองที่เราตั้งค่าไว้
- เรียกใช้งานการคาดการณ์แบบกลุ่มในโมเดลการแยกประเภท Scikit-learn ที่ฝึกแล้ว
ขั้นตอนที่ 1: กำหนดไปป์ไลน์
เนื่องจากเราใช้คอมโพเนนต์ที่สร้างไว้ล่วงหน้า เราจึงตั้งค่าทั้งไปป์ไลน์ในการกำหนดไปป์ไลน์ได้ เพิ่มข้อมูลต่อไปนี้ลงในเซลล์ Notebook
@pipeline(name="automl-beans-custom",
pipeline_root=PIPELINE_ROOT)
def pipeline(
bq_source: str = "bq://sara-vertex-demos.beans_demo.large_dataset",
bucket: str = BUCKET_NAME,
project: str = PROJECT_ID,
gcp_region: str = REGION,
bq_dest: str = "",
container_uri: str = "",
batch_destination: str = ""
):
dataset_create_op = gcc_aip.TabularDatasetCreateOp(
display_name="tabular-beans-dataset",
bq_source=bq_source,
project=project,
location=gcp_region
)
training_op = gcc_aip.CustomContainerTrainingJobRunOp(
display_name="pipeline-beans-custom-train",
container_uri=container_uri,
project=project,
location=gcp_region,
dataset=dataset_create_op.outputs["dataset"],
staging_bucket=bucket,
training_fraction_split=0.8,
validation_fraction_split=0.1,
test_fraction_split=0.1,
bigquery_destination=bq_dest,
model_serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/sklearn-cpu.0-24:latest",
model_display_name="scikit-beans-model-pipeline",
machine_type="n1-standard-4",
)
batch_predict_op = gcc_aip.ModelBatchPredictOp(
project=project,
location=gcp_region,
job_display_name="beans-batch-predict",
model=training_op.outputs["model"],
gcs_source_uris=["{0}/batch_examples.csv".format(BUCKET_NAME)],
instances_format="csv",
gcs_destination_output_uri_prefix=batch_destination,
machine_type="n1-standard-4"
)
ขั้นตอนที่ 2: คอมไพล์และเรียกใช้ไปป์ไลน์
เมื่อกำหนดไปป์ไลน์แล้ว คุณก็พร้อมที่จะคอมไพล์ คำสั่งต่อไปนี้จะสร้างไฟล์ JSON ที่คุณจะใช้เพื่อเรียกใช้ไปป์ไลน์
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="custom_train_pipeline.json"
)
จากนั้นสร้างTIMESTAMPตัวแปร เราจะใช้ข้อมูลนี้ในรหัสงาน
from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
จากนั้นกำหนดงานไปป์ไลน์โดยส่งพารามิเตอร์เฉพาะโปรเจ็กต์ 2-3 รายการ
pipeline_job = aiplatform.PipelineJob(
display_name="custom-train-pipeline",
template_path="custom_train_pipeline.json",
job_id="custom-train-pipeline-{0}".format(TIMESTAMP),
parameter_values={
"project": PROJECT_ID,
"bucket": BUCKET_NAME,
"bq_dest": "bq://{0}".format(PROJECT_ID),
"container_uri": "gcr.io/{0}/scikit:v1".format(PROJECT_ID),
"batch_destination": "{0}/batchpredresults".format(BUCKET_NAME)
},
enable_caching=True,
)
สุดท้าย ให้เรียกใช้งานเพื่อสร้างการดำเนินการไปป์ไลน์ใหม่
pipeline_job.submit()
หลังจากเรียกใช้เซลล์นี้แล้ว คุณควรเห็นบันทึกพร้อมลิงก์เพื่อดูการเรียกใช้ไปป์ไลน์ในคอนโซล
ไปที่ลิงก์นั้น นอกจากนี้ คุณยังเข้าถึงได้โดยเปิดแดชบอร์ดไปป์ไลน์ เมื่อเสร็จสมบูรณ์แล้ว ไปป์ไลน์ควรมีลักษณะดังนี้
ไปป์ไลน์นี้จะใช้เวลา 5-10 นาทีในการเรียกใช้ แต่คุณสามารถไปยังขั้นตอนถัดไปได้ก่อนที่ไปป์ไลน์จะเสร็จสมบูรณ์ จากนั้นคุณจะได้ดูข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่เกิดขึ้นในแต่ละขั้นตอนของไปป์ไลน์เหล่านี้
8. ทำความเข้าใจการดำเนินการไปป์ไลน์
มาเจาะลึกขั้นตอนในไปป์ไลน์ทั้ง 3 ขั้นตอนกัน
ขั้นตอนที่ 1 ของไปป์ไลน์: สร้างชุดข้อมูลที่มีการจัดการ
ขั้นตอนแรกในไปป์ไลน์ของเราจะสร้างชุดข้อมูลที่มีการจัดการใน Vertex AI หากคุณคลิกลิงก์ชุดข้อมูลต่อไปนี้ในส่วนไปป์ไลน์ของคอนโซล
คุณจะเห็นชุดข้อมูลใน Vertex AI ซึ่งมีลิงก์ไปยังแหล่งข้อมูลใน BigQuery พร้อมกับข้อมูลเกี่ยวกับคอลัมน์ต่างๆ ในชุดข้อมูล เมื่ออัปโหลดชุดข้อมูลที่มีการจัดการไปยัง Vertex AI แล้ว คุณจะใช้ชุดข้อมูลดังกล่าวเพื่อฝึกโมเดล AutoML หรือโมเดลที่กำหนดเองก็ได้
สำหรับงานโมเดลที่กำหนดเองซึ่งใช้ชุดข้อมูลที่มีการจัดการ Vertex AI จะส่งตัวแปรสภาพแวดล้อมพิเศษไปยังงานการฝึก และจัดการการแยกข้อมูลออกเป็นชุดการฝึกและชุดทดสอบ เราจะใช้ข้อมูลนี้ในขั้นตอนไปป์ไลน์ถัดไป
ขั้นตอนที่ 2 ของไปป์ไลน์: การฝึกโมเดลใน Vertex AI Training
ขณะที่งานฝึกโมเดลที่กำหนดเองทำงานอยู่ คุณสามารถคลิกเพื่อดูบันทึกในคอนโซล Vertex Pipelines ได้โดยตรง
นอกจากนี้ คุณยังดูรายละเอียดเกี่ยวกับงานการฝึกแบบกำหนดเองได้ในแดชบอร์ดการฝึกของ Vertex AI เมื่องานการฝึกเสร็จสมบูรณ์ ระบบจะสร้างทรัพยากรโมเดลใน Vertex AI จากนั้นเราจะทำให้โมเดลนี้ใช้งานได้ที่อุปกรณ์ปลายทางสำหรับการคาดการณ์ออนไลน์ หรือสร้างงานคาดการณ์แบบกลุ่ม ซึ่งเราจะทำในขั้นตอนไปป์ไลน์ถัดไป
ขั้นตอนที่ 3 ของไปป์ไลน์: เรียกใช้งานการคาดการณ์แบบกลุ่มในโมเดล
สุดท้าย ไปป์ไลน์ของเราจะได้รับการคาดการณ์เกี่ยวกับตัวอย่างที่เราส่งผ่านไฟล์ CSV เมื่องานการคาดการณ์แบบเป็นชุดเสร็จสมบูรณ์แล้ว Vertex AI จะเขียนไฟล์ CSV ไปยังตำแหน่งที่เราระบุไว้ใน Cloud Storage เมื่อขั้นตอนไปป์ไลน์นี้เริ่มทำงาน คุณจะไปที่ส่วนการคาดการณ์แบบกลุ่มของคอนโซล Vertex AI เพื่อดูงานที่สร้างขึ้นได้
คลิกที่งานเมื่อเสร็จสมบูรณ์เพื่อดู URL ของ Cloud Storage ของการคาดการณ์แบบเป็นชุด
คลิกลิงก์ดังกล่าวเพื่อไปยังไดเรกทอรี Cloud Storage ซึ่งคุณจะเห็นผลการคาดการณ์ จากนั้นคลิกเพื่อดาวน์โหลดไฟล์ prediction.results ไฟล์ใดไฟล์หนึ่ง ในไฟล์ คุณควรเห็นแถวที่มีลักษณะดังนี้
{"instance": [33954.0, 716.75, 277.3684803, 156.3563259, 1.773951126, 0.825970469, 34420.0, 207.9220419, 0.7994819873, 0.9864613597, 0.8305492781, 0.7496238998, 0.008168948587, 0.001591181142, 0.5619359911, 0.996846984], "prediction": "HOROZ"}
ซึ่งรวมถึงค่าฟีเจอร์สำหรับอินสแตนซ์หนึ่งๆ พร้อมกับคลาสที่โมเดลคาดการณ์ ในตัวอย่างนี้ โมเดลของเราคิดว่าถั่วนี้คือถั่ว "HOROZ"
เพียงเท่านี้คุณก็ทำแล็บเสร็จแล้ว
🎉 ยินดีด้วย 🎉
คุณได้เรียนรู้วิธีใช้ Vertex AI เพื่อทำสิ่งต่อไปนี้
- ใช้ SDK ของ Kubeflow Pipelines เพื่อสร้างไปป์ไลน์แบบต้นทางถึงปลายทางด้วยคอมโพเนนต์ที่กำหนดเอง
- เรียกใช้ไปป์ไลน์ใน Vertex Pipelines และเริ่มการเรียกใช้ไปป์ไลน์ด้วย SDK
- ดูและวิเคราะห์กราฟ Vertex Pipelines ในคอนโซล
- ใช้คอมโพเนนต์ไปป์ไลน์ที่สร้างไว้ล่วงหน้าเพื่อเพิ่มบริการ Vertex AI ลงในไปป์ไลน์
- ตั้งเวลางานไปป์ไลน์ที่เกิดซ้ำ
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ที่เอกสารประกอบ
9. ล้างข้อมูล
เราขอแนะนำให้คุณลบทรัพยากรที่สร้างขึ้นตลอดแล็บนี้เพื่อไม่ให้ระบบเรียกเก็บเงินจากคุณ
ขั้นตอนที่ 1: หยุดหรือลบอินสแตนซ์ Notebooks
หากต้องการใช้ Notebook ที่สร้างขึ้นใน Lab นี้ต่อไป ขอแนะนำให้ปิดเมื่อไม่ได้ใช้งาน จาก UI ของ Notebook ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด หากต้องการลบอินสแตนซ์ทั้งหมด ให้เลือกลบ
ขั้นตอนที่ 2: ลบที่เก็บข้อมูล Cloud Storage
หากต้องการลบ Storage Bucket ให้ใช้เมนูการนำทางใน Cloud Console ไปที่ Storage เลือก Bucket แล้วคลิกลบ
