วิธีการใช้งานแอปพลิเคชันแมชชีนเลิร์นนิงระดับเอดจ์ที่พร้อมใช้อย่างรวดเร็ว

แมชชีนเลิร์นนิง (ML) มีศักยภาพมหาศาลสำหรับการสร้างผลิตภัณฑ์อัจฉริยะ แต่ความซับซ้อนและความท้าทายที่เกี่ยวข้องกับการสร้างโมเดลโครงข่ายประสาทเทียม (Neural Network, NN) และการสร้างแอปพลิเคชัน ML สำหรับเอดจ์นั้นได้จำกัดความสามารถของนักพัฒนาในการส่งมอบโซลูชันที่เป็นประโยชน์อย่างรวดเร็ว แม้ว่าเครื่องมือที่พร้อมใช้งานได้ที่มีอยู่จะทำให้การสร้างโมเดล ML สามารถเข้าถึงได้โดยทั่วไป แต่แนวทางการพัฒนา ML แบบเดิมไม่ได้ออกแบบมาเพื่อตอบสนองความต้องการเฉพาะของโซลูชันสำหรับระบบ Internet of Things (IoT), ยานยนต์, อุตสาหกรรม และแอปพลิเคชันฝังตัวอื่น ๆ

บทความนี้ให้ข้อมูลเบื้องต้นเกี่ยวกับการสร้างโมเดล NN จากนั้นจะแนะนำและอธิบายวิธีใช้แพลตฟอร์ม ML ที่ครอบคลุมจาก NXP Semiconductors ที่ช่วยให้นักพัฒนาส่งมอบแอปพลิเคชัน ML ที่พร้อมสำหรับเอดจ์ได้อย่างมีประสิทธิภาพยิ่งขึ้น

ศึกษาการสร้างโมเดล NN อย่างรวดเร็ว

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

รูปที่ 1: NN เช่นเครือข่ายที่เชื่อมต่ออย่างสมบูรณ์นี้จัดประเภทวัตถุอินพุตโดยใช้พารามิเตอร์น้ำหนักและไบแอสที่ตั้งไว้ระหว่างการฝึก (แหล่งที่มารูปภาพ: NXP Semiconductors)

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

รูปที่ 2: ผู้เชี่ยวชาญ ML ใช้สถาปัตยกรรม NN เฉพาะทาง เช่น โครงข่ายประสาทเทียมแบบคอนโวลูชัน (CNN) สำหรับงานเฉพาะ เช่น การจดจำภาพ (แหล่งที่มารูปภาพ: NXP Semiconductors)

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

คัดลอก
def model_create(shape_in, shape_out):
    from keras.regularizers import l2
    
    tf.random.set_seed(RANDOM_SEED)
 
    model = tf.keras.Sequential()
    model.add(tf.keras.Input(shape=shape_in, name='acceleration'))
    model.add(tf.keras.layers.Conv2D(8, (4, 1), activation='relu'))
    model.add(tf.keras.layers.Conv2D(8, (4, 1), activation='relu'))
    
    model.add(tf.keras.layers.Dropout(0.5))
    
    model.add(tf.keras.layers.MaxPool2D((8, 1), padding='valid'))
    model.add(tf.keras.layers.Flatten())
    
    model.add(tf.keras.layers.Dense(64, kernel_regularizer=l2(1e-4), bias_regularizer=l2(1e-4), activation='relu'))
    model.add(tf.keras.layers.Dropout(0.5))
    model.add(tf.keras.layers.Dense(32, kernel_regularizer=l2(1e-4), bias_regularizer=l2(1e-4), activation='relu'))
    model.add(tf.keras.layers.Dropout(0.5))
    model.add(tf.keras.layers.Dense(shape_out, activation='softmax'))
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc'])
    
    return model

ข้อความที่ 1: นักพัฒนาสามารถเขียนโมเดล NN โดยใช้โค้ดเพียงไม่กี่บรรทัด (แหล่งที่มาของโค้ด: NXP Semiconductors)

รูปที่ 3: สร้างโดยโปรแกรมแสดงโมเดล Netron แสดงภาพกราฟิกของโมเดลที่ระบุในข้อความที่ 1 สามารถช่วยนักพัฒนาจัดทำเอกสารเกี่ยวกับฟังก์ชันและการเชื่อมต่อของแต่ละชั้น (แหล่งที่มีรูปภาพ: Stephen Evanczuk ใช้งาน Netron บนซอร์สโค้ดรุ่น NXP ในข้อความที่ 1)

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

ทำไมการพัฒนาแอปพลิเคชั่นบน ML สำหรับผลิตภัณฑ์อัจฉริยะจึงเป็นเรื่องยาก

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

รูปที่ 4: การพัฒนาแอปพลิเคชันที่ใช้ ML สำหรับเอดจ์จะขยายกระบวนการทำงานในการพัฒนา MCU แบบฝังทั่วไปด้วยกระบวนการทำงาน ML ที่จำเป็นในการฝึก ตรวจสอบ และปรับใช้โมเดล ML (แหล่งที่มารูปภาพ: NXP Semiconductors)

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

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

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

NXP จัดการทั้งด้านประสิทธิภาพของฮาร์ดแวร์และการใช้งานโมเดลของการพัฒนา ML สำหรับเอดจ์ ในระดับฮาร์ดแวร์ i.MX RT1170 ไมโครคอนโทรลเลอร์แบบครอสโอเวอร์ประสิทธิภาพสูงของ NXP ตอบสนองความต้องการด้านประสิทธิภาพที่กว้างขวางของ ML สำหรับเอดจ์ เพื่อใช้ประโยชน์จากฐานฮาร์ดแวร์นี้อย่างเต็มที่ eIQ (Edge Intelligence) สภาพแวดล้อมการพัฒนาซอฟต์แวร์ ML และชุดซอฟต์แวร์แอปพลิเคชันของ NXP ช่วยให้นักพัฒนา ML ที่เชี่ยวชาญและไม่มีประสบการณ์มีโซลูชันที่มีประสิทธิภาพสำหรับการสร้างแอปพลิเคชัน ML สำหรับเอดจ์ที่พร้อมใช้

แพลตฟอร์มที่มีประสิทธิภาพสำหรับการพัฒนาแอพพลิเคชั่น ML สำหรับเอดจ์ที่พร้อมใช้

ครอสโอเวอร์โปรเซสเซอร์ NXP i.MX RT รวมการตอบสนองแบบเรียลไทม์และเวลาแฝงต่ำของไมโครคอนโทรลเลอร์แบบฝังตัวแบบดั้งเดิมเข้ากับความสามารถในการดำเนินการของแอพพลิเคชั่นโปรเซสเซอร์ประสิทธิภาพสูง ครอสโอเวอร์โปรเซสเซอร์ i.MX RT1170 ของ NXP รวมเอา Arm® Cortex®-M4 ที่ประหยัดพลังงานและโปรเซสเซอร์ Arm Cortex-M7 ประสิทธิภาพสูงพร้อมชุดบล็อกการทำงานและอุปกรณ์ต่อพ่วงมากมายที่จำเป็นสำหรับการรันแอปพลิเคชั่นที่มีความต้องการสูง รวมถึงโซลูชันที่ใช้ ML ในอุปกรณ์ฝังตัว (รูปที่ 5)

รูปที่ 5: ครอสโอเวอร์โปรเซสเซอร์ i.MX RT1170 ของ NXP รวมความสามารถด้านการใช้พลังงานของไมโครคอนโทรลเลอร์ทั่วไปเข้ากับความสามารถในการประมวลผลประสิทธิภาพสูงของแอปพลิเคชันโปรเซสเซอร์ (แหล่งที่มารูปภาพ: NXP Semiconductors)

การผสานรวมเข้ากับสภาพแวดล้อมการพัฒนา MCUXpresso SDK และ Yocto ของ NXP อย่างสมบูรณ์ สภาพแวดล้อม NXP eIQ ได้รับการออกแบบมาโดยเฉพาะเพื่ออำนวยความสะดวกในการใช้งานโมเดลการทำนายบนระบบฝังตัวที่สร้างด้วยไมโครโปรเซสเซอร์และไมโครคอนโทรลเลอร์ของ NXP eIQ Toolkit ที่รวมอยู่ในสภาพแวดล้อม eIQ แล้ว รองรับการนำข้อมูลของคุณเอง (BYOD) และนำกระบวนการทำงานของโมเดลของคุณเอง (BYOM) ผ่านเครื่องมือต่าง ๆ รวมถึง eIQ Portal, eIQ Model Tool และเครื่องมือคอมมานด์ไลน์ (รูปที่ 6)

รูปที่ 6: NXP eIQ Toolkit รองรับนักพัฒนา BYOD ที่ต้องการสร้างโมเดล และนักพัฒนา BYOM ที่ต้องการปรับใช้โมเดลที่มีอยู่ของตนเองกับระบบเป้าหมาย (แหล่งที่มารูปภาพ: NXP Semiconductors)

eIQ Portal ได้รับการออกแบบมาเพื่อรองรับเวิร์กโฟลว์ BYOD สำหรับทั้งผู้เชี่ยวชาญและนักพัฒนาที่ยังไม่คุ้นเคยกับการพัฒนาโมเดล ML โดยพอร์ทัล eIQ มีอินเทอร์เฟซผู้ใช้แบบกราฟิก (GUI) ที่ช่วยให้นักพัฒนาทำขั้นตอนต่าง ๆ ของกระบวนการทำงานในการพัฒนาโมเดลให้เสร็จสมบูรณ์ได้ง่ายขึ้น

ในระยะเริ่มต้นของการพัฒนา เครื่องมือผู้ดูแลชุดข้อมูลของ eIQ Portal ช่วยให้นักพัฒนานำเข้าข้อมูล เก็บข้อมูลจากกล้องที่เชื่อมต่อ หรือบันทึกข้อมูลจากอุปกรณ์ระยะไกล (รูปที่ 7)

รูปที่ 7: เครื่องมือดูแลชุดข้อมูลของ eIQ Portal ช่วยอำนวยความสะดวกในการเตรียมข้อมูลการฝึกอบรมที่สำคัญ (แหล่งที่มารูปภาพ: NXP Semiconductors)

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

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

พอร์ทัล eIQ นำนักพัฒนาไปสู่ขั้นตอนการฝึกที่สำคัญถัดไป โดยให้ GUI ที่ใช้งานง่ายสำหรับการปรับเปลี่ยนพารามิเตอร์การฝึกอบรมและดูการเปลี่ยนแปลงในความแม่นยำในการทำนายของโมเดลในแต่ละขั้นตอนการฝึก (รูปที่ 8)

รูปที่ 8: นักพัฒนาใช้เครื่องมือฝึกของพอร์ทัล eIQ เพื่อสังเกตการปรับปรุงความแม่นยำในการฝึกในแต่ละขั้นตอนและแก้ไขหากจำเป็น (แหล่งที่มารูปภาพ: NXP Semiconductors)

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

รูปที่ 9: เครื่องมือตรวจสอบความถูกต้องของพอร์ทัล eIQ ช่วยให้นักพัฒนาได้ Confusion Matrix ซึ่งเป็นผลมาจากการรันโมเดลบนสถาปัตยกรรมเป้าหมาย (แหล่งที่มารูปภาพ: NXP Semiconductors)

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

• Arm CMSIS-NN (เครือข่ายประสาทเทียมมาตรฐานอินเทอร์เฟซซอฟต์แวร์ไมโครคอนโทรลเลอร์ทั่วไป)—เคอร์เนลเครือข่ายประสาทเทียมที่พัฒนาขึ้นเพื่อเพิ่มประสิทธิภาพสูงสุดและลดขนาดหน่วยความจำของเครือข่ายประสาทเทียมบนคอร์โปรเซสเซอร์ Arm Cortex-M
• Arm NN SDK (ชุดพัฒนาซอฟต์แวร์โครงข่ายประสาทเทียม)—ชุดเครื่องมือและเอ็นจิ้นการทำนายที่ออกแบบมาเพื่อเชื่อมระหว่างเฟรมเวิร์กของโครงข่ายประสาทเทียมที่มีอยู่กับตัวประมวลผล Arm Cortex-A และอื่น ๆ
• DeepViewRT —เอ็นจินการทำนายกรรมสิทธิ์ของ NXP สำหรับ MCU ครอสโอเวอร์ i.MX RT
• Glow NN — จากคอมไพเลอร์ Glow (การลดกราฟ) ของ Meta และปรับให้เหมาะสมโดย NXP สำหรับแกน Arm Cortex-M โดยใช้การเรียกใช้ฟังก์ชันไปยังเคอร์เนล CMSIS-NN หรือไลบรารี Arm NN ถ้ามี หรือโดยการรวบรวมโค้ดจากไลบรารีดั้งเดิมของตัวเอง
• ONXX Runtime —เครื่องมือของ Microsoft Research ที่ออกแบบมาเพื่อเพิ่มประสิทธิภาพสำหรับโปรเซสเซอร์ Arm Cortex-A
• TensorFlow Lite สำหรับไมโครคอนโทรลเลอร์ — TensorFlow Lite เวอร์ชันที่เล็กลง ซึ่งได้รับการปรับให้เหมาะสมสำหรับการเรียกใช้โมเดลแมชชีนเลิร์นนิงบน MCU แบบครอสโอเวอร์ i.MX RT
• TensorFlow Lite — เวอร์ชันหนึ่งของ TensorFlow ที่ให้การสนับสนุนระบบที่มีขนาดเล็กลง

