สร้างสถาปัตยกรรมการฝึกอบรมแบบกระจายที่ยืดหยุ่นและปรับขนาดได้โดยใช้ Kubeflow บน AWS และ Amazon SageMaker

ในโพสต์นี้เราจะสาธิตวิธีการ Kubeflow บน AWS (การกระจายเฉพาะ AWS ของ Kubeflow) ที่ใช้กับ คอนเทนเนอร์การเรียนรู้เชิงลึกของ AWS และ ระบบไฟล์ Amazon Elastic (Amazon EFS) ช่วยลดความยุ่งยากในการทำงานร่วมกันและให้ความยืดหยุ่นในการฝึกอบรมโมเดลการเรียนรู้เชิงลึกในขนาดต่างๆ ทั้งคู่ บริการ Amazon Elastic Kubernetes (Amazon EKS) และ อเมซอน SageMaker โดยใช้แนวทางสถาปัตยกรรมแบบไฮบริด

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

Kubernetes เป็นระบบที่ใช้กันอย่างแพร่หลายสำหรับการปรับใช้โครงสร้างพื้นฐานอัตโนมัติ การปรับขนาดทรัพยากร และการจัดการแอปพลิเคชันที่มีคอนเทนเนอร์เหล่านี้ อย่างไรก็ตาม Kubernetes ไม่ได้สร้างขึ้นโดยคำนึงถึง ML ดังนั้นจึงสามารถรู้สึกขัดกับสัญชาตญาณของนักวิทยาศาสตร์ด้านข้อมูล เนื่องจากการพึ่งพาไฟล์ข้อมูลจำเพาะ YAML อย่างหนัก ไม่มีประสบการณ์ Jupyter และมีความสามารถเฉพาะ ML ไม่มาก เช่น การจัดการเวิร์กโฟลว์และไปป์ไลน์ และความสามารถอื่นๆ ที่ผู้เชี่ยวชาญ ML คาดหวัง เช่น การปรับแต่งไฮเปอร์พารามิเตอร์ การโฮสต์โมเดล และอื่นๆ ความสามารถดังกล่าวสามารถสร้างขึ้นได้ แต่ Kubernetes ไม่ได้ออกแบบมาเพื่อให้เป็นวัตถุประสงค์หลัก

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

Kubeflow และ Kubernetes มอบความยืดหยุ่นและการควบคุมให้กับทีมนักวิทยาศาสตร์ข้อมูล อย่างไรก็ตาม การดูแลให้คลัสเตอร์การฝึกอบรมมีการใช้งานในวงกว้างโดยมีค่าโสหุ้ยในการปฏิบัติงานที่ลดลงยังคงเป็นเรื่องที่ท้าทาย

โพสต์นี้สาธิตวิธีที่ลูกค้าที่มีข้อจำกัดภายในองค์กรหรือการลงทุน Kubernetes ที่มีอยู่สามารถจัดการกับความท้าทายนี้ได้โดยใช้ Amazon EKS และ Kubeflow บน AWS เพื่อปรับใช้ไปป์ไลน์ ML สำหรับการฝึกอบรมแบบกระจายตามแนวทางการจัดการด้วยตนเอง และใช้ SageMaker ที่มีการจัดการเต็มรูปแบบสำหรับ โครงสร้างพื้นฐานการฝึกอบรมที่ปรับต้นทุนได้อย่างเหมาะสม มีการจัดการเต็มรูปแบบ และมีขนาดการผลิต ซึ่งรวมถึงการใช้งานแบบทีละขั้นตอนของสถาปัตยกรรมการฝึกอบรมแบบกระจายแบบไฮบริดที่ให้คุณเลือกระหว่างสองแนวทางที่รันไทม์ ให้การควบคุมสูงสุดและความยืดหยุ่นพร้อมความต้องการที่เข้มงวดสำหรับการปรับใช้ของคุณ คุณจะเห็นว่าคุณสามารถใช้ไลบรารีโอเพนซอร์ซต่อไปในสคริปต์การฝึกอบรมการเรียนรู้เชิงลึกได้อย่างไร และยังทำให้ใช้งานได้กับทั้ง Kubernetes และ SageMaker ในลักษณะที่ไม่เกี่ยวกับแพลตฟอร์ม

Kubeflow บน AWS และ SageMaker ช่วยเหลืออย่างไร

โมเดลโครงข่ายประสาทเทียมที่สร้างขึ้นด้วยเฟรมเวิร์กการเรียนรู้เชิงลึก เช่น TensorFlow, PyTorch, MXNet และอื่นๆ ให้ความแม่นยำที่สูงกว่ามากโดยใช้ชุดข้อมูลการฝึกอบรมที่ใหญ่ขึ้นอย่างเห็นได้ชัด โดยเฉพาะอย่างยิ่งในกรณีการใช้งานคอมพิวเตอร์วิทัศน์และการประมวลผลภาษาธรรมชาติ อย่างไรก็ตาม ด้วยชุดข้อมูลการฝึกอบรมขนาดใหญ่ ต้องใช้เวลานานกว่าในการฝึกโมเดลการเรียนรู้เชิงลึก ซึ่งจะทำให้เวลาในการออกสู่ตลาดช้าลงในที่สุด หากเราสามารถขยายคลัสเตอร์และลดเวลาการฝึกโมเดลจากสัปดาห์เป็นวันหรือหลายชั่วโมง อาจส่งผลกระทบอย่างมากต่อประสิทธิภาพการทำงานและความเร็วของธุรกิจ

Amazon EKS ช่วยจัดเตรียมระนาบควบคุม Kubernetes ที่มีการจัดการ คุณสามารถใช้ Amazon EKS เพื่อสร้างคลัสเตอร์การฝึกอบรมขนาดใหญ่ที่มีอินสแตนซ์ CPU และ GPU และใช้ชุดเครื่องมือ Kubeflow เพื่อจัดเตรียมเครื่องมือโอเพนซอร์สที่เป็นมิตรกับ ML และดำเนินการเวิร์กโฟลว์ ML แบบพกพาและปรับขนาดได้โดยใช้ Kubeflow Pipelines เพื่อปรับปรุงประสิทธิภาพการทำงานของทีมและ ลดเวลาในการออกสู่ตลาด

อย่างไรก็ตาม แนวทางนี้อาจมีความท้าทายบางประการ:

• รับรองการใช้ประโยชน์สูงสุดของคลัสเตอร์ข้ามทีมวิทยาศาสตร์ข้อมูล ตัวอย่างเช่น คุณควรจัดเตรียมอินสแตนซ์ GPU ตามความต้องการและให้แน่ใจว่ามีการใช้งานสูงสำหรับงานระดับการผลิตที่มีความต้องการสูง เช่น การฝึกอบรมการเรียนรู้เชิงลึก และใช้อินสแตนซ์ CPU สำหรับงานที่มีความต้องการน้อยกว่า เช่น การประมวลผลข้อมูลล่วงหน้า
• สร้างความมั่นใจในความพร้อมใช้งานสูงของส่วนประกอบโครงสร้างพื้นฐาน Kubeflow รุ่นหนา ซึ่งรวมถึงฐานข้อมูล พื้นที่จัดเก็บ และการตรวจสอบสิทธิ์ ที่ปรับใช้ในโหนดผู้ปฏิบัติงานคลัสเตอร์ Kubernetes ตัวอย่างเช่น ระนาบการควบคุม Kubeflow จะสร้างสิ่งประดิษฐ์ (เช่น อินสแตนซ์ MySQL บันทึกพ็อด หรือพื้นที่จัดเก็บ MinIO) ที่เติบโตเมื่อเวลาผ่านไปและต้องการปริมาณพื้นที่จัดเก็บที่ปรับขนาดได้พร้อมความสามารถในการตรวจสอบอย่างต่อเนื่อง
• การแชร์ชุดข้อมูลการฝึกอบรม โค้ด และสภาพแวดล้อมในการประมวลผลระหว่างนักพัฒนา คลัสเตอร์การฝึกอบรม และโครงการเป็นสิ่งที่ท้าทาย ตัวอย่างเช่น หากคุณกำลังทำงานกับชุดไลบรารีของคุณเองและไลบรารีเหล่านั้นมีการพึ่งพาอาศัยกันอย่างแน่นหนา การแชร์และเรียกใช้โค้ดชิ้นเดียวกันระหว่างนักวิทยาศาสตร์ข้อมูลในทีมเดียวกันนั้นเป็นเรื่องยาก นอกจากนี้ การฝึกวิ่งแต่ละครั้งต้องการให้คุณดาวน์โหลดชุดข้อมูลการฝึก และสร้างอิมเมจการฝึกด้วยการเปลี่ยนแปลงโค้ดใหม่

Kubeflow บน AWS ช่วยจัดการกับความท้าทายเหล่านี้และมอบผลิตภัณฑ์ Kubeflow กึ่งจัดการระดับองค์กร ด้วย Kubeflow บน AWS คุณสามารถแทนที่บริการเครื่องบินควบคุมของ Kubeflow เช่น ฐานข้อมูล พื้นที่จัดเก็บ การตรวจสอบ และการจัดการผู้ใช้ด้วยบริการที่มีการจัดการของ AWS เช่น บริการฐานข้อมูลเชิงสัมพันธ์ของ Amazon (อเมซอน RDS), บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (อเมซอน เอส3) ระบบไฟล์ Amazon Elastic (อเมซอน อีเอฟเอส), อเมซอน FSx, อเมซอน คลาวด์วอตช์และ Amazon Cognito Co.

การเปลี่ยนส่วนประกอบ Kubeflow เหล่านี้จะแยกชิ้นส่วนที่สำคัญของระนาบควบคุม Kubeflow ออกจาก Kubernetes ให้การออกแบบที่ปลอดภัย ปรับขนาดได้ ยืดหยุ่น และคุ้มค่าที่สุด วิธีการนี้ยังช่วยเพิ่มพื้นที่ว่างในการจัดเก็บและประมวลผลทรัพยากรจากระนาบข้อมูล EKS ซึ่งอาจจำเป็นสำหรับแอปพลิเคชัน เช่น การฝึกอบรมแบบจำลองแบบกระจายหรือเซิร์ฟเวอร์โน้ตบุ๊กของผู้ใช้ Kubeflow บน AWS ยังให้การผสานรวมดั้งเดิมของโน้ตบุ๊ก Jupyter กับอิมเมจ Deep Learning Container (DLC) ซึ่งจัดแพคเกจไว้ล่วงหน้าและกำหนดค่าล่วงหน้าด้วยเฟรมเวิร์กการเรียนรู้เชิงลึกของ AWS ที่ปรับให้เหมาะสม เช่น PyTorch และ TensorFlow ที่ให้คุณเริ่มเขียนโค้ดการฝึกอบรมได้ทันทีโดยไม่ต้องดำเนินการใดๆ ด้วยความละเอียดในการพึ่งพาและการปรับเฟรมเวิร์กให้เหมาะสม นอกจากนี้ การผสานรวม Amazon EFS กับคลัสเตอร์การฝึกอบรมและสภาพแวดล้อมการพัฒนายังช่วยให้คุณแชร์โค้ดและชุดข้อมูลการฝึกอบรมที่ประมวลผลแล้ว ซึ่งช่วยหลีกเลี่ยงการสร้างอิมเมจคอนเทนเนอร์และการโหลดชุดข้อมูลขนาดใหญ่หลังจากการเปลี่ยนแปลงโค้ดทุกครั้ง การผสานรวมเหล่านี้กับ Kubeflow บน AWS ช่วยให้คุณเร่งเวลาในการสร้างแบบจำลองและการฝึกอบรม และช่วยให้ทำงานร่วมกันได้ดียิ่งขึ้นด้วยข้อมูลและการแชร์โค้ดที่ง่ายขึ้น

Kubeflow บน AWS ช่วยสร้างแพลตฟอร์ม ML ที่มีความพร้อมใช้งานสูงและมีประสิทธิภาพ แพลตฟอร์มนี้ให้ความยืดหยุ่นในการสร้างและฝึกอบรมโมเดลการเรียนรู้เชิงลึก และให้การเข้าถึงชุดเครื่องมือโอเพนซอร์ส ข้อมูลเชิงลึกเกี่ยวกับบันทึก และการดีบักเชิงโต้ตอบสำหรับการทดลอง อย่างไรก็ตาม การใช้ทรัพยากรโครงสร้างพื้นฐานให้เกิดประโยชน์สูงสุดในขณะที่การฝึกโมเดลการเรียนรู้เชิงลึกบน GPU หลายร้อยตัวยังคงมีค่าใช้จ่ายในการดำเนินงานเป็นจำนวนมาก ปัญหานี้สามารถแก้ไขได้โดยใช้ SageMaker ซึ่งเป็นบริการที่มีการจัดการเต็มรูปแบบซึ่งได้รับการออกแบบและปรับให้เหมาะสมสำหรับการจัดการคลัสเตอร์การฝึกอบรมที่มีประสิทธิภาพและคุ้มค่า โดยจะจัดสรรเมื่อได้รับการร้องขอเท่านั้น ปรับขนาดตามความจำเป็น และปิดโดยอัตโนมัติเมื่องานเสร็จสมบูรณ์ ส่งผลให้มีเกือบ 100 % การใช้ทรัพยากร คุณสามารถผสานรวม SageMaker กับ Kubeflow Pipelines โดยใช้ส่วนประกอบ SageMaker ที่มีการจัดการ ซึ่งช่วยให้คุณดำเนินการเวิร์กโฟลว์ ML โดยเป็นส่วนหนึ่งของไปป์ไลน์ Kubeflow ซึ่งคุณสามารถใช้ Kubernetes สำหรับการฝึกอบรมในพื้นที่ และ SageMaker สำหรับการฝึกอบรมในระดับผลิตภัณฑ์ในสถาปัตยกรรมไฮบริด

ภาพรวมโซลูชัน

สถาปัตยกรรมต่อไปนี้อธิบายวิธีที่เราใช้ Kubeflow Pipelines เพื่อสร้างและปรับใช้เวิร์กโฟลว์ ML แบบ end-to-end แบบพกพาและปรับขนาดได้ เพื่อรันการฝึกอบรมแบบกระจายตามเงื่อนไขบน Kubernetes โดยใช้การฝึกอบรม Kubeflow หรือ SageMaker ตามพารามิเตอร์รันไทม์

การฝึกอบรม Kubeflow คือกลุ่มของตัวดำเนินการ Kubernetes ที่เพิ่มการสนับสนุนสำหรับการฝึกอบรมแบบกระจายของโมเดล ML โดยใช้เฟรมเวิร์กต่างๆ เช่น TensorFlow, PyTorch และอื่นๆ pytorch-operator คือการนำ Kubeflow ไปปฏิบัติของ Kubernetes ทรัพยากรที่กำหนดเอง (PyTorchJob) เพื่อเรียกใช้งานฝึกอบรม PyTorch แบบกระจายบน Kubernetes

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

