כיצד לפרוס במהירות יישומי למידת מכונה מוכני-קצה (Edge-Ready)

למידת מכונה (ML‏) מציעה פוטנציאל אדיר ליצירת מוצרים חכמים, אך המורכבות והאתגרים הכרוכים במידול רשת נוירונים (NN‏) ויצירת יישומי לימוד מכונה (ML)‏ עבור הקצה‏ הגבילו את יכולת המפתחים לספק במהירות פתרונות שימושיים. למרות שכלים זמינים מן המוכן עשו את יצירת מודל ה-ML לנגישה ‏באופן כללי, פרקטיקות פיתוח ML קונבנציונלי אינן מתוכננות לעמוד בדרישות הייחודיות של פתרונות עבור האינטרנט-של-דברים (IoT‏), רכב, מערכות תעשייתיות ויישומים משובצים אחרים.

מאמר זה מספק‏ מבוא קצר למידול NN‏. אחר כך המאמר מציג ומתאר כיצד להשתמש בפלטפורמת ML מקיפה מבית NXP Semiconductors המאפשרת למפתחים לספק ביתר אפקטיביות יישומים מוכני-קצה (edge-ready).

סקירה מהירה של מידול NN‏

אלגוריתמים ML מספקים למפתחים אופציה שונה דרמטית עבור פיתוח יישומים. במקום לכתוב קוד תוכנה בכוונה לפתור בעיות באופן מפורש כמו סיווג תמונה, מפתחים מאמנים מודלים NN על ידי הצגת‏ קבוצת נתונים כגון תמונות מלוות בהערות עם השם הממשי (או סוג) של ההויה הכלולה בתמונה. תהליך האימון משתמש במגוון שיטות לחישוב פרמטרים של מודל, משקלים וערכי מקדם (Bias) עבור כל נוירון ושכבה, בהתאמה, ובכך לאפשר למודל לספק חזוי מדויק למדי של הסוג הנכון של תמונת כניסה (איור 1).

איור 1‏: רשתות NN‏ כגון רשת מחוברת במלואה זו המסווגת אובייקט כניסה תוך שימוש בפרמטרים של משקל ומקדם (bias) שנקבעו בזמן אימון. (מקור תמונה: NXP Semiconductors)

חוקרי ML פתחו‏ מערך רחב של ארכיטקטורות NN‏ מעבר ל-NN הגנרי המחובר במלואו המוצג באיור 1‏. לדוגמה, יישומי סיווג תמונה משתמשים בדרך כלל בקונבולציית NN‏ (CNN‏), ‏ארכיטקטורה מיוחדת המפצלת זיהוי תמונה לשלב התחלתי המוצא מאפייני מפתח של תמונה, ובעקבותיו שלב סיווג החוזה את ההיתכנות שהיא שייכת לאחד מתוך מספר סוגים שנקבעו בזמן אימון (איור 2‏).

איור 2‏: מומחי ML משתמשים בארכיטקטורות NN‏ מיוחדות כגון רשת נוירונים קונבולציה (CNN‏) זו עבור משימות ספציפיות כגון זיהוי תמונה. (מקור תמונה: NXP Semiconductors)

למרות שהבחירה של ארכיטקטורת‏ מודל ומשטר אימונים מתאימים הוגבלו למומחי ML, הזמינות של כלי קוד-פתוח ומסחריים פשטה באופן דרמטי פיתוח מודל עבור פריסות בקנה-מידה גדול. כיום, מפתחים יכולים להגדיר מודלים באמצעות מספר שורות קוד (רשימה 1), ולהשתמש בכלים כמו Viewer מודל 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 Viewer‏, ייצוג גרפי זה של המודל המוגדר ברשימה 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 Crossover ביצועים-עיליים של NXP עומדים בדרישות הביצועים הנרחבות של ML קצה. כדי להפיק את מלוא היתרון מבסיס חומרה זה, סביבת פיתוח תוכנה eIQ (Edge Intelligence) ML וחבילות תוכנת יישום של NXP מציעות למפתחי ML מומחים כמו גם חסרי ניסיון פתרון יעיל עבור יצירת יישומי ML מוכני-קצה.