สำหรับกระบวนการทำงาน BYOM นักพัฒนาสามารถใช้เครื่องมือโมเดล eIQ เพื่อย้ายไปยังการวิเคราะห์โมเดลและการทำโปรไฟล์เวลาต่อเลเยอร์โดยตรง สำหรับกระบวนการทำงานทั้ง BYOD และ BYOM นักพัฒนาสามารถใช้เครื่องมือคอมมานน์ไลน์ eIQ ซึ่งให้การเข้าถึงฟังก์ชันการทำงานของเครื่องมือ ตลอดจนคุณลักษณะ eIQ ที่ไม่สามารถใช้งานได้โดยตรงผ่าน GUI

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

วิธีประเมินการพัฒนาโมเดลอย่างรวดเร็วโดยใช้แพ็ค App SW

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

รูปที่ 10: นักพัฒนาสามารถใช้แพ็ค NXP App SW เช่น แพ็ค ML State Monitor App SW สำหรับการประเมินในทันที หรือเป็นพื้นฐานของการพัฒนาโค้ดที่กำหนดเอง (แหล่งที่มารูปภาพ: NXP Semiconductors)

แพ็ค ML State Monitor App SW ใช้โซลูชันสำเร็จรูปสำหรับการใช้งานที่ต้องการตรวจจับว่าพัดลมทำงานในสถานะใดสถานะหนึ่งจากสี่สถานะ:

• เปิด
• ปิด
• อุดตัน เมื่อเปิดพัดลมแต่เกิดการอุดตัน
• เสียดทาน เมื่อพัดลมเปิดอยู่แต่ใบพัดลมอย่างน้อยหนึ่งใบมีการเสียดสีมากเกินไประหว่างการทำงาน

แพ็ค ML State Monitor App SW มีความสำคัญไม่แพ้กัน รวมถึงโมเดล ML และชุดข้อมูลที่สมบูรณ์ซึ่งแสดงถึงการอ่านค่าความเร่งจากพัดลมที่ทำงานในแต่ละสถานะทั้งสี่

นักพัฒนาสามารถศึกษาโค้ด โมเดล และข้อมูลที่มีให้ในแพ็ค ML State Monitor App SW เพื่อทำความเข้าใจวิธีใช้ข้อมูลเซ็นเซอร์เพื่อฝึกโมเดล สร้างโมเดลการทำนาย และตรวจสอบการทำนายกับชุดข้อมูลเซนเซอร์ตรวจสอบความถูกต้อง ที่จริงแล้วไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP ที่อยู่ในแพ็ค App SW นั้นเป็นเครื่องมือที่พร้อมใช้งานทันทีสำหรับการศึกษากระบวนการทำงานการพัฒนาโมเดลให้ดีก่อนใช้งานฮาร์ดแวร์ใด ๆ

