Jak rychle nasadit aplikace strojového učení připravené na okraj

Strojové učení (ML) nabízí obrovský potenciál pro vytváření chytrých produktů, avšak složitost a problémy spojené s modelováním neuronových sítí (NN) a vytvářením aplikací ML na okraj sítě omezují schopnost vývojářů rychle dodávat užitečná řešení. Přestože snadno dostupné nástroje obecně zpřístupnily tvorbu modelů ML, běžné postupy vývoje ML nejsou navrženy tak, aby splňovaly jedinečné požadavky řešení pro internet věcí (IoT), automobilový průmysl, průmyslové systémy a další vestavěné aplikace.

Tento článek poskytuje krátký úvod do modelování neuronových sítí. Poté představuje a popisuje, jak používat komplexní platformu MLPolovodiče NXP to umožňuje vývojářům efektivněji dodávat aplikace ML připravené na okraj.

Rychlý přehled modelování neuronových sítí

Algoritmy ML poskytují vývojářům výrazně odlišné možnosti pro vývoj aplikací. Namísto psaní softwarového kódu určeného k explicitnímu řešení problémů, jako je klasifikace obrázků, vývojáři učí modely NN tím, že prezentují sadu dat, jako jsou obrázky anotované skutečným názvem (nebo třídou) entity obsažené v obrázku. Proces učení využívá různé metody pro výpočet parametrů modelu vah a hodnot zkreslení pro každý neuron a vrstvu, v daném pořadí, což umožňuje modelu poskytnout přiměřeně přesnou předpověď správné třídy vstupního obrázku (obrázek 1).

Obrázek 1: Neuronové sítě, například tato plně připojená síť, klasifikují vstupní objekt pomocí parametrů váhy a zkreslení nastavených během učení. (Zdroj obrázku: NXP Semiconductors)

Výzkumníci strojového učení vyvinuli širokou škálu architektur neuronových sítí nad rámec generické, plně připojené sítě NN znázorněné na obrázku 1. Například aplikace pro klasifikaci obrazu obvykle využívají konvoluční síť NN (CNN), specializovanou architekturu, která rozděluje rozpoznávání obrazu na počáteční fázi, která najde klíčové rysy obrazu, po níž následuje klasifikační fáze, která předpovídá pravděpodobnost, že patří do jednoho z několika třídy vytvořené během učení (obrázek 2).

Obrázek 2: Odborníci na strojové učení používají specializované architektury sítí NN, jakou má např. tato konvoluční neuronová síť (CNN), pro specifické úkoly, například rozpoznávání obrazu. (Zdroj obrázku: NXP Semiconductors)

Ačkoli byl výběr vhodné architektury modelu a režimu učení omezen na ML experty, dostupnost mnoha open source a komerčních nástrojů výrazně zjednodušila vývoj modelu pro rozsáhlá nasazení. Dnes mohou vývojáři definovat modely pomocí několika řádků kódu (výpis 1) a používat různé nástroje, například modelový prohlížeč Netron typu open-source na vygenerování grafického znázornění modelu (obrázek 3) pro kontrolu definice a konektivity každé vrstvy.

Kopírovat
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

Výpis 1: Vývojáři mohou definovat modely neuronových sítí pomocí pouze několika řádků kódu. (Zdroj kódu: NXP Semiconductors)

Obrázek 3: Toto grafické znázornění modelu definovaného ve výpisu 1 generované prohlížečem Netron může vývojářům pomoci zdokumentovat funkce a konektivitu každé vrstvy. (Zdroj obrázku: Stephen Evanczuk, prohlížeč Netron spuštěný na zdrojovém kódu modelu NXP ve výpisu 1)

Pro konečné nasazení jiné nástroje odstraňují struktury modelu požadované pouze během učení a provádějí další optimalizace, aby se vytvořil efektivní model odvození.

Proč byl dosud vývoj aplikací založených na strojovém učení pro chytré produkty tak obtížný

Definování a učení modelu pro IoT nebo jiné chytré produkty se řídí podobným pracovním postupem jako vytváření modelu pro podnikové aplikace strojového učení. Kromě této podobnosti však vývoj aplikací ML pro okraj přináší řadu dalších výzev. Spolu s vývojem modelu čelí návrháři známým výzvám vývoje hlavní aplikace potřebné pro provoz jejich produktu založeného na mikrokontroléru (MCU). Výsledkem je, že přivedení strojového učení na okraj vyžaduje správu dvou vzájemně souvisejících pracovních postupů (obrázek 4).

