Cum să implementați rapid aplicații de învățare automată compatibile cu edge computing

Învățarea automată (ML) oferă un potențial extraordinar pentru crearea produselor inteligente, dar complexitatea și provocările implicate în modelarea rețelelor neuronale (NN) și crearea de aplicații ML pentru marginea rețelei au limitat capacitatea dezvoltatorilor de a furniza rapid soluții utile. Deși instrumentele ușor disponibile au făcut, în general, mai accesibilă crearea de modele ML, practicile convenționale de dezvoltare ML nu sunt concepute pentru a satisface cerințele unice ale soluțiilor pentru Internetul lucrurilor (IoT), automobile, sisteme industriale și alte aplicații integrate.

Acest articol oferă o scurtă introducere în modelarea NN. Apoi, prezintă și descrie modul de utilizare a unei platforme ML cuprinzătoare de la NXP Semiconductors, care permite dezvoltatorilor să livreze mai eficient aplicații ML compatibile cu edge computing.

O scurtă trecere în revistă a modelării NN

Algoritmii ML oferă dezvoltatorilor o opțiune extrem de diferită pentru dezvoltarea aplicațiilor. În loc să scrie coduri software menite să rezolve în mod explicit probleme precum clasificarea imaginilor, dezvoltatorii antrenează modele NN prin prezentarea unui set de date, cum ar fi imagini adnotate cu numele real (sau clasa) entității conținute în imagine. Procesul de instruire utilizează o varietate de metode pentru a calcula parametrii unui model de ponderi și valori de polarizare pentru fiecare neuron și, respectiv, pentru fiecare strat, permițând modelului să ofere o predicție rezonabil de precisă a clasei corecte a unei imagini introduse (Figura 1).

Figura 1: NN-urile, cum ar fi această rețea complet conectată, clasifică un obiect introdus, utilizând parametrii de ponderare și de polarizare stabiliți în timpul instruirii. (Sursă imagine: NXP Semiconductors)

Cercetătorii în domeniul ML au dezvoltat o gamă largă de arhitecturi NN, dincolo de NN generică complet conectată prezentată în Figura 1. De exemplu, aplicațiile de clasificare a imaginilor utilizează în mod obișnuit un NN convoluțional (CNN), o arhitectură specializată care împarte recunoașterea imaginilor într-o fază inițială care găsește caracteristicile cheie ale unei imagini, urmată de o fază de clasificare care prezice probabilitatea ca aceasta să aparțină uneia dintre cele câteva clase stabilite în timpul instruirii (Figura 2).

Figura 2: experții în ML utilizează arhitecturi NN specializate, cum ar fi această rețea neuronală convoluțională (CNN), pentru sarcini specifice, cum ar fi recunoașterea imaginilor. (Sursă imagine: NXP Semiconductors)

Deși selectarea unei arhitecturi de model și a unui regim de instruire adecvate a fost limitată la experții în ML, disponibilitatea mai multor instrumente comerciale și open-source a simplificat în mod dramatic dezvoltarea de modele pentru implementări la scară largă. În prezent, dezvoltatorii pot defini modelele cu câteva linii de cod (Lista 1) și pot utiliza instrumente precum vizualizatorul de modele Netron open-source pentru a genera o reprezentare grafică a modelului (Figura 3) în scopul de a verifica definiția și conectivitatea fiecărui strat.

Copiați
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

Lista 1: dezvoltatorii pot defini modele NN folosind doar câteva linii de cod. (Sursa codului: NXP Semiconductors)

Figura 3: generată de vizualizatorul Netron, această reprezentare grafică a modelului definit în Lista 1 poate ajuta dezvoltatorul să documenteze funcția și conectivitatea fiecărui strat. (Sursa imaginii: Stephen Evanczuk, rulare Netron pe codul sursă pentru modelul NXP din Lista 1)

Pentru implementarea finală, alte instrumente elimină structurile modelului care sunt necesare doar în timpul instruirii și efectuează alte optimizări pentru a crea un model de inferență eficient.

De ce a fost atât de dificilă dezvoltarea aplicațiilor bazate pe ML pentru produse inteligente

Definirea și instruirea unui model pentru IoT sau pentru alte produse inteligente urmează un flux de lucru similar cu crearea unui model pentru aplicațiile de învățare automată la nivel de întreprindere. Dincolo de această asemănare, însă, dezvoltarea aplicațiilor ML pentru edge computing aduce cu sine multiple provocări suplimentare. Pe lângă dezvoltarea modelului, proiectanții se confruntă cu provocările familiare legate de dezvoltarea aplicației principale necesare pentru a rula produsul lor bazat pe microcontroler (MCU). Prin urmare, aducerea ML la marginea rețelei necesită gestionarea a două fluxuri de lucru interdependente (Figura 4).

