สร้างโซลูชันการบำรุงรักษาเชิงคาดการณ์ด้วย Amazon Kinesis, AWS Glue และ Amazon SageMaker

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

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

ภาพรวมกรณีใช้งาน

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

ในโพสต์นี้ เราเน้นที่การใช้การเรียนรู้ของเครื่องกับชุดข้อมูลสังเคราะห์ที่มีความล้มเหลวของเครื่องจักรเนื่องจากคุณลักษณะต่างๆ เช่น อุณหภูมิของอากาศ อุณหภูมิในกระบวนการ ความเร็วในการหมุน แรงบิด และการสึกหรอของเครื่องมือ ชุดข้อมูลที่ใช้มีที่มาจาก ที่เก็บข้อมูล UCI.

ความล้มเหลวของเครื่องจักรประกอบด้วยโหมดความล้มเหลวที่เป็นอิสระห้าโหมด:

• การสึกหรอของเครื่องมือล้มเหลว (TWF)
• ความล้มเหลวในการกระจายความร้อน (HDF)
• ไฟฟ้าขัดข้อง (PWF)
• ความล้มเหลวเกินความเครียด (OSF)
• ความล้มเหลวแบบสุ่ม (RNF)

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

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

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

ไดอะแกรมต่อไปนี้แสดงสถาปัตยกรรมของโซลูชันโดยรวมของเรา

วิธีแก้ปัญหาอย่างกว้างๆ ประกอบด้วยส่วนต่างๆ ต่อไปนี้ ซึ่งจะอธิบายโดยละเอียดในโพสต์นี้:

• แหล่งข้อมูลสตรีมมิ่งและการนำเข้า - เราใช้ สตรีมข้อมูล Amazon Kinesis เพื่อรวบรวมข้อมูลการสตรีมจากเซ็นเซอร์ภาคสนามตามขนาดและทำให้พร้อมสำหรับการประมวลผลต่อไป
• วิศวกรรมคุณสมบัติใกล้เคียงเรียลไทม์ – เราใช้งานการสตรีม AWS Glue เพื่ออ่านข้อมูลจากสตรีมข้อมูล Kinesis และดำเนินการประมวลผลข้อมูลและวิศวกรรมคุณสมบัติ ก่อนจัดเก็บคุณสมบัติที่ได้รับใน บริการจัดเก็บข้อมูลอย่างง่ายของ Amazon (อเมซอน เอส3). Amazon S3 มอบตัวเลือกที่เชื่อถือได้และคุ้มค่าในการจัดเก็บข้อมูลปริมาณมาก
• การฝึกโมเดลและการปรับใช้ – เราใช้ชุดข้อมูลการบำรุงรักษาเชิงคาดการณ์ AI4I จาก UCI Data Repository เพื่อฝึกโมเดล ML ตามอัลกอริทึม XGBoost โดยใช้ SageMaker จากนั้น เราปรับใช้โมเดลที่ได้รับการฝึกกับจุดสิ้นสุดการอนุมานแบบอะซิงโครนัสของ SageMaker
• การอนุมาน ML แบบใกล้เรียลไทม์ – หลังจากที่คุณสมบัติพร้อมใช้งานใน Amazon S3 เราจำเป็นต้องสร้างการอนุมานจากโมเดลที่ปรับใช้ในเวลาที่เกือบเรียลไทม์ จุดสิ้นสุดการอนุมานแบบอะซิงโครนัสของ SageMaker เหมาะอย่างยิ่งสำหรับข้อกำหนดนี้ เนื่องจากรองรับขนาดเพย์โหลดที่ใหญ่ขึ้น (สูงสุด 1 GB) และสามารถสร้างการอนุมานได้ภายในไม่กี่นาที (สูงสุด 15 นาที) เราใช้การแจ้งเตือนเหตุการณ์ S3 เพื่อเรียกใช้ AWS แลมบ์ดา ฟังก์ชันเพื่อเรียกใช้จุดสิ้นสุดการอนุมานแบบอะซิงโครนัสของ SageMaker จุดสิ้นสุดการอนุมานแบบอะซิงโครนัสของ SageMaker ยอมรับตำแหน่ง S3 เป็นอินพุต สร้างการอนุมานจากโมเดลที่ปรับใช้ และเขียนการอนุมานเหล่านี้กลับไปยัง Amazon S3 ในเวลาที่เกือบเรียลไทม์

ซอร์สโค้ดสำหรับโซลูชันนี้อยู่ที่ GitHub. โซลูชันได้รับการทดสอบแล้วและควรดำเนินการใน us-east-1

เราใช้ไฟล์ การก่อตัวของ AWS Cloud เทมเพลต ปรับใช้โดยใช้ โมเดลแอปพลิเคชัน AWS Serverless (AWS SAM) และโน้ตบุ๊ก SageMaker เพื่อปรับใช้โซลูชัน

เบื้องต้น

ในการเริ่มต้น คุณจะต้องมี แซม คลิ, งูหลาม 3และ PIP ติดตั้ง คุณต้องมี .ด้วย อินเทอร์เฟซบรรทัดคำสั่ง AWS AWS (AWS CLI) กำหนดค่าอย่างเหมาะสม

ปรับใช้โซลูชัน

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

• เราเริ่มต้นด้วยการสร้างบัคเก็ต S3 ที่เราเก็บสคริปต์สำหรับงานสตรีม AWS Glue รันคำสั่งต่อไปนี้ในเทอร์มินัลของคุณเพื่อสร้างบัคเก็ตใหม่:

aws s3api create-bucket --bucket sample-script-bucket-$RANDOM --region us-east-1

• จดชื่อที่ฝากข้อมูลที่สร้างขึ้น

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

git clone https://github.com/aws-samples/amazon-sagemaker-predictive-maintenance

• ไปที่ไดเร็กทอรี sam-template:

cd amazon-sagemaker-predictive-maintenance/sam-template

• เรียกใช้คำสั่งต่อไปนี้เพื่อคัดลอกสคริปต์งาน AWS Glue (จาก glue_streaming/app.py) ไปยังบัคเก็ต S3 ที่คุณสร้างขึ้น:

aws s3 cp glue_streaming/app.py s3://sample-script-bucket-30232/glue_streaming/app.py

• ตอนนี้คุณสามารถดำเนินการสร้างและปรับใช้โซลูชันผ่านเทมเพลต CloudFormation ผ่าน AWS SAM ได้แล้ว รันคำสั่งต่อไปนี้:

sam deploy --guided

• ระบุอาร์กิวเมนต์สำหรับการปรับใช้ เช่น ชื่อสแต็ก ภูมิภาค AWS ที่ต้องการ (us-east-1), และ GlueScriptsBucket.

ตรวจสอบให้แน่ใจว่าคุณระบุบัคเก็ต S3 เดียวกันกับที่คุณสร้างไว้ก่อนหน้านี้สำหรับบัคเก็ต S3 ของสคริปต์ AWS Glue (พารามิเตอร์ GlueScriptsBucket ในภาพหน้าจอต่อไปนี้)

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

หลังจากปรับใช้สแตกสำเร็จแล้ว คุณควรเห็นข้อความต่อไปนี้

• บนคอนโซล AWS CloudFormation ให้เปิดสแต็ก (สำหรับโพสต์นี้ nrt-streaming-inference) ที่มีให้เมื่อปรับใช้เทมเพลต CloudFormation
• เกี่ยวกับ แหล่งข้อมูล ให้จดบันทึก ID อินสแตนซ์โน้ตบุ๊ก SageMaker

• บนคอนโซล SageMaker ให้เปิดอินสแตนซ์นี้

อินสแตนซ์โน้ตบุ๊ก SageMaker มีการโหลดโน้ตบุ๊กที่จำเป็นไว้ล่วงหน้าแล้ว

ไปที่โฟลเดอร์สมุดบันทึกและเปิดและทำตามคำแนะนำภายในสมุดบันทึก (Data_Pre-Processing.ipynb และ ModelTraining-Evaluation-and-Deployment.ipynb) เพื่อสำรวจชุดข้อมูล ดำเนินการประมวลผลล่วงหน้าและวิศวกรรมคุณลักษณะ และฝึกอบรมและปรับใช้โมเดลกับจุดสิ้นสุดการอนุมานแบบอะซิงโครนัสของ SageMaker

แหล่งข้อมูลสตรีมมิ่งและการนำเข้า

Kinesis Data Streams เป็นบริการสตรีมข้อมูลแบบเรียลไทม์แบบไร้เซิร์ฟเวอร์ ปรับขนาดได้ และทนทาน ซึ่งคุณสามารถใช้รวบรวมและประมวลผลสตรีมข้อมูลขนาดใหญ่แบบเรียลไทม์ Kinesis Data Streams ช่วยให้สามารถจับ ประมวลผล และจัดเก็บสตรีมข้อมูลจากแหล่งต่างๆ เช่น ข้อมูลบันทึกโครงสร้างพื้นฐานด้านไอที บันทึกแอปพลิเคชัน โซเชียลมีเดีย ฟีดข้อมูลตลาด ข้อมูลการคลิกเว็บ อุปกรณ์ IoT และเซ็นเซอร์ และอื่นๆ คุณสามารถจัดเตรียมสตรีมข้อมูล Kinesis ได้ในโหมดตามความต้องการหรือโหมดที่จัดเตรียมโดยขึ้นอยู่กับปริมาณงานและข้อกำหนดในการปรับขนาด ดูข้อมูลเพิ่มเติมได้ที่ การเลือกโหมดความจุสตรีมข้อมูล.

สำหรับกรณีการใช้งานของเรา เราคิดว่าเซ็นเซอร์ต่างๆ กำลังส่งการวัด เช่น อุณหภูมิ ความเร็วในการหมุน แรงบิด และการสึกหรอของเครื่องมือไปยังสตรีมข้อมูล Kinesis Data Streams ทำหน้าที่เป็นช่องทางในการรวบรวมและนำเข้าสตรีมข้อมูล

เราใช้ โปรแกรมสร้างข้อมูล Amazon Kinesis (KDG) ในโพสต์นี้เพื่อสร้างและส่งข้อมูลไปยังสตรีมข้อมูล Kinesis โดยจำลองข้อมูลที่สร้างขึ้นโดยเซ็นเซอร์ ข้อมูลจาก data stream sensor-data-stream ถูกนำเข้าและประมวลผลโดยใช้งานการสตรีมของ AWS Glue ซึ่งเราจะพูดถึงต่อไป

วิศวกรรมคุณสมบัติใกล้เคียงเรียลไทม์

งานการสตรีม AWS Glue เป็นวิธีที่สะดวกในการประมวลผลข้อมูลการสตรีมตามขนาด โดยไม่จำเป็นต้องจัดการสภาพแวดล้อมการประมวลผล AWS Glue ช่วยให้คุณดำเนินการแยก แปลง และโหลด (ETL) ในการสตรีมข้อมูลโดยใช้งานที่รันอย่างต่อเนื่อง ETL การสตรีม AWS Glue สร้างขึ้นบนเอ็นจิ้น Apache Spark Structured Streaming และสามารถนำเข้าสตรีมจาก Kinesis, Apache Kafka และ Amazon Managed Streaming สำหรับ Apache Kafka (อเมซอน เอ็มเอสเค).

งาน ETL การสตรีมสามารถใช้ทั้งการแปลงและการแปลงในตัวของ AWS Glue ที่มาจาก Apache Spark Structured Streaming คุณยังสามารถใช้ Spark ML และ MLLib ไลบรารีในงาน AWS Glue เพื่อการประมวลผลคุณสมบัติที่ง่ายขึ้นโดยใช้ไลบรารีตัวช่วยที่พร้อมใช้งาน

หากสคีมาของแหล่งข้อมูลการสตรีมถูกกำหนดไว้ล่วงหน้า คุณสามารถระบุได้ในตาราง AWS Data Catalog หากกำหนดคำจำกัดความของสคีมาล่วงหน้าไม่ได้ คุณสามารถเปิดใช้การตรวจหาสคีมาในงาน ETL สำหรับการสตรีมได้ จากนั้นงานจะกำหนดสคีมาจากข้อมูลขาเข้าโดยอัตโนมัติ นอกจากนี้ คุณสามารถใช้ รีจิสทรี AWS Glue Schema เพื่อให้สามารถค้นพบ ควบคุม และวิวัฒนาการของสคีมาสตรีมข้อมูลได้จากส่วนกลาง คุณสามารถผสานรวม Schema Registry กับ Data Catalog เพิ่มเติมเพื่อใช้สคีมาที่จัดเก็บไว้ใน Schema Registry เมื่อสร้างหรืออัปเดตตารางหรือพาร์ติชั่น AWS Glue ใน Data Catalog

