Snel Edge-Ready Machine Learning-applicaties implementeren

Machine learning (ML) biedt een enorm potentieel voor het creëren van slimme producten, maar de complexiteit en uitdagingen die komen kijken bij het modelleren van neurale netwerken (NN) en het creëren van ML-toepassingen voor de rand, hebben ontwikkelaars beperkt in hun mogelijkheden om snel bruikbare oplossingen te leveren. Hoewel direct beschikbare tools het maken van ML-modellen in het algemeen toegankelijker hebben gemaakt, zijn conventionele ML-ontwikkelingspraktijken niet ontworpen om te voldoen aan de unieke vereisten van oplossingen voor het Internet of Things (IoT), de auto-industrie, industriële systemen en andere ingebedde toepassingen.

Dit artikel geeft een korte inleiding tot NN-modellering. Vervolgens wordt een uitgebreid ML-platform van NXP Semiconductors geïntroduceerd en beschreven, waarmee ontwikkelaars effectiever kant-en-klare ML-toepassingen kunnen leveren.

Een kort overzicht van NN-modellering

ML-algoritmen bieden ontwikkelaars een totaal andere optie voor de ontwikkeling van toepassingen. In plaats van softwarecode te schrijven die bedoeld is om problemen zoals beeldclassificatie expliciet op te lossen, trainen ontwikkelaars NN-modellen door een reeks gegevens te presenteren, zoals afbeeldingen die geannoteerd zijn met de feitelijke naam (of klasse) van de entiteit die in de afbeelding voorkomt. Bij het opleidingsproces worden verschillende methoden gebruikt om de parameters van het model te berekenen: de gewichten en de biaswaarden voor elk neuron en elke laag, zodat het model een redelijk nauwkeurige voorspelling kan geven van de juiste klasse van een inputbeeld (Afbeelding 1).

Afbeelding 1: NN's zoals dit volledig aangesloten netwerk classificeren een inputobject met behulp van gewichts- en biasparameters die tijdens de training zijn ingesteld. (Bron afbeelding: NXP Semiconductors)

ML-onderzoekers hebben een breed scala van NN-architecturen ontwikkeld die verder gaan dan het algemene, volledig gekoppelde NN dat in Afbeelding 1 wordt getoond. Zo wordt bij beeldclassificatietoepassingen doorgaans gebruik gemaakt van het convolutionele NN (CNN), een gespecialiseerde architectuur die beeldherkenning opsplitst in een eerste fase waarin de belangrijkste kenmerken van een beeld worden gevonden, gevolgd door een classificatiefase waarin wordt voorspeld hoe waarschijnlijk het is dat het beeld tot een van de tijdens de training vastgestelde klassen behoort (Afbeelding 2).

Afbeelding 2: ML-deskundigen gebruiken gespecialiseerde NN-architecturen zoals dit convolutioneel neuraal netwerk (CNN) voor specifieke taken zoals beeldherkenning. (Bron afbeelding: NXP Semiconductors)

Hoewel de selectie van een geschikte modelarchitectuur en een geschikt trainingsschema tot dusver beperkt was tot ML-deskundigen, heeft de beschikbaarheid van talrijke open-source en commerciële hulpmiddelen de ontwikkeling van modellen voor grootschalige toepassingen drastisch vereenvoudigd. Tegenwoordig kunnen ontwikkelaars modellen definiëren met een paar regels code (Listing 1), en hulpmiddelen gebruiken zoals de open-source Netron model viewer om een grafische voorstelling van het model te genereren (Afbeelding 3) voor het controleren van elke laagdefinitie en connectiviteit.

Kopieer
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

Lijst 1: Ontwikkelaars kunnen NN-modellen definiëren met slechts een paar regels code. (Bron code: NXP Semiconductors)

Afbeelding 3: Deze grafische voorstelling van het model gedefinieerd in Lijst 1, gegenereerd door de Netron-viewer, kan de ontwikkelaar helpen bij het documenteren van de functie en connectiviteit van elke laag. (Bron afbeelding: Stephen Evanczuk, draait Netron op NXP-modelbroncode in Lijst 1)

Voor het uiteindelijke gebruik worden in andere hulpmiddelen de modelstructuren die alleen tijdens de training nodig zijn, verwijderd en worden andere optimalisaties uitgevoerd om een efficiënt inferentiemodel tot stand te brengen.

Waarom de ontwikkeling van op ML gebaseerde toepassingen voor slimme producten zo moeilijk is geweest

Het definiëren en trainen van een model voor het IoT of andere slimme producten volgt een soortgelijke workflow als het maken van een model voor machineleertoepassingen op bedrijfsschaal. Afgezien van deze gelijkenis brengt de ontwikkeling van ML-toepassingen voor de rand echter tal van extra uitdagingen met zich mee. Naast de ontwikkeling van modellen worden ontwerpers ook geconfronteerd met de bekende uitdagingen van de ontwikkeling van de belangrijkste toepassing die nodig is om hun op een microcontroller (MCU) gebaseerde product te laten werken. Om ML naar de rand te brengen, moeten dus twee met elkaar samenhangende werkstromen worden beheerd (Afbeelding 4).

Afbeelding 4: De ontwikkeling van een op ML gebaseerde toepassing voor de rand breidt de typische embedded MCU-ontwikkelingsworkflow uit met een ML-workflow die nodig is om een ML-model te trainen, te valideren en in te zetten. (Bron afbeelding: NXP Semiconductors)

Hoewel de MCU-projectworkflow bekend is bij embedded ontwikkelaars, kan het ML project extra eisen stellen aan de MCU-gebaseerde applicatie als ontwikkelaars werken aan het creëren van een geoptimaliseerd ML inferentie model. In feite heeft het ML-project dramatische gevolgen voor de eisen die aan de ingebedde apparatuur worden gesteld. De zware rekenbelasting en de geheugenvereisten die gewoonlijk gepaard gaan met de uitvoering van modellen kunnen de middelen van microcontrollers die in het IoT en slimme producten worden gebruikt, te boven gaan. Om de benodigde middelen te beperken, passen ML-deskundigen technieken toe als model network pruning, compressie, quantisatie tot lagere precisie, of zelfs single-bit parameters en tussenwaarden, en andere methoden.

Zelfs met deze optimalisatiemethoden kunnen ontwikkelaars er echter nog steeds achter komen dat conventionele microcontrollers niet de prestaties leveren die nodig zijn om het grote aantal wiskundige bewerkingen te verwerken die met ML-algoritmen gepaard gaan. Anderzijds zou het gebruik van een krachtige applicatieprocessor de ML-rekenlast aankunnen, maar die aanpak zou kunnen resulteren in een grotere latentie en een niet-deterministische respons, waardoor de real-time kenmerken van hun ingebedde ontwerp zouden worden aangetast.

Naast de uitdagingen op het gebied van hardwareselectie, kent het leveren van geoptimaliseerde ML-modellen voor de rand extra uitdagingen die uniek zijn voor embedded ontwikkeling. Het grote aantal gereedschappen en methoden dat is ontwikkeld voor ML-toepassingen op bedrijfsschaal is wellicht niet goed schaalbaar voor de toepassing en de bedrijfsomgeving van de embedded ontwikkelaar. Zelfs doorgewinterde embedded ontwikkelaars die verwachten snel ML-gebaseerde apparaten te kunnen implementeren, kunnen moeite hebben om een effectieve oplossing te vinden tussen een overvloed aan beschikbare NN-modelarchitecturen, tools, frameworks en workflows.

NXP richt zich op zowel de hardwareprestaties als de modelimplementatie facetten van edge ML ontwikkeling. Op hardwareniveau voldoen de krachtige i.MX RT1170 cross-over microcontrollers van NXP aan de brede prestatie-eisen van edge ML. Om optimaal te profiteren van deze hardwarebasis, bieden NXP's eIQ (edge intelligence) ML software-ontwikkelomgeving en applicatiesoftwarepakketten zowel onervaren als deskundige ML-ontwikkelaars een effectieve oplossing voor het creëren van edge-ready ML-toepassingen.

Een effectief platform voor de ontwikkeling van kant-en-klare ML-toepassingen

NXP i.MX RT crossover-processoren combineren de real-time respons met lage latentie van traditionele ingebedde microcontrollers met de uitvoeringsmogelijkheden van krachtige applicatieprocessoren. De i.MX RT1170 cross-over processorserie van NXP integreert een energiezuinige Arm® Cortex®-M4 en een krachtige Arm Cortex-M7 processor met een uitgebreide set functionele blokken en randapparatuur die nodig zijn voor veeleisende toepassingen, waaronder ML-gebaseerde oplossingen in embedded apparaten (Afbeelding 5).

Afbeelding 5: NXP's i.MX RT1170 cross-overprocessoren combineren de energiezuinige mogelijkheden van conventionele microcontrollers met de krachtige verwerkingsmogelijkheden van applicatieprocessoren. (Bron afbeelding: NXP Semiconductors)

De NXP eIQ-omgeving is volledig geïntegreerd in NXP's MCUXpresso SDK en Yocto ontwikkelomgevingen en is speciaal ontworpen om de implementatie van inferentiemodellen te vergemakkelijken op ingebedde systemen die zijn gebouwd met NXP-microprocessoren en microcontrollers. De eIQ Toolkit, die deel uitmaakt van de eIQ-omgeving, ondersteunt bring your own data (BYOD) en bring your own model BYOM-workflows via verschillende tools, waaronder het eIQ-portaal, de eIQ-modeltool en opdrachtregeltools (Afbeelding 6).

Afbeelding 6: De NXP eIQ-toolkit ondersteunt BYOD-ontwikkelaars die een model moeten maken en BYOM-ontwikkelaars die hun eigen bestaande model moeten implementeren op een doelsysteem. (Bron afbeelding: NXP Semiconductors)

Het eIQ-portaal is ontworpen ter ondersteuning van BYOD-workflows voor zowel experts als ontwikkelaars die nieuw zijn met ML-modelontwikkeling, en biedt een grafische gebruikersinterface (GUI) waarmee ontwikkelaars elke fase van de modelontwikkelingsworkflow eenvoudiger kunnen doorlopen.

In het beginstadium van de ontwikkeling helpt de dataset-curatortool van het eIQ-portaal ontwikkelaars bij het importeren van data, het vastleggen van data van een aangesloten camera, of het vastleggen van data van een extern apparaat (Afbeelding 7).

Afbeelding 7: Het hulpprogramma voor het samenstellen van gegevensverzamelingen van het eIQ-portaal vergemakkelijkt de kritische taak van het voorbereiden van opleidingsgegevens. (Bron afbeelding: NXP Semiconductors)

Met behulp van de curatortool van datasets kunnen ontwikkelaars elk item in de dataset annoteren, of labelen, door de hele afbeelding te labelen, of alleen specifieke regio's die binnen een gespecificeerde begrenzingsbox vallen. Een augmentatiefunctie helpt ontwikkelaars de nodige diversiteit in de dataset aan te brengen door beelden onscherp te maken, willekeurige ruis toe te voegen, kenmerken als helderheid of contrast te veranderen, en andere methoden.

In de volgende fase helpt het eIQ-portaal ontwikkelaars bij het selecteren van het type model dat het meest geschikt is voor de toepassing. Voor ontwikkelaars die niet zeker zijn over het type model, leidt een modelkeuzewizard hen door het selectieproces op basis van het type toepassing en de hardwarebasis. Ontwikkelaars die al weten welk type model zij nodig hebben, kunnen een aangepast model kiezen dat bij de eIQ-installatie wordt geleverd of andere aangepaste implementaties.

Het eIQ-portaal leidt ontwikkelaars door de volgende kritische trainingsstap, waarbij een intuïtieve GUI wordt geboden voor het wijzigen van trainingsparameters en het bekijken van de veranderingen in de nauwkeurigheid van de modelvoorspelling bij elke trainingsstap (Afbeelding 8).

Afbeelding 8: Ontwikkelaars gebruiken de trainertool van het eIQ-portaal om bij elke stap een verbetering van de trainingsnauwkeurigheid waar te nemen, en deze zo nodig aan te passen. (Bron afbeelding: NXP Semiconductors)

In de volgende stap helpt de eIQ-portaal-GUI ontwikkelaars het model te valideren. In dit stadium wordt het model geconverteerd om op de doelarchitectuur te draaien en de werkelijke prestaties te bepalen. Wanneer de validatie is voltooid, toont het validatiescherm de verwarringsmatrix - een fundamenteel ML-validatie-instrument waarmee ontwikkelaars de werkelijke klasse van het ingevoerde object kunnen vergelijken met de klasse die door het model is voorspeld (Afbeelding 9).

Afbeelding 9: Het validatiehulpmiddel van het eIQ-portaal biedt ontwikkelaars de verwarringsmatrix die het resultaat is van het uitvoeren van een model op een doelarchitectuur. (Bron afbeelding: NXP Semiconductors)

Voor de uiteindelijke implementatie biedt de omgeving de ontwikkelaars een keuze uit doel-inferentie-engines, afhankelijk van de processor, waaronder:

• Arm CMSIS-NN (Common Microcontroller Software Interface Standard, Neural Network)-neurale netwerkkernels, ontwikkeld om de prestaties te maximaliseren en de geheugenvoetafdruk van neurale netwerken op Arm Cortex-M-processorkernen te minimaliseren
• Arm NN SDK (neuraal netwerk, software development kit)-een reeks hulpmiddelen en een inferentie-engine die is ontworpen als brug tussen onder meer bestaande neurale netwerkframeworks en Arm Cortex-A-processoren
• DeepViewRT - NXP's eigen inferentie-engine voor i.MX RT cross-over MCU's
• Glow NN - gebaseerdop Meta's Glow (graph lowering) compiler en geoptimaliseerd door NXP voor Arm Cortex-M cores door gebruik te maken van functieaanroepen naar CMSIS-NN kernels of de Arm NN bibliotheek indien beschikbaar, anders door code te compileren uit zijn eigen native bibliotheek
• ONXX Runtime - MicrosoftResearch's tools ontworpen om de prestaties voor Arm Cortex-A processoren te optimaliseren.
• TensorFlow Lite voor Microcontrollers - een kleinere versie van TensorFlow Lite, geoptimaliseerd voor het uitvoeren van modellen voor machinaal leren op i.MX RT crossover MCU's
• TensorFlow Lite - een versie van TensorFlow met ondersteuning voor kleinere systemen

Voor BYOM-workflows kunnen ontwikkelaars de eIQ-modeltool gebruiken om direct over te gaan naar modelanalyse en tijdprofilering per laag. Voor zowel BYOD- als BYOM-workflows kunnen ontwikkelaars eIQ command line tools gebruiken die toegang bieden tot tool functionaliteit, alsmede eIQ functies die niet direct beschikbaar zijn via de GUI.

Naast de functies die in dit artikel worden beschreven, ondersteunt de eIQ-toolkit een uitgebreide reeks mogelijkheden, waaronder modelconversie en -optimalisatie, die ver buiten het bestek van dit artikel vallen. Voor het snel ontwikkelen van prototypes van ML-toepassingen die klaar zijn voor de rand, kunnen ontwikkelaars over het algemeen snel werken aan hun ontwikkeling en implementatie, zonder dat zij veel van de meer geavanceerde mogelijkheden van de eIQ-omgeving hoeven te gebruiken. In feite bieden gespecialiseerde pakketten toepassingssoftware (App SW) van NXP complete toepassingen die ontwikkelaars kunnen gebruiken voor onmiddellijke evaluatie, of als basis voor hun eigen toepassingen op maat.

Hoe modelontwikkeling snel te evalueren met behulp van een App SW Pack

NXP App SW Packs bieden een complete ML-gebaseerde applicatie, een combinatie van productieklare broncode, drivers, middleware en tools. Zo biedt het NXP ML State Monitor App SW Pack een directe op ML gebaseerde oplossing voor het veel voorkomende probleem van het bepalen van de toestand van complexe systemen op basis van sensorinputs (Afbeelding 10).

Afbeelding 10: Ontwikkelaars kunnen NXP App SW Packs, zoals het ML State Monitor App SW Pack, gebruiken voor onmiddellijke evaluatie, of als basis voor de ontwikkeling van aangepaste code. (Bron afbeelding: NXP Semiconductors)

Het ML State Monitor App SW Pack implementeert een complete oplossing voor een toepassing die bedoeld is om te detecteren wanneer een ventilator in één van de vier toestanden werkt:

• ON
• OFF
• CLOGGED, wanneer de ventilator aanstaat maar de luchtstroom geblokkeerd is
• FRICTION, wanneer de ventilator aanstaat maar één of meer ventilatorbladen tijdens de werking te veel wrijving ondervinden

Net zo belangrijk voor modelontwikkelaars is dat het ML State Monitor App SW Pack ML-modellen bevat, evenals een complete dataset met versnellingsmetermetingen van een ventilator die in elk van deze vier toestanden werkt.

Ontwikkelaars kunnen de code, modellen en gegevens bestuderen die worden geleverd in het ML State Monitor App SW Pack om te begrijpen hoe de sensorgegevens kunnen worden gebruikt om een model te trainen, een inferentiemodel te maken en de inferentie te valideren tegen een validatieset met sensorgegevens. In feite biedt NXP's ML_State_Monitor.ipynb Jupyter Notebook, dat is opgenomen in het App SW Pack, een direct, out-of-the-box hulpmiddel voor het bestuderen van de workflow van de modelontwikkeling, lang voordat er hardware wordt ingezet.

Jupyter Notebook is een interactief, browsergebaseerd platform voor Python-uitvoering waarmee ontwikkelaars onmiddellijk de resultaten van de uitvoering van Python-code kunnen bekijken. Het uitvoeren van een Jupyter Notebook genereert een blok Python-code, onmiddellijk gevolgd door de resultaten van het uitvoeren van dat codeblok. Deze resultaten zijn niet louter statische weergaven, maar zijn de werkelijke resultaten die worden verkregen door de code uit te voeren. Wanneer ontwikkelaars bijvoorbeeld NXP's ML_State_Monitor.ipynb Jupyter Notebook uitvoeren, kunnen ze onmiddellijk een samenvatting van de ingevoerde dataset bekijken (Afbeelding 11).

Afbeelding 11: NXP's ML_State_Monitor.ipynb Jupyter Notebook laat ontwikkelaars interactief werken door de neurale netwerkmodelontwikkelingsworkflow, waarbij ze trainingsgegevens bekijken die worden geleverd in het ML State Monitor App SW Pack. [Opmerking: Code hier ingekort voor display doeleinden.] (Bron afbeelding: Stephen Evanczuk, draaiend met NXP's ML_State_Monitor.ipynb Jupyter Notebook)

Het volgende deel van de code in het notitieboek biedt de gebruiker een grafische weergave van de invoergegevens, gepresenteerd als afzonderlijke plots voor tijdsverloop en frequentie (Afbeelding 12).

Afbeelding 12: Het Jupyter-notitieboek biedt ontwikkelaars tijdreeks- en frequentieweergaven van de voorbeeldgegevensreeks over de ventilatorstand (UIT: groen; AAN: rood; GESLOTEN: blauw; FRICTIE: geel). [Opmerking: Code ingekort voor presentatiedoeleinden.] (Bron afbeelding: Stephen Evanczuk, draaiend met NXP's ML_State_Monitor.ipynb Jupyter Notebook)

Extra secties code zorgen voor verdere gegevensanalyse, normalisatie, vormgeving en andere voorbereidingen, totdat de uitvoering van de code uitmondt in dezelfde functiedefinitie voor het maken van modellen, model_create(), die eerder in Lijst 1 te zien was. Het allernieuwste code-onderdeel voert deze model_create() functie uit en drukt een samenvatting af voor een snelle validatie (Afbeelding 13).

Afbeelding 13: NXP's ML_State_Monitor.ipynb Jupyter-notitieboek maakt het model (getoond in Lijst 1) en geeft de modeloverzichtsinformatie weer. (Bron afbeelding: Stephen Evanczuk, draaiend met NXP's ML_State_Monitor.ipynb Jupyter Notebook)

