1. ภาพรวม
ในห้องทดลองนี้ คุณจะได้เรียนรู้วิธีเรียกใช้งานการฝึกโมเดลที่กำหนดเองโดยใช้ SDK ไปป์ไลน์ Kubeflow ในไปป์ไลน์ Vertex
สิ่งที่ได้เรียนรู้
โดยคุณจะได้เรียนรู้วิธีต่อไปนี้
- ใช้ 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 (จุดมุ่งเน้นของห้องทดลองนี้), การตรวจสอบโมเดล, Feature Store และอื่นๆ คุณดูข้อเสนอผลิตภัณฑ์ Vertex AI ทั้งหมดได้ในแผนภาพด้านล่าง
หากมีความคิดเห็น โปรดดูหน้าการสนับสนุน
ทำไมไปป์ไลน์ ML ถึงมีประโยชน์
ก่อนที่จะเจาะลึกรายละเอียด เรามาทำความเข้าใจว่าทำไมคุณต้องการใช้ไปป์ไลน์ ลองจินตนาการว่าคุณกำลังสร้างเวิร์กโฟลว์ ML ที่มีการประมวลผลข้อมูล การฝึกโมเดล การปรับแต่งไฮเปอร์พารามิเตอร์ การประเมิน และการทำให้โมเดลใช้งานได้ แต่ละขั้นตอนเหล่านี้อาจมีทรัพยากร Dependency ที่แตกต่างกัน ซึ่งอาจใช้งานยากหากคุณมองว่าเวิร์กโฟลว์ทั้งหมดเป็นโมโนลิธ เมื่อเริ่มปรับขนาดกระบวนการ ML คุณอาจต้องการแชร์เวิร์กโฟลว์ ML กับคนอื่นๆ ในทีมเพื่อให้พวกเขาเรียกใช้และมีส่วนร่วมในโค้ดได้ หากไม่มีขั้นตอนที่เชื่อถือได้และทำซ้ำได้ ก็อาจกลายเป็นเรื่องยุ่งยากได้ เมื่อใช้ไปป์ไลน์ แต่ละขั้นตอนในกระบวนการ ML จะเป็นคอนเทนเนอร์ของตัวเอง ซึ่งจะช่วยให้คุณพัฒนาขั้นตอนต่างๆ ได้อย่างอิสระและติดตามอินพุตและเอาต์พุตจากแต่ละขั้นตอนในลักษณะที่ทำให้เกิดซ้ำได้ นอกจากนี้ คุณยังกำหนดเวลาหรือทริกเกอร์การเรียกใช้ไปป์ไลน์โดยอิงตามเหตุการณ์อื่นๆ ในสภาพแวดล้อมระบบคลาวด์ได้ด้วย เช่น การเริ่มต้นเรียกใช้ไปป์ไลน์เมื่อมีข้อมูลการฝึกใหม่
tl;dr: ไปป์ไลน์จะช่วยให้คุณปรับปรุงและทำซ้ำเวิร์กโฟลว์ ML ได้
3. การตั้งค่าสภาพแวดล้อมระบบคลาวด์
คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่
ขั้นตอนที่ 1: เริ่มต้น 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
คุณควรเห็นข้อมูลดังนี้ในเอาต์พุตคำสั่ง
เรียกใช้คำสั่งต่อไปนี้ใน 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 ที่นี่ แต่คุณสามารถใช้ภูมิภาคอื่น (ใช้แทนในห้องทดลองนี้) หากมีที่เก็บข้อมูลอยู่แล้ว ให้ข้ามขั้นตอนนี้
เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล 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
ขั้นตอนที่ 4: สร้างอินสแตนซ์ Vertex AI Workbench
จากส่วน Vertex AI ของ Cloud Console ให้คลิก Workbench ดังนี้
จากภายในสมุดบันทึกที่จัดการโดยผู้ใช้ ให้คลิกสมุดบันทึกใหม่
จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 2.3 (ที่มี LTS) ที่ไม่มี GPU ดังนี้
ใช้ตัวเลือกเริ่มต้นแล้วคลิกสร้าง
ขั้นตอนที่ 5: เปิดสมุดบันทึก
เมื่อสร้างอินสแตนซ์แล้ว ให้เลือก Open JupyterLab:
4. การตั้งค่าไปป์ไลน์ Vertex
มีไลบรารีเพิ่มเติม 2-3 รายการที่เราต้องติดตั้งเพื่อใช้ Vertex Pipelines ดังนี้
- ไปป์ไลน์ Kubernetes: นี่คือ SDK ที่เราจะใช้สร้างไปป์ไลน์ Vertex Pipelines รองรับการเรียกใช้ไปป์ไลน์ที่สร้างด้วย Kubeflow Pipelines หรือ TFX
- คอมโพเนนต์ไปป์ไลน์ของ Google Cloud: ไลบรารีนี้มีคอมโพเนนต์ที่สร้างไว้ล่วงหน้าเพื่อช่วยให้โต้ตอบกับบริการ Vertex AI ได้ง่ายขึ้นจากขั้นตอนของไปป์ไลน์
ขั้นตอนที่ 1: สร้างสมุดบันทึก Python และติดตั้งไลบรารี
ขั้นแรก จากเมนู Launcher ในอินสแตนซ์สมุดบันทึก (ซึ่งเข้าถึงได้โดยคลิกไอคอน + ที่ด้านซ้ายบนของสมุดบันทึก) ให้สร้างสมุดบันทึกโดยเลือก Python 3 ดังนี้
คุณเข้าถึงเมนู Launcher ได้โดยคลิกเครื่องหมาย + ที่ด้านซ้ายบนของอินสแตนซ์สมุดบันทึก
ในการติดตั้งทั้ง 2 บริการที่เราจะใช้ในห้องทดลองนี้ ให้ตั้งค่าแฟล็กผู้ใช้ในเซลล์สมุดบันทึกก่อน ดังนี้
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: ตั้งค่ารหัสโปรเจ็กต์และที่เก็บข้อมูล
ในห้องทดลองนี้ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ที่อยู่ในระบบคลาวด์และที่เก็บข้อมูลที่คุณสร้างไว้ก่อนหน้านี้ ต่อไป เราจะสร้างตัวแปรสำหรับแต่ละตัวแปร
หากคุณไม่ทราบรหัสโปรเจ็กต์ คุณอาจรับรหัสดังกล่าวได้โดยเรียกใช้โค้ดต่อไปนี้
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: นำเข้าไลบรารี
เพิ่มรายการต่อไปนี้เพื่อนำเข้าไลบรารีที่เราจะใช้ใน 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. การกำหนดค่างานการฝึกโมเดลที่กำหนดเอง
ก่อนสร้างไปป์ไลน์ เราต้องเขียนโค้ดสำหรับงานการฝึกโมเดลที่กำหนดเอง ในการฝึกโมเดล เราจะใช้ชุดข้อมูล 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
ขั้นตอนแรกของไปป์ไลน์จะสร้างชุดข้อมูลที่มีการจัดการใน Vertex AI โดยใช้ตาราง BigQuery ที่มีข้อมูลเวอร์ชันของถั่วนี้ ระบบจะส่งชุดข้อมูลเป็นอินพุตในงานการฝึกของเรา ในโค้ดการฝึก เราจะมีสิทธิ์เข้าถึงตัวแปรสภาพแวดล้อมเพื่อเข้าถึงชุดข้อมูลที่มีการจัดการนี้
นี่คือวิธีที่เราตั้งค่างานการฝึกที่กำหนดเองของเรา
- เขียนโมเดล Scikit-learn
DecisionTreeClassifierเพื่อจำแนกประเภทถั่วในข้อมูลของเรา - สร้างแพ็กเกจโค้ดการฝึกในคอนเทนเนอร์ Docker แล้วพุชไปยัง Container Registry
จากนั้นเราจะเริ่มงานการฝึก Vertex AI ได้โดยตรงจากไปป์ไลน์ มาเริ่มกันเลย
ขั้นตอนที่ 1: กำหนดโค้ดการฝึกในคอนเทนเนอร์ Docker
จากอินสแตนซ์สมุดบันทึก ให้เปิด Launcher และเลือกเทอร์มินัล:
จากนั้นเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไดเรกทอรีที่จะเพิ่มโค้ดที่มีคอนเทนเนอร์
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 มาที่คอนเทนเนอร์นี้
กลับไปที่เทอร์มินัล และจากรูทของไดเรกทอรี 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 นี้ในสมุดบันทึกและคัดลอกไปยัง 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
- เรียกใช้งานการฝึกบน Vertx 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")
จากนั้นสร้างงานไปป์ไลน์ โดยส่งผ่านพารามิเตอร์เฉพาะโปรเจ็กต์บางรายการ ดังนี้
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 จากนั้นเรียกดูพื้นที่เก็บข้อมูล เลือกที่เก็บข้อมูล แล้วคลิกลบ:
