Hoe een "Hello World" machine learningmodel uitvoeren op STM32-microcontrollers

Machine learning (ML) is al jaren een rage in server- en mobiele toepassingen, maar is nu gemigreerd en van cruciaal belang geworden op randapparaten. Aangezien edge-apparaten energie-efficiënt moeten zijn, moeten ontwikkelaars leren en begrijpen hoe zij ML-modellen kunnen inzetten op microcontroller-gebaseerde systemen. ML-modellen die op een microcontroller worden uitgevoerd, worden vaak aangeduid als tinyML. Helaas is het implementeren van een model op een microcontroller geen triviale onderneming. Toch wordt het steeds gemakkelijker, en ontwikkelaars zonder gespecialiseerde opleiding zullen merken dat zij dit tijdig kunnen doen.

Dit artikel gaat in op hoe embedded ontwikkelaars aan de slag kunnen met ML met behulp van STMicroelectronics' STM32-microcontrollers. Hiertoe wordt getoond hoe een "Hello World"-toepassing kan worden gemaakt door een TensorFlow Lite voor Microcontrollers-model te converteren voor gebruik in STM32CubeIDE met behulp van X-CUBE-AI.

Inleiding tot tinyML-use cases

TinyML is een groeiend gebied dat de kracht van ML toepast op apparatuur met beperkte middelen en energie, zoals microcontrollers, waarbij gewoonlijk gebruik wordt gemaakt van diepe neurale netwerken. Deze microcontrollerapparaten kunnen dan het ML-model uitvoeren en waardevol werk verrichten aan de rand. Er zijn verschillende use cases waarin tinyML nu heel interessant is.

De eerste use case, dat in veel mobiele apparaten en domotica-apparatuur wordt toegepast, is keyword spotting. Keyword spotting stelt het ingebedde toestel in staat een microfoon te gebruiken om spraak op te vangen en vooraf getrainde zoekwoorden te detecteren. Het tinyML-model gebruikt een tijdreeksinvoer die de spraak weergeeft en zet deze om in spraakkenmerken, meestal een spectrogram. Het spectrogram bevat informatie over de frequentie in de tijd. Het spectrogram wordt vervolgens ingevoerd in een neuraal netwerk dat getraind is om specifieke woorden te detecteren, en het resultaat is een waarschijnlijkheid dat een bepaald woord gedetecteerd is. Afbeelding 1 geeft een voorbeeld van hoe dit proces eruit ziet.

Afbeelding 1: Keyword spotting is een interessante toepassing voor tinyML. De ingevoerde spraak wordt omgezet in een spectrogram en vervolgens ingevoerd in een getraind neuraal netwerk om te bepalen of een vooraf getraind woord aanwezig is. (Bron afbeelding: Arm®)

De volgende toepassing van tinyML waarin veel embedded ontwikkelaars geïnteresseerd zijn, is beeldherkenning. De microcontroller registreert beelden van een camera, die vervolgens worden ingevoerd in een vooraf getraind model. Het model kan onderscheiden wat er in het beeld is. Zo zou men bijvoorbeeld kunnen bepalen of er een kat, een hond, een vis, enzovoort is. Een goed voorbeeld van hoe beeldherkenning aan de rand wordt gebruikt, is in videodeurbellen. De videodeurbel kan vaak detecteren of er een mens aan de deur staat of dat er een pakje is achtergelaten.

Een laatste zeer populair gebruik is het gebruik van tinyML voor voorspellend onderhoud. Voorspellend onderhoud maakt gebruik van ML om de toestand van apparatuur te voorspellen op basis van abnormaliteitsdetectie, classificatiealgoritmen en voorspellende modellen. Ook hier zijn tal van toepassingen beschikbaar, gaande van HVAC-systemen tot fabrieksvloerapparatuur.

Hoewel de bovenstaande drie use cases momenteel populair zijn voor tinyML, zijn er ongetwijfeld veel potentiële use cases die ontwikkelaars kunnen vinden. Hier is een snelle lijst:

• Gebarenclassificatie
• Opsporing van anomalieën
• Analoge meterlezer
• Guidance and control (GNC)
• Pakketdetectie

