หน้านี้ได้รับการแปลโดย Cloud Translation API

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

1. บทนำ

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

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

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

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

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

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

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

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

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

ความเข้าใจเบื้องต้นเกี่ยวกับ 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}

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

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

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 แล้วสร้างโทเค็นใหม่ที่ไม่มีขอบเขต
บันทึกไว้ในที่ปลอดภัย หากทำหาย คุณจะต้องลบและสร้างขึ้นมาใหม่

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

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

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

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

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

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

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

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 เพื่อไปที่หน้า 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

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

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

ในส่วนนี้ เราจะได้อธิบายวิธีรวบรวมคำจำกัดความของไปป์ไลน์ สิ่งแรกที่เราต้องทำคือติดตั้ง 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 ให้คลิกอัปโหลดไปป์ไลน์ แล้วเลือกนำเข้าโดย 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

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

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

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

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

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

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

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

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

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

เปิดเว็บแอปที่ไปป์ไลน์สร้างขึ้นและคาดการณ์

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

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

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

kubectl get services

ค้นหาชื่อบริการ เช่น ghsumm-*-webappsvc ในรายการ

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

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

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

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

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

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

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

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

สร้างอินสแตนซ์สมุดบันทึก

เราจะสร้างอินสแตนซ์สมุดบันทึกจาก Cloud Shell โดยใช้ API (หรือคุณสามารถสร้างสมุดบันทึกผ่าน 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"

จากนั้นเรียกใช้คำสั่งจาก 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 นาที เซิร์ฟเวอร์สมุดบันทึกจะเริ่มทำงาน คุณดูอินสแตนซ์สมุดบันทึกแสดงอยู่ใน Cloud Console ได้

อัปโหลดสมุดบันทึก Codelab

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

ใช้งานสมุดบันทึก

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

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

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

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

ลบคลัสเตอร์ไปป์ไลน์ GKE

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

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

หากเรียกใช้ "สมุดบันทึก" ใน Codelab คุณลบหรือหยุดอินสแตนซ์สมุดบันทึกได้จาก Cloud Console

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

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

6. ภาคผนวก

ดูโค้ด

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

ไปป์ไลน์ที่ใช้ใน Codelab ได้รับการกำหนดไว้ที่นี่

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

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

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

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'
  )

ด้านล่างนี้เป็นคำจำกัดความของคอมโพเนนต์สำหรับการดำเนินการฝึกในรูปแบบ 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 ได้ด้วย ตามที่เราจะเห็นด้านล่าง

ด้านล่างนี้คือกลุ่มของคำจำกัดความของไปป์ไลน์ เรากำลังกำหนดอินพุตของไปป์ไลน์ (และค่าเริ่มต้น) จากนั้นเราจะกำหนดขั้นตอนของไปป์ไลน์ โดยส่วนใหญ่เราใช้ "การดำเนินการ" ที่กำหนดไว้ข้างต้น แต่เรากำลังกำหนด "บริการ" ขั้นตอนในบรรทัดผ่าน 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)

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

  train.set_gpu_limit(1)

ขั้นตอนสุดท้ายในไปป์ไลน์ (ซึ่งกำหนดแบบอินไลน์) ต้องเป็นไปตามเงื่อนไข รายการนี้จะทำงานหลัง "serve" เสร็จสิ้น หากเอาต์พุตขั้นตอนการฝึก launch_server เป็นสตริง "จริง" เท่านั้น เปิดตัว "เว็บแอปการคาดคะเน" ที่เราเคยขอสรุปปัญหาจากโมเดล 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 จะอธิบายแนวทางปฏิบัติแนะนำในการสร้างคอมโพเนนต์ของคุณเอง ในขั้นตอนนี้ คุณจะต้องกำหนดและสร้างอิมเมจคอนเทนเนอร์ ดูขั้นตอนคอมโพเนนต์สำหรับไปป์ไลน์ของ Codelab ได้ที่นี่ คำจำกัดความ Dockerfile อยู่ในไดเรกทอรีย่อย containers เช่น ที่นี่

ใช้ VM ที่ยอมให้มีการขัดจังหวะชั่วคราวกับ GPU สำหรับการฝึก

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

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

คุณสามารถตั้งค่า Node Pool ที่เปิดใช้ GPU ที่ยอมให้มีการขัดจังหวะชั่วคราวสำหรับคลัสเตอร์ของคุณโดยเรียกใช้คำสั่งที่คล้ายกับคำสั่งต่อไปนี้ แก้ไขคำสั่งต่อไปนี้ที่มีชื่อและโซนของคลัสเตอร์ รวมถึงปรับเปลี่ยนประเภทและจำนวน Accelerator ตามความต้องการของคุณ คุณเลือกกำหนด 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 ที่มีขั้นตอนของไปป์ไลน์ (คอมโพเนนต์) อย่างน้อย 1 ขั้นตอนที่เรียกใช้บนโหนดที่ยุติการทำงานเองได้ ซึ่งช่วยลดค่าใช้จ่ายในการเรียกใช้งาน หากต้องการใช้ VM ที่ยอมให้มีการขัดจังหวะชั่วคราวเพื่อให้ผลลัพธ์ที่ถูกต้อง ขั้นตอนที่คุณระบุว่ายอมให้มีการขัดจังหวะชั่วคราวควรเป็นแบบไม่มีความเคลื่อนไหว (กล่าวคือ หากคุณเรียกใช้ขั้นตอนหนึ่งหลายครั้ง ก็จะมีผลลัพธ์เหมือนกัน) หรือจุดตรวจควรทำงานได้เพื่อให้ขั้นตอนดำเนินการต่อจากจุดที่ค้างไว้ได้หากหยุดชะงัก

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

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 ที่ยอมให้มีการขัดจังหวะชั่วคราว

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

  train.set_gpu_limit(1)

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