Figura 4: dezvoltarea unei aplicații bazate pe ML pentru edge computing extinde fluxul de lucru tipic de dezvoltare a MCU încorporat cu un flux de lucru ML necesar pentru instruirea, validarea și implementarea unui model ML. (Sursă imagine: NXP Semiconductors)

Deși fluxul de lucru al proiectului MCU este familiar dezvoltatorilor de aplicații integrate, proiectul ML poate impune cerințe suplimentare pentru aplicația bazată pe MCU, pe măsură ce dezvoltatorii lucrează pentru a crea un model de inferență ML optimizat. De fapt, proiectul ML are un impact dramatic asupra cerințelor dispozitivului încorporat. Sarcina mare de calcul și cerințele de memorie asociate, de obicei, cu executarea modelelor, pot depăși resursele microcontrolerelor utilizate în IoT și în produsele inteligente. Pentru a reduce necesarul de resurse, experții ML aplică tehnici precum curățarea rețelei de modele, compresia, cuantificarea la o precizie mai mică sau chiar la parametri și valori intermediare pe un singur bit, și alte metode.

Cu toate acestea, chiar și cu aceste metode de optimizare, dezvoltatorii pot constata că microcontrolerele convenționale nu dispun de performanța necesară pentru a gestiona numărul mare de operații matematice asociate cu algoritmii ML. Pe de altă parte, utilizarea unui procesor de aplicații de înaltă performanță ar putea gestiona sarcina de calcul ML, dar această abordare ar putea duce la o latență crescută și la un răspuns nedeterminist, degradând caracteristicile din timp real ale proiectului încorporat.

În afară de provocările legate de selecția hardware, furnizarea de modele ML optimizate pentru edge computing prezintă provocări suplimentare, unice pentru dezvoltarea încorporată. Este posibil ca numărul mare de instrumente și metode dezvoltate pentru aplicațiile ML la scară de întreprindere să nu se adapteze bine la aplicația și mediul de operare ale dezvoltatorului de aplicații încorporate. Chiar și dezvoltatorii experimentați de dispozitive încorporate care se așteaptă să implementeze rapid dispozitive bazate pe ML se pot confrunta cu dificultăți în găsirea unei soluții eficiente printre numeroasele arhitecturi, instrumente, cadre și fluxuri de lucru disponibile pentru modele NN.

NXP se ocupă atât de performanța hardware, cât și de aspectele legate de implementarea modelului de dezvoltare a ML pentru edge computing. La nivel de hardware, microcontrolerele crossover i.MX RT1170 de înaltă performanță de la NXP îndeplinesc cerințele extinse de performanță ale tehnologiei ML pentru edge computing. Pentru a profita pe deplin de această bază hardware, mediul de dezvoltare software ML eIQ (edge intelligence) și pachetele de software de aplicație de la NXP oferă atât dezvoltatorilor ML neexperimentați, cât și celor experți o soluție eficientă pentru crearea de aplicații ML compatibile cu edge computing.

O platformă eficientă pentru dezvoltarea de aplicații ML de edge computing

Procesoarele crossover NXP i.MX RT combină răspunsul în timp real, cu latență redusă, al microcontrolerelor integrate tradiționale cu capacitățile de execuție ale procesoarelor de aplicații de înaltă performanță. Seria de procesoare crossover i.MX RT1170 de la NXP integrează un procesor Arm® Cortex®-M4 cu consum redus de energie și un procesor Arm Cortex-M7 de înaltă performanță cu un set extins de blocuri funcționale și periferice necesare pentru a rula aplicații solicitante, inclusiv soluții bazate pe ML în dispozitive încorporate (Figura 5).

Figura 5: procesoarele crossover i.MX RT1170 de la NXP combină capacitatea de eficiență energetică a microcontrolerelor convenționale cu capacitatea de procesare de înaltă performanță a procesoarelor de aplicații. (Sursă imagine: NXP Semiconductors)

Complet integrat în mediile de dezvoltare MCUXpresso SDK și Yocto de la NXP, mediul NXP eIQ este conceput special pentru a facilita implementarea modelelor de inferență pe sistemele integrate construite cu microprocesoare și microcontrolere NXP. Inclus în mediul eIQ, setul de instrumente eIQ susține fluxurile de lucru Bring your own data (BYOD) și Bring your own model BYOM prin intermediul mai multor instrumente, inclusiv portalul eIQ, instrumentul eIQ Model Tool și instrumentele pentru linie de comandă (Figura 6).