De beste manier om vertrouwd te raken met tinyML is met een "Hello World"-toepassing, zodat ontwikkelaars het basisproces leren kennen en begrijpen dat ze moeten volgen om een minimaal systeem op te starten. Er zijn vijf stappen nodig om een tinyML-model op een STM32-microcontroller uit te voeren:

1. Gegevens vastleggen
2. Gegevens labelen
3. Het neurale netwerk trainen
4. Converteer het model
5. Start het model op de microcontroller

Vastleggen, labelen en trainen van een "Hello World"-model

Ontwikkelaars hebben over het algemeen veel opties voor de manier waarop zij de gegevens die nodig zijn om hun model te trainen, vastleggen en labelen. Ten eerste zijn er heel wat databanken voor online opleidingen. Ontwikkelaars kunnen zoeken naar gegevens die iemand heeft verzameld en gelabeld. Voor basisbeelddetectie is er bijvoorbeeld CIFAR-10 of ImageNet. Om een model te trainen om glimlachen op foto's te detecteren, is er ook een beeldcollectie. Online data repositories zijn duidelijk een goede plaats om te beginnen.

Als de vereiste gegevens nog niet openbaar beschikbaar zijn gemaakt op het internet, is een andere optie dat ontwikkelaars hun eigen gegevens genereren. Matlab of een ander instrument kan worden gebruikt om de datasets te genereren. Als het automatisch genereren van gegevens geen optie is, kan het handmatig worden gedaan. Tenslotte, als dit alles te tijdrovend lijkt, zijn er een aantal datasets te koop, ook op het internet. Het verzamelen van de gegevens is vaak de spannendste en interessantste optie, maar ook het meeste werk.

Het "Hello World"-voorbeeld dat hier wordt onderzocht, laat zien hoe een model wordt getraind om een sinusgolf te genereren en hoe het wordt ingezet op een STM32. Het voorbeeld is samengesteld door Pete Warden en Daniel Situnayake als onderdeel van hun werk bij Google aan TensorFlow Lite voor microcontrollers. Dit maakt het werk gemakkelijker omdat zij een eenvoudige, openbare handleiding hebben samengesteld voor het vastleggen, labelen en trainen van het model. Het kan hier op Github gevonden worden; eenmaal daar, moeten ontwikkelaars op de knop "Run in Google Colab" klikken. Google Colab, kort voor Google Collaboratory, stelt ontwikkelaars in staat Python te schrijven en uit te voeren in hun browser met nul configuratie en biedt gratis toegang tot Google GPU's.

De uitvoer van het doorlopen van het trainingsvoorbeeld zal twee verschillende modelbestanden bevatten; een model.tflite TensorFlow model dat gekwantiseerd is voor microcontrollers en een model_no_quant.tflite model dat niet gekwantiseerd is. De kwantisering geeft aan hoe de modelactiveringen en de bias numeriek worden opgeslagen. De gekwantiseerde versie geeft een kleiner model dat meer geschikt is voor een microcontroller. Voor de nieuwsgierige lezer: de resultaten van het getrainde model tegenover de werkelijke sinusgolf zijn te zien in Afbeelding 2. De output van het model is in rood. De sinusgolf is niet perfect, maar het werkt goed genoeg voor een "Hello World"-programma.

Afbeelding 2: Een vergelijking tussen de voorspellingen van het TensorFlow-model voor een sinusgolf en de werkelijke waarden. (Bron afbeelding: Beningo Embedded Group)

Een ontwikkelingskaart kiezen

Voordat we gaan kijken hoe we het TensorFlow-model kunnen converteren om op een microcontroller te draaien, moet er eerst een microcontroller geselecteerd worden om in het model te gebruiken. Dit artikel zal zich richten op STM32-microcontrollers omdat STMicroelectronics veel tinyML/ML-tools heeft die goed werken voor het converteren en uitvoeren van modellen. Bovendien heeft STMicroelectronics een grote verscheidenheid van onderdelen die compatibel zijn met hun ML-tools (Afbeelding 3).

Afbeelding 3: Afgebeeld zijn de microcontrollers en de microprocessor unit (MPU) die momenteel door het AI-ecosysteem van STMicroelectronics worden ondersteund. (Bron afbeelding: STMicroelectronics)