Obrázek 4: Vývoj aplikace na bázi strojového učení pro okraj rozšiřuje typický pracovní postup vývoje vestavěného mikrokontroléru (MCU) o strojové učení, které potřebné k učení, ověřování a nasazení modelu ML. (Zdroj obrázku: NXP Semiconductors)

Přestože pracovní postup projektu MCU je vývojářům vestavěných aplikací známý, projekt strojového učení může klást další požadavky na aplikaci založení na mikrokontroléru MCU, neboť vývojáři pracují na vytvoření optimalizovaného inferenčního modelu strojového učení. Ve skutečnosti projekt strojového učení dramaticky ovlivňuje požadavky na vestavěné zařízení. Velká výpočetní zátěž a požadavky na paměť obvykle spojené s prováděním modelu mohou přesáhnout zdroje mikrokontrolérů používaných v IoT a chytrých produktech. Ke snížení nároků na prostředky používají ML experti různé techniky, například čistění modelové sítě, kompresi, kvantizaci na nižší přesnost nebo dokonce jednobitové parametry, mezihodnoty a další.

I s těmito optimalizačními metodami však vývojáři stále mohou zjistit, že konvenční mikrokontroléry postrádají výkon potřebný ke zvládnutí velkého počtu matematických operací spojených s algoritmy strojového učení. Na druhou stranu použití vysoce výkonného aplikačního procesoru by mohlo zvládnout výpočetní zátěž ML, ale tento přístup by mohl vést ke zvýšené latenci a nedeterministické odezvě, což by degradovalo charakteristiky jejich vestavěného návrhu v reálném čase.

Kromě problémů s výběrem hardwaru přináší poskytování optimalizovaných modelů ML pro okraj další výzvy jedinečné pro vestavěný vývoj. Obrovské množství nástrojů a metod vyvinutých pro podnikové aplikace ML nemusí být vhodné pro vestavěné vývojářské aplikace a provozní prostředí. Dokonce i zkušení vývojáři vestavěných aplikací, kteří očekávají rychlé nasazení zařízení na bázi strojového učení, mohou mít problémy s nalezením efektivního řešení mezi množstvím dostupných architektur, nástrojů, rámců a pracovních postupů modelů neuronových sítí.

NXP se zaměřuje jak na výkon hardwaru, tak na aspekty implementace modelu vývoje strojového učení na okraji. Na hardwarové úrovni splňují vysoce výkonné crossover mikrokontroléry i.MX RT1170 od společnosti NXP široké požadavky na výkon strojového učení na okraji. Chcete-li plně využít tuto hardwarovou základnu, prostředí pro vývoj softwaru a balíčky aplikačního softwaru eIQ (edge intelligence) od společnosti NXP nabízejí nezkušeným i zkušeným vývojářům ML efektivní řešení pro vytváření aplikací strojového učení připravených na okraj.

Efektivní platforma pro vývoj aplikací ML připravených na okraj

Crossover procesory NXP i.MX RT kombinují odezvu tradičních vestavěných mikrokontrolérů s nízkou latencí v reálném čase se schopnostmi provádění vysoce výkonných aplikačních procesorů. Crossover procesory NXP řady i.MX RT1170 integrují energeticky účinný procesor Arm® Cortex®-M4 a vysoce výkonný procesor Arm Cortex-M7 s rozsáhlou sadou funkčních bloků a periferií potřebných pro provoz náročných aplikací, včetně řešení na bázi ML ve vestavěných zařízeních (obrázek 5).

Obrázek 5: Crossover procesory NXP i.MX RT1170 kombinují schopnosti vysoké energetické účinnosti běžných mikrokontrolérů s vysoce výkonnými schopnostmi zpracování aplikačních procesorů. (Zdroj obrázku: NXP Semiconductors)

Prostředí NXP eIQ, které je plně integrováno do vývojových prostředí NXP MCUXpresso SDK a Yocto, je navrženo speciálně pro usnadnění implementace odvozených modelů na vestavěných systémech postavených s mikroprocesory a mikrokontroléry NXP. Sada eIQ Toolkit, která je součástí prostředí eIQ, podporuje přenos vlastních dat (BYOD) a vlastní pracovní postupy BYOM modelu prostřednictvím několika nástrojů, včetně portálu eIQ, nástroje eIQ Model Tool a nástrojů příkazového řádku (obrázek 6).

Obrázek 6: NXP eIQ Toolkit podporuje vývojáře trendu BYOD, jejichž cílem je vytvářet modely, a vývojáře trendu BYOM, jejichž cílem nasazení vlastních stávajících modelů do cílového systému. (Zdroj obrázku: NXP Semiconductors)

Portál eIQ, navržený tak, aby podporoval pracovní postupy trendu BYOD jak pro odborníky, tak pro nové vývojáře modelů ML, poskytuje grafické uživatelské rozhraní (GUI), které pomáhá vývojářům snadněji dokončit každou fázi pracovního postupu vývoje modelu.

V počáteční fázi vývoje pomáhá nástroj pro kurátory datové sady portálu eIQ Portal vývojářům importovat data, zachytit data z připojené kamery nebo zachytit data ze vzdáleného zařízení (obrázek 7).

Obrázek 7: Nástroj pro kurátory datové sady portálu eIQ Portal usnadňuje kritický úkol přípravy dat učení. (Zdroj obrázku: NXP Semiconductors)

Pomocí nástroje datové sady pro kurátory vývojáři anotují nebo označují každou položku v datové sadě označením celého obrázku nebo jen konkrétních oblastí obsažených v určeném ohraničovacím rámečku. Funkce rozšíření pomáhá vývojářům poskytnout potřebnou rozmanitost datové sadě rozmazáním obrázků, přidáním náhodného šumu, změnou charakteristik, jako je jas nebo kontrast, a dalšími metodami.

V další fázi eIQ Portal pomáhá vývojářům vybrat typ modelu, který nejlépe vyhovuje dané aplikaci. Pokud si vývojáři nejsou jisti typem modelu, průvodce výběrem modelu je provede výběrem na základě typu aplikace a hardwarového základu. Vývojáři, kteří již vědí, jaký typ modelu potřebují, mohou zvolit vlastní model dodávaný s instalací eIQ nebo jinou vlastní implementací.

Portál eIQ provede vývojáře dalším kritickým školicím krokem s poskytnutím intuitivního rozhraní GUI pro úpravu parametrů učení a prohlížení změn v přesnosti predikce modelu v každém kroku učení (obrázek 8).

Obrázek 8: Vývojáři používají nástroj učení portálu eIQ ke sledování zlepšení přesnosti učení s každým krokem a v případě potřeby je upravují. (Zdroj obrázku: NXP Semiconductors)

V dalším kroku GUI portálu eIQ pomáhá vývojářům ověřit model. V této fázi je model převeden na provoz na cílové architektuře, aby mohl být stanoven jeho skutečný výkon. Po dokončení ověřování se na ověřovací obrazovce zobrazí matice záměn - základní nástroj ověřování strojového učení, který vývojářům umožňuje porovnat skutečnou třídu vstupního objektu s třídou predikovanou modelem (obrázek 9).

Obrázek 9: Ověřovací nástroj portálu eIQ Portal poskytuje vývojářům matici záměn vyplývající ze spuštění modelu na cílové architektuře. (Zdroj obrázku: NXP Semiconductors)

Pro konečné nasazení poskytuje prostředí vývojářům výběr cílových inferenčních enginů v závislosti na procesoru, včetně:

• Arm CMSIS-NN (Common Microcontroller Software Interface Standard, Neural Network) - jáder neuronových sítí vyvinutých s cílem maximalizovat výkon a minimalizovat paměťovou stopu neuronových sítí na jádrech procesorů Arm Cortex-M.
• Arm NN SDK (neuronová síť, sada pro vývoj softwaru) - sady nástrojů a inferenčního enginu navržené mimo jiné na přemostění mezi existujícími rámci neuronové sítě a procesory Arm Cortex-A.
• DeepViewRT - patentovaného inferenčního enginu společnosti NXP pro crossover procesor MCU i.MX RT.
• Glow NN - enginu založeného na kompilátoru Glow (snižování grafu) společnosti Meta a optimalizovaný společností NXP pro jádra procesoru Arm Cortex-M pomocí volání funkcí jader CMSIS-NN nebo knihovny Arm NN, pokud je k dispozici, jinak kompilací kódu z vlastní nativní knihovny.
• ONXX Runtime - nástrojů společnosti Microsoft Research určených k optimalizaci výkonu pro procesory Arm Cortex-A.
• TensorFlow Lite pro mikrokontroléry - menší verze TensorFlow Lite, optimalizované pro spouštění modelů strojového učení na crossover procesorech MCU i.MX RT.
• TensorFlow Lite - verze TensorFlow poskytující podporu pro menší systémy.