פלטפורמה יעילה עבור פיתוח יישומי ML מוכני-קצה

מעבדי NXP i.MX RT Crossover‏ משלבים את תגובת הזמן-אמת, שיהוי-נמוך (Low-Latency) של מיקרו-בקרים משובצים מסורתיים עם יכולות הביצוע של מעבדי יישומים ביצועים-עיליים. סדרת המעבדים i.MX RT1170 Crossover של NXP משלבת‏ ARM® Cortex®-M4‏ נציל-הספקית‏ ומעבד ARM Cortex-M7 ביצועים-עיליים עם מערך נרחב של ‏בלוקים פונקציונליים ואלמנטים היקפיים הדרושים כדי להריץ יישומים תובעניים, כולל פתרונות מבוססי-ML בהתקנים משובצים (איור 5‏).

איור 5‏: מעבדי i.MX RT1170 Crossover של NXP משלבים‏ את היכולת הנצילה-הספקית של מיקרו-בקרים קונבנציונליים עם יכולת העיבוד ביצועים-עיליים של מעבדי יישומים. (מקור תמונה: NXP Semiconductors)

סביבת ה-NXP eIQ, המשולבת במלואה בסביבות פיתוח MCUXpresso SDK ו-Yocto של NXP, מתוכננת במיוחד כדי להקל על מימוש מודלים של היסק על מערכות משובצות הבנויות עם מיקרו-מעבדים ומיקרו-בקרים NXP‏. כלולה בסביבת ה-eIQ, ה-eIQ Toolkit תומכת בתהליכי עבודה "הבא את הנתונים שלך" (BYOD) ו"הבא את המודל שלך" BYOM באמצעות מספר כלים, כולל ה-eIQ Portal, ה-eIQ Model Tool וכלי Command Line‏ (איור 6‏).

איור 6‏: ה-NXP eIQ Toolkit תומכת במפתחי BYOD שצריכים ליצור מודל ומפתחי BYOM שצריכים להשתמש במודל הקיים שלהם במערכת מטרה. (מקור תמונה: NXP Semiconductors)

ה-eIQ Portal, שמתוכנן לתמוך בתהליכי עבודה BYOD של מומחים כמו גם מפתחים חדשים בפיתוח מודל ML‏, מספק‏ ממשק משתמש גרפי (GUI) המסייע למפתחים להשלים ביתר קלות כל שלב בתהליך העבודה של פיתוח מודל.

בשלב הראשון של הפיתוח, כלי האוצר (curator) מערך נתונים של eIQ Portal מסייע למפתחים ליבא נתונים, ללכוד נתונים‏ ממצלמה מחוברת, או ללכוד נתונים מהתקן‏ מרוחק (איור 7‏).

איור 7‏: כלי האוצר (curator) מערך נתונים של eIQ Portal מקל על המשימה הקריטית של הכנת נתוני אימון. (מקור תמונה: NXP Semiconductors)

תוך שימוש בכלי האוצר (curator) מערך נתונים, מפתחים מוסיפים הערות, או מתיגים כל פריט במערך הנתונים על ידי תיוג התמונה כולה, או רק אזורים מסוימים הכלולים בתוך תיבה תוחמת מוגדרת. מאפיין הרחבה מסייע למפתחים לספק את הגוון הדרוש למערך הנתונים על ידי טשטוש תמונות, הוספת רעש אקראי, שינוי מאפיינים כמו בהירות או ניגודיות ושיטות אחרות.