Als er zo'n bord op kantoor rondslingert, is het perfect om de "Hello World"-toepassing aan de praat te krijgen. Wie echter verder wil gaan dan dit voorbeeld en zich wil verdiepen in gebarenbesturing of keyword spotting, kan kiezen voor de STM32 B-L4S5I-IOT01A Discovery IoT Node (Afbeelding 4).

Dit bord heeft een Arm Cortex®-M4-processor, gebaseerd op de STM32L4+ serie. De processor heeft 2 megabyte (Mbytes) flashgeheugen en 640 kilobyte (Kbytes) RAM, zodat er voldoende ruimte is voor tinyML-modellen. De module is aanpasbaar voor experimenten met tinyML-gebruikssituaties omdat hij ook beschikt over STMicroelectronics' MP34DT01 micro-elektromechanische systemen-microfoon (MEMS) die kan worden gebruikt voor de ontwikkeling van toepassingen voor keyword spotting. Bovendien kan de ingebouwde LIS3MDLTR drieassige versnellingsmeter, eveneens van STMicroelectronics, worden gebruikt voor op tinyML gebaseerde gebarendetectie.

Afbeelding 4: De STM32 B-L4S5I-IOT01A Discovery IoT Node is een aanpasbaar experimenteerplatform voor tinyML dankzij de ingebouwde Arm Cortex-M4-processor, MEMS-microfoon en drieassige versnellingsmeter. (Bron afbeelding: STMicroelectronics)

Converteren en uitvoeren van het TensorFlow Lite-model met behulp van STM32Cube.AI

Gewapend met een ontwikkelbord waarop het tinyML-model kan worden uitgevoerd, kunnen ontwikkelaars nu beginnen met het omzetten van het TensorFlow Lite-model in iets dat op de microcontroller kan draaien. Het TensorFlow Lite-model kan direct op de microcontroller draaien, maar het heeft een runtime omgeving nodig om het te verwerken.

Wanneer het model wordt uitgevoerd, moet een reeks functies worden uitgevoerd. Deze functies beginnen met het verzamelen van de sensorgegevens, vervolgens met het filteren ervan, het extraheren van de nodige kenmerken, en het voeden van het model. Het model spuwt een resultaat uit dat verder kan worden gefilterd, waarna - meestal - actie wordt ondernomen. Afbeelding 5 geeft een overzicht van hoe dit proces eruit ziet.

Afbeelding 5: Hoe gegevens stromen van sensoren naar de runtime en vervolgens naar de output in een tinyML-toepassing. (Bron afbeelding: Beningo Embedded Group)

De X-CUBE-AI plug-in voor STM32CubeMx biedt de runtime-omgeving om het TensorFlow Lite-model te interpreteren en biedt alternatieve runtimes en conversietools die ontwikkelaars kunnen gebruiken. De X-CUBE-AI plug-in is niet standaard ingeschakeld in een project. Echter, na het maken van een nieuw project en het initialiseren van het bord, onder Software Packs-> Components Select, is er een optie om de AI-runtime in te schakelen. Er zijn hier verschillende opties; zorg ervoor dat het applicatiesjabloon wordt gebruikt voor dit voorbeeld, zoals getoond in Afbeelding 6.

Afbeelding 6: De X-CUBE-AI plug-in moet worden ingeschakeld met behulp van het applicatiesjabloon voor dit voorbeeld. (Bron afbeelding: Beningo Embedded Group)

Zodra X-CUBE-AI is ingeschakeld, verschijnt er een STMicroelectronics X-CUBE-AI-categorie in de toolchain. Door op de categorie te klikken kan de ontwikkelaar het door hem gemaakte modelbestand selecteren en de modelparameters instellen, zoals getoond in Afbeelding 7. Een analyse-knop zal ook het model analyseren en de ontwikkelaars RAM, ROM, en uitvoeringscyclus informatie verschaffen. Het is sterk aan te bevelen dat ontwikkelaars de Keras- en TFLite-modelopties vergelijken. Bij het voorbeeld van het sinusgolfmodel, dat klein is, zal er geen enorm verschil zijn, maar het is wel merkbaar. Het project kan dan worden gegenereerd door op "Generate code" te klikken.

