ลดต้นทุนและเวลาในการพัฒนาด้วยโหมดในพื้นที่ของ Amazon SageMaker Pipelines

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

ภาพรวมของวงจรชีวิต ML

หนึ่งในตัวขับเคลื่อนหลักสำหรับนวัตกรรมและแอปพลิเคชันใหม่ใน ML คือความพร้อมใช้งานและจำนวนข้อมูลพร้อมกับตัวเลือกการประมวลผลที่ถูกกว่า ในหลายโดเมน ML ได้พิสูจน์แล้วว่าสามารถแก้ปัญหาที่ก่อนหน้านี้ไม่สามารถแก้ไขได้ด้วยบิ๊กดาต้าแบบคลาสสิกและเทคนิคการวิเคราะห์ และความต้องการด้านวิทยาศาสตร์ข้อมูลและผู้ปฏิบัติงาน ML ก็เพิ่มขึ้นอย่างต่อเนื่อง จากระดับที่สูงมาก วงจรชีวิต ML ประกอบด้วยส่วนต่างๆ มากมาย แต่การสร้างแบบจำลอง ML มักจะประกอบด้วยขั้นตอนทั่วไปดังต่อไปนี้:

1. การล้างข้อมูลและการเตรียมข้อมูล (วิศวกรรมคุณลักษณะ)
2. การฝึกและปรับแต่งโมเดล
3. การประเมินแบบจำลอง
4. การปรับใช้โมเดล (หรือการแปลงเป็นชุด)

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

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

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

ท่อส่ง SageMaker

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

SageMaker Pipelines นำแนวทางปฏิบัติในการผสานรวมและการปรับใช้อย่างต่อเนื่อง (CI/CD) อย่างต่อเนื่องมาสู่ ML เช่น การรักษาความเท่าเทียมกันระหว่างสภาพแวดล้อมการพัฒนาและการผลิต การควบคุมเวอร์ชัน การทดสอบตามต้องการ และระบบอัตโนมัติแบบครบวงจร ซึ่งจะช่วยให้คุณปรับขนาด ML ได้ตลอด องค์กร. ผู้ปฏิบัติงาน DevOps ทราบดีว่าประโยชน์หลักบางประการของการใช้เทคนิค CI/CD ได้แก่ การเพิ่มผลผลิตผ่านส่วนประกอบที่นำกลับมาใช้ใหม่ได้ และการเพิ่มคุณภาพผ่านการทดสอบอัตโนมัติ ซึ่งจะทำให้ ROI เร็วขึ้นสำหรับวัตถุประสงค์ทางธุรกิจของคุณ ประโยชน์เหล่านี้พร้อมใช้งานสำหรับผู้ปฏิบัติงาน MLOps โดยใช้ SageMaker Pipelines เพื่อทำให้การฝึกอบรม การทดสอบ และการปรับใช้โมเดล ML เป็นไปโดยอัตโนมัติ ด้วยโหมดโลคัล คุณสามารถทำซ้ำได้เร็วขึ้นมากในขณะที่พัฒนาสคริปต์เพื่อใช้ในไปป์ไลน์ โปรดทราบว่าไม่สามารถดูหรือเรียกใช้อินสแตนซ์ไปป์ไลน์ในเครื่องภายใน Studio IDE ได้ อย่างไรก็ตาม ตัวเลือกการดูเพิ่มเติมสำหรับไปป์ไลน์ในพื้นที่จะมีให้ในเร็วๆ นี้

SageMaker SDK มีจุดประสงค์ทั่วไป การกำหนดค่าโหมดท้องถิ่น ที่ช่วยให้นักพัฒนาสามารถเรียกใช้และทดสอบโปรเซสเซอร์และตัวประมาณการที่สนับสนุนในสภาพแวดล้อมท้องถิ่นของตน คุณสามารถใช้การฝึกอบรมในโหมดท้องถิ่นกับอิมเมจเฟรมเวิร์กที่รองรับ AWS ได้หลายแบบ (TensorFlow, MXNet, Chainer, PyTorch และ Scikit-Learn) รวมถึงอิมเมจที่คุณจัดหาเอง

SageMaker Pipelines ซึ่งสร้าง Directed Acyclic Graph (DAG) ของขั้นตอนเวิร์กโฟลว์ที่ประสานกันไว้ รองรับกิจกรรมมากมายที่เป็นส่วนหนึ่งของวงจรชีวิต ML ในโหมดท้องถิ่น รองรับขั้นตอนต่อไปนี้:

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

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

โซลูชันของเราสาธิตขั้นตอนที่จำเป็นในการสร้างและเรียกใช้ SageMaker Pipelines ในโหมดโลคัล ซึ่งหมายถึงการใช้ทรัพยากร CPU, RAM และดิสก์ในเครื่องเพื่อโหลดและรันขั้นตอนเวิร์กโฟลว์ สภาพแวดล้อมในพื้นที่ของคุณอาจทำงานบนแล็ปท็อป โดยใช้ IDE ยอดนิยม เช่น VSCode หรือ PyCharm หรือสามารถโฮสต์โดย SageMaker โดยใช้อินสแตนซ์โน้ตบุ๊กแบบคลาสสิก

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

สำหรับตัวอย่างสมุดบันทึกนี้ เราใช้ชุดข้อมูลมาตรฐานที่เปิดเผยต่อสาธารณะ ชุดข้อมูล UCI Machine Learning Abalone. เป้าหมายคือการฝึกแบบจำลอง ML เพื่อกำหนดอายุของหอยเป๋าฮื้อจากการวัดทางกายภาพ ที่แกนกลาง นี่คือปัญหาการถดถอย

รหัสทั้งหมดที่จำเป็นในการเรียกใช้ตัวอย่างสมุดบันทึกนี้มีอยู่ใน GitHub ใน amazon-sagemaker ตัวอย่าง ที่เก็บ ในตัวอย่างสมุดบันทึกนี้ แต่ละขั้นตอนเวิร์กโฟลว์ไปป์ไลน์จะถูกสร้างขึ้นอย่างอิสระ จากนั้นต่อสายเข้าด้วยกันเพื่อสร้างไปป์ไลน์ เราสร้างขั้นตอนต่อไปนี้:

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

ไดอะแกรมต่อไปนี้แสดงไปป์ไลน์ของเรา

เบื้องต้น

เพื่อติดตามในโพสต์นี้ คุณต้องมีสิ่งต่อไปนี้:

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

สร้างไปป์ไลน์ของคุณ

ในสมุดบันทึกเล่มนี้ เราใช้ โหมดสคริปต์ SageMaker สำหรับกระบวนการ ML ส่วนใหญ่ ซึ่งหมายความว่าเราจัดเตรียมโค้ด Python (สคริปต์) จริงเพื่อดำเนินกิจกรรมและส่งการอ้างอิงไปยังโค้ดนี้ โหมดสคริปต์มีความยืดหยุ่นสูงในการควบคุมพฤติกรรมภายในการประมวลผล SageMaker โดยให้คุณปรับแต่งโค้ดของคุณในขณะที่ยังคงใช้ประโยชน์จากคอนเทนเนอร์ที่สร้างไว้ล่วงหน้าของ SageMaker เช่น XGBoost หรือ Scikit-Learn โค้ดที่กำหนดเองถูกเขียนลงในไฟล์สคริปต์ Python โดยใช้เซลล์ที่ขึ้นต้นด้วย magic command %%writefileดังต่อไปนี้:

%%writefile code/evaluation.py

ตัวเปิดใช้งานหลักของโหมดท้องถิ่นคือ LocalPipelineSession วัตถุซึ่งสร้างอินสแตนซ์จาก Python SDK ส่วนรหัสต่อไปนี้แสดงวิธีสร้างไปป์ไลน์ SageMaker ในโหมดโลคัล แม้ว่าคุณสามารถกำหนดค่าเส้นทางข้อมูลในเครื่องสำหรับขั้นตอนไปป์ไลน์ในเครื่องได้หลายขั้นตอน แต่ Amazon S3 เป็นตำแหน่งเริ่มต้นในการจัดเก็บข้อมูลที่ส่งออกโดยการแปลง ใหม่ LocalPipelineSession วัตถุถูกส่งไปยัง Python SDK ในการเรียก API เวิร์กโฟลว์ SageMaker จำนวนมากที่อธิบายไว้ในโพสต์นี้ สังเกตว่าคุณสามารถใช้ local_pipeline_session ตัวแปรเพื่อดึงข้อมูลอ้างอิงไปยังบัคเก็ตเริ่มต้นของ S3 และชื่อภูมิภาคปัจจุบัน

from sagemaker.workflow.pipeline_context import LocalPipelineSession

# Create a `LocalPipelineSession` object so that each 
# pipeline step will run locally
# To run this pipeline in the cloud, you must change 
# the `LocalPipelineSession()` to `PipelineSession()`
local_pipeline_session = LocalPipelineSession()
region = local_pipeline_session.boto_region_name

default_bucket = local_pipeline_session.default_bucket()
prefix = "sagemaker-pipelines-local-mode-example"

ก่อนที่เราจะสร้างขั้นตอนไปป์ไลน์แต่ละรายการ เราตั้งค่าพารามิเตอร์บางตัวที่ใช้โดยไปป์ไลน์ พารามิเตอร์เหล่านี้บางส่วนเป็นตัวอักษรสตริง ในขณะที่พารามิเตอร์อื่นๆ ถูกสร้างขึ้นเป็นประเภทที่แจกแจงพิเศษที่ SDK จัดเตรียมให้ การพิมพ์ที่แจกแจงทำให้มั่นใจได้ว่าการตั้งค่าที่ถูกต้องถูกจัดเตรียมให้กับไปป์ไลน์ เช่น ค่านี้ ซึ่งส่งผ่านไปยัง ConditionLessThanOrEqualTo ก้าวลงไปอีกขั้น:

mse_threshold = ParameterFloat(name="MseThreshold", default_value=7.0)

ในการสร้างขั้นตอนการประมวลผลข้อมูล ซึ่งใช้ที่นี่เพื่อดำเนินการวิศวกรรมคุณลักษณะ เราใช้ SKLearnProcessor เพื่อโหลดและแปลงชุดข้อมูล เราผ่าน local_pipeline_session ตัวแปรไปยังตัวสร้างคลาส ซึ่งสั่งให้ขั้นตอนเวิร์กโฟลว์ทำงานในโหมดโลคัล:

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=local_pipeline_session,
)

ต่อไป เราสร้างขั้นตอนไปป์ไลน์จริงครั้งแรกของเรา a ProcessingStep ออบเจ็กต์ตามที่นำเข้าจาก SageMaker SDK อาร์กิวเมนต์ตัวประมวลผลจะถูกส่งกลับจากการเรียกไปยัง SKLearnProcessor เรียกใช้ () วิธีการ ขั้นตอนเวิร์กโฟลว์นี้รวมกับขั้นตอนอื่นๆ ที่ส่วนท้ายของโน้ตบุ๊กเพื่อระบุลำดับการทำงานภายในไปป์ไลน์

from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep

processor_args = sklearn_processor.run(
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="code/preprocessing.py",
)

step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args)

ต่อไป เราจัดเตรียมรหัสเพื่อสร้างขั้นตอนการฝึกอบรมโดยสร้างอินสแตนซ์ตัวประมาณมาตรฐานก่อนโดยใช้ SageMaker SDK เราก็ผ่านเหมือนกัน local_pipeline_session ตัวแปรไปยังตัวประมาณค่าชื่อ xgb_train เป็น sagemaker_session การโต้แย้ง. เนื่องจากเราต้องการฝึกโมเดล XGBoost เราจึงต้องสร้าง URI รูปภาพที่ถูกต้องโดยระบุพารามิเตอร์ต่อไปนี้ รวมถึงเฟรมเวิร์กและพารามิเตอร์เวอร์ชันต่างๆ:

from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput

model_path = f"s3://{default_bucket}/{prefix}/model"
image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.5-1",
    py_version="py3",
    instance_type=instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    entry_point="code/abalone.py",
    instance_type=instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    role=role,
    sagemaker_session=local_pipeline_session,
)

เราสามารถเลือกเรียกวิธีการประมาณค่าเพิ่มเติมได้ เช่น set_hyperparameters()เพื่อจัดเตรียมการตั้งค่าไฮเปอร์พารามิเตอร์สำหรับงานฝึกอบรม ตอนนี้เราได้กำหนดค่าตัวประมาณแล้ว เราก็พร้อมที่จะสร้างขั้นตอนการฝึกอบรมจริง อีกครั้งที่เรานำเข้า TrainingStep คลาสจากไลบรารี SageMaker SDK:

from sagemaker.workflow.steps import TrainingStep

step_train = TrainingStep(name="AbaloneTrain", step_args=train_args)

ต่อไป เราสร้างขั้นตอนการประมวลผลอื่นเพื่อดำเนินการประเมินแบบจำลอง ทำได้โดยการสร้าง a ScriptProcessor ตัวอย่างและผ่าน local_pipeline_session วัตถุเป็นพารามิเตอร์:

from sagemaker.processing import ScriptProcessor

script_eval = ScriptProcessor(
    image_uri=image_uri,
    command=["python3"],
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="script-abalone-eval",
    role=role,
    sagemaker_session=local_pipeline_session,
)

เพื่อเปิดใช้งานการปรับใช้โมเดลที่ผ่านการฝึกอบรม ไม่ว่าจะเป็น a จุดสิ้นสุดแบบเรียลไทม์ของ SageMaker หรือการแปลงเป็นแบทช์ เราต้องสร้าง a Model อ็อบเจ็กต์โดยส่งสิ่งประดิษฐ์ของโมเดล, URI รูปภาพที่เหมาะสม และโค้ดการอนุมานแบบกำหนดเองของเรา แล้วเราก็ผ่านสิ่งนี้ไป Model คัดค้าน a ModelStepซึ่งถูกเพิ่มไปยังไปป์ไลน์ในเครื่อง ดูรหัสต่อไปนี้:

from sagemaker.model import Model

