ไปป์ไลน์ Kubeflow - การสรุปปัญหา GitHub

1. บทนำ

Kubeflow คือชุดเครื่องมือแมชชีนเลิร์นนิงสำหรับ Kubernetes โปรเจ็กต์นี้มุ่งเน้นที่การทำให้การติดตั้งใช้งานเวิร์กโฟลว์แมชชีนเลิร์นนิง (ML) ใน Kubernetes เป็นเรื่องง่าย พกพาได้ และปรับขนาดได้ เป้าหมายคือการมอบวิธีที่ตรงไปตรงมาในการติดตั้งใช้งานระบบโอเพนซอร์สที่ดีที่สุดสำหรับ ML กับโครงสร้างพื้นฐานที่หลากหลาย

เวิร์กโฟลว์แมชชีนเลิร์นนิงอาจมีหลายขั้นตอนที่ต้องพึ่งพาซึ่งกันและกัน ตั้งแต่การเตรียมและการวิเคราะห์ข้อมูล ไปจนถึงการฝึก การประเมิน การติดตั้งใช้งาน และอื่นๆ การเขียนและติดตามกระบวนการเหล่านี้ในลักษณะเฉพาะกิจ เช่น ในชุดสมุดบันทึกหรือสคริปต์ เป็นเรื่องยาก และสิ่งต่างๆ เช่น การตรวจสอบและการทำซ้ำจะกลายเป็นปัญหามากขึ้นเรื่อยๆKubeflow Pipelines (KFP) ช่วยแก้ปัญหาเหล่านี้ด้วยการจัดหาวิธีการติดตั้งใช้งานไปป์ไลน์แมชชีนเลิร์นนิงที่แข็งแกร่งและทำซ้ำได้ พร้อมกับการตรวจสอบ การตรวจสอบ การติดตามเวอร์ชัน และการทำซ้ำ ไปป์ไลน์ AI ของ Cloud ช่วยให้ตั้งค่าการติดตั้ง KFP ได้ง่าย

สิ่งที่คุณจะสร้าง

ในโค้ดแล็บนี้ คุณจะได้สร้างเว็บแอปที่สรุปปัญหาใน GitHub โดยใช้ Kubeflow Pipelines เพื่อฝึกและแสดงโมเดล ซึ่งอิงตามตัวอย่างในที่เก็บตัวอย่าง Kubeflow เมื่อเสร็จสมบูรณ์แล้ว โครงสร้างพื้นฐานของคุณจะมีสิ่งต่อไปนี้

คลัสเตอร์ Google Kubernetes Engine (GKE) ที่ติดตั้ง Kubeflow Pipelines (ผ่าน Cloud AI Pipelines)
ไปป์ไลน์ที่ฝึกโมเดล Tensor2Tensor ใน GPU
คอนเทนเนอร์ที่ให้บริการซึ่งให้การคาดการณ์จากโมเดลที่ฝึกแล้ว
UI ที่ตีความการคาดการณ์เพื่อสรุปปัญหาใน GitHub
Notebook ที่สร้างไปป์ไลน์ตั้งแต่ต้นโดยใช้ SDK ของ Kubeflow Pipelines (KFP)

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

ไปป์ไลน์ที่คุณจะสร้างขึ้นจะฝึกโมเดล Tensor2Tensor ในข้อมูลปัญหาของ GitHub เพื่อเรียนรู้วิธีคาดการณ์ชื่อปัญหาจากเนื้อหาของปัญหา จากนั้นจะส่งออกโมเดลที่ฝึกแล้วและนําโมเดลที่ส่งออกมาใช้งานโดยใช้ Tensorflow Serving ขั้นตอนสุดท้ายในไปป์ไลน์จะเปิดตัวเว็บแอป ซึ่งโต้ตอบกับอินสแตนซ์ TF-Serving เพื่อรับการคาดการณ์ของโมเดล

วิธีติดตั้ง Kubeflow Pipelines ในคลัสเตอร์ GKE
วิธีสร้างและเรียกใช้เวิร์กโฟลว์ ML โดยใช้ Kubeflow Pipelines
วิธีกำหนดและเรียกใช้ไปป์ไลน์จาก AI Platform Notebook

สิ่งที่คุณต้องมี

ความเข้าใจพื้นฐานเกี่ยวกับ Kubernetes จะเป็นประโยชน์ แต่ไม่จำเป็น
โปรเจ็กต์ GCP ที่ใช้งานอยู่ซึ่งคุณมีสิทธิ์เจ้าของ
(ไม่บังคับ) บัญชี GitHub
สิทธิ์เข้าถึง Google Cloud Shell ซึ่งมีอยู่ในคอนโซล Google Cloud Platform (GCP)

2. ตั้งค่า

Cloud Shell

ไปที่คอนโซล GCP ในเบราว์เซอร์ แล้วเข้าสู่ระบบด้วยข้อมูลเข้าสู่ระบบของโปรเจ็กต์

คลิก "เลือกโปรเจ็กต์" หากจำเป็น เพื่อให้คุณทำงานกับโปรเจ็กต์ Codelab

จากนั้นคลิกไอคอน "เปิดใช้งาน Cloud Shell" ที่ด้านขวาบนของคอนโซลเพื่อเริ่ม Cloud Shell

เมื่อเริ่มต้น Cloud Shell ระบบจะแจ้งชื่อโปรเจ็กต์ที่ตั้งค่าให้ใช้ ตรวจสอบว่าการตั้งค่านี้ถูกต้อง

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

จากนั้นในเทอร์มินัล Cloud Shell ให้เรียกใช้คำสั่งต่อไปนี้หากจำเป็นเพื่อกำหนดค่า gcloud ให้ใช้โปรเจ็กต์ที่ถูกต้อง

export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}

สร้างที่เก็บข้อมูล

สร้าง Bucket ของ Cloud Storage สำหรับจัดเก็บไฟล์ไปป์ไลน์ คุณจะต้องใช้รหัสที่ไม่ซ้ำกันทั่วโลก ดังนั้นจึงควรตั้งชื่อ Bucket ที่มีรหัสโปรเจ็กต์ของคุณ สร้าง Bucket โดยใช้คำสั่ง gsutil mb (สร้าง Bucket) ดังนี้

export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}

หรือจะสร้างที่เก็บข้อมูลผ่านคอนโซล GCP ก็ได้

ไม่บังคับ: สร้างโทเค็น GitHub

Codelab นี้เรียกใช้ GitHub API เพื่อดึงข้อมูลที่เปิดเผยต่อสาธารณะ หากต้องการป้องกันการจำกัดอัตรา โดยเฉพาะในกิจกรรมที่มีการส่งคำขอแบบไม่ระบุตัวตนจำนวนมากไปยัง GitHub API ให้ตั้งค่าโทเค็นการเข้าถึงที่ไม่มีสิทธิ์ ซึ่งเป็นเพียงการให้สิทธิ์คุณในฐานะบุคคลธรรมดาแทนที่จะเป็นผู้ใช้ที่ไม่ระบุชื่อ

ไปที่ https://github.com/settings/tokens แล้วสร้างโทเค็นใหม่โดยไม่มีขอบเขต
บันทึกไว้ในที่ปลอดภัย หากทำหาย คุณจะต้องลบและสร้างใหม่

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

ไม่บังคับ: ปักหมุดแดชบอร์ดที่มีประโยชน์

ในคอนโซล GCP ให้ปักหมุดแดชบอร์ด Kubernetes Engine และ Storage เพื่อให้เข้าถึงได้ง่ายขึ้น

สร้างการติดตั้ง AI Platform Pipelines (Kubeflow Pipelines ที่โฮสต์)

ทำตามวิธีการในส่วน "ก่อนเริ่มต้น" และ "ตั้งค่าอินสแตนซ์" ที่นี่เพื่อตั้งค่าอินสแตนซ์ GKE ที่ติดตั้ง KFP อย่าลืมเลือกช่องอนุญาตการเข้าถึง Cloud APIs ต่อไปนี้ตามที่ระบุไว้ในเอกสารประกอบ (หากไม่มี ไปป์ไลน์ตัวอย่างจะไม่ทำงานสำเร็จ) ปล่อยให้เนมสเปซการติดตั้งเป็น default