เรายังใช้ส่วนประกอบ SageMaker สำหรับ Kubeflow Pipelines เพื่อดำเนินการฝึกอบรมแบบจำลองของเราในระดับการผลิต ซึ่งช่วยให้เราใช้ประโยชน์จากคุณสมบัติ SageMaker อันทรงพลัง เช่น บริการที่มีการจัดการเต็มรูปแบบ งานฝึกอบรมแบบกระจายโดยใช้ GPU สูงสุด และการฝึกอบรมที่คุ้มค่าใช้จ่ายผ่าน อเมซอน อีลาสติก คอมพิวท์ คลาวด์ (Amazon EC2) อินสแตนซ์ Spot

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

1. ใช้ไฟล์ Manifest ของ Kubeflow เพื่อสร้างแดชบอร์ด Kubeflow และเข้าถึงสมุดบันทึก Jupyter จากแดชบอร์ดส่วนกลางของ Kubeflow
2. ใช้ Kubeflow ไปป์ไลน์ SDK เพื่อสร้างและคอมไพล์ไปป์ไลน์ Kubeflow โดยใช้โค้ด Python การรวบรวมไปป์ไลน์จะแปลงฟังก์ชัน Python เป็นทรัพยากรเวิร์กโฟลว์ ซึ่งเป็นรูปแบบ YAML ที่เข้ากันได้กับ Argo
3. ใช้ไคลเอ็นต์ SDK ของ Kubeflow Pipelines เพื่อเรียกปลายทางบริการไปป์ไลน์เพื่อเรียกใช้ไปป์ไลน์
4. ไปป์ไลน์ประเมินตัวแปรรันไทม์แบบมีเงื่อนไขและตัดสินใจระหว่าง SageMaker หรือ Kubernetes เป็นสภาพแวดล้อมการรันเป้าหมาย
5. ใช้คอมโพเนนต์ Kubeflow PyTorch Launcher เพื่อเรียกใช้การฝึกอบรมแบบกระจายบนสภาพแวดล้อม Kubernetes ดั้งเดิม หรือใช้คอมโพเนนต์ SageMaker เพื่อส่งการฝึกอบรมบนแพลตฟอร์มที่มีการจัดการของ SageMaker

รูปต่อไปนี้แสดงส่วนประกอบ Kubeflow Pipelines ที่เกี่ยวข้องกับสถาปัตยกรรมที่ให้ความยืดหยุ่นในการเลือกระหว่างสภาพแวดล้อมแบบกระจายของ Kubernetes หรือ SageMaker

ใช้เวิร์กโฟลว์กรณีและปัญหา

เราใช้วิธีการทีละขั้นตอนต่อไปนี้ในการติดตั้งและเรียกใช้กรณีการใช้งานสำหรับการฝึกอบรมแบบกระจายโดยใช้ Amazon EKS และ SageMaker โดยใช้ Kubeflow บน AWS

เบื้องต้น

สำหรับคำแนะนำนี้ คุณควรมีข้อกำหนดเบื้องต้นต่อไปนี้:

• An บัญชี AWS.
• เครื่องที่มี Docker และ อินเทอร์เฟซบรรทัดคำสั่ง AWS AWS (AWS CLI) ติดตั้งแล้ว
• หรือคุณสามารถใช้ AWS Cloud9ซึ่งเป็นสภาพแวดล้อมการพัฒนาแบบบูรณาการบนคลาวด์ (IDE) ที่ช่วยให้ทำงานทั้งหมดจากเว็บเบราว์เซอร์ของคุณ สำหรับคำแนะนำในการตั้งค่า โปรดดูที่ ตั้งค่า Cloud9 IDE. จากสภาพแวดล้อม Cloud9 ของคุณ ให้เลือกเครื่องหมายบวกและเปิดเทอร์มินัลใหม่
• สร้างบทบาท มีชื่อ sagemakerrole. เพิ่มนโยบายที่มีการจัดการ AmazonSageMakerFullAccess และ AmazonS3FullAccess เพื่อให้ SageMaker เข้าถึงบัคเก็ต S3 บทบาทนี้ถูกใช้โดยงาน SageMaker ที่ส่งโดยเป็นส่วนหนึ่งของขั้นตอน Kubeflow Pipelines
• ตรวจสอบให้แน่ใจว่าบัญชีของคุณมีขีดจำกัดประเภททรัพยากรการฝึกอบรม SageMaker สำหรับ ml.p3.2xlarge เพิ่มขึ้นเป็น 2 โดยใช้ คอนโซลโควต้าบริการ

1. ติดตั้ง Amazon EKS และ Kubeflow บน AWS

คุณสามารถใช้วิธีการต่างๆ ในการสร้างคลัสเตอร์ Kubernetes และปรับใช้ Kubeflow ได้ ในโพสต์นี้ เรามุ่งเน้นไปที่แนวทางที่เราเชื่อว่าจะนำความเรียบง่ายมาสู่กระบวนการ อันดับแรก เราสร้างคลัสเตอร์ EKS จากนั้นปรับใช้ Kubeflow บน AWS v1.5 สำหรับแต่ละงานเหล่านี้ เราใช้โครงการโอเพ่นซอร์สที่สอดคล้องกันซึ่งเป็นไปตามหลักการของ ทำกรอบงาน. แทนที่จะติดตั้งชุดข้อกำหนดเบื้องต้นสำหรับแต่ละงาน เราสร้างคอนเทนเนอร์ Docker ที่มีเครื่องมือที่จำเป็นทั้งหมดและทำงานจากภายในคอนเทนเนอร์

เราใช้ Do Framework ในโพสต์นี้ ซึ่งทำให้การปรับใช้ Kubeflow โดยอัตโนมัติด้วย Amazon EFS เป็นส่วนเสริม สำหรับตัวเลือกการปรับใช้ Kubeflow บน AWS อย่างเป็นทางการสำหรับการปรับใช้ที่ใช้งานจริง โปรดดูที่ การใช้งาน.

กำหนดค่าไดเรกทอรีการทำงานปัจจุบันและ AWS CLI

เรากำหนดค่าไดเร็กทอรีการทำงานเพื่อให้เราสามารถอ้างถึงไดเร็กทอรีนี้เป็นจุดเริ่มต้นสำหรับขั้นตอนต่อไปนี้:

export working_dir=$PWD

นอกจากนี้เรายังกำหนดค่าโปรไฟล์ AWS CLI ในการดำเนินการดังกล่าว คุณต้องมีรหัสคีย์การเข้าถึงและรหัสลับของ an AWS Identity และการจัดการการเข้าถึง (ฉัน) ผู้ใช้งาน บัญชีที่มีสิทธิ์ของผู้ดูแลระบบ (แนบนโยบายที่มีการจัดการที่มีอยู่) และการเข้าถึงแบบเป็นโปรแกรม ดูรหัสต่อไปนี้:

aws configure --profile=kubeflow
AWS Access Key ID [None]: 
AWS Secret Access Key [None]: 
Default region name [None]: us-west-2
Default output format [None]: json

# (In Cloud9, select “Cancel” and “Permanently disable” when the AWS managed temporary credentials dialog pops up)

export AWS_PROFILE=kubeflow

1.1 สร้างคลัสเตอร์ EKS