Jupyter Notebook เป็นแพลตฟอร์มการเรียกใช้ Python บนเบราว์เซอร์แบบโต้ตอบที่ช่วยให้นักพัฒนาสามารถดูผลลัพธ์ของการเรียกใช้โค้ด Python ได้ทันที การเรียกใช้ Jupyter Notebook จะสร้างบล็อกของโค้ด Python ตามด้วยผลลัพธ์ของการเรียกใช้บล็อกโค้ดนั้นทันที ผลลัพธ์เหล่านี้ไม่ได้เป็นเพียงการแสดงผลแบบคงที่ แต่เป็นผลลัพธ์จริงที่ได้รับจากการรันโค้ด ตัวอย่างเช่น เมื่อนักพัฒนาเรียกใช้ไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP พวกเขาสามารถดูสรุปของชุดข้อมูลอินพุตได้ทันที (รูปที่ 11)

รูปที่ 11: ไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP ช่วยให้นักพัฒนาสามารถโต้ตอบผ่านกระบวนการทำงานการพัฒนาโมเดลโครงข่ายประสาทเทียม โดยดูข้อมูลการฝึกอบรมที่มีให้ในแพ็ค ML State Monitor App SW [หมายเหตุ: โค้ดถูกตัดทอนที่นี่เพื่อจุดประสงค์ในการแสดงผล] (แหล่งที่มารูปภาพ: Stephen Evanczuk ใช้งานไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP)

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

รูปที่ 12: Jupyter Notebook ให้นักพัฒนาแสดงอนุกรมเวลาและความถี่ของชุดข้อมูลสถานะพัดลมตัวอย่าง (ปิด: สีเขียว เปิด: สีแดง อุดตัน: สีน้ำเงิน เสียดทาน: สีเหลือง) [หมายเหตุ: โค้ดถูกตัดทอนเพื่อวัตถุประสงค์ในการนำเสนอ] (แหล่งที่มารูปภาพ: Stephen Evanczuk ใช้งานไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP)

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

รูปที่ 13: ไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP สร้างโมเดล (แสดงในรายการ 1) และแสดงข้อมูลสรุปโมเดล (แหล่งที่มารูปภาพ: Stephen Evanczuk ใช้งานไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP)

จากส่วนของโค้ดสำหรับการฝึกโมเดลและการประเมินไฟล์ Jupyter Notebook ML_State_Monitor.ipynb จะแสดง Confusion Matrix สำหรับชุดข้อมูลแบบเต็ม ชุดข้อมูลการฝึก และชุดข้อมูลการตรวจสอบความถูกต้อง (ชุดย่อยของชุดข้อมูลที่ไม่รวมอยู่ในชุดข้อมูลการฝึก) ในกรณีนี้ Confusion Matrix สำหรับชุดข้อมูลทั้งหมดจะแสดงความแม่นยำที่ดีโดยมีข้อผิดพลาดจำนวนหนึ่ง โดยเฉพาะอย่างยิ่งเมื่อโมเดลสร้างความสับสนให้กับชุดข้อมูลในเปอร์เซ็นต์เล็ก ๆ ว่าอยู่ในสถานะเปิด เมื่อจริงๆ แล้วอยู่ในสถานะอดตัน ตามที่ระบุไว้ในชุดข้อมูลต้นฉบับ (รูปที่ 14)

รูปที่ 14: นักพัฒนาสามารถดู Confusion Matrix สำหรับชุดข้อมูลทั้งหมด (แหล่งรูปภาพ: Stephen Evanczuk ใช้งานไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP)

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

รูปที่ 15: ไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP สาธิตวิธีที่นักพัฒนาสามารถบันทึกโมเดลที่ผ่านการฝึกในประเภทและรูปแบบต่างๆ ของโมเดลต่าง ๆ มากมาย (แหล่งที่มารูปภาพ: Stephen Evanczuk ใช้งานไฟล์ Jupyter Notebook ML_State_Monitor.ipynb ของ NXP)

การเลือกกลไกการทำนายมีความสำคัญอย่างยิ่งต่อการปฏิบัติตามข้อกำหนดด้านประสิทธิภาพที่เฉพาะเจาะจง สำหรับแอปพลิเคชันนี้ NXP วัดขนาดโมเดล ขนาดโค้ด และเวลาทำนาย (เวลาที่ต้องใช้ในการทำนายวัตถุอินพุตเดียว) เมื่อโมเดลกำหนดเป้าหมายไปยังเอ็นจินการทำนายหลายตัว ตัวหนึ่งทำงานที่ 996 เมกะเฮิรตซ์ (MHz) และอีกตัวทำงานที่ 156 MHz (รูปที่ 16 และ 17)