คุณจะต้องเลือกโซนที่รองรับ Nvidia k80 คุณใช้ us-central1-a หรือ us-central1-c เป็นค่าเริ่มต้นได้

จดชื่อคลัสเตอร์และโซน GKE ที่แสดงสำหรับการติดตั้งในแดชบอร์ด AI Pipelines เมื่อการติดตั้งเสร็จสมบูรณ์แล้ว และเพื่อความสะดวก ให้ตั้งค่าตัวแปรสภาพแวดล้อมเป็นค่าเหล่านี้

export ZONE=<your zone>
export CLUSTER_NAME=<your cluster name>

ตั้งค่า kubectl ให้ใช้ข้อมูลเข้าสู่ระบบของคลัสเตอร์ GKE ใหม่

หลังจากสร้างคลัสเตอร์ GKE แล้ว ให้กำหนดค่า kubectl เพื่อใช้ข้อมูลเข้าสู่ระบบของคลัสเตอร์ใหม่โดยเรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell

gcloud container clusters get-credentials ${CLUSTER_NAME} \
  --project ${PROJECT_ID} \
  --zone ${ZONE}

หรือคลิกชื่อคลัสเตอร์ในแดชบอร์ด AI Pipelines เพื่อไปที่หน้า GKE ของคลัสเตอร์นั้น แล้วคลิก "เชื่อมต่อ" ที่ด้านบนของหน้า จากป๊อปอัป ให้วางคำสั่งลงใน Cloud Shell

ซึ่งจะกำหนดค่าบริบท kubectl เพื่อให้คุณโต้ตอบกับคลัสเตอร์ได้ หากต้องการยืนยันการกำหนดค่า ให้เรียกใช้คำสั่งต่อไปนี้

kubectl get nodes -o wide

คุณควรเห็นโหนดที่แสดงพร้อมสถานะ "Ready" และข้อมูลอื่นๆ เกี่ยวกับอายุของโหนด เวอร์ชัน ที่อยู่ IP ภายนอก อิมเมจของระบบปฏิบัติการ เวอร์ชันเคอร์เนล และรันไทม์ของคอนเทนเนอร์

กำหนดค่าคลัสเตอร์เพื่อติดตั้งไดรเวอร์ Nvidia ใน Node Pool ที่เปิดใช้ GPU

จากนั้นเราจะใช้ daemonset กับคลัสเตอร์ ซึ่งจะติดตั้งไดรเวอร์ Nvidia บนโหนดคลัสเตอร์ที่เปิดใช้ GPU

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

จากนั้นเรียกใช้คำสั่งต่อไปนี้ ซึ่งจะให้สิทธิ์คอมโพเนนต์ KFP ในการสร้างทรัพยากร Kubernetes ใหม่

kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner

สร้าง Node Pool ของ GPU

จากนั้นเราจะตั้งค่า Node Pool ของ GPU ที่มีขนาด 1 ดังนี้

gcloud container node-pools create gpu-pool \
    --cluster=${CLUSTER_NAME} \
    --zone ${ZONE} \
    --num-nodes=1 \
    --machine-type n1-highmem-8 \
    --scopes cloud-platform --verbosity error \
    --accelerator=type=nvidia-tesla-k80,count=1

3. เรียกใช้ไปป์ไลน์จากแดชบอร์ดไปป์ไลน์

เปิดแดชบอร์ดไปป์ไลน์

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

คำอธิบายไปป์ไลน์

ไปป์ไลน์ที่คุณจะเรียกใช้มีหลายขั้นตอน (ดูรายละเอียดได้ที่ภาคผนวกของ Codelab นี้) ดังนี้

ระบบจะคัดลอกจุดตรวจสอบโมเดลที่มีอยู่ไปยังที่เก็บข้อมูล
โมเดล Tensor2Tensor ได้รับการฝึกโดยใช้ข้อมูลที่ประมวลผลล่วงหน้า

การฝึกจะเริ่มต้นจากจุดตรวจสอบโมเดลที่มีอยู่ซึ่งคัดลอกในขั้นตอนแรก จากนั้นจะฝึกอีก 2-300 ขั้นตอน (การฝึกโมเดลให้สมบูรณ์ในระหว่าง Codelab จะใช้เวลานานเกินไป)
เมื่อการฝึกเสร็จสิ้น ขั้นตอนของไปป์ไลน์จะส่งออกโมเดลในรูปแบบที่เหมาะสำหรับการแสดงผลโดย TensorFlow Serving

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