สำหรับโพสต์นี้ เราสร้างตาราง AWS Glue Data Catalog (sensor-stream) โดยมีสตรีมข้อมูล Kinesis เป็นแหล่งที่มาและกำหนดสคีมาสำหรับข้อมูลเซ็นเซอร์ของเรา

เราสร้างดาต้าเฟรมไดนามิกของ AWS Glue จากตาราง Data Catalog เพื่ออ่านข้อมูลการสตรีมจาก Kinesis เรายังระบุตัวเลือกต่อไปนี้:

• ขนาดหน้าต่าง 60 วินาที เพื่อให้งาน AWS Glue อ่านและประมวลผลข้อมูลในหน้าต่าง 60 วินาที
• ตำแหน่งเริ่มต้น TRIM_HORIZONเพื่อให้สามารถอ่านจากระเบียนที่เก่าที่สุดใน Kinesis data stream

เรายังใช้ Spark MLlib's ตัวสร้างดัชนีสตริง คุณสมบัติหม้อแปลงเพื่อเข้ารหัสประเภทคอลัมน์สตริงลงในดัชนีฉลาก การเปลี่ยนแปลงนี้ดำเนินการโดยใช้ Spark ML Pipelines ท่อส่ง Spark ML จัดเตรียมชุด API ระดับสูงที่เหมือนกันสำหรับอัลกอริธึม ML เพื่อให้ง่ายต่อการรวมอัลกอริธึมหลาย ๆ ตัวไว้ในไปป์ไลน์หรือเวิร์กโฟลว์เดียว

เราใช้ foreachBatch API เพื่อเรียกใช้ฟังก์ชันที่ชื่อ processBatch ซึ่งจะประมวลผลข้อมูลที่อ้างอิงโดย dataframe นี้ ดูรหัสต่อไปนี้:

# Read from Kinesis Data Stream
sourceStreamData = glueContext.create_data_frame.from_catalog(database = "sensordb", table_name = "sensor-stream", transformation_ctx = "sourceStreamData", additional_options = {"startingPosition": "TRIM_HORIZON"})
type_indexer = StringIndexer(inputCol="type", outputCol="type_enc", stringOrderType="alphabetAsc")
pipeline = Pipeline(stages=[type_indexer])
glueContext.forEachBatch(frame = sourceStreamData, batch_function = processBatch, options = {"windowSize": "60 seconds", "checkpointLocation": checkpoint_location})

ProcessBatch ของฟังก์ชันดำเนินการแปลงที่ระบุและแบ่งพาร์ติชั่นข้อมูลใน Amazon S3 ตามปี เดือน วัน และรหัสแบทช์

เรายังแบ่งพาร์ติชั่น AWS Glue ใหม่เป็นพาร์ติชั่นเดียว เพื่อหลีกเลี่ยงไม่ให้มีไฟล์ขนาดเล็กมากเกินไปใน Amazon S3 การมีไฟล์ขนาดเล็กหลายไฟล์อาจขัดขวางประสิทธิภาพการอ่าน เนื่องจากจะขยายโอเวอร์เฮดที่เกี่ยวข้องกับการค้นหา การเปิด และการอ่านแต่ละไฟล์ ในที่สุด เราก็เขียนคุณสมบัติเพื่อสร้างการอนุมานเป็นคำนำหน้า (คุณสมบัติ) ภายในบัคเก็ต S3 ดูรหัสต่อไปนี้:

# Function that gets called to perform processing, feature engineering and writes to S3 for every micro batch of streaming data from Kinesis.
def processBatch(data_frame, batchId):
transformer = pipeline.fit(data_frame)
now = datetime.datetime.now()
year = now.year
month = now.month
day = now.day
hour = now.hour
minute = now.minute
if (data_frame.count() > 0):
data_frame = transformer.transform(data_frame)
data_frame = data_frame.drop("type")
data_frame = DynamicFrame.fromDF(data_frame, glueContext, "from_data_frame")
data_frame.printSchema()
# Write output features to S3
s3prefix = "features" + "/year=" + "{:0>4}".format(str(year)) + "/month=" + "{:0>2}".format(str(month)) + "/day=" + "{:0>2}".format(str(day)) + "/hour=" + "{:0>2}".format(str(hour)) + "/min=" + "{:0>2}".format(str(minute)) + "/batchid=" + str(batchId)
s3path = "s3://" + out_bucket_name + "/" + s3prefix + "/"
print("-------write start time------------")
print(str(datetime.datetime.now()))
data_frame = data_frame.toDF().repartition(1)
data_frame.write.mode("overwrite").option("header",False).csv(s3path)
print("-------write end time------------")
print(str(datetime.datetime.now()))

การฝึกโมเดลและการปรับใช้

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

ภายในสมุดบันทึก Data_Pre-Processing.ipynb, ก่อนอื่นเรานำเข้าชุดข้อมูล AI4I Predictive Maintenance จาก UCI Data Repository และทำการวิเคราะห์ข้อมูลเชิงสำรวจ (EDA) เรายังดำเนินการวิศวกรรมคุณลักษณะเพื่อทำให้คุณลักษณะของเรามีประโยชน์มากขึ้นสำหรับการฝึกโมเดล

ตัวอย่างเช่น ภายในชุดข้อมูล เรามีคุณลักษณะชื่อประเภท ซึ่งแสดงถึงประเภทคุณภาพของผลิตภัณฑ์เป็น L (ต่ำ) M (ปานกลาง) หรือ H (สูง) เนื่องจากนี่เป็นคุณสมบัติตามหมวดหมู่ เราจึงต้องเข้ารหัสก่อนฝึกโมเดลของเรา เราใช้ LabelEncoder ของ Scikit-Learn เพื่อให้บรรลุสิ่งนี้:

from sklearn.preprocessing import LabelEncoder
type_encoder = LabelEncoder()
type_encoder.fit(origdf['type'])
type_values = type_encoder.transform(origdf['type'])

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

งานฝึกอบรม SageMaker มอบวิธีที่มีประสิทธิภาพและยืดหยุ่นในการฝึกโมเดล ML บน SageMaker SageMaker จัดการโครงสร้างพื้นฐานการประมวลผลพื้นฐานและให้บริการ หลายตัวเลือก เพื่อเลือกจากความต้องการการฝึกอบรมแบบจำลองที่หลากหลายตามกรณีการใช้งาน

xgb = sagemaker.estimator.Estimator(container,
role,
instance_count=1,
instance_type='ml.c4.4xlarge',
output_path=xgb_upload_location,
sagemaker_session=sagemaker_session)
xgb.set_hyperparameters(max_depth=5,
eta=0.2,
gamma=4,
min_child_weight=6,
subsample=0.8,
silent=0,
objective='binary:hinge',
num_round=100)

xgb.fit({'train': s3_train_channel, 'validation': s3_valid_channel})

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

endpoint_config_name = resource_name.format("EndpointConfig")
create_endpoint_config_response = sm_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": "variant1",
"ModelName": model_name,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
}
],
AsyncInferenceConfig={
"OutputConfig": {
"S3OutputPath": f"s3://{bucket}/{prefix}/output",
#Specify Amazon SNS topics
"NotificationConfig": {
"SuccessTopic": "arn:aws:sns:<region>:<account-id>:<success-sns-topic>",
"ErrorTopic": "arn:aws:sns:<region>:<account-id>:<error-sns-topic>",
}},
"ClientConfig": {"MaxConcurrentInvocationsPerInstance": 4},
},)

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

endpoint_name = resource_name.format("Endpoint")
create_endpoint_response = sm_client.create_endpoint(
EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name)

การอนุมานใกล้เคียงเรียลไทม์

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

คุณสามารถสร้างจุดสิ้นสุดการอนุมานแบบอะซิงโครนัสของ SageMaker ได้เหมือนกับที่คุณสร้างจุดสิ้นสุดการอนุมานแบบเรียลไทม์และระบุเพิ่มเติม AsyncInferenceConfig ขณะสร้างการกำหนดค่าปลายทางของคุณด้วยฟิลด์ EndpointConfig ใน CreateEndpointConfig API ไดอะแกรมต่อไปนี้แสดงเวิร์กโฟลว์การอนุมานและวิธีที่จุดสิ้นสุดการอนุมานแบบอะซิงโครนัสสร้างการอนุมาน

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