בשלב הבא, ה-eIQ Portal מסייע למפתחים לבחור את סוג המודל המתאים ביותר ליישום. עבור מפתחים שאינם בטוחים בסוג המודל, מומחה בחירת מודל יצעיד מפתחים דרך תהליך הבחירה בהתבסס על סוג היישום ובסיס חומרה. מפתחים שכבר יודעים איזה סוג מודל הם צריכים יכולים לבחור במודל מותאם-במיוחד המסופק עם התקנת ה-eIQ או מימושים מותאמים-במיוחד אחרים.

ה-eIQ Portal לוקח את המפתחים לצעד האימון הקריטי הבא, מספק GUI‏ אינטואיטיבי עבור שינוי פרמטרים של אימון וצפיה בשינויי דיוק חיזוי מודל עם כל צעד של אימון (איור 8‏).

איור 8‏: מפתחים משתמשים בכלי אימון של eIQ Portal כדי לצפות בשיפורי דיוק אימון עם כל צעד, ולשנות אותם במידת הצורך. (מקור תמונה: NXP Semiconductors)

בצעד הבא, ה-eIQ Portal GUI מסייע למפתחים לתקף את המודל. בשלב זה, המודל מומר לרוץ על ארכיטקטורת היעד כדי לקבוע את ביצועיו בפועל. בתום התיקוף, מסך התיקוף מציג את מטריצת הבלבול (confusion matrix)—כלי תיקוף ML בסיסי המאפשר למפתחים להשוות את הקטגוריה האקטואלית של אובייקט הכניסה עם הקטגוריה ‏שנחזתה על ידי המודל (איור 9‏).

איור 9‏: כלי התיקוף של eIQ Portal מספק למפתחים את מטריצת הבלבול (confusion matrix) המתקבלת מהרצת מודל על ארכיטקטורת יעד. (מקור תמונה: NXP Semiconductors)

עבור פריסה סופית, הסביבה מספקת למפתחים מבחר של מנועי היסק (inference engines) מטרה בהתאם למעבד, כולל:

• Arm CMSIS-NN‏ (Common Microcontroller Software Interface Standard, Neural Network)—ליבות רשת נוירונים פותחו למקסום הביצועים ולהקטנה למינימום של חתימת-שטח הזיכרון של רשתות נוירונים על ליבות מעבד Arm Cortex-M
• Arm NN SDK‏ (neural network, software development kit)—סט כלים ומנוע היסק (inference engine) המתוכננים לגשר בין מסגרות-עבודה רשת נוירונים קיימות ובין השאר, מעבדי Arm Cortex-A
• DeepViewRT—מנוע היסק (inference engine) קנייני של NXP עבור מיקרו-בקרי i.MX RT Crossover‏
• Glow NN‏—מבוסס על קומפיילר Glow (הנמכת גרף) של Meta וממוטב על ידי NXP‏ עבור ליבות Arm Cortex-M‏ על ידי שימוש בקריאות פונקציה לליבות CMSIS-NN או ספריית ה-Arm NN‏ אם זמינה, אחרת על ידי קומפילציה של קוד מהספרייה העצמית המקומית
• ONXX Runtime—כלים של Microsoft Research המתוכננים למיטוב ביצועים עבור מעבדי Arm Cortex-A
• TensorFlow Lite עבור מיקרו-בקרים‏—גרסה‏ קטנה יותר של TensorFlow Lite, ממוטבת במיוחד עבור הרצת מודלים של לימוד מכונה על יחידות מיקרו-בקר i.MX RT Crossover‏
• TensorFlow Lite—‏ גרסה של TensorFlow המספקת תמיכה עבור מערכות קטנות יותר

עבור תהליכי עבודה BYOM, מפתחים יכולים להשתמש ב-eIQ Model Tool כדי לעבור ישר לניתוח מודל ויצירת פרופיל זמן לכל שכבה. עבור תהליכי עבודה BYOD כמו גם BYOM, מפתחים יכולים להשתמש בכלי eIQ command line‏ שמספקים גישה לפונקציונליות כלי, כמו גם מאפייני eIQ שאינם זמינים ישירות דרך ה-GUI.