หากคุณมีคลัสเตอร์ EKS อยู่แล้ว คุณสามารถข้ามไปยังส่วนถัดไปได้ สำหรับโพสต์นี้เราใช้ โครงการ aws-do-eks เพื่อสร้างคลัสเตอร์ของเรา

1. ขั้นแรกให้โคลนโปรเจ็กต์ในไดเร็กทอรีการทำงานของคุณ

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-eks
   cd aws-do-eks/

2. จากนั้นสร้างและเรียกใช้ aws-do-eks ภาชนะ:

   ./build.sh
   ./run.sh

   พื้นที่ build.sh สคริปต์สร้างอิมเมจคอนเทนเนอร์ Docker ที่มีเครื่องมือและสคริปต์ที่จำเป็นทั้งหมดสำหรับการจัดเตรียมและการทำงานของคลัสเตอร์ EKS ดิ run.sh สคริปต์เริ่มคอนเทนเนอร์โดยใช้อิมเมจ Docker ที่สร้างขึ้นและเก็บไว้ เพื่อให้เราสามารถใช้เป็นสภาพแวดล้อมการจัดการ EKS ได้ เพื่อดูสถานะของคุณ aws-do-eks คอนเทนเนอร์คุณสามารถเรียกใช้ ./status.sh. หากคอนเทนเนอร์อยู่ในสถานะออกแล้ว คุณสามารถใช้ ./start.sh สคริปต์เพื่อนำคอนเทนเนอร์ขึ้นหรือรีสตาร์ทคอนเทนเนอร์ คุณสามารถเรียกใช้ ./stop.sh ตามมาด้วย ./run.sh.

3. เปิดเปลือกในการวิ่ง aws-do-eks ภาชนะ:
4. หากต้องการตรวจสอบการกำหนดค่าคลัสเตอร์ EKS สำหรับการปรับใช้ KubeFlow ให้เรียกใช้คำสั่งต่อไปนี้:

   vi ./eks-kubeflow.yaml

   โดยค่าเริ่มต้น การกำหนดค่านี้จะสร้างคลัสเตอร์ชื่อ eks-kubeflow ใน us-west-2 ภูมิภาคที่มีโหนด m5.xlarge หกโหนด นอกจากนี้ การเข้ารหัสโวลุ่ม EBS ไม่ได้เปิดใช้งานตามค่าเริ่มต้น คุณสามารถเปิดใช้งานได้โดยเพิ่ม "volumeEncrypted: true" ไปยัง nodegroup และจะเข้ารหัสโดยใช้คีย์เริ่มต้น แก้ไขการตั้งค่าการกำหนดค่าอื่นๆ หากจำเป็น

5. ในการสร้างคลัสเตอร์ ให้รันคำสั่งต่อไปนี้:

   export AWS_PROFILE=kubeflow
   eksctl create cluster -f ./eks-kubeflow.yaml

   กระบวนการจัดเตรียมคลัสเตอร์อาจใช้เวลานานถึง 30 นาที

6. เมื่อต้องการตรวจสอบว่าสร้างคลัสเตอร์สำเร็จแล้ว ให้รันคำสั่งต่อไปนี้:

   kubectl get nodes

   เอาต์พุตจากคำสั่งก่อนหน้าสำหรับคลัสเตอร์ที่สร้างสำเร็จจะดูเหมือนโค้ดต่อไปนี้:

   root@cdf4ecbebf62:/eks# kubectl get nodes
   NAME                                           STATUS   ROLES    AGE   VERSION
   ip-192-168-0-166.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-13-28.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-45-240.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-63-84.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-75-56.us-west-2.compute.internal    Ready       23m   v1.21.14-eks-ba74326
   ip-192-168-85-226.us-west-2.compute.internal   Ready       23m   v1.21.14-eks-ba74326

สร้างไดรฟ์ข้อมูล EFS สำหรับงานฝึกอบรม SageMaker

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

เราสร้างไดรฟ์ข้อมูล EFS และปรับใช้ไดรเวอร์ EFS Container Storage Interface (CSI) ทำได้โดยสคริปต์การปรับใช้ที่อยู่ใน /eks/deployment/csi/efs ภายใน aws-do-eks ภาชนะ

สคริปต์นี้ถือว่าคุณมีคลัสเตอร์ EKS หนึ่งรายการในบัญชีของคุณ ชุด CLUSTER_NAME= ในกรณีที่คุณมีคลัสเตอร์ EKS มากกว่าหนึ่งคลัสเตอร์

cd /eks/deployment/csi/efs
./deploy.sh

สคริปต์นี้จัดเตรียมวอลุ่ม EFS และสร้างเป้าหมายการต่อเชื่อมสำหรับซับเน็ตของ VPC ของคลัสเตอร์ จากนั้นปรับใช้ไดรเวอร์ EFS CSI และสร้าง efs-sc ชั้นเก็บของและ efs-pv ปริมาณถาวรในคลัสเตอร์ EKS

เมื่อสคริปต์เสร็จสมบูรณ์ คุณจะเห็นผลลัพธ์ดังนี้:

Generating efs-sc.yaml ...

Applying efs-sc.yaml ...
storageclass.storage.k8s.io/efs-sc created
NAME            PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
efs-sc          efs.csi.aws.com         Delete          Immediate              false                  1s
gp2 (default)   kubernetes.io/aws-ebs   Delete          WaitForFirstConsumer   false                  36m

Generating efs-pv.yaml ...
Applying efs-pv.yaml ...
persistentvolume/efs-pv created
NAME     CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS      CLAIM   STORAGECLASS   REASON   AGE
efs-pv   5Gi        RWX            Retain           Available           efs-sc                  10s

Done ...

สร้างตำแหน่งข้อมูล Amazon S3 VPC

คุณใช้ VPC ส่วนตัวที่งานฝึกอบรม SageMaker และระบบไฟล์ EFS ของคุณสามารถเข้าถึงได้ หากต้องการให้คลัสเตอร์การฝึกอบรม SageMaker เข้าถึงบัคเก็ต S3 จาก VPC ส่วนตัว คุณต้องสร้างตำแหน่งข้อมูล VPC:

cd /eks/vpc 
export CLUSTER_NAME= 
export REGION= 
./vpc-endpoint-create.sh

ตอนนี้คุณสามารถออกจาก aws-do-eks เปลือกคอนเทนเนอร์และดำเนินการในส่วนถัดไป:

exit

root@cdf4ecbebf62:/eks/deployment/csi/efs# exit
exit
TeamRole:~/environment/aws-do-eks (main) $

1.2 ปรับใช้ Kubeflow บน AWS บน Amazon EKS

ในการปรับใช้ Kubeflow บน Amazon EKS เราใช้ aws-do-kubeflow โครงการ.

1. โคลนที่เก็บโดยใช้คำสั่งต่อไปนี้:

   cd ${working_dir}
   git clone https://github.com/aws-samples/aws-do-kubeflow
   cd aws-do-kubeflow

