Hur man kör en maskininlärningsmodell för "Hello World" på microcontrollern STM32

Maskininlärning (ML) har i flera år varit en populär teknik i server- och mobilapplikationer, men har nu migrerat och blivit nödvändigt för enheter i molnkanten. Med tanke på att enheter i molnkanten måste vara energieffektiva, måste utvecklare lära sig och förstå hur man använder maskininlärningsmodeller i microcontroller-baserade system. Maskininlärningsmodeller som körs på en microcontroller kallas ofta för tinyML. Tyvärr är det inte helt enkelt att distribuera en modell till en microcontroller. Det blir dock allt lättare, och utvecklare som inte har någon specialutbildning kommer att upptäcka att de kan göra det relativt snabbt.

Artikeln handlar om hur utvecklare av inbäddade system kan komma igång med maskininlärning med microcontrollern STM32 från STMicroelectronics. För att göra det, visar den hur man skapar en "Hello World"-applikation genom att konvertera en TensorFlow Lite for Microcontrollers-modell för användning i STM32CubeIDE med hjälp av X-CUBE-AI.

Introduktion till användningsfall med tinyML

TinyML är ett växande område där maskininlärningens kraft förmedlas till resurs- och energibegränsade enheter som microcontrollers, vanligtvis med hjälp av djupa neurala nätverk. Dessa microcontrollers kan sedan köra maskininlärningsmodellen och utföra värdefullt arbete i molnkanten. Det finns flera användningsområden där tinyML nu är ganska intressant.

Det första användningsfallet, som finns i många mobila enheter och utrustning för hemautomation, är detektering av nyckelord. Med hjälp av detektering av nyckelord kan den inbyggda enheten använda en mikrofon för att fånga upp tal och upptäcka redan inlärda nyckelord. TinyML-modellen använder en tidsserie som representerar talet och omvandlar detta till talegenskaper, vanligtvis ett spektrogram. Spektrogrammet innehåller frekvensinformation över tid. Spektrogrammet matas sedan in i ett neuralt nätverk som är tränat för att upptäcka specifika ord, och resultatet är en sannolikhet för att ett visst ord har upptäckts. Figur 1 visar ett exempel på hur denna process ser ut.

Figur 1: Att detektera nyckelord är ett intressant användningsområde för tinyML. Det inmatade talet omvandlas till ett spektrogram och matas sedan in i ett tränat neuralt nätverk för att avgöra om ett redan inlärt ord förekommer. (Bildkälla: Arm®)

Nästa användningsfall för tinyML som många utvecklare av inbäddade system är intresserade av är bildigenkänning. Microcontrollern hämtar bilder från en kamera som sedan matas in i en redan tränad modell. Modellen kan urskilja vad som finns i bilden. Man kan till exempel avgöra om det finns en katt, en hund, en fisk och så vidare. Ett bra exempel på hur bildigenkänning används i molnkanten är dörrklockor med video. Videodörrklockan kan ofta upptäcka om det finns en människa vid dörren eller om ett paket har lämnats.

Ett sista användningsområde som är mycket populärt är användningen av tinyML för prediktivt underhåll. Prediktivt underhåll använder maskininlärning för att förutsäga utrustningens tillstånd baserat på upptäckt av avvikelser, klassificeringsalgoritmer och prediktiva modeller. Även här finns det många användningsområden, allt ifrån luftbehandlingssystem till utrustning på fabriksgolvet.

De tre ovan nämnda användningsområdena är för närvarande populära för tinyML, men det finns utan tvekan många potentiella användningsområden som utvecklare kan hitta. Här följer en snabb lista:

• Klassificering av gester
• Upptäckt av avvikelser
• Analog mätaravläsning
• Styrning och kontroll (GNC)
• Detektering av förpackningar

Oavsett användningsområde är det bästa sättet att börja bekanta sig med tinyML att använda en "Hello World"-applikation, som hjälper utvecklare att lära sig och förstå den grundläggande processen som de kan följa för att få igång ett minimalt system. Det finns fem nödvändiga steg för att köra en tinyML-modell på en STM32-microcontroller:

1. Insamling av information
2. Märk informationen
3. Träna det neurala nätverket
4. Konvertera modellen
5. Kör modellen på microcontrollern

Insamling, märkning och träning av en "Hello World"-modell

Utvecklare har i allmänhet många alternativ när det gäller hur de ska samla in och märka den information som krävs för att träna sin modell. För det första finns det många utbildningsdatabaser på nätet. Utvecklare kan söka efter information som någon har samlat in och märkt. För grundläggande bilddetektering finns till exempel CIFAR-10 eller ImageNet. För att träna en modell för att upptäcka leenden i foton finns det en bildsamling för det också. Datalagringsutrymmen online är en utmärkt plats att börja på.