Figura 6: setul de instrumente NXP eIQ susține dezvoltatorii BYOD care trebuie să creeze un model și dezvoltatorii BYOM care trebuie să implementeze propriul model existent pe un sistem țintă. (Sursă imagine: NXP Semiconductors)

Conceput pentru a susține fluxurile de lucru BYOD atât pentru experți, cât și pentru dezvoltatorii noi în dezvoltarea modelelor ML, portalul eIQ oferă o interfață grafică de utilizare (GUI) care îi ajută pe dezvoltatori să parcurgă mai ușor fiecare etapă a fluxului de lucru pentru dezvoltarea modelului.

În etapa inițială de dezvoltare, instrumentul de organizare a seturilor de date al portalului eIQ ajută dezvoltatorii să importe date, să captureze date de la o cameră conectată sau să captureze date de la un dispozitiv aflat la distanță (Figura 7).

Figura 7: instrumentul de organizare a seturilor de date al portalului eIQ facilitează sarcina esențială de pregătire a datelor pentru instruire. (Sursă imagine: NXP Semiconductors)

Cu ajutorul instrumentului de organizare a setului de date, dezvoltatorii adnotează sau etichetează fiecare element din setul de date prin etichetarea întregii imagini sau doar a unor regiuni specifice conținute în interiorul unei casete de delimitare specificate. O funcție de augmentare ajută dezvoltatorii să ofere diversitatea necesară setului de date prin estomparea imaginilor, adăugarea de zgomot aleatoriu, modificarea unor caracteristici precum luminozitatea sau contrastul și alte metode.

În faza următoare, portalul eIQ ajută dezvoltatorii să selecteze tipul de model cel mai potrivit pentru aplicație. Pentru dezvoltatorii care nu sunt siguri de tipul de model, un asistent pentru selectarea modelului îi ghidează prin procesul de selecție în funcție de tipul de aplicație și de baza hardware. Dezvoltatorii care știu deja de ce tip de model au nevoie pot selecta un model personalizat furnizat odată cu instalarea eIQ sau alte implementări personalizate.

Portalul eIQ îi conduce pe dezvoltatori prin următoarea etapă critică de instruire, oferind o interfață grafică intuitivă pentru modificarea parametrilor de instruire și vizualizarea modificărilor în acuratețea predicției modelului cu fiecare etapă de instruire (Figura 8).

Figura 8: dezvoltatorii utilizează instrumentul de instruire al portalului eIQ pentru a observa îmbunătățirea acurateței instruirii la fiecare etapă și pentru a le modifica, dacă este necesar. (Sursă imagine: NXP Semiconductors)

În etapa următoare, interfața grafică a portalului eIQ ajută dezvoltatorii să valideze modelul. În această etapă, modelul este convertit pentru a rula pe arhitectura țintă, în scopul de a determina performanța sa reală. La finalizarea validării, ecranul de validare afișează matricea de confuzie – un instrument fundamental de validare ML care permite dezvoltatorilor să compare clasa reală a obiectului introdus cu clasa prezisă de model (Figura 9).

Figura 9: instrumentul de validare al portalului eIQ oferă dezvoltatorilor matricea de confuzie rezultată în urma rulării unui model pe o arhitectură țintă. (Sursă imagine: NXP Semiconductors)

Pentru implementarea finală, mediul oferă dezvoltatorilor posibilitatea de a alege între mai multe motoare de inferență în funcție de procesor, inclusiv:

• Arm CMSIS-NN (Common Microcontroller Software Interface Standard, Neural Network) – nuclee de rețele neuronale dezvoltate pentru a maximiza performanța și a minimiza amprenta de memorie a rețelelor neuronale pe nucleele de procesoare Arm Cortex-M
• Arm NN SDK (rețea neuronală, kit de dezvoltare software) – un set de instrumente și un motor de inferență conceput pentru a face legătura între cadrele de rețea neuronală existente și procesoarele Arm Cortex-A, printre altele.
• DeepViewRT – motorul de inferență brevetat al NXP pentru MCU-urile crossover i.MX RT
• Glow NN – bazat pe compilatorul Glow (reducere grafică) de la Meta și optimizat de NXP pentru nucleele Arm Cortex-M prin utilizarea apelurilor de funcții către nucleele CMSIS-NN sau biblioteca Arm NN, dacă este disponibilă, altfel prin compilarea codului din propria bibliotecă nativă
• ONXX Runtime – instrumente Microsoft Research concepute pentru a optimiza performanța pentru procesoarele Arm Cortex-A.
• TensorFlow Lite for Microcontrollers – o versiune mai mică a TensorFlow Lite, optimizată pentru rularea modelelor de învățare automată pe MCU-uri crossover i.MX RT
• TensorFlow Lite – o versiune de TensorFlow care oferă suport pentru sisteme mai mici

Pentru fluxurile de lucru BYOM, dezvoltatorii pot utiliza instrumentul eIQ Model Tool pentru a trece direct la analiza modelului și la profilarea timpului pe strat. Atât pentru fluxurile de lucru BYOD, cât și pentru cele BYOM, dezvoltatorii pot utiliza instrumentele pentru linia de comandă eIQ care oferă acces la funcționalitatea instrumentelor, precum și la caracteristicile eIQ care nu sunt disponibile direct prin intermediul interfeței grafice.

În afară de caracteristicile descrise în acest articol, setul de instrumente eIQ acceptă un set extins de capabilități, inclusiv conversia și optimizarea modelelor, care depășește cu mult sfera acestui articol. Cu toate acestea, pentru crearea rapidă a prototipurilor de aplicații ML pentru edge computing, dezvoltatorii pot, în general, să treacă rapid la dezvoltare și implementare, fără a fi nevoie să utilizeze multe dintre capacitățile mai sofisticate ale mediului eIQ. De fapt, pachetele specializate de software de aplicație (App SW) de la NXP oferă aplicații complete pe care dezvoltatorii le pot folosi pentru evaluare imediată sau ca bază pentru propriile aplicații personalizate.

Cum să evaluați rapid dezvoltarea modelelor utilizând un pachet App SW

Pachetele App SW de la NXP oferă o aplicație completă bazată pe ML, combinând codul sursă, driverele, middleware-ul și instrumentele gata de producție. De exemplu, ML State Monitor App SW Pack de la NXP oferă o soluție imediată bazată pe ML pentru problema frecventă de determinare a stării sistemelor complexe pe baza intrărilor senzorilor (Figura 10).

Figura 10: dezvoltatorii pot utiliza pachetele NXP App SW, cum ar fi ML State Monitor App SW Pack, pentru o evaluare imediată sau ca bază pentru dezvoltarea de cod personalizat. (Sursă imagine: NXP Semiconductors)

ML State Monitor App SW Pack implementează o soluție completă pentru o aplicație destinată să detecteze când un ventilator funcționează într-una din cele patru stări:

• PORNIT
• OPRIT
• BLOCAT, când ventilatorul este pornit, dar fluxul de aer este obstrucționat
• FRECARE, atunci când ventilatorul este pornit, dar una sau mai multe palete ale ventilatorului întâmpină o frecare excesivă în timpul funcționării

La fel de important pentru dezvoltatorii de modele, ML State Monitor App SW Pack include modele ML, precum și un set complet de date reprezentând citirile accelerometrului de la un ventilator care funcționează în fiecare dintre aceste patru stări.

Dezvoltatorii pot studia codul, modelele și datele furnizate în ML State Monitor App SW Pack pentru a înțelege cum să utilizeze datele senzorilor pentru a instrui un model, a crea un model de inferență și a valida inferența în raport cu un set de date pentru senzor de validare. De fapt, Jupyter Notebook ML_State_Monitor.ipynb al NXP, inclus în App SW Pack, oferă un instrument imediat, gata de utilizare, pentru studierea fluxului de lucru de dezvoltare a modelului cu mult înainte de orice implementare hardware.

Jupyter Notebook este o platformă interactivă de execuție Python bazată pe browser, care permite dezvoltatorilor să vizualizeze imediat rezultatele execuției codului Python. Rularea unui Jupyter Notebook generează un bloc de cod Python, urmat imediat de rezultatele rulării acelui bloc de cod. Aceste rezultate nu sunt simple afișări statice, ci sunt rezultatele reale obținute prin rularea codului. De exemplu, atunci când dezvoltatorii rulează Jupyter Notebook ML_State_Monitor.ipynb de la NXP, pot vedea imediat un rezumat al setului de date introduse (Figura 11).