2. จากนั้นกำหนดค่าโครงการ:

   ./config.sh

   สคริปต์นี้เปิดไฟล์การกำหนดค่าโครงการในโปรแกรมแก้ไขข้อความ มันสำคัญสำหรับ AWS_REGION เพื่อตั้งค่าเป็นภูมิภาคที่คลัสเตอร์ของคุณอยู่ เช่นเดียวกับ AWS_CLUSTER_NAME เพื่อให้ตรงกับชื่อของคลัสเตอร์ที่คุณสร้างไว้ก่อนหน้านี้ โดยค่าเริ่มต้น การกำหนดค่าของคุณได้รับการตั้งค่าอย่างถูกต้องแล้ว ดังนั้น หากคุณไม่ต้องการทำการเปลี่ยนแปลงใดๆ เพียงแค่ปิดตัวแก้ไข

   ./build.sh
   ./run.sh
   ./exec.sh

   พื้นที่ build.sh สคริปต์สร้างอิมเมจคอนเทนเนอร์ Docker ที่มีเครื่องมือทั้งหมดที่จำเป็นในการปรับใช้และจัดการ Kubeflow บนคลัสเตอร์ Kubernetes ที่มีอยู่ ดิ run.sh สคริปต์เริ่มคอนเทนเนอร์ โดยใช้อิมเมจ Docker และสคริปต์ exec.sh จะเปิดเชลล์คำสั่งในคอนเทนเนอร์ ซึ่งเราสามารถใช้เป็นสภาพแวดล้อมการจัดการ Kubeflow ได้ คุณสามารถใช้ ./status.sh สคริปต์เพื่อดูว่า aws-do-kubeflow คอนเทนเนอร์กำลังทำงานและ ./stop.sh และ ./run.sh สคริปต์เพื่อเริ่มต้นใหม่ตามต้องการ

3. หลังจากที่คุณเปิดเปลือกใน aws-do-eks คอนเทนเนอร์ คุณสามารถตรวจสอบว่าบริบทคลัสเตอร์ที่กำหนดค่าไว้เป็นไปตามที่คาดไว้:

   root@ip-172-31-43-155:/kubeflow# kubectx
   kubeflow@eks-kubeflow.us-west-2.eksctl.io

4. ในการปรับใช้ Kubeflow บนคลัสเตอร์ EKS ให้เรียกใช้ deploy.sh สคริปต์:

   ./kubeflow-deploy.sh

   การปรับใช้จะสำเร็จเมื่อพ็อดทั้งหมดในเนมสเปซ kubeflow เข้าสู่สถานะกำลังทำงาน เอาต์พุตทั่วไปดูเหมือนโค้ดต่อไปนี้:

   Waiting for all Kubeflow pods to start Running ...
   
   Waiting for all Kubeflow pods to start Running ...
   
   Restarting central dashboard ...
   pod "centraldashboard-79f489b55-vr6lp" deleted
   /kubeflow/deploy/distro/aws/kubeflow-manifests /kubeflow/deploy/distro/aws
   /kubeflow/deploy/distro/aws
   
   Kubeflow deployment succeeded
   Granting cluster access to kubeflow profile user ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   clusterrolebinding.rbac.authorization.k8s.io/kubeflow-user-example-com-cluster-admin-binding created
   Setting up access to Kubeflow Pipelines ...
   Argument not provided, assuming default user namespace kubeflow-user-example-com ...
   
   Creating pod-default for namespace kubeflow-user-example-com ...
   poddefault.kubeflow.org/access-ml-pipeline created

5. ในการตรวจสอบสถานะของพ็อด KubeFlow ในหน้าต่างแยกต่างหาก คุณสามารถใช้คำสั่งต่อไปนี้:

   watch kubectl -n kubeflow get pods

6. ข่าวประชา CTRL + C เมื่อพ็อดทั้งหมดกำลังทำงาน ให้เปิดเผยแดชบอร์ด Kubeflow ภายนอกคลัสเตอร์โดยเรียกใช้คำสั่งต่อไปนี้:

   ./kubeflow-expose.sh

คุณควรเห็นผลลัพธ์ที่ดูเหมือนรหัสต่อไปนี้:

root@ip-172-31-43-155:/kubeflow# ./kubeflow-expose.sh
root@ip-172-31-43-155:/kubeflow# Forwarding from 127.0.0.1:8080 -> 8080
Forwarding from [::1]:8080 -> 8080

คำสั่งนี้ส่งต่อบริการเกตเวย์ Istio ingress จากคลัสเตอร์ของคุณไปยังพอร์ต 8080 ในเครื่อง หากต้องการเข้าถึงแดชบอร์ด Kubeflow ให้ไปที่ http://localhost:8080 และเข้าสู่ระบบโดยใช้ข้อมูลรับรองผู้ใช้เริ่มต้น (user@example.com/12341234). หากคุณกำลังเรียกใช้ aws-do-kubeflow คอนเทนเนอร์ใน AWS Cloud9 จากนั้นคุณสามารถเลือก ดูตัวอย่างแล้วเลือก ดูตัวอย่างการใช้งานแอปพลิเคชัน. หากคุณใช้งานบน Docker Desktop คุณอาจต้องเรียกใช้ ./kubeflow-expose.sh สคริปต์นอก aws-do-kubeflow ภาชนะ

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

ในการตั้งค่า Kubeflow บนสภาพแวดล้อม AWS เราสร้างโวลุ่ม EFS และสมุดบันทึก Jupyter

2.1 สร้างโวลุ่ม EFS

ในการสร้างโวลุ่ม EFS ให้ทำตามขั้นตอนต่อไปนี้:

• บนแดชบอร์ด Kubeflow ให้เลือก ไดรฟ์ ในบานหน้าต่างนำทาง
• เลือก เล่มใหม่.
• สำหรับ Nameป้อน efs-sc-claim.
• สำหรับ ขนาดเสียงป้อน 10.
• สำหรับ ชั้นเก็บของเลือก ef-sc.
• สำหรับ เข้าถึงโหมดเลือก อ่านเขียนครั้งเดียว.
• Choose สร้างบัญชีตัวแทน.

2.2 สร้างสมุดบันทึก Jupyter

ในการสร้างสมุดบันทึกใหม่ ให้ทำตามขั้นตอนต่อไปนี้:

• บนแดชบอร์ด Kubeflow ให้เลือก โน๊ตบุ๊ค ในบานหน้าต่างนำทาง
• Choose โน๊ตบุ๊คใหม่.
• สำหรับ Nameป้อน aws-hybrid-nb.
• สำหรับ รูปภาพ Jupyter Docket, เลือกภาพ c9e4w0g3/notebook-servers/jupyter-pytorch:1.11.0-cpu-py38-ubuntu20.04-e3-v1.1 (ภาพ DLC jupyter-pytorch ล่าสุดที่มี)
• สำหรับ ซีพียูป้อน 1.
• สำหรับ หน่วยความจำป้อน 5.
• สำหรับ GPUs, ปล่อยให้เป็น ไม่มี.
• อย่าทำการเปลี่ยนแปลงใด ๆ กับ ปริมาณพื้นที่ทำงาน มาตรา.
• ตัว Vortex Indicator ได้ถูกนำเสนอลงในนิตยสาร ปริมาณข้อมูล ส่วนเลือก แนบวอลุ่มที่มีอยู่ และขยายส่วนปริมาณที่มีอยู่
• สำหรับ Nameเลือก efs-sc-claim.
• สำหรับ ทางขึ้นป้อน /home/jovyan/efs-sc-claim.
  สิ่งนี้จะเมานต์โวลุ่ม EFS กับพ็อดโน้ตบุ๊ก Jupyter ของคุณและคุณสามารถดูโฟลเดอร์ efs-sc-claim ในอินเทอร์เฟซแล็บ Jupyter ของคุณ คุณบันทึกชุดข้อมูลการฝึกและรหัสการฝึกลงในโฟลเดอร์นี้ เพื่อให้กลุ่มการฝึกสามารถเข้าถึงได้โดยไม่จำเป็นต้องสร้างอิมเมจคอนเทนเนอร์ใหม่สำหรับการทดสอบ