model = Model(
    image_uri=image_uri,
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir="code",
    entry_point="inference.py",
    role=role,
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.model_step import ModelStep

step_create_model = ModelStep(name="AbaloneCreateModel", 
    step_args=model.create(instance_type=instance_type)
)

ต่อไป เราสร้างขั้นตอนการแปลงเป็นชุดที่เราส่งชุดของเวกเตอร์คุณลักษณะและทำการอนุมาน ก่อนอื่นเราต้องสร้าง a Transformer วัตถุและผ่าน local_pipeline_session พารามิเตอร์ไป จากนั้นเราก็สร้าง TransformStep, ส่งผ่านอาร์กิวเมนต์ที่จำเป็น และเพิ่มสิ่งนี้ไปยังข้อกำหนดไปป์ไลน์:

from sagemaker.transformer import Transformer

transformer = Transformer(
    model_name=step_create_model.properties.ModelName,
    instance_type=instance_type,
    instance_count=transform_instance_count,
    output_path=f"s3://{default_bucket}/{prefix}/transform",
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.steps import TransformStep

transform_args = transformer.transform(transform_data, content_type="text/csv")

step_transform = TransformStep(name="AbaloneTransform", step_args=transform_args)

สุดท้าย เราต้องการเพิ่มเงื่อนไขสาขาให้กับเวิร์กโฟลว์ เพื่อให้เรารันการแปลงชุดงานก็ต่อเมื่อผลลัพธ์ของการประเมินแบบจำลองตรงตามเกณฑ์ของเรา เราสามารถระบุเงื่อนไขนี้ได้โดยการเพิ่ม a ConditionStep โดยมีเงื่อนไขเฉพาะ เช่น ConditionLessThanOrEqualTo. จากนั้นเราจะแจกแจงขั้นตอนสำหรับสองสาขา โดยพื้นฐานแล้วจะกำหนดสาขา if/else หรือ true/false ของไปป์ไลน์ if_steps ที่ให้ไว้ใน ConditionStep (step_create_model, step_transform) จะทำงานเมื่อใดก็ตามที่เงื่อนไขประเมินถึง True.

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet

cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step_name=step_eval.name,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",),
    right=mse_threshold,
)

step_cond = ConditionStep(
    name="AbaloneMSECond",
    conditions=[cond_lte],
    if_steps=[step_create_model, step_transform],
    else_steps=[step_fail],
)

ไดอะแกรมต่อไปนี้แสดงให้เห็นถึงสาขาที่มีเงื่อนไขและขั้นตอน if/else ที่เกี่ยวข้อง รันสาขาเดียวเท่านั้น โดยยึดตามผลลัพธ์ของขั้นตอนการประเมินแบบจำลองเมื่อเปรียบเทียบในขั้นตอนเงื่อนไข

ตอนนี้เราได้กำหนดขั้นตอนทั้งหมดแล้ว และสร้างอินสแตนซ์ของคลาสพื้นฐานแล้ว เราสามารถรวมมันไว้ในไปป์ไลน์ได้ เราจัดเตรียมพารามิเตอร์บางอย่าง และกำหนดลำดับการดำเนินการที่สำคัญโดยเพียงแค่ระบุขั้นตอนในลำดับที่ต้องการ โปรดทราบว่า TransformStep ไม่แสดงที่นี่เนื่องจากเป็นเป้าหมายของขั้นตอนแบบมีเงื่อนไข และระบุเป็นอาร์กิวเมนต์ขั้นตอนสำหรับ ConditionalStep ก่อน

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=local_pipeline_session,
)

ในการรันไปป์ไลน์ คุณต้องเรียกสองวิธี: pipeline.upsert()ซึ่งอัปโหลดไปป์ไลน์ไปยังบริการพื้นฐาน และ pipeline.start()ซึ่งเริ่มดำเนินการไปป์ไลน์ คุณสามารถใช้วิธีการอื่นๆ เพื่อสอบถามสถานะการรัน แสดงรายการขั้นตอนไปป์ไลน์ และอื่นๆ เนื่องจากเราใช้เซสชันไปป์ไลน์โหมดโลคัล ขั้นตอนเหล่านี้ทั้งหมดจึงรันบนโปรเซสเซอร์ของคุณ ผลลัพธ์ของเซลล์ใต้วิธีการเริ่มต้นแสดงผลลัพธ์จากไปป์ไลน์:

pipeline.upsert(role_arn=role)
execution = pipeline.start()

คุณควรเห็นข้อความที่ด้านล่างของผลลัพธ์ของเซลล์ที่คล้ายกับต่อไปนี้:

Pipeline execution d8c3e172-089e-4e7a-ad6d-6d76caf987b7 SUCCEEDED

เปลี่ยนกลับเป็นทรัพยากรที่มีการจัดการ

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

ราคาเริ่มต้นที่ sagemaker.workflow.pipeline_context นำเข้า LocalPipelineSession
from sagemaker.workflow.pipeline_context import PipelineSession

local_pipeline_session = LocalPipelineSession ()
pipeline_session = PipelineSession()

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

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=pipeline_session,  # non-local session
)