מעבר למאפיינים המתוארים במאמר זה, ה-eIQ Toolkit תומכת במערך נרחב של יכולות, כולל המרת מודל ומיטוב, שהם הרבה מעבר להקף מאמר זה. עם זאת, עבור בנייה מהירה של אב-טיפוס יישומי‏‏ ML‏ מוכני-קצה, מפתחים יכולים בדרך כלל לנוע מהר דרך שלבי הפיתוח והפריסה עם מעט צורך להשתמש ברבות מהיכולות המתוחכמות יותר של סביבת ה-eIQ. למעשה, חבילות תוכנות יישום (App SW) מיוחדות מבית NXP‏ מציעות יישומים שלמים בהם מפתחים יכולים להשתמש עבור הערכה מידית, או כבסיס של היישומים המותאמים-במיוחד שלהם עצמם.

כיצד להעריך במהירות פיתוח מודל תוך שימוש בחבילת‏ App SW

חבילות תוכנה NXP App SW‏ מספקות יישום מבוסס-ML‏ שלם, תוך שילוב קוד מקור מוכן-ייצור, מנהלי-התקנים, תוכנת ביניים (Middleware), וכלים. לדוגמה, חבילת ה-NXP ML State Monitor App SW Pack מציעה‏ פתרון מבוסס-ML מיידי לבעיה התכופה של קביעת המצב של מערכות מורכבות בהתבסס על כניסות חיישן (איור 10‏).

איור 10‏: מפתחים יכולים להשתמש בחבילות NXP App SW Pack‏ כמו ה-ML State Monitor App SW Pack עבור הערכה מיידית, או כבסיס לפיתוח קוד מותאם-במיוחד. (מקור תמונה: NXP Semiconductors)

ה-ML State Monitor App SW Pack מממשת פתרון שלם עבור יישום המיועד לגלות מתי מאוורר עובד באחד מארבעת המצבים:

• מצב-מופעל (ON)
• מצב-מושבת (OFF)
• חסום (CLOGGED), כשהמאוורר במצב-מופעל אך זרם האוויר חסום
• חיכוך (FRICTION), כשהמאוורר במצב-מופעל אך להב אחד או יותר של המאוורר נתקל בחיכוך יתר במהלך העבודה

חשוב לא פחות למפתחי מודל, ה-ML State Monitor App SW Pack כוללת מודלים ML כמו גם מערך נתונים שלם המייצג קריאות מד-תאוצה ממאוורר העובד בכל אחד מארבעת המצבים הללו.‏

מפתחים יכולים לבחון קוד, מודלים ונתונים המסופקים ב-‏ML State Monitor App SW Pack כדי להבין כיצד להשתמש בנתוני החיישן כדי לאמן מודל, ליצור מודל היסק ולתקף את ההיסק כנגד מערך נתונים של חיישן תיקוף. למעשה, ML_State_Monitor.ipynb Jupyter Notebook של NXP, הכלול ב-‏App SW Pack, מספק כלי מיידי, ישר-מן-הקופסה, עבור בחינת תהליך העבודה פיתוח מודל‏ הרבה לפני פריסה כלשהי של חומרה.

ה-Jupyter Notebook‏ הוא פלטפורמת ביצוע Python מבוססת-דפדפן אינטראקטיבית המאפשרת למפתחים לצפות מייד בתוצאות של ביצועי קוד Python. הרצת‏ Jupyter Notebook מייצרת‏ בלוק של קוד Python‏, ומיד לאחר מכן מקבלים את תוצאות ריצת בלוק קוד זה. תוצאות אלו אינן פשוט תצוגות סטטיות, אלא הן התוצאות בפועל שהתקבלו על ידי הרצת הקוד. לדוגמה, כשמפתחים מריצים ML_State_Monitor.ipynb Jupyter Notebook של NXP, הם יכולים לצפות מיידית בסיכום של מערך נתוני הכניסה‏ (איור 11‏).