• เลือก อนุญาตให้เข้าถึง Kubeflow Pipelines ในส่วนการกำหนดค่า
• Choose ยิง.
  ตรวจสอบว่าสมุดบันทึกของคุณสร้างสำเร็จแล้ว (อาจใช้เวลาสองสามนาที)
• เกี่ยวกับ โน๊ตบุ๊ค หน้าให้เลือก เชื่อมต่อ เพื่อล็อกอินเข้าสู่สภาพแวดล้อม JupyterLab
• เกี่ยวกับ ไป เมนูให้เลือก โคลนที่เก็บ.
• สำหรับ โคลน repoป้อน https://github.com/aws-samples/aws-do-kubeflow.
  

3. เรียกใช้การฝึกอบรมแบบกระจาย

หลังจากที่คุณตั้งค่าสมุดบันทึก Jupyter แล้ว คุณสามารถเรียกใช้การสาธิตทั้งหมดโดยใช้ขั้นตอนระดับสูงต่อไปนี้จากโฟลเดอร์ aws-do-kubeflow/workshop ในที่เก็บโคลน:

• สคริปต์การฝึกอบรม PyTorch Distributed Data Parallel (DDP): อ้างถึงสคริปต์การฝึกอบรม PyTorch DDP cifar10-distributed-gpu-final.py ซึ่งรวมถึงตัวอย่างเครือข่ายประสาทเทียมแบบหมุนวนและตรรกะเพื่อแจกจ่ายการฝึกอบรมบนคลัสเตอร์ CPU แบบหลายโหนดและ GPU (ดูรายละเอียดในข้อ 3.1)
• ติดตั้งไลบรารี: เรียกใช้โน้ตบุ๊ก 0_initialize_dependencies.ipynb เพื่อเริ่มต้นการพึ่งพาทั้งหมด (ดูรายละเอียดในข้อ 3.2)
• เรียกใช้การฝึกอบรมงาน PyTorch แบบกระจายบน Kubernetes: เรียกใช้โน้ตบุ๊ก 1_submit_pytorchdist_k8s.ipynb เพื่อสร้างและส่งการฝึกอบรมแบบกระจายในคอนเทนเนอร์หลักหนึ่งและสองคอนเทนเนอร์ของผู้ปฏิบัติงานโดยใช้ไฟล์ PyTorchJob YAML ทรัพยากรที่กำหนดเองของ Kubernetes โดยใช้โค้ด Python (ดูรายละเอียดในข้อ 3.3)
• สร้างไปป์ไลน์ Kubeflow แบบไฮบริด: เรียกใช้โน้ตบุ๊ก 2_create_pipeline_k8s_sagemaker.ipynb เพื่อสร้างไปป์ไลน์ Kubeflow แบบไฮบริดที่รันการฝึกอบรมแบบกระจายบน SageMaker หรือ Amazon EKS โดยใช้ตัวแปรรันไทม์ training_runtime. (ดูรายละเอียดในข้อ 3.4)

ตรวจสอบให้แน่ใจว่าคุณใช้โน้ตบุ๊ก 1_submit_pytorchdist_k8s.ipynb ก่อนที่คุณจะเริ่มโน๊ตบุ๊ค 2_create_pipeline_k8s_sagemaker.ipynb.

ในหัวข้อถัดไป เราจะพูดถึงแต่ละขั้นตอนเหล่านี้โดยละเอียด

3.1 สคริปต์การฝึกอบรม PyTorch Distributed Data Parallel (DDP)

ในส่วนหนึ่งของการฝึกอบรมแบบกระจาย เราฝึกอบรมแบบจำลองการจัดหมวดหมู่ที่สร้างโดยโครงข่ายประสาทเทียมแบบง่ายที่ทำงานบนชุดข้อมูล CIFAR10 สคริปต์การฝึกอบรม cifar10-distributed-gpu-final.py มีเฉพาะไลบรารีโอเพนซอร์สและสามารถทำงานได้ทั้งบนคลัสเตอร์การฝึกอบรม Kubernetes และ SageMaker บนอุปกรณ์ GPU หรืออินสแตนซ์ของ CPU มาดูแง่มุมที่สำคัญบางประการของสคริปต์การฝึกอบรมก่อนที่เราจะเรียกใช้ตัวอย่างสมุดบันทึกของเรา

เราใช้ torch.distributed โมดูลซึ่งมีการสนับสนุน PyTorch และการสื่อสารแบบพื้นฐานสำหรับการขนานแบบหลายกระบวนการข้ามโหนดในคลัสเตอร์:

...
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
from torchvision import datasets, transforms
...

เราสร้างแบบจำลองการจัดประเภทรูปภาพอย่างง่ายโดยใช้การผสมผสานระหว่างชั้น convolutional, max pooling และเส้นตรงซึ่งมีการใช้ฟังก์ชันการเปิดใช้งาน relu ในการส่งต่อของการฝึกแบบจำลอง:

# Define models
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)

def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

เราใช้ไฟฉาย DataLoader ที่รวมชุดข้อมูลและ DistributedSampler (โหลดชุดย่อยของข้อมูลในลักษณะกระจายโดยใช้ torch.nn.parallel.DistributedDataParallel) และจัดเตรียมตัววนซ้ำแบบกระบวนการเดียวหรือหลายกระบวนการบนข้อมูล:

# Define data loader for training dataset
def _get_train_data_loader(batch_size, training_dir, is_distributed):
logger.info("Get train data loader")

train_set = torchvision.datasets.CIFAR10(root=training_dir,
train=True,
download=False,
transform=_get_transforms())

train_sampler = (
torch.utils.data.distributed.DistributedSampler(train_set) if is_distributed else None
)

return torch.utils.data.DataLoader(
train_set,
batch_size=batch_size,
shuffle=train_sampler is None,
sampler=train_sampler)
...

หากคลัสเตอร์การฝึกมี GPU สคริปต์จะเรียกใช้การฝึกบนอุปกรณ์ CUDA และตัวแปรอุปกรณ์จะเก็บอุปกรณ์ CUDA เริ่มต้นไว้:

device = "cuda" if torch.cuda.is_available() else "cpu"
...

ก่อนที่คุณจะรันการฝึกอบรมแบบกระจายโดยใช้ PyTorch DistributedDataParallel ในการรันการประมวลผลแบบกระจายบนหลายโหนด คุณต้องเริ่มต้นสภาพแวดล้อมแบบกระจายโดยการเรียก init_process_group. ซึ่งจะเริ่มต้นในแต่ละเครื่องของคลัสเตอร์การฝึกอบรม

dist.init_process_group(backend=args.backend, rank=host_rank, world_size=world_size)
...

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

model = Net().to(device)

if is_distributed:
model = torch.nn.parallel.DistributedDataParallel(model)

...

3.2 ติดตั้งไลบรารี

คุณจะติดตั้งไลบรารีที่จำเป็นทั้งหมดเพื่อเรียกใช้ตัวอย่างการฝึกอบรมแบบกระจาย PyTorch ซึ่งรวมถึง Kubeflow Pipelines SDK, ตัวดำเนินการฝึกอบรม Python SDK, ไคลเอ็นต์ Python สำหรับ Kubernetes และ Amazon SageMaker Python SDK

#Please run the below commands to install necessary libraries

!pip install kfp==1.8.4

!pip install kubeflow-training

!pip install kubernetes

!pip install sagemaker

3.3 เรียกใช้การฝึกอบรมงาน PyTorch แบบกระจายบน Kubernetes