ดาวน์โหลดและคอมไพล์ไปป์ไลน์

ในส่วนนี้ เราจะดูวิธีรวบรวมคำจำกัดความของไปป์ไลน์ สิ่งแรกที่เราต้องทำคือติดตั้ง KFP SDK เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell

pip3 install -U kfp

หากต้องการดาวน์โหลดไฟล์คำจำกัดความของไปป์ไลน์ ให้เรียกใช้คำสั่งนี้จาก Cloud Shell

curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py

จากนั้นคอมไพล์ไฟล์คำจำกัดความของไปป์ไลน์โดยเรียกใช้ดังนี้

python3 gh_summ_hosted_kfp.py

คุณจะเห็นไฟล์ gh_summ_hosted_kfp.py.tar.gz ปรากฏขึ้นเป็นผลลัพธ์

อัปโหลดไปป์ไลน์ที่คอมไพล์แล้ว

ในเว็บ UI ของ Kubeflow Pipelines ให้คลิกอัปโหลดไปป์ไลน์ แล้วเลือกนำเข้าโดยใช้ URL คัดลอก จากนั้นวางใน URL ต่อไปนี้ ซึ่งชี้ไปยังไปป์ไลน์เดียวกันกับที่คุณเพิ่งคอมไพล์ (การอัปโหลดไฟล์จาก Cloud Shell มีขั้นตอนเพิ่มเติมเล็กน้อย เราจึงใช้ทางลัด)

https://storage.googleapis.com/aju-dev-demos-codelabs/KF/compiled_pipelines/gh_summ_hosted_kfp.py.tar.gz

ตั้งชื่อไปป์ไลน์ (เช่น gh_summ)

เรียกใช้ไปป์ไลน์

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

ตั้งชื่อการทดสอบ (เช่น ชื่อเดียวกับไปป์ไลน์ gh_summ) แล้วคลิกถัดไปเพื่อสร้าง

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

คุณอาจต้องเรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อช่วยกรอกพารามิเตอร์

gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"

ระบบจะป้อนชื่อการเรียกใช้โดยอัตโนมัติ แต่คุณตั้งชื่ออื่นได้หากต้องการ

จากนั้นกรอกข้อมูลในช่องพารามิเตอร์ 3 ช่อง

project
(ไม่บังคับ) github-token
working-dir

สำหรับ working-dir ให้ป้อนเส้นทางบางอย่างภายใต้ Bucket ของ GCS ที่คุณสร้างขึ้น ใส่คำนำหน้า "gs://" สำหรับฟิลด์ github-token ให้ป้อนโทเค็นที่คุณอาจสร้างไว้ก่อนหน้านี้ หรือปล่อยให้สตริงตัวยึดตำแหน่งเป็นไปตามเดิมหากคุณไม่ได้สร้างโทเค็น

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

ดูคำจำกัดความของไปป์ไลน์

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

ดูข้อมูลการฝึกโมเดลใน TensorBoard

เมื่อขั้นตอนการฝึกเสร็จสมบูรณ์ ให้เลือกแท็บการแสดงภาพ แล้วคลิกปุ่มเริ่ม TensorBoard สีน้ำเงิน จากนั้นเมื่อพร้อมแล้ว ให้คลิกเปิด TensorBoard

สำรวจแดชบอร์ดอาร์ติแฟกต์และการดำเนินการ

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

สำหรับอาร์ติแฟกต์ คุณจะดูได้ทั้งแผงภาพรวมและแผง Lineage Explorer

เรียกใช้เว็บแอปที่สร้างโดยไปป์ไลน์และทำการคาดการณ์

ขั้นตอนสุดท้ายในไปป์ไลน์จะทําการติดตั้งใช้งานเว็บแอป ซึ่งมี UI สําหรับการค้นหาโมเดลที่ฝึกแล้ว ซึ่งแสดงผ่าน TF Serving เพื่อทําการคาดการณ์

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

ค้นหาชื่อบริการโดยเรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell

kubectl get services

มองหาชื่อบริการที่คล้ายกับ ghsumm-*-webappsvc ในรายการ

จากนั้นใน Cloud Shell ให้ส่งต่อพอร์ตไปยังบริการนั้นดังนี้ เปลี่ยนคำสั่งต่อไปนี้เพื่อใช้ชื่อ webappsvc

kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80

เมื่อการส่งต่อพอร์ตทำงานแล้ว ให้คลิกไอคอน "แสดงตัวอย่าง" เหนือแผง Cloud Shell แล้วคลิก "แสดงตัวอย่างบนพอร์ต 8080" ในเมนูแบบเลื่อนลง

คุณควรเห็นหน้าเว็บลักษณะนี้ปรากฏขึ้นในแท็บใหม่

คลิกปุ่มสร้างปัญหาแบบสุ่มเพื่อดึงข้อความ คลิกสร้างชื่อเพื่อเรียกใช้โมเดลที่ฝึกแล้วและแสดงการคาดการณ์

หากพารามิเตอร์ของไปป์ไลน์มีโทเค็น GitHub ที่ถูกต้อง คุณสามารถลองป้อน URL ของ GitHub ในช่องที่ 2 แล้วคลิก "สร้างชื่อ" แทนได้ หากไม่ได้ตั้งค่าโทเค็น GitHub ที่ถูกต้อง ให้ใช้เฉพาะช่อง "สร้างปัญหาแบบสุ่ม"

4. เรียกใช้ไปป์ไลน์จาก AI Platform Notebook

นอกจากนี้ คุณยังกำหนดและเรียกใช้ไปป์ไลน์ Kubeflow จากสมุดบันทึก Jupyter แบบอินเทอร์แอกทีฟได้โดยใช้ KFP SDK AI Platform Notebooks ซึ่งเราจะใช้สำหรับ Codelab นี้ ทำให้กระบวนการนี้เป็นไปอย่างตรงไปตรงมา

สร้างอินสแตนซ์ Notebook

เราจะสร้างอินสแตนซ์สมุดบันทึกจาก Cloud Shell โดยใช้ API ของอินสแตนซ์ (หรือจะสร้าง Notebook ผ่าน Cloud Console ก็ได้ ดูข้อมูลเพิ่มเติมในเอกสารประกอบ

ตั้งค่าตัวแปรสภาพแวดล้อมต่อไปนี้ใน Cloud Shell

export INSTANCE_NAME="kfp-ghsumm"
export VM_IMAGE_PROJECT="deeplearning-platform-release"
export VM_IMAGE_FAMILY="tf2-2-3-cpu"
export MACHINE_TYPE="n1-standard-4"
export LOCATION="us-central1-c"

จากนั้นเรียกใช้คำสั่งเพื่อสร้างอินสแตนซ์ Notebook จาก Cloud Shell

gcloud beta notebooks instances create $INSTANCE_NAME \
  --vm-image-project=$VM_IMAGE_PROJECT \
  --vm-image-family=$VM_IMAGE_FAMILY \
  --machine-type=$MACHINE_TYPE --location=$LOCATION

เมื่อเรียกใช้คำสั่งนี้เป็นครั้งแรก ระบบอาจขอให้คุณเปิดใช้ notebooks API สำหรับโปรเจ็กต์ ตอบว่า "y" หากใช่

หลังจากผ่านไป 2-3 นาที เซิร์ฟเวอร์ Notebook จะพร้อมใช้งาน คุณดูอินสแตนซ์ Notebook ที่แสดงอยู่ใน Cloud Console ได้

อัปโหลด Notebook ของ Codelab

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

เรียกใช้ Notebook

ทำตามวิธีการใน Notebook สำหรับส่วนที่เหลือของแล็บ โปรดทราบว่าในส่วน "การตั้งค่า" ของ Notebook คุณจะต้องกรอกค่าของคุณเองก่อนที่จะเรียกใช้ส่วนที่เหลือของ Notebook

(หากใช้โปรเจ็กต์ของคุณเอง อย่าลืมกลับมาทำส่วน "ล้างข้อมูล" ของแล็บนี้)

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

คุณไม่จำเป็นต้องดำเนินการนี้หากใช้บัญชี Codelab ชั่วคราว แต่คุณอาจต้องการนำการติดตั้ง Pipelines และ Notebook ออกหากใช้โปรเจ็กต์ของคุณเอง

ปิดคลัสเตอร์ GKE ของไปป์ไลน์

คุณลบคลาสเตอร์ไปป์ไลน์ได้จาก Cloud Console (คุณมีตัวเลือกในการลบเฉพาะการติดตั้ง Pipelines หากต้องการใช้คลัสเตอร์ GKE ซ้ำ)

ลบอินสแตนซ์ AI Notebook

หากคุณเรียกใช้ส่วน "Notebook" ของ Codelab คุณสามารถลบหรือหยุดอินสแตนซ์ Notebook จาก Cloud Console ได้

ไม่บังคับ: นำโทเค็น GitHub ออก

ไปที่ https://github.com/settings/tokens แล้วนำโทเค็นที่สร้างออก

6. ภาคผนวก

ดูโค้ด

การกำหนดไปป์ไลน์

ไปป์ไลน์ที่ใช้ในโค้ดแล็บนี้มีการกำหนดไว้ที่นี่

มาดูวิธีที่กำหนดการไหลของงาน รวมถึงวิธีที่กำหนดคอมโพเนนต์ (ขั้นตอน) ของการไหลของงาน เราจะกล่าวถึงไฮไลต์บางส่วน แต่ดูรายละเอียดเพิ่มเติมได้ในเอกสารประกอบ

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

ขั้นตอนในไปป์ไลน์ 4 ขั้นตอนกำหนดจากคอมโพเนนต์ที่นำกลับมาใช้ใหม่ได้ ซึ่งเข้าถึงได้ผ่านไฟล์คำจำกัดความคอมโพเนนต์ ในข้อมูลโค้ดแรกนี้ เราจะเข้าถึงไฟล์คำจำกัดความของคอมโพเนนต์เหล่านี้ผ่าน URL และใช้คำจำกัดความเหล่านี้เพื่อสร้าง "ops" ที่เราจะใช้เพื่อสร้างขั้นตอนของไปป์ไลน์

import kfp.dsl as dsl
import kfp.gcp as gcp
import kfp.components as comp

...

copydata_op = comp.load_component_from_url(
  'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/datacopy_component.yaml'
  )

train_op = comp.load_component_from_url(
  'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/train_component.yaml'
  )

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

name: Train T2T model
description: |
  A Kubeflow Pipeline component to train a Tensor2Tensor
  model
metadata:
  labels:
    add-pod-env: 'true'
inputs:
  - name: train_steps
    description: '...'
    type: Integer
    default: 2019300
  - name: data_dir
    description: '...'
    type: GCSPath
  - name: model_dir
    description: '...'
    type: GCSPath
  - name: action
    description: '...'
    type: String
  - name: deploy_webapp
    description: '...'
    type: String
outputs:
  - name: launch_server
    description: '...'
    type: String
  - name: train_output_path
    description: '...'
    type: GCSPath
  - name: MLPipeline UI metadata
    type: UI metadata
implementation:
  container:
    image: gcr.io/google-samples/ml-pipeline-t2ttrain:v3ap
    args: [
      --data-dir, {inputValue: data_dir},
      --action, {inputValue: action},
      --model-dir, {inputValue: model_dir},
      --train-steps, {inputValue: train_steps},
      --deploy-webapp, {inputValue: deploy_webapp},
      --train-output-path, {outputPath: train_output_path}
    ]
    env:
      KFP_POD_NAME: "{{pod.name}}"
    fileOutputs:
      launch_server: /tmp/output
      MLPipeline UI metadata: /mlpipeline-ui-metadata.json

คุณยังกำหนดขั้นตอนไปป์ไลน์ผ่านdsl.ContainerOpตัวสร้างได้ด้วย ดังที่เราจะเห็นด้านล่าง

ด้านล่างนี้คือคำจำกัดความของไปป์ไลน์ส่วนใหญ่ เรากำลังกำหนดอินพุตของไปป์ไลน์ (และค่าเริ่มต้น) จากนั้นเราจะกำหนดขั้นตอนของไปป์ไลน์ สำหรับส่วนใหญ่ เราใช้ "ops" ที่กำหนดไว้ข้างต้น แต่เรายังกำหนดขั้นตอน "serve" แบบอินไลน์ผ่าน ContainerOp โดยระบุอาร์กิวเมนต์ของอิมเมจคอนเทนเนอร์และอาร์กิวเมนต์ของจุดแรกเข้าโดยตรงด้วย

คุณจะเห็นว่าขั้นตอน train, log_model และ serve กำลังเข้าถึงเอาต์พุตจากขั้นตอนก่อนหน้าเป็นอินพุต อ่านเพิ่มเติมเกี่ยวกับวิธีระบุเรื่องนี้ได้ที่นี่

@dsl.pipeline(
 name='Github issue summarization',
 description='Demonstrate Tensor2Tensor-based training and TF-Serving'
)
def gh_summ(  #pylint: disable=unused-argument
 train_steps: 'Integer' = 2019300,
 project: str = 'YOUR_PROJECT_HERE',
 github_token: str = 'YOUR_GITHUB_TOKEN_HERE',
 working_dir: 'GCSPath' = 'gs://YOUR_GCS_DIR_HERE',
 checkpoint_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/model_output_tbase.bak2019000/',
 deploy_webapp: str = 'true',
 data_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/t2t_data_gh_all/'
 ):


 copydata = copydata_op(
   data_dir=data_dir,
   checkpoint_dir=checkpoint_dir,
   model_dir='%s/%s/model_output' % (working_dir, dsl.RUN_ID_PLACEHOLDER),
   action=COPY_ACTION,
   )


 train = train_op(
   data_dir=data_dir,
   model_dir=copydata.outputs['copy_output_path'],
   action=TRAIN_ACTION, train_steps=train_steps,
   deploy_webapp=deploy_webapp
   )

 serve = dsl.ContainerOp(
     name='serve',
     image='gcr.io/google-samples/ml-pipeline-kubeflow-tfserve:v6',
     arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
         "--model_path", train.outputs['train_output_path']
         ]
     )

 train.set_gpu_limit(1)

โปรดทราบว่าเรากำหนดให้ขั้นตอน "train" ทำงานบนโหนดในคลัสเตอร์ที่มี GPU พร้อมใช้งานอย่างน้อย 1 ตัว

  train.set_gpu_limit(1)

ขั้นตอนสุดท้ายในไปป์ไลน์ซึ่งกำหนดไว้ในบรรทัดด้วยคือขั้นตอนแบบมีเงื่อนไข โดยจะทำงานหลังจากขั้นตอน "serve" เสร็จสิ้น และจะทำงานก็ต่อเมื่อเอาต์พุตของขั้นตอนการฝึก launch_server เป็นสตริง "true" เท่านั้น ซึ่งจะเปิดตัว "เว็บแอปการคาดการณ์" ที่เราใช้เพื่อขอสรุปปัญหาจากโมเดล T2T ที่ฝึกแล้ว

 with dsl.Condition(train.outputs['launch_server'] == 'true'):
   webapp = dsl.ContainerOp(
       name='webapp',
       image='gcr.io/google-samples/ml-pipeline-webapp-launcher:v1',
       arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
           "--github_token", github_token]

       )
   webapp.after(serve)

คำจำกัดความของอิมเมจคอนเทนเนอร์ของคอมโพเนนต์

เอกสารประกอบของ Kubeflow Pipeline อธิบายแนวทางปฏิบัติแนะนำบางส่วนสำหรับการสร้างคอมโพเนนต์ของคุณเอง ในกระบวนการนี้ คุณจะต้องกำหนดและสร้างอิมเมจคอนเทนเนอร์ คุณดูขั้นตอนของคอมโพเนนต์สำหรับไปป์ไลน์ของโค้ดแล็บนี้ได้ที่นี่ คำจำกัดความของ Dockerfile อยู่ในcontainersไดเรกทอรีย่อย เช่น ที่นี่

ใช้ VM ที่หยุดชั่วคราวได้กับ GPU สำหรับการฝึก

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