รูปที่ 16: การเลือกประเภทโมเดลอาจส่งผลกระทบอย่างมากต่อขนาดของโมเดล แม้ว่าความแตกต่างอย่างมากที่แสดงไว้ที่นี่อาจใช้ไม่ได้กับโมเดลที่ใหญ่กว่า (แหล่งที่มารูปภาพ: NXP Semiconductors)

รูปที่ 17: เวลาในการทำนายอาจแตกต่างกันอย่างมากสำหรับการประเมินวัตถุอินพุตเมื่อโหลดจาก RAM หรือหน่วยความจำแฟลช หรือเมื่อใช้งานโปรเซสเซอร์ที่ความถี่สูงกว่า 996 MHz เทียบกับ 156 MHz (แหล่งที่มารูปภาพ: NXP Semiconductors)

จากหมายเหตุของ NXP แอปพลิเคชันตัวอย่างนี้ใช้โมเดลขนาดเล็กมาก ดังนั้นความแตกต่างที่ค่อนข้างชัดเจนที่แสดงในรูปเหล่านี้อาจเด่นชัดน้อยกว่าอย่างมากในโมเดลขนาดใหญ่ที่ใช้สำหรับการจำแนกหมวดหมู่ที่ซับซ้อน

การสร้างโซลูชันระบบสำหรับการตรวจสอบสถานะ

นอกจาก Jupyter Notebook สำหรับการสำรวจเชิงโต้ตอบของกระบวนการพัฒนาโมเดลแล้วแพ็ค NXP ML State Monitoring App SW ยังมีซอร์สโค้ดที่สมบูรณ์สำหรับการนำการออกแบบไปใช้บนบอร์ดประเมินผล NXPMIMXRT1170-EVK บอร์ดประเมินผลนี้สร้างขึ้นจาก MCU ครอสโอเวอร์ NXPMIMXRT1176DVMAA มีแพลตฟอร์มฮาร์ดแวร์ที่ครอบคลุม พร้อมด้วยหน่วยความจำเพิ่มเติมและอินเทอร์เฟซที่หลากหลาย (รูปที่ 18)

รูปที่ 18: บอร์ดประเมินผล MIMXRT1170-EVK ของ NXP จัดเตรียมแพลตฟอร์มฮาร์ดแวร์ที่ครอบคลุมสำหรับการพัฒนาแอพพลิเคชั่นจาก MCU ครอสโอเวอร์ NXP i.MX RT1170 (แหล่งที่มารูปภาพ: NXP Semiconductors)

นักพัฒนาสามารถใช้แอปพลิเคชันการตรวจสอบสถานะพัดลม NXP เพื่อทำนายสถานะของพัดลมได้โดยการใช้บอร์ดประเมินผล MIMXRT1170-EVK รวมกับบอร์ดเซ็นเซอร์ NXP FRDM-STBC-AGM01 ที่เป็นอุปกรณ์เสริม, ชิลด์ Arduino และพัดลม DC แบบไม่มีแปรงถ่าน 5 โวลต์ที่เหมาะสม เช่น 4468 ของ Adafruit (รูปที่ 19)

รูปที่ 19: นักพัฒนาสามารถทดสอบแอปพลิเคชันตัวอย่างในตการตรวจสอบสถานะพัดลม NXP ด้วยการใช้ร่วมกับบอร์ดประเมินผล MIMXRT1170-EVK (แหล่งที่มารูปภาพ: NXP Semiconductors)

เมื่อใช้สภาพแวดล้อมการพัฒนาแบบรวม (IDE) MCUXpresso นักพัฒนาสามารถกำหนดค่าแอปพลิเคชันเพื่อรับและจัดเก็บข้อมูลสถานะพัดลมหรือเรียกใช้การทำนายข้อมูลที่ได้รับทันทีโดยใช้เอ็นจิ้นการทำนาย TensorFlow, เอ็นจิ้นการทำนาย DeepViewRT หรือเอ็นจิ้นการทำนายของ Glow (รายการ 2)

คัดลอก
/* Action to be performed */
#define SENSOR_COLLECT_LOG_EXT                  1   // Collect and log data externally
#define SENSOR_COLLECT_RUN_INFERENCE            2   // Collect data and run inference
 