Pro pracovní postupy BYOM mohou vývojáři použít nástroj eIQ Model Tool k přímému přechodu na analýzu modelu a časové profilování podle vrstev. Pro pracovní postupy BYOD i BYOM mohou vývojáři používat nástroje příkazového řádku eIQ, které poskytují přístup k funkcím nástroje, stejně jako funkce eIQ, které nejsou dostupné přímo prostřednictvím GUI.

Kromě funkcí popsaných v tomto článku podporuje eIQ Toolkit rozsáhlou sadu funkcí, včetně konverze a optimalizace modelu, což je výrazně nad rámec tohoto článku. Nicméně pro rychlé prototypování aplikací strojového učení připravených na okraj mohou vývojáři obecně rychle postupovat málo potřebným vývojem a nasazením, aby mohli využívat mnoho sofistikovanějších schopností prostředí eIQ. Specializované balíčky aplikačního softwaru (App SW) od společnosti NXP ve skutečnosti nabízejí kompletní aplikace, které mohou vývojáři použít k okamžitému vyhodnocení nebo jako základ svých vlastních aplikací.

Jak rychle vyhodnotit vývoj modelu pomocí balíčku App SW Pack

Balíčky App SW Pack od společnosti NXP poskytují kompletní aplikaci založenou na strojovém učení, která kombinuje zdrojový kód připravený pro produkci, ovladače, middleware a nástroje. Například balíček ML State Monitor App SW Pack od společnosti NXP nabízí okamžité řešení na bázi strojového učení pro častý problém určování stavu složitých systémů na základě senzorových vstupů (obrázek 10).

Obrázek 10: Vývojáři mohou pro okamžité vyhodnocení nebo jako základ vývoje vlastního kódu využít balíček NXP App, například ML State Monitor App. (Zdroj obrázku: NXP Semiconductors)

Balíček ML State Monitor App implementuje kompletní řešení pro aplikaci určenou ke zjištění, kdy ventilátor pracuje v jednom ze čtyř stavů:

• ZAP
• VYP
• UCPÁNO, je-li ventilátor zapnutý, ale brání proudění vzduchu.
• TŘENÍ, je-li ventilátor zapnutý, ale jedna nebo více lopatek ventilátoru je během provozu vystavena nadměrnému tření.

Balíček ML State Monitor App, který je pro vývojáře modelů neméně důležitý, obsahuje modely ML, jakož i kompletní datovou sadu představující hodnoty akcelerometru odečtené z ventilátoru pracujícího v každém z těchto čtyř stavů.

Vývojáři mohou studovat kód, modely a data poskytovaná v balíčku ML State Monitor App, aby pochopili, jak použít data senzoru k učení modelu, vytvoření inferenčního modelu a ověření inference oproti sadě dat ověřovacího senzoru. Notebook ML_State_Monitor.ipynb Jupyter od společnosti NXP, který je součástí balíčku App SW, ve skutečnosti poskytuje okamžitý, hotový nástroj pro studium pracovního postupu vývoje modelu ještě před nasazením hardwaru.

Jupyter Notebook je interaktivní platforma pro spouštění jazyka Python založená na prohlížeči, která umožňuje vývojářům ihned zobrazit výsledky spouštění kódu Python. Spuštění platformy Jupyter Notebook vygeneruje blok kódu jazyka Python, za kterým bezprostředně následují výsledky spuštění tohoto bloku kódu. Tyto výsledky nejsou pouze statická zobrazení, ale jsou to skutečné výsledky získané spuštěním kódu. Pokud vývojáři spustí například platformu ML_State_Monitor.ipynb Jupyter Notebook od společnosti NXP, mohou ihned zobrazit souhrn vstupní datové sady (obrázek 11).

Obrázek 11: platforma Notebook ML_State_Monitor.ipynb Jupyter od společnosti NXP umožňuje vývojářům interaktivně pracovat prostřednictvím pracovního postupu vývoje modelu neuronové sítě a zobrazovat data učení poskytovaná v softwarovém balíčku aplikací ML State Monitor. [Poznámka: Kód je zde zkrácen pro účely zobrazení.] (Zdroj obrázku: Stephen Evanczuk, běžící na NXP's ML_State_Monitor.ipynb Jupyter Notebook)

Další část kódu v platformě Notebook poskytuje uživateli grafické zobrazení vstupních dat, prezentovaných jako samostatné grafy pro časovou sekvenci a frekvenci (obrázek 12).

Obrázek 12: platforma Notebook Jupyter poskytuje vývojářům zobrazení časových řad a frekvence ukázkové sady stavových dat ventilátoru (VYP: zelená; ZAP: červená; CLOGGED: modrá; TŘENÍ: žlutá). [Poznámka: Kód zkrácen pro účely prezentace.] (Zdroj obrázku: Stephen Evanczuk, spuštěná plarforma ML_State_Monitor.ipynb Jupyter Notebook od společnosti NXP)

Další části kódu poskytují další analýzu dat, normalizaci, tvarování a další přípravu, dokud spuštění kódu nedosáhne stejné definice funkce vytváření modelu, model_create(), jak je uvedeno výše ve výpisu 1. Hned další část kódu provede tuto funkci model_create() a vytiskne shrnutí pro rychlé ověření (obrázek 13).

Obrázek 13: Notebook ML_State_Monitor.ipynb Jupyter NXP vytvoří model (zobrazený ve výpisu 1) a zobrazí souhrnné informace o modelu. (Zdroj obrázku: Stephen Evanczuk, spuštěná plarforma ML_State_Monitor.ipynb Jupyter Notebook od společnosti NXP)

Po části kódu pro učení a vyhodnocování modelu zobrazuje platforma ML_State_Monitor.ipynb Jupyter Notebook jednotlivé matice záměn pro celou datovou sadu, učicí a ověřovací datovou sadu (podmnožinu datové sady vyloučenou z učicí datové sady). V tomto případě matice záměn pro kompletní datovou sadu vykazuje dobrou přesnost s určitým množstvím chyb, zejména tam, kde model chybně interpretuje malé procento datových sad jako ve stavu ZAP, jsou-li ve skutečnosti ve stavu UCPÁNO, jak bylo uvedeno v poznámce originální datové sady (obrázek 14).

Obrázek 14: Vývojáři mohou zobrazit matice záměn, jakou je např. tato, pro celou datovou sadu. (Zdroj obrázku: Stephen Evanczuk, spuštěná platforma ML_State_Monitor.ipynb Jupyter Notebook od společnosti NXP)

V pozdější části kódu je model exportován do několika různých typů modelů a formátů používaných různými inferenčními enginy podporovanými vývojovým prostředím eIQ (obrázek 15).

Obrázek 15: platforma Notebook ML_State_Monitor.ipynb Jupyter od společnosti NXP ukazuje, jak mohou vývojáři uložit svůj naučený model v několika různých typech a formátech modelů. (Zdroj obrázku: Stephen Evanczuk, spuštěná plarforma ML_State_Monitor.ipynb Jupyter Notebook od společnosti NXP)

Výběr inferenčního enginu může být kriticky důležitý pro splnění specifických požadavků na výkon. Pro tuto aplikaci společnost NXP měřila velikost modelu, kódu a čas inference (čas potřebný k dokončení inference jednoho vstupního objektu), je-li model zaměřen na několik inferenčních procesorů, z nichž jeden běží na 996 MHz a druhý na 156 MHz (obrázky 16 a 17).

Obrázek 16: Volba typu modelu může dramaticky ovlivnit jeho velikost, ačkoli zde uvedené dramatické rozdíly nemusí platit pro větší modely. (Zdroj obrázku: NXP Semiconductors)

Obrázek 17: Doba inference se může výrazně lišit pro vyhodnocení vstupního objektu při načítání z paměti RAM nebo flash nebo při provozu procesoru na vyšší frekvenci 996 MHz oproti 156 MHz. (Zdroj obrázku: NXP Semiconductors)

Jak uvádí společnost NXP, tato ukázková aplikace používá velmi malý model, takže dosti výrazné rozdíly zobrazené na těchto obrázcích mohou být podstatně méně výrazné ve větším modelu používaném pro komplexní klasifikace.

Vybudování systémového řešení pro sledování stavu

Kromě platformy Jupyter Notebook pro interaktivní zkoumání pracovního postupu vývoje modelu poskytuje balíček ML State Monitoring App od společnost NXP kompletní zdrojový kód pro implementaci návrhu na vyhodnocovací desce.MIMXRT1170-EVK společnosti NXP. Vyhodnocovací deska postavená na crossover procesoru MCU MIMXRT1176DVMAA od společnosti NXP poskytuje komplexní hardwarovou platformu rozšířenou o další paměti a několik rozhraní (obrázek 18).

Obrázek 18: Vyhodnocovací deska MIMXRT1170-EVK od společnosti NXP poskytuje komplexní hardwarovou platformu pro vývoj aplikací založených na crossover procesoru MCU řady NXP i.MX RT1170. (Zdroj obrázku: NXP Semiconductors)

Vývojáři mohou rozšířením vyhodnocovací desky MIMXRT1170-EVK o volitelnou senzorovou desku FRDM-STBC-AGM01 od společnosti NXP, stínění Arduino a vhodný 5V bezkartáčový stejnosměrný ventilátor, například 4468 od společnosti Adafruit (obrázek 19) využít stavovou aplikaci od společnosti NXP k předpovědi stavu ventilátoru.

Obrázek 19: Vývojáři mohou testovat ukázkovou aplikaci stavu ventilátoru NXP pomocí jednoduchého zásobníku postaveného na vyhodnocovací desce MIMXRT1170-EVK. (Zdroj obrázku: NXP Semiconductors)

Pomocí integrovaného vývojového prostředí (IDE) MCUXpresso mohou vývojáři nakonfigurovat aplikaci tak, aby jednoduše získávala a ukládala data o stavu ventilátoru nebo ihned spouštěla inference získaných dat pomocí inferenčních enginů TensorFlow, DeepViewRT nebo Glow (výpis 2).

Kopírovat
/* 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

Výpis 2: Úpravou definic obsažených v souboru záhlaví sensor_collect.h mohou vývojáři mohou snadno nakonfigurovat ukázkovou aplikaci ML State Monitor od společnosti NXP. (Zdroj kódu: NXP Semiconductors)

Aplikace pracuje s přímočarým tokem procesu. Hlavní rutina v části main.c vytvoří úlohu s názvem MainTask, což je rutina umístěná v modulu sensor_collect.c.

Kopírovat
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

Výpis 3: V ukázkové aplikaci ML State Monitor od společnosti NXP vyvolá úloha MainTask podúlohu pro získání dat nebo spuštění inference. (Zdroj kódu: NXP Semiconductors)

MainTask provádí různé inicializační úlohy před spuštěním jedné ze dvou podúloh v závislosti na definicích nastavených uživatelem v modulu sensor_collect.h:

• pokud je SENSOR_COLLECT_ACTION nastaveno na SENSOR_COLLECT_LOG_EXT, MainTask spustí podúlohu SENSOR_Collect_LogExt_Task(), která shromažďuje data a ukládá je na SD kartu, je-li nakonfigurována.
• pokud je SENSOR_COLLECT_ACTION nastaveno na SENSOR_COLLECT_RUN_INFERENCE, MainTask spustí podúlohu SENSOR_Collect_RunInf_Task(), která spustí inferenční engine (Glow, DeepViewRT nebo TensorFlow) definovaný v modulu sensor_collect.h proti shromážděným datům, a pokud je definován model SENSOR_EVALUATE_MODEL, zobrazí se výsledná předpověď výkonu a klasifikace.

Kopírovat
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 */

Výpis 4: Ukázková aplikace ML State Monitor od společnosti demonstruje základní návrhový vzor pro získávání dat ze senzorů a spuštění vybraného inferenčního enginu na získaných datech. (Zdroj kódu: NXP Semiconductors)

Vzhledem k tomu, že balíček ML State Monitor App od společnosti NXP poskytuje úplný zdrojový kód spolu s kompletní sadou požadovaných ovladačů a middlewaru, mohou vývojáři aplikaci snadno rozšířit o další funkce nebo ji použít jako výchozí bod pro svůj vlastní vývoj.

Závěr

Implementace strojového učení na okraji v chytrých produktech v IoT a dalších aplikacích může poskytnout výkonnou sadu funkcí, ale vývojáři se často potýkají s problémy s aplikací nástrojů a metod ML vyvinutých pro podnikové aplikace. Díky dostupnosti vývojové platformy NXP obsahující crossover procesory a specializovaný software pro vývoj modelů mohou jak ML experti, tak vývojáři s malými nebo žádnými zkušenostmi s ML efektivněji vytvářet aplikace ML navržené speciálně pro splnění požadavků na efektivní okrajový výkon.