คอมพิวเตอร์พกพา 1_submit_pytorchdist_k8s.ipynb สร้างไฟล์ PyTorchJob YAML ทรัพยากรที่กำหนดเองของ Kubernetes โดยใช้การฝึกอบรม Kubeflow และ Python SDK ของไคลเอ็นต์ Kubernetes ต่อไปนี้คือตัวอย่างข้อมูลสำคัญบางส่วนจากสมุดบันทึกนี้

เราสร้าง PyTorchJob YAML ด้วยคอนเทนเนอร์หลักและผู้ปฏิบัติงานดังแสดงในรหัสต่อไปนี้:

# Define PyTorchJob custom resource manifest
pytorchjob = V1PyTorchJob(
api_version="kubeflow.org/v1",
kind="PyTorchJob",
metadata=V1ObjectMeta(name=pytorch_distributed_jobname,namespace=user_namespace),
spec=V1PyTorchJobSpec(
run_policy=V1RunPolicy(clean_pod_policy="None"),
pytorch_replica_specs={"Master": master,
"Worker": worker}
)
)

สิ่งนี้ถูกส่งไปยังระนาบควบคุม Kubernetes โดยใช้ PyTorchJobClient:

# Creates and Submits PyTorchJob custom resource file to Kubernetes
pytorchjob_client = PyTorchJobClient()

pytorch_job_manifest=pytorchjob_client.create(pytorchjob):

ดูบันทึกการฝึกอบรม Kubernetes

คุณสามารถดูบันทึกการฝึกได้จากสมุดบันทึก Jupyter เดียวกันโดยใช้โค้ด Python หรือจากเชลล์ไคลเอ็นต์ Kubernetes

3.4 สร้างไปป์ไลน์ Kubeflow แบบไฮบริด

คอมพิวเตอร์พกพา 2_create_pipeline_k8s_sagemaker.ipynb สร้างไปป์ไลน์ Kubeflow แบบไฮบริดตามตัวแปรรันไทม์แบบมีเงื่อนไข training_runtimeดังแสดงในรหัสต่อไปนี้ โน้ตบุ๊กใช้ Kubeflow ไปป์ไลน์ SDK และได้จัดเตรียมชุดของแพ็คเกจ Python เพื่อระบุและเรียกใช้ไปป์ไลน์เวิร์กโฟลว์ ML ในฐานะที่เป็นส่วนหนึ่งของ SDK นี้ เราใช้แพ็คเกจต่อไปนี้:

• ตัวตกแต่งแพ็คเกจภาษาเฉพาะโดเมน (DSL) dsl.pipelineซึ่งตกแต่งฟังก์ชัน Python เพื่อส่งคืนไปป์ไลน์
• พื้นที่ dsl.Condition package ซึ่งหมายถึงกลุ่มของการดำเนินการที่รันเมื่อตรงตามเงื่อนไขที่กำหนดเท่านั้น เช่น การตรวจสอบ training_runtime ค่าเป็น sagemaker or kubernetes

ดูรหัสต่อไปนี้:

# Define your training runtime value with either 'sagemaker' or 'kubernetes'
training_runtime='sagemaker'

# Create Hybrid Pipeline using Kubeflow PyTorch Training Operators and Amazon SageMaker Service
@dsl.pipeline(name="PyTorch Training pipeline", description="Sample training job test")
def pytorch_cnn_pipeline():

# Pipeline Step 1: to evaluate the condition. You can enter any logic here. For demonstration we are checking if GPU is needed for training
condition_result = check_condition_op(training_runtime)

# Pipeline Step 2: to run training on Kuberentes using PyTorch Training Operators. This will be executed if gpus are not needed
with dsl.Condition(condition_result.output == 'kubernetes', name="PyTorch_Comp"):
train_task = pytorch_job_op(
name=training_job_name,
namespace=user_namespace,
master_spec=json.dumps(master_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_master_spec.yml
worker_spec=json.dumps(worker_spec_loaded), # Please refer file at pipeline_yaml_specifications/pipeline_worker_spec.yml
delete_after_done=False
).after(condition_result)

# Pipeline Step 3: to run training on SageMaker using SageMaker Components for Pipeline. This will be executed if gpus are needed
with dsl.Condition(condition_result.output == 'sagemaker', name="SageMaker_Comp"):
training = sagemaker_train_op(
region=region,
image=train_image,
job_name=training_job_name,
training_input_mode=training_input_mode,
hyperparameters='{ 
"backend": "'+str(pytorch_backend)+'", 
"batch-size": "64", 
"epochs": "3", 
"lr": "'+str(learning_rate)+'", 
"model-type": "custom", 
"sagemaker_container_log_level": "20", 
"sagemaker_program": "cifar10-distributed-gpu-final.py", 
"sagemaker_region": "us-west-2", 
"sagemaker_submit_directory": "'+source_s3+'" 
}',
channels=channels,
instance_type=instance_type,
instance_count=instance_count,
volume_size=volume_size,
max_run_time=max_run_time,
model_artifact_path=f's3://{bucket_name}/jobs',
network_isolation=network_isolation,
traffic_encryption=traffic_encryption,
role=role,
vpc_subnets=subnet_id,
vpc_security_group_ids=security_group_id
).after(condition_result)

เรากำหนดค่าการฝึกอบรมแบบกระจาย SageMaker โดยใช้อินสแตนซ์ ml.p3.2xlarge สองอินสแตนซ์

หลังจากกำหนดไปป์ไลน์แล้ว คุณสามารถคอมไพล์ไปป์ไลน์ไปยังข้อกำหนด Argo YAML โดยใช้ Kubeflow Pipelines SDK kfp.compiler บรรจุุภัณฑ์. คุณสามารถเรียกใช้ไปป์ไลน์นี้โดยใช้ไคลเอ็นต์ Kubeflow Pipeline SDK ซึ่งเรียกใช้ปลายทางบริการไปป์ไลน์และส่งผ่านในส่วนหัวการตรวจสอบสิทธิ์ที่เหมาะสมจากโน้ตบุ๊กโดยตรง ดูรหัสต่อไปนี้:

# DSL Compiler that compiles pipeline functions into workflow yaml.
kfp.compiler.Compiler().compile(pytorch_cnn_pipeline, "pytorch_cnn_pipeline.yaml")

# Connect to Kubeflow Pipelines using the Kubeflow Pipelines SDK client
client = kfp.Client()

experiment = client.create_experiment(name="kubeflow")

# Run a specified pipeline
my_run = client.run_pipeline(experiment.id, "pytorch_cnn_pipeline", "pytorch_cnn_pipeline.yaml")

# Please click “Run details” link generated below this cell to view your pipeline. You can click every pipeline step to see logs.

หากคุณได้รับไฟล์ sagemaker import ข้อผิดพลาด ให้รัน !pip ติดตั้ง sagemaker และรีสตาร์ทเคอร์เนล (บน เมล็ด เมนูให้เลือก รีสตาร์ทเคอร์เนล).

เลือก รายละเอียดการวิ่ง ใต้เซลล์สุดท้ายเพื่อดูไปป์ไลน์ Kubeflow

ทำซ้ำขั้นตอนการสร้างไปป์ไลน์ด้วย training_runtime='kubernetes' เพื่อทดสอบการทำงานของไปป์ไลน์บนสภาพแวดล้อม Kubernetes ดิ training_runtime ตัวแปรยังสามารถส่งผ่านในไปป์ไลน์ CI/CD ของคุณในสถานการณ์จริง