Figura 11: Jupyter Notebook ML_State_Monitor.ipynb de la NXP permite dezvoltatorilor să lucreze interactiv prin fluxul de lucru pentru dezvoltarea modelului de rețea neuronală, vizualizând datele de instruire furnizate în ML State Monitor App SW Pack. [Notă: codul a fost trunchiat aici pentru afișare.] (Sursa imaginii: Stephen Evanczuk, rulare Jupyter Notebook ML_State_Monitor.ipynb de la NXP)

Următoarea secțiune de cod din Notebook oferă utilizatorului o afișare grafică a datelor de intrare, prezentate sub formă de diagrame separate pentru secvența de timp și frecvență (Figura 12).

Figura 12: Jupyter Notebook oferă dezvoltatorilor serii de timp și afișări de frecvență ale setului de date privind starea ventilatorului de probă (OPRIT: verde; PORNIT: roșu; BLOCAT: albastru; FRECARE: galben). [Notă: cod trunchiat în scopul prezentării.] (Sursa imaginii: Stephen Evanczuk, rulare Jupyter Notebook ML_State_Monitor.ipynb de la NXP)

Secțiuni suplimentare de cod asigură o analiză suplimentară a datelor, normalizarea, modelarea și alte pregătiri până când execuția codului ajunge la aceeași definiție a funcției de creare a modelului, model_create(), prezentată anterior în Lista 1. Următoarea secțiune de cod execută această funcție model_create() și tipărește un rezumat pentru o validare rapidă (Figura 13).

Figura 13: Jupyter Notebook ML_State_Monitor.ipynb de la NXP creează modelul (prezentat în Lista 1) și afișează informațiile pe scurt ale modelului. (Sursa imaginii: Stephen Evanczuk, rulare Jupyter Notebook ML_State_Monitor.ipynb de la NXP)

După o secțiune de cod pentru instruirea și evaluarea modelului, Jupyter Notebook ML_State_Monitor.ipynb afișează fiecare matrice de confuzie pentru setul complet de date, setul de date de instruire și setul de date de validare (un subset de date exclus din setul de date de instruire). În acest caz, matricea de confuzie pentru întregul set de date arată o precizie bună, cu unele erori, mai ales în cazul în care modelul confundă un mic procent din seturile de date ca fiind în starea PORNITĂ, când acestea se află, de fapt, în starea BLOCATĂ, așa cum a fost adnotat în setul de date original (Figura 14).

Figura 14: dezvoltatorii pot vizualiza matrice de confuzie precum aceasta pentru întregul set de date. (Sursa imaginii: Stephen Evanczuk, rulare Jupyter Notebook ML_State_Monitor.ipynb de la NXP)

Într-o secțiune de cod ulterioară, modelul este exportat în mai multe tipuri de modele și formate diferite utilizate de diversele motoare de inferență acceptate de mediul de dezvoltare eIQ (Figura 15).

Figura 15: Jupyter Notebook ML_State_Monitor.ipynb de la NXP demonstrează modul în care dezvoltatorii își pot salva modelul instruit în mai multe tipuri și formate diferite de modele. (Sursa imaginii: Stephen Evanczuk, rulare Jupyter Notebook ML_State_Monitor.ipynb de la NXP)

Alegerea motorului de inferență poate fi extrem de importantă pentru îndeplinirea unor cerințe specifice de performanță. Pentru această aplicație, NXP a măsurat dimensiunea modelului, dimensiunea codului și timpul de inferență (timpul necesar pentru a finaliza inferența pe un singur obiect de intrare) atunci când modelul este direcționat către mai multe motoare de inferență, unul care funcționează la 996 megahertzi (MHz) și unul care funcționează la 156 MHz (Figurile 16 și 17).

Figura 16: alegerea tipului de model poate avea un impact dramatic asupra dimensiunii modelului, deși s-ar putea ca diferențele dramatice prezentate aici să nu se aplice în cazul modelelor mai mari. (Sursă imagine: NXP Semiconductors)

Figura 17: timpul de inferență poate diferi semnificativ pentru evaluarea unui obiect de intrare atunci când este încărcat din memoria RAM sau flash sau atunci când procesorul funcționează la o frecvență mai mare, de 996 MHz față de 156 MHz. (Sursă imagine: NXP Semiconductors)

După cum remarcă NXP, această aplicație de eșantionare utilizează un model foarte mic, astfel încât diferențele destul de clare prezentate în aceste cifre ar putea fi mult mai puțin pronunțate într-un model mai mare utilizat pentru clasificări complexe.

Construirea unei soluții de sistem pentru monitorizarea stării