Na een sectie code voor modeltraining en -evaluatie geeft het ML_State_Monitor.ipynb Jupyter-notitieboek elke verwarringsmatrix weer voor de volledige dataset, de trainingsdataset en de validatiedataset (een subset van de dataset die is uitgesloten van de trainingsdataset). In dit geval vertoont de verwarringsmatrix voor de volledige dataset een goede nauwkeurigheid met enige fouten, met name wanneer het model een klein percentage van de datasets verwart met de AAN-status, terwijl ze eigenlijk in de CLOGGED-status staan zoals in de oorspronkelijke dataset is geannoteerd (figuur 14).

Afbeelding 14: Ontwikkelaars kunnen verwarringsmatrices zoals deze bekijken voor de volledige dataset. (Bron afbeelding: Stephen Evanczuk, draaiend met NXP's ML_State_Monitor.ipynb Jupyter Notebook)

In een later code-gedeelte wordt het model geëxporteerd naar verschillende modeltypen en -formaten die worden gebruikt door de verschillende inferentie-engines die door de eIQ-ontwikkelingsomgeving worden ondersteund (Afbeelding 15).

Afbeelding 15: NXP's ML_State_Monitor.ipynb Jupyter Notebook demonstreert hoe ontwikkelaars hun getrainde model kunnen opslaan in verschillende modeltypen en -formaten. (Bron afbeelding: Stephen Evanczuk, draaiend met NXP's ML_State_Monitor.ipynb Jupyter Notebook)

De keuze van de inferentie-engine kan van doorslaggevend belang zijn om aan specifieke prestatie-eisen te voldoen. Voor deze toepassing heeft NXP de modelgrootte, de codegrootte en de inferentietijd (de tijd die nodig is om de inferentie op één invoerobject te voltooien) gemeten wanneer het model wordt gericht op verschillende inferentie-engines, één die draait op 996 megahertz (MHz) en één die draait op 156 MHz (Afbeeldingen 16 en 17).

Afbeelding 16: De keuze van het modeltype kan een dramatisch effect hebben op de omvang van het model, hoewel de hier getoonde dramatische verschillen wellicht niet gelden voor grotere modellen. (Bron afbeelding: NXP Semiconductors)

Afbeelding 17: De inferentietijd kan aanzienlijk verschillen voor de evaluatie van een invoerobject wanneer het wordt geladen uit RAM- of flashgeheugen, of wanneer de processor werkt op een hogere frequentie van 996 MHz versus 156 MHz. (Bron afbeelding: NXP Semiconductors)

Zoals NXP opmerkt, wordt voor deze voorbeeldtoepassing een zeer klein model gebruikt, zodat de nogal grote verschillen die uit deze cijfers blijken, veel minder uitgesproken zouden kunnen zijn in een groter model dat voor complexe classificaties wordt gebruikt.

Bouwen van een systeemoplossing voor toezicht op de toestand

Naast het Jupyter-notitieboek voor interactieve verkenning van de modelontwikkelingsworkflow, biedt het NXP ML State Monitoring App SW Pack de volledige broncode voor de implementatie van het ontwerp op NXP's MIMXRT1170-EVK-evaluatiebord. Het evaluatiebord is gebouwd rond een NXP MIMXRT1176DVMAA crossover MCU en biedt een uitgebreid hardwareplatform, compleet met extra geheugen en meerdere interfaces (Afbeelding 18).

Afbeelding 18: NXP's MIMXRT1170-EVK-evaluatiebord biedt een uitgebreid hardwareplatform voor de ontwikkeling van toepassingen op basis van de NXP i.MX RT1170-serie crossover MCU. (Bron afbeelding: NXP Semiconductors)

Ontwikkelaars kunnen de NXP ventilatortoestandtoepassing gebruiken om de toestand van een ventilator te voorspellen door het MIMXRT1170-EVK evaluatiebord te stapelen met een optionele NXP FRDM-STBC-AGM01 sensorbord, een Arduino schild, en een geschikte 5 volt borstelloze gelijkstroomventilator zoals de 4468 van Adafruit (Afbeelding 19).

Afbeelding 19: Ontwikkelaars kunnen de NXP-ventilatortoestand voorbeeldtoepassing testen met een eenvoudige stack gebouwd op het MIMXRT1170-EVK-evaluatiebord. (Bron afbeelding: NXP Semiconductors)

Met behulp van de geïntegreerde ontwikkelomgeving (IDE) van MCUXpresso kunnen ontwikkelaars de toepassing configureren om eenvoudig de fan-state gegevens te verwerven en op te slaan, of onmiddellijk inferentie uitvoeren op de verworven gegevens met behulp van een TensorFlow inferentie-engine, DeepViewRT inferentie-engine, of Glow inferentie-engine (Lijst 2).

Kopieer
/* 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

Lijst 2: Ontwikkelaars kunnen de NXP ML State Monitor voorbeeldtoepassing eenvoudig configureren door definities in het sensor_collect.h header-bestand te wijzigen. (Bron code: NXP Semiconductors)

De toepassing werkt met een eenvoudige processtroom. De hoofdroutine in main.c creëert een taak genaamd MainTask, die een routine is in de module sensor_collect.c.

Kopieer
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

Lijst 3: In de NXP ML State Monitor voorbeeldapplicatie, roept MainTask een subtask aan om gegevens te verzamelen of inferentie uit te voeren. (Bron code: NXP Semiconductors)

MainTask voert verschillende initialisatietaken uit alvorens een van de twee subtaken te starten, afhankelijk van de definities die door de gebruiker zijn ingesteld in sensor_collect.h:

• indien SENSOR_COLLECT_ACTION is ingesteld op SENSOR_COLLECT_LOG_EXT, start MainTask de subtaak SENSOR_Collect_LogExt_Task(), die gegevens verzamelt en deze opslaat op de SD-kaart, indien geconfigureerd
• indien SENSOR_COLLECT_ACTION is ingesteld op SENSOR_COLLECT_RUN_INFERENCE, start MainTask de subtaak SENSOR_Collect_RunInf_Task(), die de in sensor_collect.h gedefinieerde inferentie-engine (Glow, DeepViewRT of TensorFlow) uitvoert op de verzamelde gegevens, en indien SENSOR_EVALUATE_MODEL is gedefinieerd, de resulterende prestatie en classificatievoorspelling weergeeft

Kopiëren
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 */

Lijst 4: De NXP ML State Monitor voorbeeld applicatie demonstreert het basis ontwerp patroon voor het verwerven van sensor data en het uitvoeren van de geselecteerde inferentie engine op de verkregen data. (Bron code: NXP Semiconductors)

Omdat het NXP ML State Monitor App SW Pack de volledige broncode levert samen met een complete set van vereiste drivers en middleware, kunnen ontwikkelaars de applicatie gemakkelijk uitbreiden om functies toe te voegen of gebruiken als startpunt voor hun eigen aangepaste ontwikkeling.

Conclusie

De implementatie van ML aan de rand van slimme producten in het IoT en andere toepassingen kan een krachtige reeks functies bieden, maar laat ontwikkelaars vaak worstelen met de toepassing van ML-tools en -methoden die zijn ontwikkeld voor toepassingen op bedrijfsschaal. Met de beschikbaarheid van een NXP-ontwikkelingsplatform dat bestaat uit crossover-processoren en gespecialiseerde software voor modelontwikkeling, kunnen zowel ML-experts als ontwikkelaars met weinig of geen ML-ervaring effectiever ML-toepassingen maken die speciaal zijn ontworpen om te voldoen aan de eisen voor efficiënte randprestaties.