หลังจากแทนที่วัตถุเซสชันในเครื่องทุกแห่งแล้ว เราจะสร้างไปป์ไลน์ขึ้นใหม่และเรียกใช้ด้วยทรัพยากรที่มีการจัดการของ SageMaker:

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=pipeline_session, # non-local session
)

pipeline.upsert(role_arn=role)
execution = pipeline.start()

ทำความสะอาด

หากคุณต้องการรักษาสภาพแวดล้อมของ Studio ให้เป็นระเบียบ คุณสามารถใช้วิธีการต่อไปนี้เพื่อลบไปป์ไลน์ SageMaker และโมเดล รหัสเต็มสามารถพบได้ในตัวอย่าง สมุดบันทึก.

# delete models 
sm_client = boto3.client("sagemaker")
model_prefix="AbaloneCreateModel"
delete_models(sm_client, model_prefix)

# delete managed pipeline
pipeline_to_delete = 'SM-Managed-Pipeline'
delete_sagemaker_pipeline(sm_client, pipeline_to_delete)

สรุป

ก่อนหน้านี้ คุณสามารถใช้คุณลักษณะโหมดท้องถิ่นของ SageMaker Processing และ SageMaker Training เพื่อทำซ้ำในการประมวลผลและสคริปต์การฝึกอบรมในเครื่อง ก่อนที่จะรันบนข้อมูลทั้งหมดด้วยทรัพยากรที่มีการจัดการของ SageMaker ด้วยฟีเจอร์โหมดในพื้นที่ใหม่ของ SageMaker Pipelines ผู้ปฏิบัติงาน ML สามารถใช้วิธีการเดียวกันนี้เมื่อวนซ้ำบนไปป์ไลน์ ML ของตน โดยผสานเวิร์กโฟลว์ ML ต่างๆ เข้าด้วยกัน เมื่อไปป์ไลน์พร้อมสำหรับการผลิต การรันด้วยทรัพยากรที่มีการจัดการของ SageMaker ต้องการการเปลี่ยนแปลงโค้ดเพียงไม่กี่บรรทัด ซึ่งจะช่วยลดเวลารันไปป์ไลน์ระหว่างการพัฒนา นำไปสู่การพัฒนาไปป์ไลน์ที่รวดเร็วยิ่งขึ้นด้วยรอบการพัฒนาที่เร็วขึ้น ในขณะที่ลดต้นทุนของทรัพยากรที่มีการจัดการของ SageMaker

ต้องการเรียนรู้เพิ่มเติมโปรดเยี่ยมชม ท่อส่ง Amazon SageMaker or ใช้ไปป์ไลน์ของ SageMaker เพื่อเรียกใช้งานของคุณในพื้นที่.

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

พอล ฮาร์กิส ได้มุ่งเน้นความพยายามของเขาในการเรียนรู้ของเครื่องในหลายบริษัท รวมถึง AWS, Amazon และ Hortonworks เขาสนุกกับการสร้างโซลูชันด้านเทคโนโลยีและสอนผู้คนถึงวิธีใช้ประโยชน์สูงสุดจากมัน ก่อนมาทำงานที่ AWS เขาเป็นหัวหน้าสถาปนิกของ Amazon Exports and Expansions โดยช่วย amazon.com ปรับปรุงประสบการณ์สำหรับนักช็อปต่างประเทศ Paul ชอบที่จะช่วยลูกค้าขยายความคิดริเริ่มของแมชชีนเลิร์นนิงเพื่อแก้ปัญหาในโลกแห่งความเป็นจริง

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

คิริท ธาดากา เป็นสถาปนิก ML Solutions ที่ทำงานในทีม SageMaker Service SA ก่อนร่วมงานกับ AWS คิริทเคยทำงานในสตาร์ทอัพ AI ระยะเริ่มต้น ตามด้วยให้คำปรึกษาในบทบาทต่างๆ ในการวิจัย AI, MLOps และความเป็นผู้นำด้านเทคนิค