Pe lângă Jupyter Notebook pentru explorarea interactivă a fluxului de lucru pentru dezvoltarea modelului, ML State Monitoring App SW Pack de la NXP oferă codul sursă complet pentru implementarea proiectului pe placa de evaluare MIMXRT1170-EVK de la NXP. Construită în jurul unui MCU crossover MIMXRT1176DVMAA de la NXP, placa de evaluare oferă o platformă hardware cuprinzătoare, cu memorie suplimentară și interfețe multiple (Figura 18).

Figura 18: placa de evaluare MIMXRT1170-EVK de la NXP oferă o platformă hardware cuprinzătoare pentru dezvoltarea de aplicații bazate pe MCU crossover din seria NXP i.MX RT1170. (Sursă imagine: NXP Semiconductors)

Dezvoltatorii pot utiliza aplicația NXP pentru a prezice starea unui ventilator prin stivuirea plăcii de evaluare MIMXRT1170-EVK cu o placă de senzori opțională NXP FRDM-STBC-AGM01, un scut Arduino și un ventilator c.c. adecvat fără perii, de 5 volți, cum ar fi Adafruit 4468 (Figura 19).

Figura 19: dezvoltatorii pot testa aplicația de probă NXP pentru starea ventilatorului cu o stivă simplă construită pe placa de evaluare MIMXRT1170-EVK. (Sursă imagine: NXP Semiconductors)

Utilizând mediul de dezvoltare integrat (IDE) MCUXpresso, dezvoltatorii pot configura aplicația pentru a achiziționa și stoca pur și simplu datele de stare a ventilatorului sau pentru a executa imediat inferența pe datele achiziționate cu un motor de inferență TensorFlow, un motor de inferență DeepViewRT sau un motor de inferență Glow (Lista 2).

Copiați
/* 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

Lista 2: dezvoltatorii pot configura cu ușurință aplicația de probă NXP ML State Monitor prin modificarea definițiilor incluse în fișierul de antet sensor_collect.h. (Sursa codului: NXP Semiconductors)

Aplicația funcționează cu un flux de proces simplu. Rutina principală din main.c creează o sarcină numită MainTask, care este o rutină localizată în modulul sensor_collect.c.

Copiați
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

Lista 3: în aplicația de probă NXP ML State Monitor, MainTask invocă o sub-sarcină pentru a achiziționa date sau pentru a efectua inferențe. (Sursa codului: NXP Semiconductors)

MainTask efectuează diverse sarcini de inițializare înainte de a lansa una dintre cele două sub-sarcini, în funcție de definițiile stabilite de utilizator în sensor_collect.h:

• dacă SENSOR_COLLECT_ACTION este setat la SENSOR_COLLECT_LOG_EXT, MainTask pornește sub-sarcina SENSOR_Collect_LogExt_Task(), care colectează datele și le stochează pe cardul SD, dacă acesta este configurat
• dacă SENSOR_COLLECT_ACTION este setat la SENSOR_COLLECT_RUN_INFERENCE, MainTask pornește sub-sarcina SENSOR_Collect_RunInf_Task(), care execută motorul de inferență (Glow, DeepViewRT sau TensorFlow) definit în sensor_collect.h pe baza datelor colectate și, dacă este definit SENSOR_EVALUATE_MODEL, afișează performanța și predicția de clasificare rezultate

Copiați
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 */

Lista 4: exemplul de aplicație NXP ML State Monitor demonstrează modelul de proiectare de bază pentru achiziția de date de la senzori și rularea motorului de inferență selectat pe datele achiziționate. (Sursa codului: NXP Semiconductors)

Deoarece NXP ML State Monitor App SW Pack oferă codul sursă complet, împreună cu un set complet de drivere și middleware necesare, dezvoltatorii pot extinde cu ușurință aplicația pentru a adăuga caracteristici sau o pot utiliza ca punct de plecare pentru propria dezvoltare personalizată.

Concluzie

Implementarea ML la marginea rețelei în produsele inteligente din IoT și alte aplicații poate oferi un set puternic de caracteristici, dar, adesea, dezvoltatorii se chinuiesc să aplice instrumentele și metodele ML dezvoltate pentru aplicații la scară de întreprindere. Datorită disponibilității unei platforme de dezvoltare NXP alcătuită din procesoare crossover și software specializat de dezvoltare a modelelor, atât experții în ML, cât și dezvoltatorii cu puțină experiență sau care nu au deloc experiență în ML pot crea mai eficient aplicații ML concepute special pentru a îndeplini cerințele de performanță eficientă în edge computing.