Afbeelding 7: De analyseknop geeft ontwikkelaars informatie over RAM, ROM en uitvoeringscyclus. (Bron afbeelding: Beningo Embedded Group)

De codegenerator initialiseert het project en bouwt de runtime omgeving voor het tinyML model in. Standaard wordt het model echter niet gevoed. Ontwikkelaars moeten code toevoegen om de invoerwaarden van het model - de x-waarden - te verstrekken, die het model dan zal interpreteren en gebruiken om de sinus y-waarden te genereren. Er moeten een paar stukjes code worden toegevoegd aan de functies "acquire_and_process_data" en "post_process", zoals getoond in Afbeelding 8.

Afbeelding 8: De getoonde code verbindt nep-ingangssensorwaarden met het sinusgolfmodel. (Bron afbeelding: Beningo Embedded Group)

Op dit punt is het voorbeeld nu klaar om te draaien. Opmerking: voeg enkele printf-statements toe om de uitvoer van het model te verkrijgen voor een snelle verificatie. Een snelle compilatie en implementatie resulteert in het draaien van het "Hello World" tinyML-model. Het trekken aan de modeluitgang voor een volledige cyclus resulteert in de sinusgolf die in Afbeelding 9 wordt getoond. Het is niet perfect, maar het is uitstekend voor een eerste tinyML-applicatie. Van hieruit kunnen ontwikkelaars de output verbinden met een pulsbreedtemodulator (PWM) en de sinusgolf genereren.

Afbeelding 9: De uitvoer van het "Hello World"-sinusgolfmodel op de STM32. (Bron afbeelding: Beningo Embedded Group)

Tips and tricks voor ML op embedded systemen

Ontwikkelaars die aan de slag willen met ML op microcontroller-gebaseerde systemen hebben heel wat werk voor de boeg om hun eerste tinyML-toepassing van de grond te krijgen. Er zijn echter een aantal "tips and tricks" om in gedachten te houden die de ontwikkeling ervan kunnen vereenvoudigen en versnellen:

• Loop door het TensorFlow Lite voor microcontrollers "Hello World"-voorbeeld, inclusief het Google Colab-bestand. Neem de tijd om de parameters aan te passen en te begrijpen hoe ze het getrainde model beïnvloeden.
• Gebruik gekwantiseerde modellen voor microcontroller toepassingen. Het gekwantiseerde model is gecomprimeerd om te werken met uint8_t in plaats van 32-bit floating-point getallen. Daardoor zal het model kleiner zijn en sneller worden uitgevoerd.
• Bekijk de aanvullende voorbeelden in de TensorFlow Lite voor microcontrollers-repository. Andere voorbeelden zijn gebarendetectie en zoekwoordherkenning.
• Neem het "Hello World"-voorbeeld door de modeluitgang te verbinden met een PWM en een laagdoorlaatfilter om de resulterende sinusgolf te zien. Experimenteer met de looptijd om de frequentie van de sinusgolf te verhogen of te verlagen.
• Kies een ontwikkelingsbord dat "extra" sensoren bevat waarmee een breed scala van ML-toepassingen kan worden uitgeprobeerd.
• Hoe leuk het verzamelen van gegevens ook kan zijn, over het algemeen is het gemakkelijker om een open-source database aan te schaffen of te gebruiken om het model te trainen.

Ontwikkelaars die deze "tips and tricks" volgen, besparen heel wat tijd en verdriet bij het beveiligen van hun toepassing.

Conclusie

ML is naar de rand van het netwerk gekomen, en microcontrollersystemen met beperkte middelen zijn een doelwit bij uitstek. Met de nieuwste hulpmiddelen kunnen ML-modellen worden geconverteerd en geoptimaliseerd om op realtime systemen te draaien. Zoals blijkt, is het relatief eenvoudig om een model op een STM32-ontwikkelingsbord op te zetten en te laten werken, ondanks de complexiteit ervan. Terwijl in de bespreking een eenvoudig model werd onderzocht dat een sinusgolf genereert, zijn veel complexere modellen mogelijk, zoals gebarendetectie en keyword spotting.