Om den nödvändiga informationen inte redan har gjorts tillgänglig för allmänheten på internet kan utvecklare även skapa sin egen information. Matlab eller något annat verktyg kan användas för att generera datauppsättningarna. Om automatisk datagenerering inte är ett alternativ, kan det utföras manuellt. Om allt detta verkar för tidskrävande finns det även en del datauppsättningar som kan köpas, även detta på internet. Att samla in information är ofta det mest spännande och intressanta alternativet, men det är också det som kräver mest arbete.

Exemplet "Hello World" som vi utforskar här visar hur man tränar en modell för att generera en sinusvåg och distribuera den till en STM32. Exemplet sammanställdes av Pete Warden och Daniel Situnayake som en del av deras arbete på Google med TensorFlow Lite for Microcontrollers. Det gör arbetet enklare eftersom de har sammanställt en enkel, offentlig handledning om insamling, märkning och träning av modellen. Den finns på Github här, när du är där kan du klicka på "Run in Google Colab". Google Colab, som är en förkortning av Google Collaboratory, gör det möjligt för utvecklare att skriva och köra Python i webbläsaren utan någon konfiguration och ger fri tillgång till Googles GPU:er.

Utdata efter genomgånget träningsexempel kommer att innehålla två olika modellfiler; en model.tflite TensorFlow-modell som är kvantifierad för microcontrollers och en model_no_quant.tflite-modell som inte är kvantifierad. Kvantiseringen anger hur modellens aktiveringar och påverkan lagras numeriskt. Den kvantiserade versionen skapar en mindre modell som lämpar sig bättre för en microcontroller. För de nyfikna läsarna kan man i figur 2 se resultaten av den tränade modellen jämfört med de faktiska resultaten för sinuskurvorna. Modellens utdata visas med rött. Sinusvågen som utdata är inte perfekt, men den fungerar tillräckligt bra för ett "Hello World"-program.

Figur 2: En jämförelse mellan TensorFlow-modellens förutsägelser för en sinusvåg jämfört med de faktiska värdena. (Bildkälla: Beningo Embedded Group)

Val av utvecklingskort

Innan vi tittar på hur man konverterar TensorFlow-modellen för körning på en microcontroller måste en microcontroller väljas ut för användning i modellen. Artikeln kommer att fokusera på microcontrollern STM32 eftersom STMicroelectronics har många tinyML-/ML-verktyg som fungerar bra för att konvertera och köra modeller. STMicroelectronics har dessutom ett brett utbud av delar som är kompatibla med deras ML-verktyg (figur 3).

Figur 3: Här visas de microcontrollers och mikroprocessorenheter (MPU) som för närvarande stöds av STMicroelectronics ekosystem för AI. (Bildkälla: STMicroelectronics)

Om du har något av dessa kort liggande på kontoret är det perfekt för att få igång programmet "Hello World". Men om du är intresserad av att gå längre än exemplet och börja med styrning med gester eller detektering av nyckelord kan du välja Discovery IoT-noden STM32 B-L4S5I-IOT01A (figur 4).

Kortet har en Arm Cortex®-M4 processor baserad på serien STM32L4+. Processorn har 2 Mbytes flashminne och 640 Kbytes RAM-minne, vilket ger gott om utrymme för tinyML-modeller. Modulen kan anpassas för tinyML-experiment eftersom den även innehåller den mikroelektromekaniska systemmikrofonen (MEMS) MP34DT01 som kan användas för utveckling av detektering av nyckelord. Den kan dessutom använda den inbyggda accelerometern LIS3MDLTR med tre axlar, också från STMicroelectronics, för att upptäcka TinyML-baserade gester.

Figur 4: Discovery IoT-noden STM32 B-L4S5I-IOT01A är en anpassningsbar experimentplattform för tinyML tack vare en inbyggd Arm Cortex-M4-processor, MEMS-mikrofon och accelerometer med tre axlar. (Bildkälla: STMicroelectronics)

Konvertering och körning av TensorFlow Lite-modellen med STM32Cube.AI

Med ett utvecklingskort som kan användas för att köra tinyML-modellen kan utvecklare nu börja konvertera TensorFlow Lite-modellen till något som kan köras på microcontrollern. TensorFlow Lite-modellen kan köras direkt på microcontrollern, men den behöver en exekveringsmiljö för att bearbetas.

När modellen körs måste en rad funktioner utföras. Dessa funktioner inleds med insamling av givardata, filtrering av denna, extrahering av nödvändiga funktioner och överföring av dessa till modellen. Modellen ger ett resultat som sedan kan filtreras ytterligare, och sedan vidtas - vanligtvis - någon åtgärd. Figur 5 visar en översikt på hur processen ser ut.

Figur 5: Hur information flödar från givare till exekveringsmiljön och sedan till utgången i en tinyML-applikation. (Bildkälla: Beningo Embedded Group)