ทดสอบโซลูชันแบบครบวงจร

ในการทดสอบโซลูชัน ให้ทำตามขั้นตอนต่อไปนี้:

• บนคอนโซล AWS CloudFormation ให้เปิดสแต็กที่คุณสร้างไว้ก่อนหน้านี้ (nrt-streaming-inference).
• เกี่ยวกับ Outputs แท็บคัดลอกชื่อของที่ฝากข้อมูล S3 (EventsBucket).

นี่คือบัคเก็ต S3 ที่งานการสตรีม AWS Glue ของเราเขียนคุณสมบัติหลังจากอ่านและประมวลผลจากสตรีมข้อมูล Kinesis

ต่อไป เราตั้งค่าการแจ้งเตือนกิจกรรมสำหรับบัคเก็ต S3 นี้

• บนคอนโซล Amazon S3 ให้ไปที่ที่เก็บข้อมูล EventsBucket.
• เกี่ยวกับ อสังหาริมทรัพย์ ในแท็บ การแจ้งเตือนเหตุการณ์ ส่วนเลือก สร้างการแจ้งเตือนเหตุการณ์.

• สำหรับ ชื่อเหตุการณ์ป้อน invoke-endpoint-lambda.
• สำหรับ อุปสรรคป้อน features/.
• สำหรับ วิภัตติป้อน .csv.
• สำหรับ ประเภทเหตุการณ์ให้เลือก วัตถุทั้งหมดสร้างเหตุการณ์.

• สำหรับ ปลายทางให้เลือก ฟังก์ชันแลมบ์ดา.
• สำหรับ ฟังก์ชันแลมบ์ดาและเลือกฟังก์ชั่น invoke-endpoint-asynch.
• Choose บันทึกการเปลี่ยนแปลง.

• บนคอนโซล AWS Glue เปิดงาน GlueStreaming-Kinesis-S3.
• Choose เรียกใช้งาน.

ต่อไป เราใช้ Kinesis Data Generator (KDG) เพื่อจำลองเซ็นเซอร์ที่ส่งข้อมูลไปยังสตรีมข้อมูล Kinesis ของเรา หากนี่เป็นครั้งแรกที่คุณใช้ KDG โปรดดูที่ ขององค์กร สำหรับการตั้งค่าเริ่มต้น KDG มีเทมเพลต CloudFormation เพื่อสร้างผู้ใช้และกำหนดสิทธิ์ให้เพียงพอเพื่อใช้ KDG ในการส่งกิจกรรมไปยัง Kinesis เรียกใช้ เทมเพลต CloudFormation ภายในบัญชี AWS ที่คุณใช้สร้างโซลูชันในโพสต์นี้ หลังจากตั้งค่า KDG แล้ว ให้เข้าสู่ระบบและเข้าถึง KDG เพื่อส่งเหตุการณ์ทดสอบไปยังสตรีมข้อมูล Kinesis ของเรา

• ใช้ภูมิภาคที่คุณสร้างสตรีมข้อมูล Kinesis (us-east-1)
• บนเมนูแบบเลื่อนลง ให้เลือกสตรีมข้อมูล sensor-data-stream.
• ตัว Vortex Indicator ได้ถูกนำเสนอลงในนิตยสาร บันทึกต่อวินาที เลือก ค่าคงที่ และป้อน 100
• ยกเลิกการเลือก บีบอัดบันทึก.
• สำหรับ เทมเพลตบันทึกให้ใช้เทมเพลตต่อไปนี้:

{
"air_temperature": {{random.number({"min":295,"max":305, "precision":0.01})}},
"process_temperature": {{random.number({"min":305,"max":315, "precision":0.01})}},
"rotational_speed": {{random.number({"min":1150,"max":2900})}},
"torque": {{random.number({"min":3,"max":80, "precision":0.01})}},
"tool_wear": {{random.number({"min":0,"max":250})}},
"type": "{{random.arrayElement(["L","M","H"])}}"
}

