1. ภาพรวม
ในชั้นเรียนนี้ คุณจะได้เรียนรู้วิธีเรียกใช้งานการฝึกโมเดลที่กําหนดเองโดยใช้ Kubeflow Pipelines SDK ใน Vertex Pipelines
สิ่งที่คุณเรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์ ML ที่รองรับการปรับขนาด
- สร้างและคอนเทนเนอร์งานการฝึกโมเดล Scikit-learn ที่กำหนดเองซึ่งใช้ชุดข้อมูลที่มีการจัดการของ Vertex AI และจะทำงานในการฝึก Vertex AI ภายในไปป์ไลน์
- เรียกใช้งานการคาดการณ์แบบกลุ่มภายในไปป์ไลน์ Vertex
- ใช้คอมโพเนนต์ที่สร้างไว้ล่วงหน้าเพื่อโต้ตอบกับบริการ Vertex AI ซึ่งมีให้ผ่านไลบรารี
google_cloud_pipeline_components
ต้นทุนทั้งหมดในการใช้งานห้องทดลองนี้ใน 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 ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้โค้ดแล็บนี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 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 มีตัวแปรสภาพแวดล้อมบางรายการ รวมถึง GOOGLE_CLOUD_PROJECT ที่มีชื่อโปรเจ็กต์ Cloud ปัจจุบันของเรา เราจะใช้คำนี้ในหลายๆ ที่ตลอดทั้งบทแนะนำนี้ คุณดูได้โดยเรียกใช้
echo $GOOGLE_CLOUD_PROJECT
ขั้นตอนที่ 2: เปิดใช้ API
ในขั้นตอนต่อไป คุณจะเห็นว่าต้องใช้บริการเหล่านี้ (และเหตุผล) ที่ใดบ้าง แต่ตอนนี้ให้เรียกใช้คำสั่งนี้เพื่อให้สิทธิ์เข้าถึงบริการ Compute Engine, Container Registry และ Vertex AI
gcloud services enable compute.googleapis.com \
containerregistry.googleapis.com \
aiplatform.googleapis.com
ซึ่งควรแสดงข้อความสำเร็จที่คล้ายกับข้อความนี้
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 ดังนี้
จากตรงนั้น ให้คลิกโน้ตบุ๊กใหม่ภายในโน้ตบุ๊กที่ผู้ใช้จัดการ
จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.3 (มี LTS) ที่ไม่มี GPU
ใช้ตัวเลือกเริ่มต้นแล้วคลิกสร้าง
ขั้นตอนที่ 5: เปิดสมุดบันทึก
เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JupyterLab
4. การตั้งค่า Vertex Pipelines
เราต้องติดตั้งไลบรารีเพิ่มเติมอีก 2-3 รายการเพื่อใช้ Vertex Pipelines
- Kubeflow Pipelines: SDK ที่เราจะใช้สร้างไปป์ไลน์ Vertex Pipelines รองรับการเรียกใช้ไปป์ไลน์ที่สร้างด้วยทั้ง Kubeflow Pipelines หรือ TFX
- คอมโพเนนต์ไปป์ไลน์ของ Google Cloud: ไลบรารีนี้มีคอมโพเนนต์ที่สร้างไว้ล่วงหน้าซึ่งช่วยให้คุณโต้ตอบกับบริการ Vertex AI จากขั้นตอนในไปป์ไลน์ได้ง่ายขึ้น
ขั้นตอนที่ 1: สร้างสมุดบันทึก Python และติดตั้งไลบรารี
ก่อนอื่น จากเมนู Launcher ในอินสแตนซ์ Notebook (ซึ่งเข้าถึงได้โดยคลิกไอคอน + ที่ด้านซ้ายบนของ Notebook) ให้สร้าง Notebook โดยเลือก Python 3
คุณเข้าถึงเมนู 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: นําเข้าคลัง
เพิ่มบรรทัดต่อไปนี้เพื่อนําเข้าไลบรารีที่เราจะใช้ตลอดทั้งโค้ดแล็บนี้
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. 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
ขั้นตอนแรกในไปป์ไลน์จะสร้างชุดข้อมูลที่จัดการใน Vertex AI โดยใช้ตาราง BigQuery ที่มีข้อมูล Beans เวอร์ชันนี้ ระบบจะส่งชุดข้อมูลเป็นอินพุตในงานการฝึกของเรา ในโค้ดการฝึกของเรา เราจะเข้าถึงตัวแปรสภาพแวดล้อมเพื่อเข้าถึงชุดข้อมูลที่จัดการนี้ได้
นี่คือวิธีที่เราจะตั้งค่างานการฝึกอบรมที่กำหนดเอง
- เขียนโมเดล 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"]
หากต้องการบันทึกไฟล์ขณะแก้ไขในอินสแตนซ์โน้ตบุ๊ก ให้ใช้ 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")
จากนั้นกลับไปที่โน้ตบุ๊กและเรียกใช้คำสั่งต่อไปนี้เพื่อแทนที่ YOUR_GCS_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 ไปยังคอนเทนเนอร์นี้
กลับไปที่เทอร์มินัล แล้วกำหนดตัวแปรที่มี URI สำหรับอิมเมจคอนเทนเนอร์ใน Container Registry จากรูทของไดเรกทอรี traincontainer/
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 นี้ในโน้ตบุ๊กและคัดลอกไปยัง 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
จากนั้นคัดลอกไฟล์ไปยังที่เก็บข้อมูล 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: กำหนดกระบวนการทำงานของเรา
เนื่องจากเราใช้คอมโพเนนต์ที่สร้างไว้ล่วงหน้า เราจึงตั้งค่าไปป์ไลน์ทั้งหมดได้ในคําจํากัดความไปป์ไลน์ เพิ่มข้อมูลต่อไปนี้ลงในเซลล์ของสมุดบันทึก
@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
ขณะที่งานการฝึกที่กำหนดเองทำงานอยู่ คุณสามารถคลิกเพื่อดูบันทึกในคอนโซล 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 เพื่อทำสิ่งต่อไปนี้
- ใช้ Kubeflow Pipelines SDK เพื่อสร้างไปป์ไลน์จากต้นทางถึงปลายทางด้วยคอมโพเนนต์ที่กําหนดเอง
- เรียกใช้ไปป์ไลน์ใน Vertex Pipelines และเริ่มการเรียกใช้ไปป์ไลน์ด้วย SDK
- ดูและวิเคราะห์กราฟ Vertex Pipelines ในคอนโซล
- ใช้คอมโพเนนต์ไปป์ไลน์ที่สร้างไว้ล่วงหน้าเพื่อเพิ่มบริการ Vertex AI ลงในไปป์ไลน์
- ตั้งเวลางานในไปป์ไลน์ที่เกิดซ้ำ
ดูข้อมูลเพิ่มเติมเกี่ยวกับส่วนต่างๆ ของ Vertex ได้ในเอกสารประกอบ
9. ล้างข้อมูล
เราขอแนะนำให้คุณลบทรัพยากรที่สร้างขึ้นในตลอดทั้งห้องทดลองนี้เพื่อไม่ให้ระบบเรียกเก็บเงินจากคุณ
ขั้นตอนที่ 1: หยุดหรือลบอินสแตนซ์โน้ตบุ๊ก
ถ้าคุณต้องการใช้สมุดบันทึกที่คุณสร้างไว้ในห้องทดลองนี้ต่อไป ขอแนะนำให้คุณปิดสมุดบันทึกเมื่อไม่ได้ใช้งาน จาก UI ของโน้ตบุ๊กใน Cloud Console ให้เลือกโน้ตบุ๊ก แล้วเลือกหยุด หากต้องการลบอินสแตนซ์ทั้งหมด ให้เลือกลบ
ขั้นตอนที่ 2: ลบที่เก็บข้อมูล Cloud Storage
หากต้องการลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล โดยใช้เมนูการนำทางใน Cloud Console จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:
