จากสมุดบันทึกไปจนถึงไปป์ไลน์ Kubeflow ด้วย MiniKF และเคล

1. บทนำ

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

การติดตั้งใช้งาน Kubeflow มีลักษณะอย่างไร

การติดตั้งใช้งาน Kubeflow มีลักษณะดังนี้

พกพาได้ - ทำงานในคลัสเตอร์ Kubernetes ใดก็ได้ ไม่ว่าจะอยู่ใน Google Cloud Platform (GCP), ในองค์กร หรือในผู้ให้บริการต่างๆ
ปรับขนาดได้ - ใช้ทรัพยากรที่ผันผวนได้และมีข้อจำกัดเฉพาะจำนวนทรัพยากรที่จัดสรรให้กับคลัสเตอร์ Kubernetes
Composable - เพิ่มประสิทธิภาพด้วย Service Worker เพื่อให้ทำงานแบบออฟไลน์หรือในเครือข่ายคุณภาพต่ำได้

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

Codelab นี้จะแนะนำวิธีสร้างการติดตั้งใช้งาน Kubeflow ของคุณเองโดยใช้ MiniKF และการเรียกใช้เวิร์กโฟลว์ Kubeflow Pipelines จากภายใน Jupyter Notebook

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

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

VM ของ MiniKF (Mini Kubeflow) ที่ติดตั้งโดยอัตโนมัติ
Kubernetes (ใช้ Minikube)
Kubeflow
Kale ซึ่งเป็นเครื่องมือสำหรับแปลง Jupyter Notebooks แบบอเนกประสงค์ให้เป็นเวิร์กโฟลว์ Kubeflow Pipelines ( GitHub)
Arrikto Rok สำหรับการควบคุมเวอร์ชันข้อมูลและความสามารถในการทำซ้ำ

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

วิธีติดตั้ง Kubeflow ด้วย MiniKF
วิธีแปลงสมุดบันทึก Jupyter เป็นไปป์ไลน์ Kubeflow โดยไม่ต้องใช้คำสั่ง CLI หรือ SDK
วิธีเรียกใช้ Kubeflow Pipelines จากภายใน Notebook ด้วยการคลิกปุ่ม
วิธีสร้างเวอร์ชันข้อมูลใน Notebook และในทุกขั้นตอนของไปป์ไลน์โดยอัตโนมัติ

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

โปรเจ็กต์ GCP ที่ใช้งานอยู่ซึ่งคุณมีสิทธิ์เจ้าของ

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

2. ตั้งค่าสภาพแวดล้อม

ตั้งค่ารหัสโปรเจ็กต์ GCP และชื่อคลัสเตอร์

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

เปิดคอนโซล GCP

หากยังไม่ได้เลือกโปรเจ็กต์ ให้คลิกเลือกโปรเจ็กต์

แล้วเลือกโปรเจ็กต์ คุณควรมีเพียงรายการเดียวต่อไปนี้

3. ติดตั้ง MiniKF

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

ค้นหา "MiniKF" ใน GCP Marketplace

เลือกเครื่องเสมือน MiniKF ของ Arrikto

คลิกปุ่มเปิดตัวใน Compute Engine แล้วเลือกโปรเจ็กต์

ในหน้าต่างกำหนดค่าและติดตั้งใช้งาน ให้เลือกชื่อสำหรับอินสแตนซ์ MiniKF แล้วปล่อยให้ตัวเลือกเริ่มต้น จากนั้นคลิกปุ่มติดตั้งใช้งาน

รอให้อินสแตนซ์การประมวลผล MiniKF บูต

เข้าสู่ระบบ MiniKF

เมื่อ VM ของ MiniKF พร้อมทำงาน ให้เชื่อมต่อและเข้าสู่ระบบโดยคลิกปุ่ม SSH ทำตามวิธีการบนหน้าจอเพื่อเรียกใช้คำสั่ง minikf ซึ่งจะเริ่มการติดตั้งใช้งาน Minikube, Kubeflow และ Rok ซึ่งอาจใช้เวลาดำเนินการสักครู่

เข้าสู่ระบบ Kubeflow

เมื่อติดตั้งเสร็จแล้วและพ็อดทั้งหมดพร้อมใช้งาน ให้ไปที่แดชบอร์ด MiniKF เข้าสู่ระบบ Kubeflow โดยใช้ชื่อผู้ใช้และรหัสผ่าน MiniKF

ผู้ใช้ Chrome จะเห็นหน้าจอนี้

ผู้ใช้ Firefox จะเห็นหน้าจอนี้

ผู้ใช้ Safari จะเห็นหน้าจอนี้

เข้าสู่ระบบ Rok

หลังจากเข้าสู่ระบบ Kubeflow แล้ว ให้เปิดเมนูด้านซ้ายโดยคลิกไอคอนเมนู 3 ขีด ไปที่ Snapshot Store แล้วเข้าสู่ระบบ Rok โดยใช้ชื่อผู้ใช้และรหัสผ่านของ MiniKF

ยินดีด้วย คุณทำให้ MiniKF ใช้งานได้บน GCP เรียบร้อยแล้ว ตอนนี้คุณสามารถสร้าง Notebook เขียนโค้ด ML และเรียกใช้ Kubeflow Pipelines ได้แล้ว ใช้ Rok สำหรับการควบคุมเวอร์ชันของข้อมูลและความสามารถในการทำซ้ำ

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

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

สร้างเซิร์ฟเวอร์ Notebook

ไปที่ลิงก์ Notebook Servers ในแดชบอร์ดส่วนกลางของ Kubeflow

คลิกเซิร์ฟเวอร์ใหม่

ระบุชื่อสำหรับ Notebook Server

ตรวจสอบว่าคุณได้เลือกรูปภาพนี้แล้ว

gcr.io/arrikto-public/tensorflow-1.14.0-notebook-cpu:kubecon-workshop

เพิ่มวอลุ่มข้อมูลใหม่ที่ว่างเปล่าขนาด 5 GB และตั้งชื่อว่า data

คลิกเปิดใช้เพื่อสร้างเซิร์ฟเวอร์ Notebook

เมื่อเซิร์ฟเวอร์ Notebook พร้อมใช้งาน ให้คลิกเชื่อมต่อเพื่อเชื่อมต่อ

ดาวน์โหลดข้อมูลและ Notebook

แท็บใหม่จะเปิดขึ้นพร้อมหน้า Landing Page ของ JupyterLab สร้างเทอร์มินัลใหม่ใน JupyterLab

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

cd data/
git clone -b kubecon-workshop https://github.com/kubeflow-kale/examples

ที่เก็บนี้มีตัวอย่างที่คัดสรรมาแล้วหลายชุดพร้อมข้อมูลและสมุดบันทึกที่มีคำอธิบายประกอบ ไปที่โฟลเดอร์ data/examples/titanic-ml-dataset/ ในแถบด้านข้าง แล้วเปิด Notebook titanic_dataset_ml.ipynb

สำรวจโค้ด ML ของชาเลนจ์ Titanic

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

กลับไปที่เทอร์มินัลแล้วติดตั้งไลบรารีที่ขาดหายไป

pip3 install --user seaborn

รีสตาร์ทเคอร์เนลของ Notebook โดยคลิกไอคอนรีเฟรช

เรียกใช้เซลล์อีกครั้งโดยติดตั้งไลบรารีที่ถูกต้อง แล้วดูผลลัพธ์

แปลง Notebook เป็นไปป์ไลน์ Kubeflow

เปิดใช้ Kale โดยคลิกไอคอน Kubeflow ในแผงด้านซ้าย

สำรวจการขึ้นต่อกันต่อเซลล์ ดูว่าเซลล์หลายเซลล์เป็นส่วนหนึ่งของขั้นตอนไปป์ไลน์เดียวได้อย่างไร และขั้นตอนไปป์ไลน์อาจขึ้นอยู่กับขั้นตอนก่อนหน้าได้อย่างไร

คลิกปุ่มคอมไพล์และเรียกใช้

ดูความคืบหน้าของสแนปชอต

ดูความคืบหน้าของการเรียกใช้ไปป์ไลน์

คลิกลิงก์เพื่อไปที่ UI ของ Kubeflow Pipelines และดูการเรียกใช้

รอจนกว่าจะเสร็จสิ้น

ยินดีด้วย คุณเพิ่งเรียกใช้ Kubeflow Pipeline แบบครบวงจรโดยเริ่มจาก Notebook

5. ความสามารถในการทำซ้ำด้วยสแนปชอตของวอลุ่ม

ตรวจสอบผลลัพธ์

ดูบันทึกของขั้นตอนไปป์ไลน์ที่ 2 จากขั้นตอนสุดท้าย Results โปรดสังเกตว่าตัวแปรทำนายทั้งหมดแสดงคะแนน 100% นักวิทยาศาสตร์ข้อมูลที่มีประสบการณ์จะพบว่าสิ่งนี้น่าสงสัยทันที ซึ่งเป็นสัญญาณที่ดีว่าโมเดลของเราไม่ได้สรุปทั่วไป แต่กลับกลายเป็นว่าโมเดลของเรามีความซับซ้อนมากเกินไปในชุดข้อมูลการฝึกแทน ซึ่งน่าจะเกิดจากปัญหาเกี่ยวกับข้อมูลที่โมเดลใช้

ทำซ้ำสถานะก่อนหน้า

โชคดีที่ Rok ดูแลการควบคุมเวอร์ชันของข้อมูลและสร้างสภาพแวดล้อมทั้งหมดขึ้นมาใหม่ตามเวลาที่คุณคลิกปุ่มคอมไพล์และเรียกใช้ วิธีนี้จะช่วยให้คุณมีไทม์แมชชีนสำหรับข้อมูลและโค้ด ดังนั้นมาดูสถานะของไปป์ไลน์ก่อนฝึกโมเดลตัวใดตัวหนึ่งกัน แล้วดูว่าเกิดอะไรขึ้น ดูขั้นตอน randomforest แล้วคลิกอาร์ติแฟกต์

ทำตามขั้นตอนใน Markdown เช่น ดูสแนปชอตใน UI ของ Rok โดยคลิกลิงก์ที่เกี่ยวข้อง

คัดลอก URL ของ Rok

ไปที่ลิงก์ Notebook Server

คลิกเซิร์ฟเวอร์ใหม่

วาง URL ของ Rok ที่คัดลอกไว้ก่อนหน้านี้ แล้วคลิกปุ่มป้อนข้อความอัตโนมัติ

ระบุชื่อสำหรับ Notebook

ตรวจสอบว่าคุณได้เลือกรูปภาพนี้แล้ว

gcr.io/arrikto-public/tensorflow-1.14.0-notebook-cpu:kubecon-workshop

คลิกเปิดใช้เพื่อสร้างเซิร์ฟเวอร์ Notebook

เมื่อเซิร์ฟเวอร์ Notebook พร้อมใช้งาน ให้คลิกเชื่อมต่อเพื่อเชื่อมต่อ

โปรดทราบว่า Notebook จะเปิดที่เซลล์ที่แน่นอนของขั้นตอนไปป์ไลน์ที่คุณสร้างขึ้น

เบื้องหลัง Kale ได้กลับมาใช้สถานะของ Notebook โดยการนำเข้าไลบรารีทั้งหมดและโหลดตัวแปรจากขั้นตอนก่อนหน้า

แก้ไขข้อบกพร่องของสถานะก่อนหน้า

เพิ่มคำสั่งพิมพ์ลงในเซลล์นี้

print(acc_random_forest)

เรียกใช้เซลล์ที่ใช้งานอยู่โดยกด Shift + Return เพื่อฝึก Random Forest อีกครั้งและพิมพ์คะแนน ซึ่งก็คือ 100

ตอนนี้ก็ถึงเวลาดูว่ามีสิ่งแปลกปลอมในข้อมูลการฝึกหรือไม่ หากต้องการสำรวจและแก้ไขปัญหานี้ ให้เพิ่มเซลล์เหนือมาร์กดาวน์ของ Random Forest โดยเลือกเซลล์ก่อนหน้า แล้วคลิกไอคอนบวก (+)

เพิ่มข้อความต่อไปนี้และเรียกใช้เซลล์เพื่อพิมพ์ชุดการฝึก

train_df

อ๊ะ! คอลัมน์ที่มีป้ายกำกับการฝึก ("รอดชีวิต") รวมอยู่ในฟีเจอร์อินพุตโดยไม่ตั้งใจ โมเดลได้เรียนรู้ที่จะมุ่งเน้นไปที่ฟีเจอร์ "รอดชีวิต" และไม่สนใจฟีเจอร์อื่นๆ ซึ่งเป็นการปนเปื้อนอินพุต คอลัมน์นี้ตรงกับเป้าหมายของโมเดลอย่างแน่นอนและไม่มีอยู่ระหว่างการคาดการณ์ จึงต้องนำออกจากชุดข้อมูลการฝึกเพื่อช่วยให้โมเดลเรียนรู้จากฟีเจอร์อื่นๆ

เพิ่มการแก้ไขข้อบกพร่อง

หากต้องการนำคอลัมน์นี้ออก ให้แก้ไขเซลล์เพื่อเพิ่มคำสั่งต่อไปนี้

train_df.drop('Survived', axis=1, inplace=True)
train_df

เปิดใช้ Kale และตรวจสอบว่าเซลล์ที่นำป้ายกำกับ Survived ออกเป็นส่วนหนึ่งของขั้นตอนไปป์ไลน์ featureengineering (ควรมีสีเส้นขอบเดียวกัน)

เรียกใช้ไปป์ไลน์อีกครั้งโดยคลิกปุ่มคอมไพล์และเรียกใช้