איור11: ה-ML_State_Monitor.ipynb Jupyter Notebook של NXP מאפשר למפתחים לעבוד באופן אינטראקטיבי בתהליך העבודה פיתוח מודל רשת נוירונים, תוך צפייה בנתוני אימון המסופקים בחבילת התוכנה ML State Monitor App. [הערה: קוד מקוצץ כאן למטרות תצוגה.] (מקור תמונה: Stephen Evanczuk,‏ הרצת ML_State_Monitor.ipynb Jupyter Notebook של NXP)

קטע הקוד הבא ב-Notebook מספק למשתמש תצוגה גרפית של נתוני הכניסה, מוצגת כשרטוטי גרף נפרדים כפונקציה של סדרה עתית ותדר (איור 12‏).

איור 12‏: ה-Jupyter Notebook מספק למפתחים תצוגות סדרה עתית ותדר של מערך הנתונים דגימות מצב מאוורר (מצב-מושבת (OFF): ירוק; מצב-מופעל (ON): אדום; חסום (CLOGGED): כחול; חיכוך (FRICTION): צהוב). [הערה: קוד מקוצץ למטרות תצוגה.] (מקור תמונה: Stephen Evanczuk,‏ הרצת ML_State_Monitor.ipynb Jupyter Notebook של NXP)

קטעי קוד נוספים מספקים ניתוח נתונים נוסף, נרמול, עיצוב והכנה אחרת עד שביצועי קוד מגיעים לאותה הגדרת פונקציה של יצירת מודל, model_create(), המוצגת למעלה ברשימה 1. קטע הקוד הבא מבצע פונקציית model_create() זו ומדפיסה‏ סיכום עבור תיקוף מהיר (איור 13‏).

איור 13‏: ה-ML_State_Monitor.ipynb Jupyter של NXP יוצר את המודל (מוצג ברשימה 1) ומציג את מידע סיכום המודל. (מקור תמונה: Stephen Evanczuk,‏ הרצת ML_State_Monitor.ipynb Jupyter Notebook של NXP)

בהמשך לקטע קוד לאימון והערכת מודל, ה-ML_State_Monitor.ipynb Jupyter Notebook מציג כל מטריצת בלבול (confusion matrix) עבור מערך הנתונים השלם, מערך נתוני האימון ומערך נתוני התיקוף (תת-מערך של מערך הנתונים שלא נכלל במערך נתוני האימון). במקרה זה, מטריצת הבלבול (confusion matrix) עבור מערך הנתונים השלם מראה דיוק טוב עם מספר שגיאות, בעיקר היכן שהמודל מתבלבל באחוז קטן של מערכי נתונים כאילו הם במצב-מופעל (ON) כשהם באמת במצב-חסום (CLOGGED), כפי שמוער במערך הנתונים המקורי (איור 14‏).

איור 14‏: מפתחים יכולים לצפות במטריצות בלבול (confusion matrices) כמו זה עבור מערך נתונים שלם. (מקור תמונה: Stephen Evanczuk,‏ הרצת ML_State_Monitor.ipynb Jupyter Notebook של NXP)

בקטע קוד‏ מאוחר יותר, המודל מיוצא למספר סוגים ופורמטים של מודל המשמשים מנועי היסק (inference engines) שונים הנתמכים על ידי סביבת הפיתוח eIQ (איור 15‏).

איור 15‏: ה-ML_State_Monitor.ipynb Jupyter Notebook‏ של NXP מדגים כיצד מפתחים יכולים לשמור את המודל המאומן שלהם במספר סוגים ופורמטים של מודל. (מקור תמונה: Stephen Evanczuk,‏ הרצת ML_State_Monitor.ipynb Jupyter Notebook של NXP)