Plugin-programmet X-CUBE-AI för STM32CubeMx tillhandahåller en exekveringsmiljö för att tolka TensorFlow Lite-modellen och erbjuder alternativa exekveringsmiljöer och konverteringsverktyg som utvecklare kan utnyttja. Plugin-programmet X-CUBE-AI är inte aktiverat som standard i ett projekt. Men efter att ha skapat ett nytt projekt och initialiserat kortet finns det ett alternativ för att aktivera AI runtime under Software Packs> Select Components. Det finns flera alternativ här, se till att mallen Application används i det här exemplet, enligt vad som visas i figur 6.

Figur 6: Plugin-programmet X-CUBE-AI måste aktiveras med hjälp av applikationsmallen för exemplet. (Bildkälla: Beningo Embedded Group)

När X-CUBE-AI har aktiverats visas en kategori för X-CUBE-AI från STMicroelectronics i verktygskedjan. Genom att klicka på kategorin kan utvecklare välja den modellfil som de skapat och ställa in modellparametrarna, enligt vad som visas i figur 7. En analysknapp analyserar också modellen och ger utvecklare information om RAM, ROM och exekveringscykel. Det rekommenderas starkt att utvecklare jämför alternativen för Keras- och TFLite-modellerna. I exemplet med sinusvågsmodellen, som är liten, blir det ingen stor skillnad, men den är märkbar. Projektet kan sedan genereras genom att klicka på "Generate code".

Figur 7: Analysknappen ger utvecklare information om RAM, ROM och exekveringscykler. (Bildkälla: Beningo Embedded Group)

Kodgeneratorn initialiserar projektet och bygger in exekveringsmiljön för tinyML-modellen. Som standard förmedlas inget till modellen. Utvecklare måste lägga till kod för att tillhandahålla modellens ingångsvärden – x-värden – som modellen sedan tolkar och använder för att generera värden för sinus y. Några kodstycken måste läggas till i funktionerna acquire_and_process_data och post_process, enligt vad som visas i figur 8.

Figur 8: Koden som visas simulerar falska ingångsvärden från givare för sinusvågsmodellen. (Bildkälla: Beningo Embedded Group)

Exemplet är nu redo att köras. Observera! Lägg till några printf-meddelanden för att få fram modellens utdata för snabb verifiering. En snabb kompilering och distribution resulterar i att tinyML-modellen "Hello World" kan köras. En hämtning av modellens utdata under en hel cykel ger den sinusvåg som visas i figur 9. Den är inte perfekt, men den är utmärkt för en första tinyML-applikation. Från detta kan utvecklare koppla utgången till en pulsbreddsmodulator (PWM) och generera en sinusvåg.

Figur 9: Utdata från sinusmodellen "Hello World" när den körs på STM32. (Bildkälla: Beningo Embedded Group)

Tips och tricks för maskininlärning i inbäddade system

Utvecklare som vill komma igång med maskininlärning i microcontroller-baserade system har en hel del att göra för att få igång sin första tinyML-applikation. Det finns dock flera "tips och tricks" att ha i åtanke för att förenkla och påskynda utvecklingen:

• Gå igenom exemplet "Hello World" i TensorFlow Lite for microcontrollers, inklusive Google Colab-filen. Ta dig tid att justera parametrarna och förstå hur de påverkar den tränade modellen.
• Använd kvantiserade modeller för microcontroller-tillämpningarna. Den kvantiserade modellen är komprimerad för att fungera med uint8_t i stället för 32-bitars flyttal. Det gör att modellen blir mindre och snabbare att exekvera.
• Utforska ytterligare exempel i lagringsutrymmet för TensorFlow Lite för microcontrollers. Andra exempel är att upptäcka gester och nyckelord.
• Ta exemplet "Hello World" och anslut modellens utgång till en pulsbreddsmodulator och ett lågpassfilter för att se den resulterande sinusvågen. Experimentera med exekveringsmiljön för att öka och minska frekvensen för sinusvågen.
• Välj ett utvecklingskort som innehåller "extra" givare som gör det möjligt att prova ett stort antal maskininlärningstillämpningar.
• Även om det kan vara roligt att samla in information, så är det i allmänhet lättare att köpa eller använda en databas med öppen källkod för att träna modellen.

Utvecklare som följer dessa "tips och tricks" kommer att upptäcka att de sparar en hel del tid och frustration när de utvecklar sin tillämpning.

Sammanfatttning

Maskininlärning har kommit till molnkanten, och resursbegränsade microcontroller-baserade system är ett utmärkt mål. Med de senaste verktygen kan maskininlärningsmodeller konverteras och optimeras för att köras i realtidssystem. Som visat, är det relativt enkelt att få igång en modell på ett utvecklingskort för STM32, trots den komplexitet som det innebär. I diskussionen undersöktes en enkel modell som genererar en sinusvåg, men det är möjligt att använda mycket mer komplicerade modeller, t.ex. för att upptäcka gester och nyckelord.