• คลิก ส่งข้อมูล เพื่อเริ่มส่งข้อมูลไปยังสตรีมข้อมูล Kinesis

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

เนื่องจากคุณสมบัติใหม่ที่สร้างโดยงานการสตรีม AWS Glue ถูกเขียนไปยังบัคเก็ต S3 ฟังก์ชัน Lambda (invoke-endpoint-asynch) ถูกทริกเกอร์ ซึ่งจะเรียกใช้จุดสิ้นสุดการอนุมานแบบอะซิงโครนัสของ SageMaker โดยส่งคำขอเรียกใช้เพื่อรับการอนุมานจากโมเดล ML ที่ปรับใช้ของเรา จุดสิ้นสุดการอนุมานแบบอะซิงโครนัสจะจัดคิวคำขอสำหรับการเรียกใช้แบบอะซิงโครนัส เมื่อการประมวลผลเสร็จสิ้น SageMaker จะเก็บผลการอนุมานไว้ในตำแหน่ง Amazon S3 (S3OutputPath) ที่ระบุระหว่างการกำหนดค่าจุดสิ้นสุดการอนุมานแบบอะซิงโครนัส

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

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

สำหรับแอปพลิเคชันในโลกแห่งความเป็นจริง คุณสามารถรวมการแจ้งเตือน SNS กับบริการอื่นๆ เช่น บริการ Amazon Simple Queue (Amazon SQS) และ Lambda สำหรับการประมวลผลภายหลังเพิ่มเติมของการอนุมานที่สร้างขึ้นหรือการรวมเข้ากับแอปพลิเคชันดาวน์สตรีมอื่นๆ ตามความต้องการของคุณ ตัวอย่างเช่น สำหรับกรณีการใช้งานการบำรุงรักษาเชิงคาดการณ์ของเรา คุณสามารถเรียกใช้ฟังก์ชัน Lambda ตามการแจ้งเตือน SNS เพื่ออ่านการอนุมานที่สร้างขึ้นจาก Amazon S3 ประมวลผลเพิ่มเติม (เช่น การรวมหรือการกรอง) และเริ่มเวิร์กโฟลว์ เช่น การส่งคำสั่งงานสำหรับ ซ่อมอุปกรณ์ให้ช่าง

ทำความสะอาด

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

เรียกใช้รหัสต่อไปนี้เพื่อลบสแต็กของคุณ:

sam delete nrt-streaming-inference

นอกจากนี้ ให้ลบทรัพยากร เช่น SageMaker endpoints โดยทำตามส่วนการล้างข้อมูลในสมุดบันทึก ModelTraining-Evaluation-and-Deployment

สรุป

ในโพสต์นี้ เราใช้กรณีการใช้งานการบำรุงรักษาเชิงคาดการณ์เพื่อสาธิตวิธีใช้บริการต่างๆ เช่น Kinesis, AWS Glue และ SageMaker เพื่อสร้างไปป์ไลน์การอนุมานแบบเกือบเรียลไทม์ เราขอแนะนำให้คุณลองใช้วิธีแก้ปัญหานี้และแจ้งให้เราทราบว่าคุณคิดอย่างไร

หากคุณมีคำถามใด ๆ แบ่งปันในความคิดเห็น

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

ราหุลชาร์ เป็นสถาปนิกโซลูชันที่ AWS Data Lab ซึ่งช่วยลูกค้า AWS ออกแบบและสร้างโซลูชัน AI/ML ก่อนร่วมงานกับ AWS Rahul ใช้เวลาหลายปีในด้านการเงินและการประกันภัย โดยช่วยลูกค้าสร้างข้อมูลและแพลตฟอร์มการวิเคราะห์

แพท ไรลี่ เป็นสถาปนิกใน AWS Data Lab ซึ่งเขาช่วยลูกค้าออกแบบและสร้างปริมาณงานข้อมูลเพื่อสนับสนุนธุรกิจของพวกเขา ก่อนหน้าที่จะร่วมงานกับ AWS Pat ได้ปรึกษากับคู่ค้าของ AWS เพื่อสร้างปริมาณงานข้อมูลของ AWS ในหลากหลายอุตสาหกรรม