הבחירה של מנוע היסק (inference engine) יכולה להיות חשובה במידה קריטית עבור עמידה בדרישות ביצועים ספציפיות. עבור יישום זה, NXP‏ מדדה גודל מודל, גודל קוד, וזמן היסק (הזמן הדרוש להשלים היסק על אובייקט כניסה יחיד) כשהמודל מיועד עבור מספר מנועי היסק, אחד הרץ ב-996 מגה-הרץ (MHz‏) ואחד הרץ ב-‎156 MHz‏ (איורים 16 ו-17).

איור 16‏: בחירת סוג מודל יכולה להשפיע באופן דרמטי על גודל מודל, למרות שההבדלים הדרמטיים המוצגים כאן יכולים להיות לא ישימים עבור מודלים גדולים יותר. (מקור תמונה: NXP Semiconductors)

איור 17‏: זמן היסק יכול להיות שונה משמעותית עבור הערכה של אובייקט כניסה כשנטען מ-RAM או זיכרון Flash, או כשמפעילים את המעבד בתדר גבוה יותר של 996‎ MHz‏ לעומת ‎156 MHz‏. (מקור תמונה: NXP Semiconductors)

כפי ש-NXP מעירה, יישום דוגמה זה משתמש במודל‏ קטן מאוד, כך שההבדלים הניכרים המוצגים באיורים אלה יכולים לבוא הרבה פחות לידי ביטוי במודל גדול יותר המשמש עבור סיווגים מורכבים.

בניית פתרון‏ מערכת עבור ניטור מצב

בנוסף ל-Jupyter Notebook עבור חקר אינטראקטיבי של תהליך העבודה פיתוח מודל, ה-NXP ML State Monitoring App SW Pack מספקת קוד מקור שלם עבור מימוש התכנון בלוח הערכה MIMXRT1170-EVK של NXP. לוח ההערכה, הבנוי סביב NXP MIMXRT1176DVMAA crossover MCU, מספק פלטפורמת חומרה מקיפה, שלמה, עם זיכרון נוסף וממשקים מרובים (איור 18‏).

איור 18: לוח ההערכה MIMXRT1170-EVK של NXP מספק פלטפורמת חומרה מקיפה עבור פיתוח יישומים המבוססים על ה-Crossover MCU מסדרת NXP i.MX RT1170. (מקור תמונה: NXP Semiconductors)

מפתחים יכולים להשתמש ביישום מצב המאוורר NXP‏ כדי לחזות את המצב של מאוורר על ידי גיבוב לוח ההערכה MIMXRT1170-EVK עם לוח חיישן‏ אופציונלי NXP FRDM-STBC-AGM01, לוח Arduino shield ומאוורר 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 header. (מקור קוד: 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_MODEL מוגדר, מציגה את ביצועי התוצאה וחיזוי הסיווג

העתק
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 Pack מספקת קוד מקור מלא יחד עם מערך שלם של מנהלי-התקן ותוכנות-ביניים (Middleware) דרושים, מפתחים יכולים להרחיב בקלות את היישום, להוסיף מאפיינים או להשתמש בה כנקודת המוצא עבור הפיתוח המותאם-במיוחד שלהם.

מסקנה

מימוש ML‏ בקצה (at the edge) במוצרים חכמים ב-IoT‏ ויישומים אחרים יכול לספק‏ מערך מאפיינים רב-עוצמה, אך לעתים קרובות הדבר משאיר מפתחים נאבקים כדי ליישם כלי ML ושיטות שפותחו עבור יישומים בקנה-מידה של חברה. עם הזמינות של פלטפורמה שפותחה על ידי NXP‏ הכוללת מעבדי Crossover‏ ותוכנת פיתוח מודל מיוחדת, מומחי ML כמו גם מפתחים עם מעט או ללא נסיון ML יכולים ליצור ביעילות יתר יישומי ML המתוכננים במיוחד לעמידה בדרישות של ביצועי קצה יעילים.