Google Kubernetes Engine (GKE) ช่วยให้ตั้งค่าคลัสเตอร์หรือ Node Pool ที่ใช้ VM แบบพรีเอมป์ชันได้ง่าย คุณตั้งค่า Node Pool ดังกล่าวได้โดยแนบ GPU กับอินสแตนซ์ที่ถูกขัดจังหวะ ซึ่งจะทำงานเหมือนกับโหนดที่เปิดใช้ GPU ทั่วไป แต่ GPU จะคงอยู่เฉพาะในช่วงเวลาที่อินสแตนซ์ทำงานเท่านั้น

คุณตั้งค่ากลุ่มโหนดที่ทำงานล่วงหน้าได้ซึ่งเปิดใช้ GPU สำหรับคลัสเตอร์ได้โดยเรียกใช้คำสั่งที่คล้ายกับคำสั่งต่อไปนี้ แก้ไขคำสั่งต่อไปนี้ด้วยชื่อคลัสเตอร์และโซนของคุณ และปรับประเภทและจำนวนตัวเร่งตามข้อกำหนดของคุณ คุณเลือกกำหนด Node Pool ให้ปรับขนาดอัตโนมัติตามภาระงานปัจจุบันได้

gcloud container node-pools create preemptible-gpu-pool \
    --cluster=<your-cluster-name> \
    --zone <your-cluster-zone> \
    --enable-autoscaling --max-nodes=4 --min-nodes=0 \
    --machine-type n1-highmem-8 \
    --preemptible \
    --node-taints=preemptible=true:NoSchedule \
    --scopes cloud-platform --verbosity error \
    --accelerator=type=nvidia-tesla-k80,count=4

นอกจากนี้ คุณยังตั้งค่า Node Pool ผ่าน Cloud Console ได้ด้วย

การกำหนดไปป์ไลน์ Kubeflow ที่ใช้โหนด GKE ที่ยุติการทำงานเองได้

หากใช้ Kubeflow ใน GKE ตอนนี้คุณสามารถกำหนดและเรียกใช้ Kubeflow Pipelines ได้อย่างง่ายดาย ซึ่งมีขั้นตอนไปป์ไลน์ (คอมโพเนนต์) อย่างน้อย 1 ขั้นตอนทำงานในโหนดที่ถูกขัดจังหวะได้ ซึ่งจะช่วยลดค่าใช้จ่ายในการเรียกใช้ชิ้นงาน หากต้องการใช้ VM ที่หยุดชั่วคราวเพื่อให้ได้ผลลัพธ์ที่ถูกต้อง ขั้นตอนที่คุณระบุว่าหยุดชั่วคราวได้ควรทำซ้ำได้ (กล่าวคือ หากคุณเรียกใช้ขั้นตอนหลายครั้ง ผลลัพธ์จะเหมือนกัน) หรือควรตรวจสอบงานเพื่อให้ขั้นตอนสามารถดำเนินการต่อจากจุดที่หยุดไว้ได้หากถูกขัดจังหวะ

เมื่อกำหนด Kubeflow Pipeline คุณจะระบุได้ว่าขั้นตอนหนึ่งๆ ควรทำงานในโหนดที่หยุดชั่วคราวได้โดยแก้ไขการดำเนินการดังนี้

your_pipelines_op.apply(gcp.use_preemptible_nodepool())

ดูรายละเอียดได้ที่เอกสารประกอบ

คุณอาจต้องลองทำขั้นตอนนี้ซ้ำหลายครั้งหากมีการขัดจังหวะโหนด คุณทำได้ดังนี้ ในที่นี้เราจะระบุการลองใหม่ 5 ครั้ง

your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)

ลองแก้ไขไปป์ไลน์ Kubeflow ที่เราใช้ใน Codelab นี้เพื่อเรียกใช้ขั้นตอนการฝึกใน VM ที่ถูกขัดจังหวะได้

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

  train.set_gpu_limit(1)

จากนั้นคอมไพล์ไปป์ไลน์อีกครั้ง อัปโหลดเวอร์ชันใหม่ (ตั้งชื่อใหม่) แล้วเรียกใช้ไปป์ไลน์เวอร์ชันใหม่