/* Inference engine to be used */
#define SENSOR_COLLECT_INFENG_TENSORFLOW        1   // TensorFlow
#define SENSOR_COLLECT_INFENG_DEEPVIEWRT        2   // DeepViewRT
#define SENSOR_COLLECT_INFENG_GLOW              3   // Glow
 
/* Data format to be used to feed the model */
#define SENSOR_COLLECT_DATA_FORMAT_BLOCKS       1   // Blocks of samples
#define SENSOR_COLLECT_DATA_FORMAT_INTERLEAVED  2   // Interleaved samples
 
 
/* Parameters to be configured by the user: */
/* Configure the action to be performed */
#define SENSOR_COLLECT_ACTION                   SENSOR_COLLECT_RUN_INFERENCE
 
#if SENSOR_COLLECT_ACTION == SENSOR_COLLECT_LOG_EXT
/* If the SD card log is not enabled the sensor data will be streamed to the terminal */
#define SENSOR_COLLECT_LOG_EXT_SDCARD           1   // Redirect the log to SD card, otherwise print to console

ข้อความที่ 2: นักพัฒนาสามารถกำหนดค่าแอปพลิเคชันตัวอย่าง NXP ML State Monitor ได้อย่างง่ายดายโดยแก้ไขค่าที่รวมอยู่ใน ไฟล์เฮดเดอร์ sensor_collect.h (แหล่งที่มาของโค้ด: NXP Semiconductors)

แอปพลิเคชันทำงานด้วยข้ันตอนการทำงานที่ตรงไปตรงมา กิจกรรมหลักใน main.c จะสร้างงานที่เรียกว่า MainTask ซึ่งเป็นกิจกรรมที่อยู่ในโมดูล sensor_collect.c