ดูบันทึกการเรียกใช้ไปป์ไลน์ Kubeflow สำหรับคอมโพเนนต์ SageMaker

ภาพหน้าจอต่อไปนี้แสดงรายละเอียดไปป์ไลน์ของเราสำหรับคอมโพเนนต์ SageMaker

เลือกขั้นตอนการฝึกอบรมและบน ท่อน แท็บ เลือกลิงก์บันทึก CloudWatch เพื่อเข้าถึงบันทึกของ SageMaker

ภาพหน้าจอต่อไปนี้แสดงบันทึก CloudWatch สำหรับอินสแตนซ์ ml.p3.2xlarge ทั้งสองอินสแตนซ์

เลือกกลุ่มใดก็ได้เพื่อดูบันทึก

ดูบันทึกการเรียกใช้ไปป์ไลน์ Kubeflow สำหรับคอมโพเนนต์ Kubeflow PyTorchJob Launcher

ภาพหน้าจอต่อไปนี้แสดงรายละเอียดไปป์ไลน์สำหรับคอมโพเนนต์ Kubeflow ของเรา

เรียกใช้คำสั่งต่อไปนี้โดยใช้ Kubectl บนเชลล์ไคลเอ็นต์ Kubernetes ของคุณที่เชื่อมต่อกับคลัสเตอร์ Kubernetes เพื่อดูบันทึก (แทนที่เนมสเปซและชื่อพ็อดของคุณ):

kubectl get pods -n kubeflow-user-example-com
kubectl logs  -n kubeflow-user-example-com -f

4.1 ทำความสะอาด

เพื่อล้างทรัพยากรทั้งหมดที่เราสร้างขึ้นในบัญชี เราจำเป็นต้องลบออกในลำดับที่กลับกัน

1. ลบการติดตั้ง Kubeflow โดยเรียกใช้ ./kubeflow-remove.sh ใน aws-do-kubeflow คอนเทนเนอร์. คำสั่งชุดแรกเป็นทางเลือก และสามารถใช้ได้ในกรณีที่คุณยังไม่มี command shell ใน your aws-do-kubeflow ภาชนะเปิด

   cd aws-do-kubeflow
   ./status.sh
   ./start.sh
   ./exec.sh
   
   ./kubeflow-remove.sh

2. จาก aws-do-eks โฟลเดอร์คอนเทนเนอร์ ลบโวลุ่ม EFS คำสั่งชุดแรกเป็นทางเลือก และสามารถใช้ได้ในกรณีที่คุณยังไม่มี command shell ใน your aws-do-eks ภาชนะเปิด

   cd aws-do-eks
   ./status.sh
   ./start.sh
   ./exec.sh
   
   cd /eks/deployment/csi/efs
   ./delete.sh
   ./efs-delete.sh

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

3. จาก aws-do-eks คอนเทนเนอร์ เรียกใช้ eks-delete.sh สคริปต์เพื่อลบคลัสเตอร์และทรัพยากรอื่นๆ ที่เกี่ยวข้อง รวมถึง VPC:

   cd /eks
   ./eks-delete.sh

สรุป

ในโพสต์นี้ เราได้พูดถึงความท้าทายทั่วไปบางประการของการฝึกอบรมแบบจำลองแบบกระจายและเวิร์กโฟลว์ ML เราได้ให้ภาพรวมของ Kubeflow บนการกระจายของ AWS และแชร์โครงการโอเพนซอร์สสองโครงการ (aws-ทำ-eks และ aws-do-kubeflow) ที่ลดความยุ่งยากในการจัดเตรียมโครงสร้างพื้นฐานและการปรับใช้ Kubeflow บนโครงสร้างพื้นฐาน สุดท้าย เราได้อธิบายและสาธิตสถาปัตยกรรมไฮบริดที่ช่วยให้ปริมาณงานสามารถเปลี่ยนแปลงได้อย่างราบรื่นระหว่างการรันบน Kubernetes ที่จัดการด้วยตนเองและโครงสร้างพื้นฐาน SageMaker ที่มีการจัดการเต็มรูปแบบ เราขอแนะนำให้คุณใช้สถาปัตยกรรมไฮบริดนี้สำหรับกรณีการใช้งานของคุณเอง

คุณสามารถทำตาม ที่เก็บ AWS Labs เพื่อติดตามการมีส่วนร่วมของ AWS ทั้งหมดกับ Kubeflow นอกจากนี้คุณยังสามารถพบเราบน Kubeflow #AWS ช่องหย่อน; ความคิดเห็นของคุณจะช่วยให้เราจัดลำดับความสำคัญของฟีเจอร์ถัดไปเพื่อสนับสนุนโครงการ Kubeflow

ขอขอบคุณเป็นพิเศษกับ Sree Arasanagatta (Software Development Manager AWS ML) และ Suraj Kota (Software Dev Engineer) สำหรับการสนับสนุนการเปิดตัวโพสต์นี้

เกี่ยวกับผู้แต่ง

กันวัลจิต คุรมี เป็นสถาปนิกโซลูชันผู้เชี่ยวชาญ AI/ML ที่ Amazon Web Services เขาทำงานร่วมกับผลิตภัณฑ์ AWS วิศวกรรม และลูกค้าเพื่อให้คำแนะนำและความช่วยเหลือด้านเทคนิค ซึ่งช่วยให้พวกเขาปรับปรุงคุณค่าของโซลูชัน ML แบบไฮบริดเมื่อใช้ AWS Kanwaljit เชี่ยวชาญในการช่วยเหลือลูกค้าด้วยแอพพลิเคชั่นการเรียนรู้แบบคอนเทนเนอร์และแมชชีนเลิร์นนิง

กัวตัมกุมาร เป็นวิศวกรซอฟต์แวร์ที่มี AWS AI Deep Learning เขาได้พัฒนา AWS Deep Learning Containers และ AWS Deep Learning AMI เขาหลงใหลในการสร้างเครื่องมือและระบบสำหรับ AI ในเวลาว่าง เขาชอบขี่จักรยานและอ่านหนังสือ

อเล็กซ์ เอียนคูลสกี้ เป็นสถาปนิกซอฟต์แวร์และโครงสร้างพื้นฐานแบบฟูลสแตก ซึ่งชอบทำงานเชิงลึกและลงมือปฏิบัติจริง ปัจจุบันเขาเป็น Principal Solutions Architect for Self-managed Machine Learning ที่ AWS ในบทบาทของเขา เขามุ่งเน้นที่การช่วยเหลือลูกค้าในการจัดคอนเทนเนอร์และประสานปริมาณงาน ML และ AI บนบริการ AWS ที่ขับเคลื่อนด้วยคอนเทนเนอร์ เขายังเป็นผู้เขียนโอเพ่นซอร์ส ทำกรอบงาน และกัปตัน Docker ที่รักการนำเทคโนโลยีคอนเทนเนอร์มาใช้เพื่อเร่งความเร็วของนวัตกรรมไปพร้อมกับแก้ปัญหาที่ท้าทายที่ใหญ่ที่สุดในโลก ในช่วง 10 ปีที่ผ่านมา Alex ได้ทำงานเพื่อต่อสู้กับการเปลี่ยนแปลงสภาพภูมิอากาศ ทำให้ AI และ ML เป็นประชาธิปไตย ทำให้การเดินทางปลอดภัยยิ่งขึ้น ดูแลสุขภาพดีขึ้น และใช้พลังงานอย่างชาญฉลาดขึ้น