คัดลอก
void MainTask(void *pvParameters)
{
    status_t status = kStatus_Success;
 
    printf("MainTask started\r\n");
 
#if !SENSOR_FEED_VALIDATION_DATA
    status = SENSOR_Init();
    if (status != kStatus_Success)
    {
        goto main_task_exit;
    }
#endif
 
    g_sensorCollectQueue = xQueueCreate(SENSOR_COLLECT_QUEUE_ITEMS, sizeof(sensor_data_t));
    if (NULL == g_sensorCollectQueue)
    {
        printf("collect queue create failed!\r\n");
        status = kStatus_Fail;
        goto main_task_exit;
    }
 
#if SENSOR_COLLECT_ACTION == SENSOR_COLLECT_LOG_EXT
    uint8_t captClassLabelIdx;
    CAPT_Init(&captClassLabelIdx, &g_SensorCollectDuration_us, &g_SensorCollectDuration_samples);
    g_SensorCollectLabel = labels[captClassLabelIdx];
 
    if (xTaskCreate(SENSOR_Collect_LogExt_Task, "SENSOR_Collect_LogExt_Task", 4096, NULL, configMAX_PRIORITIES - 1, NULL) != pdPASS)
    {
        printf("SENSOR_Collect_LogExt_Task creation failed!\r\n");
        status = kStatus_Fail;
        goto main_task_exit;
    }
#elif SENSOR_COLLECT_ACTION == SENSOR_COLLECT_RUN_INFERENCE
    if (xTaskCreate(SENSOR_Collect_RunInf_Task, "SENSOR_Collect_RunInf_Task", 4096, NULL, configMAX_PRIORITIES - 1, NULL) != pdPASS)
    {
        printf("SENSOR_Collect_RunInf_Task creation failed!\r\n");
        status = kStatus_Fail;
        goto main_task_exit;
    }
#endif

ข้อความที่ 3: ในแอปพลิเคชันตัวอย่าง NXP ML State Monitor MainTask จะเรียกใช้งานย่อยเพื่อรับข้อมูลหรือเรียกใช้การทำนาย (แหล่งที่มาของโค้ด: NXP Semiconductors)

MainTask ทำงานการเริ่มต้นต่าง ๆ ก่อนที่จะเรียกใช้งานย่อยหนึ่งในสองงาน ขึ้นอยู่กับค่าที่กำหนดโดยผู้ใช้ใน sensor_collect.h:

• ถ้า SENSOR_COLLECT_ACTION ถูกตั้งค่าเป็น SENSOR_COLLECT_LOG_EXT MainTask จะเริ่มงานย่อย SENSOR_Collect_LogExt_Task() ซึ่งจะรวบรวมข้อมูลและเก็บไว้ในการ์ด SD หากกำหนดค่าไว้
• ถ้า SENSOR_COLLECT_ACTION ถูกตั้งค่าเป็น SENSOR_COLLECT_RUN_INFERENCE MainTask จะเริ่มงานย่อย SENSOR_Collect_RunInf_Task() ซึ่งรันเอ็นจินการทำนาย (Glow, DeepViewRT หรือ TensorFlow) ที่กำหนดไว้ใน sensor_collect.h เทียบกับข้อมูลที่รวบรวม และหากกำหนดค่าเป็น SENSOR_EVALUATE_MOD จะแสดงประสิทธิภาพและผลการคาดการณ์หมวดหมู่

คัดลอก
if SENSOR_COLLECT_ACTION == SENSOR_COLLECT_LOG_EXT
void SENSOR_Collect_LogExt_Task(void *pvParameters)
{
[code deleted for simplicity]
    while (1)
    {
[code deleted for simplicity]
            bufSizeLog = snprintf(buf, bufSize, "%s,%ld,%d,%d,%d,%d,%d,%d,%d\r\n", g_SensorCollectLabel, (uint32_t)(sensorData.ts_us/1000),
                    sensorData.rawDataSensor.accel[0], sensorData.rawDataSensor.accel[1], sensorData.rawDataSensor.accel[2],
                    sensorData.rawDataSensor.mag[0], sensorData.rawDataSensor.mag[1], sensorData.rawDataSensor.mag[2],
                    sensorData.temperature);
 
#if SENSOR_COLLECT_LOG_EXT_SDCARD
                SDCARD_CaptureData(sensorData.ts_us, sensorData.sampleNum, g_SensorCollectDuration_samples, buf, bufSizeLog);
#else
                printf("%.*s", bufSizeLog, buf);
[code deleted for simplicity]
    }
 
    vTaskDelete(NULL);
}
#elif SENSOR_COLLECT_ACTION == SENSOR_COLLECT_RUN_INFERENCE
[code deleted for simplicity]
 
void SENSOR_Collect_RunInf_Task(void *pvParameters)
{
[code deleted for simplicity]
    while (1)
    {
[code deleted for simplicity]
                /* Run Inference */
                tinf_us = 0;
                SNS_MODEL_RunInference((void*)g_clsfInputData, sizeof(g_clsfInputData), (int8_t*)&predClass, &tinf_us, SENSOR_COLLECT_INFENG_VERBOSE_EN);
 
[code deleted for simplicity]
#if SENSOR_EVALUATE_MODEL
                /* Evaluate performance */
                validation.predCount++;
                if (validation.classTarget == predClass)
                {
                    validation.predCountOk++;
                }
                PRINTF("\rInference %d?%d | t %ld us | count: %d/%d/%d | %s      ",
                       validation.classTarget, predClass, tinf_us, validation.predCountOk,
                       validation.predCount, validation.predSize, labels[predClass]);
 
                tinfTotal_us += tinf_us;
                if (validation.predCount >= validation.predSize)
                {
                    printf("\r\nPrediction Accuracy for class %s %.2f%%\r\n", labels[validation.classTarget],
                            (float)(validation.predCountOk * 100)/validation.predCount);
                    printf("Average Inference Time %.1f (us)\r\n", (float)tinfTotal_us/validation.predCount);
                    tinfTotal_us = 0;
                }
#endif
 
    }
 
exit_task:
    vTaskDelete(NULL);
}
#endif  /* SENSOR_COLLECT_ACTION */

ข้อความที่ 4: แอปพลิเคชันตัวอย่าง NXP ML State Monitor สาธิตรูปแบบการออกแบบพื้นฐานสำหรับการรับข้อมูลเซ็นเซอร์และเรียกใช้เอ็นจิ้นการทำนายที่เลือกบนข้อมูลที่ได้รับ (แหล่งที่มาของโค้ด: NXP Semiconductors)

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

สรุป

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