Reunavalmiiden koneoppimissovellusten nopea käyttöönotto

Koneoppiminen (ML) tarjoaa valtavasti potentiaalia älytuotteiden luontiin. Neuroverkkomallintamiseen (NN) ja reunakäyttöön tarkoitettujen koneoppimissovellusten luonnin kompleksisuus ja haasteet ovat kuitenkin rajoittaneet kehittäjien kykyä tuottaa nopeasti hyödyllisiä ratkaisuja. Vaikka saatavilla olevat työkalut ovat tehneet koneoppimismallien luomisesta yleisesti helpommin lähestyttävää, tavanomaisia koneoppimisen kehityskäytäntöjä ei ole suunniteltu vastaamaan esineiden internetin (Internet of Things, IoT), autoteollisuuden, teollisuusjärjestelmien ja muiden sulautettujen sovellusratkaisujen erityisvaatimuksiin.

Tämä artikkeli tarjoaa lyhyen katsauksen neuroverkkomallinnukseen. Sen jälkeen artikkelissa esitellään ja kuvataan NXP Semiconductorsin laaja-alaisen koneoppimisalustan käyttöä. Sen avulla kehittäjät voivat tuottaa tehokkaammin reunavalmiita koneoppimissovelluksia.

Lyhyt katsaus neuroverkkomallinnukseen

Koneoppimisalgoritmit tarjoavat kehittäjille dramaattisesti erilaisen vaihtoehdon sovelluskehitykseen. Sen sijaan että kehittäjät pyrkisivät ratkaisemaan eksplisiittisesti kuvien luokittelun kaltaisia ongelmia kirjoittamalla ohjelmistokoodia, he voivat kouluttaa neuroverkkomalleja esittämällä datajoukkoja (kuten kuvia) yhdessä kuvan sisältämän entiteetin todellisen nimen (tai luokan) kanssa. Koulutusprosessissa käytetään erilaisia menetelmiä mallin parametrien eli painokertoimien ja vakiotermien laskemiseen kullekin neuronille ja kerrokselle, jolloin malli voi tarjota kohtuullisen tarkan arvion syötetyn kuvan oikeasta luokasta (kuva 1).

Kuva 1: Neuroverkot, kuten tämä täysin yhdistetty verkko, luokittelevat syötetyn objektin käyttämällä koulutuksen aikana asetettuja painokerroin- ja vakiotermiparametreja. (Kuvan lähde: NXP Semiconductors)

Koneoppimisen tutkijat ovat kehittäneet laajan valikoiman neuroverkkoarkkitehtuureja, jotka ovat kuvan 1 mukaista täysin yhdistettyä neuroverkkoa kehittyneempiä. Kuvien luokittelusovelluksissa käytetään yleensä esimerkiksi erikoistunutta konvoluutioneuroverkkoarkkitehtuuria (CNN). Se jakaa kuvantunnistuksen alkuvaiheeseen, jossa etsitään kuvan keskeiset piirteet, ja sitä seuraavaan luokitteluvaiheeseen, jossa arvioidaan, kuinka todennäköisesti kuva kuuluu johonkin useista koulutuksen aikana määritetyistä luokista (kuva 2).

Kuva 2: Koneoppimisasiantuntijat käyttävät tämän konvoluutioneuroverkon (CNN) kaltaisia erikoistuneita neuroverkkoarkkitehtuureja erityisiin tehtäviin, kuten kuvantunnistukseen. (Kuvan lähde: NXP Semiconductors)

Vaikka sopivan malliarkkitehtuurin ja koulutusmenetelmän valinta on tähän mennessä kuulunut koneoppimisasiantuntijoille, lukuisien avoimen lähdekoodin ja kaupallisten työkalujen saatavuus on yksinkertaistanut huomattavasti mallien kehittämistä laajamittaisia sovelluksia varten. Nykyään kehittäjät voivat määritellä mallit muutamalla koodirivillä (listaus 1) ja käyttää avoimen lähdekoodin Netron-mallinkatseluohjelman kaltaisia työkaluja mallin graafisen esityksen luontiin (kuva 3) kunkin kerroksen määrittelyn ja yhteyksien tarkastamista varten.

Kopioi
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

Listaus 1: Kehittäjät voivat määritellä neuroverkkomalleja pelkästään muutamalla koodirivillä. (Koodin lähde: NXP Semiconductors)

Kuva 3: Tämä Netron-katseluohjelmalla luotu graafinen esitys listauksessa 1 määritellystä mallista auttaa kehittäjää dokumentoimaan kunkin kerroksen tehtävän ja yhteydet. (Kuvan lähde: Stephen Evanczuk, Netronin suorittaminen NXP:n mallin lähdekoodille listauksessa 1)

Muut työkalut poistavat ainoastaan koulutuksen aikana tarvittavat mallirakenteet ja suorittavat muita optimointeja tehokkaan päättelymallin luomiseksi lopullista käyttöönottoa varten.

Miksi koneoppimispohjaisten sovellusten kehittäminen älytuotteille on ollut niin vaikeaa

Mallin määrittely ja kouluttaminen IoT- tai muita älytuotteita varten noudattaa samanlaista työnkulkua kuin mallin luonti yritysmittakaavan koneoppimissovelluksia varten. Tämän samankaltaisuuden lisäksi koneoppimissovellusten kehittäminen reunakäyttöön tuo kuitenkin mukanaan useita lisähaasteita. Suunnittelijat kohtaavat mallinkehityksen lisäksi tuttuja haasteita mikrokontrolleripohjaisen (MCU) tuotteen käyttöön tarvittavan pääsovelluksen kehittämisessä. Koneoppimisen tuonti reunakäyttöön edellyttää näin ollen kahden toisiinsa liittyvän työnkulun hallintaa (kuva 4).

Kuva 4: Koneoppimispohjaisen sovelluksen kehittäminen reunakäyttöön lisää sulautetun mikrokontrollerin tyypilliseen kehitystyönkulkuun koneoppimistyönkulun, joka tarvitaan koneoppimismallin kouluttamiseen, validointiin ja käyttöönottoon. (Kuvan lähde: NXP Semiconductors)

Vaikka mikrokontrolleriprojektin työnkulku on sulautettujen laitteiden kehittäjille tuttu, koneoppimisprojekti voi asettaa mikrokontrolleripohjaiselle sovellukselle lisävaatimuksia, kun kehittäjät luovat optimoitua koneoppimisen päättelymallia. Koneoppimisprojekti itseasiassa vaikuttaa dramaattisesti sulautetun laitteen vaatimuksiin. Mallin suoritukseen yleensä liittyvä raskas laskentakuorma ja muistivaatimukset voivat ylittää IoT-ympäristössä ja älytuotteissa käytettävien mikrokontrollereiden resurssit. Koneoppimisasiantuntijat voivat vähentää resurssien tarvetta käyttämällä sellaisia tekniikoita kuten malliverkon karsintaa, pakkausta, kvantisointia pienempään tarkkuuteen tai jopa yhden bitin parametreja ja väliarvoja sekä muita menetelmiä.

Näistä optimointimenetelmistä huolimatta kehittäjät voivat yhä huomata, ettei tavanomaisten mikrokontrollerien suorituskyky riitä koneoppimisalgoritmeihin liittyvien lukuisien matemaattisten operaatioiden suorittamiseen. Korkeatehoinen sovellusprosessori voisi periaatteessa hallita koneoppimisen laskentakuorman, mutta tämä lähestymistapa saattaisi lisätä viiveaikoja ja synnyttää epädeterministista vastetta sekä heikentää sulautetun ratkaisun reaaliaikaominaisuuksia.

Laitteiston valintaan liittyvien haasteiden lisäksi optimoitujen koneoppimismallien tarjoaminen reunakäyttöön tuo erityisiä vain sulautettuun kehitykseen liittyviä haasteita. Yritysmittakaavan koneoppimissovelluksia varten kehitetyt lukemattomat työkalut ja menetelmät eivät välttämättä sovellu hyvin sulautettujen järjestelmien sovelluksiin ja käyttöympäristöön. Jopa kokeneilla sulautettujen järjestelmien kehittäjillä, jotka haluavat ottaa koneoppimispohjaiset laitteet nopeasti käyttöön, voi olla vaikeuksia löytää tehokas ratkaisu saatavilla olevien neuroverkkojen malliarkkitehtuurien, työkalujen, kehysten ja työnkulkujen joukosta.

NXP ratkaisee sekä laitteiston suorituskykyyn että mallien toteutukseen liittyvät tekijät, kun koneoppimista kehitetään reunakäyttöön. NXP:n huipputehokkaat i.MX RT1170 -crossover-mikrokontrollerit täyttävät laitteistotasolla koneoppimisen laajat suorituskykyvaatimukset reunakäytössä. Jotta tätä laitteistopohjaa voitaisiin hyödyntää täysimääräisesti, NXP:n koneoppimisen eIQ (edge intelligence) -ohjelmistokehitysympäristö ja -sovellusohjelmistopaketit tarjoavat sekä kokemattomille että kokeneille koneoppimiskehittäjille tehokkaan ratkaisun reunavalmiiden koneoppimissovellusten luontiin.

Tehokas alusta reunavalmiiden koneoppimissovellusten kehittämiseen

NXP i.MX RT -crossover-prosessoreissa yhdistyvät perinteisten sulautettujen mikrokontrollereiden reaaliaikainen alhaisen latenssin vaste ja korkeatehoisten sovellusprosessoreiden suoritusominaisuudet. NXP:n i.MX RT1170 -crossover-prosessorisarjaan on integroitu energiatehokas Arm® Cortex®-M4- ja korkeatehoinen Arm Cortex-M7 -prosessori sekä laaja valikoima toimilohkoja ja oheislaitteita, jotka tarvitaan vaativien sovellusten, kuten koneoppimispohjaisten ratkaisujen, suorittamiseen sulautetuissa laitteissa (kuva 5).

Kuva 5: NXP:n i.MX RT1170 -crossover-prosessoreissa yhdistyvät perinteisten mikrokontrollereiden energiatehokkaat ominaisuudet ja sovellusprosessorien korkeatehoinen prosessointikyky. (Kuvan lähde: NXP Semiconductors)

Täysin NXP:n MCUXpresso SDK- ja Yocto-kehitysympäristöihin integroitu NXP eIQ -ympäristö on erityisesti suunniteltu helpottamaan päättelymallien toteutusta NXP- mikroprosessoreilla ja -mikrokontrollereilla sulautetuissa järjestelmissä. eIQ-ympäristöön sisältyvä eIQ Toolkit tukee BYOD (Bring Your Own Data)- ja BYOM (Bring Your Own Model) -työnkulkuja useilla työkaluilla, kuten eIQ Portal, eIQ Model Tool ja komentorivityökalut (kuva 6).

Kuva 6: NXP eIQ Toolkit tukee sekä BYOD-kehittäjiä, joiden täytyy luoda malli, että BYOM-kehittäjiä, joiden täytyy ottaa oma olemassa oleva malli käyttöön kohdejärjestelmässä. (Kuvan lähde: NXP Semiconductors)

eIQ Portal on suunniteltu tukemaan BYOD-työnkulkuja sekä asiantuntijoiden että ML-mallien kehittämistä aloittelevien kehittäjien avuksi. eIQ Portal tarjoaa graafisen käyttöliittymän (GUI), jonka avulla kehittäjien on helpompi suorittaa mallikehityksen työnkulun jokainen vaihe.

Kehitystyön alkuvaiheessa eIQ Portalin Data Set Curator -työkalu auttaa kehittäjiä tuomaan dataa ja keräämään dataa kamerasta tai etälaitteesta (kuva 7).

Kuva 7: eIQ Portalin Data Set Curator -työkalu helpottaa tärkeää koulutusdatan valmistelutehtävää. (Kuvan lähde: NXP Semiconductors)

Kehittäjät voivat nimetä Data Set Curator -työkalun avulla datajoukon jokaisen kohteen nimeämällä koko kuvan tai vain tietyille määriteltyyn rajauskehykseen sisältyvän alueen. Lisätoiminto auttaa kehittäjiä tuomaan datajoukkoon tarvittavaa monipuolisuutta. Toiminnolla voidaan sumentaa kuvia, lisätä satunnaiskohinaa, muuttaa ominaisuuksia, kuten kirkkautta tai kontrastia, tai käyttää muita menetelmiä.

Seuraavassa vaiheessa eIQ Portal auttaa kehittäjiä valitsemaan sovellukseen parhaiten sopivan mallin. Jos kehittäjät ovat epävarmoja mallityypistä, mallinvalintatoiminto ohjaa kehittäjät valintaprosessin läpi sovelluksen tyypin ja käytettävän laitteiston perusteella. Jos kehittäjät tietävät valmiiksi minkä tyyppistä mallia he tarvitsevat, he voivat valita jonkin eIQ-järjestelmän mukana toimitetuista muokattavista malleista tai muista muokattavista toteutuksista.

eIQ Portal ohjaa kehittäjät seuraavan kriittisen koulutusvaiheen läpi ja tarjoaa intuitiivisen graafisen käyttöliittymän koulutusparametrien muokkaamiseen ja mallin arviointitarkkuuden tarkasteluun kussakin koulutusvaiheessa (kuva 8).

Kuva 8: Kehittäjät käyttävät eIQ Portalin koulutustyökalua koulutustarkkuuden tarkkailuun jokaisessa vaiheessa ja tarvittaessa muutoksien tekemiseen. (Kuvan lähde: NXP Semiconductors)

Seuraavassa vaiheessa eIQ Portal -käyttöliittymä auttaa kehittäjiä validoimaan mallin. Tässä vaiheessa malli muunnetaan suoritettavaksi kohdearkkitehtuurilla sen todellisen suorituskyvyn määrittämistä varten. Kun validointi on valmis, validointi-ikkuna näyttää konfuusiomatriisin – se on perustavanlaatuinen koneoppimisen validointityökalu, jonka avulla kehittäjät voivat verrata syötetyn objektin todellista luokkaa mallin arvioimaan luokkaan (kuva 9).

Kuva 9: eIQ Portalin validointityökalu tarjoaa kehittäjille konfuusiomatriisin, joka saadaan suoritettaessa malli kohdearkkitehtuurilla. (Kuvan lähde: NXP Semiconductors)

Ympäristö tarjoaa kehittäjille lopullista käyttöönottoa varten valikoiman kohteen päättelykoneita prosessorin mukaan. Niihin kuuluvat:

• Arm CMSIS-NN (Common Microcontroller Software Interface Standard, Neural Network) – neuroverkkoytimet, jotka on kehitetty maksimoimaan neuroverkkojen suorituskyky ja minimoimaan niiden muistitila Arm Cortex-M -prosessoriytimissä
• Arm NN SDK (Neural Network, Software Development Kit) – joukko työkaluja ja päättelykone, jotka on kehitetty mm. olemassa olevien neuroverkkokehysten ja Arm Cortex-A -prosessoreiden väliseksi "sillaksi"
• DeepViewRT – NXP:n oma päättelykone i.MX RT -crossover-mikrokontrollereille
• Glow NN – perustuu Metan Glow (Graph lowering) -kääntäjään, jonka NXP on optimoinut Arm Cortex-M -ytimille käyttämällä CMSIS-NN-ytimien tai Arm NN-kirjaston funktiokutsuja, mikäli niitä on käytettävissä. Muutoin koodi käännetään omasta natiivikirjastosta
• ONXX Runtime – Microsoft Researchin työkalut, jotka on tarkoitettu Arm Cortex-A -prosessorien suorituskyvyn optimointiin.
• TensorFlow Lite for Microcontrollers – TensorFlow Liten pienempi versio, joka on optimoitu koneoppimismallien suorittamiseen i.MX RT -crossover-mikrokontrollereilla
• TensorFlow Lite – pienempiä järjestelmiä tukeva TensorFlow-versio.

Kehittäjät voivat käyttää BYOM-työnkulkuihin eIQ Model Tool -työkalua ja siirtyä näin suoraan mallianalyysiin ja kerroskohtaiseen aikaprofilointiin. Kehittäjät voivat käyttää sekä BYOD- että BYOM-työnkuluissa eIQ-komentorivityökaluja. Ne tarjoavat käyttöön sellaisia työkalutoimintoja ja eIQ-ominaisuuksia, joita ei ole käytettävissä suoraan graafisen käyttöliittymän kautta.

Tässä artikkelissa kuvattujen ominaisuuksien lisäksi eIQ Toolkit tukee lukuisia muitakin toimintoja, mukaan lukien mallien muuntaminen ja optimointi, jotka eivät kuulu tämän artikkelin piiriin. Kehittäjät voivat kuitenkin yleensä suorittaa kehitystyön ja käyttöönoton nopeasti reunavalmiiden koneoppimissovellusten nopeaa prototyyppien luontia varten, eikä eIQ-ympäristön hienostuneempia ominaisuuksia tarvitse juurikaan käyttää. NXP:n erityiset sovellusohjelmistopaketit (App SW Pack) itse asiassa tarjoavat valmiita sovelluksia, joita kehittäjät voivat käyttää välittömään evaluointiin tai omien asiakaskohtaisten sovellustensa perustana.

Mallikehityksen nopea evaluointi App SW Pack -ohjelmiston avulla

NXP:n App SW Pack -ohjelmistopaketit tarjoavat valmiin koneoppimispohjaisen sovelluksen, jossa yhdistyvät tuotantovalmis lähdekoodi, ohjaimet, väliohjelmistot ja työkalut. Esimerkiksi NXP:n ML State Monitor App SW Pack tarjoaa välittömän koneoppimispohjaisen ratkaisun yleiseen ongelmaan, joka koskee kompleksisten järjestelmien tilan määrittämistä anturitulojen perusteella (kuva 10).

Kuva 10: Kehittäjät voivat käyttää NXP App SW Pack -ohjelmistoja, kuten ML State Monitor App SW Pack, välittömään evaluointiin tai asiakaskohtaisen koodin kehittämisen perustana. (Kuvan lähde: NXP Semiconductors)

ML State Monitor App SW Pack tarjoaa valmiin ratkaisun sovellukseen, jonka tehtävänä on tunnistaa, milloin tuuletin toimii jossakin seuraavista neljästä tilasta:

• ON
• OFF
• CLOGGED, kun tuuletin on päällä, mutta ilmavirran tiellä on esteitä
• FRICTION, kun tuuletin on päällä, mutta yhden tai useamman tuulettimen siiven kitka on liian korkea.

Yhtä tärkeää mallien kehittäjille on, että ML State Monitor App SW Pack sisältää koneoppimismallit sekä täydellisen datajoukon, joka kattaa kiihtyvyysanturin mittausarvot tuulettimesta kaikissa näissä neljässä eri toimintatilassa.

Kehittäjät voivat tutkia ML State Monitor App SW Pack -paketin koodia, malleja ja dataa ymmärtääkseen, miten anturidataa käytetään mallin kouluttamiseen, päättelymallin luontiin ja päättelyn validointiin validointianturidataa käyttäen. NXP:n App SW Pack -paketin sisältämä ML_State_Monitor.ipynb Jupyter Notebook itse asiassa tarjoaakin heti käyttövalmiin työkalun mallikehityksen työnkulun tutkimiseen hyvissä ajoin ennen laitteiston käyttämistä.

Jupyter Notebook on interaktiivinen selainpohjainen Python-suoritusalusta, jonka avulla kehittäjät voivat saman tien tarkastella suoritettavan Python-koodin tuloksia. Jupyter Notebookin suorittaminen luo Python-koodilohkon ja heti sen jälkeen tulokset kyseisen koodilohkon suorittamisesta. Nämä tulokset eivät ole pelkkiä staattisia näyttöjä, vaan todellisia, koodia suorittamalla saatuja tuloksia. Kun kehittäjät esimerkiksi suorittavat NXP:n ML_State_Monitor.ipynb Jupyter Notebook -koodin, he näkevät välittömästi yhteenvedon syötetystä datajoukosta (kuva 11).

Kuva 11: NXP:n ML_State_Monitor.ipynb Jupyter Notebookilla kehittäjät voivat suorittaa interaktiivisesti neuroverkkomallin kehitystyönkulun ja tarkastella ML State Monitor App SW Pack -sovelluksen tarjoamaa koulutusdataa. [Huomautus: Koko koodi ei mahdu näyttöön ja siitä esitetään tässä vain osa.] (Kuvan lähde: Stephen Evanczuk, NXP:n ML_State_Monitor.ipynb Jupyter Notebookin käyttäminen)

Koodin seuraava osa tarjoaa Notebookissa käyttäjälle graafisen näytön syötetystä datasta, joka esitetään erillisinä kuvaajina aikajärjestyksessä ja taajuuden mukaan (kuva 12).

Kuva 12: Jupyter Notebook tarjoaa kehittäjille aikasarja- ja taajuusnäytöt tuulettimen tilan datajoukosta (OFF: vihreä; ON: punainen; CLOGGED: sininen; FRICTION: keltainen). [Huomautus: Koodi typistetty esitystarkoituksiin.] (Kuvan lähde: Stephen Evanczuk, NXP:n ML_State_Monitor.ipynb Jupyter Notebookin käyttäminen)

Koodin muut osat on tarkoitettu muihin data-analyyseihin, normalisointiin, muotoiluun ja muuhun valmisteluun, kunnes koodin suorituksessa saavutetaan mallinluontifunktio model_create(), sama mikä esitettiin edellä listauksessa 1. Heti seuraava koodin osa suorittaa tämän funktion model_create() ja tulostaa yhteenvedon nopeaa validointia varten (kuva 13).

Kuva 13: NXP:n ML_State_Monitor.ipynb Jupyter Notebook luo mallin (esitetty listauksessa 1) ja näyttää mallin yhteenvetotiedot. (Kuvan lähde: Stephen Evanczuk, NXP:n ML_State_Monitor.ipynb Jupyter Notebookin käyttäminen)

Mallin koulutukseen ja evaluointiin käytettävän koodiosan jälkeen ML_State_Monitor.ipynb Jupyter Notebook näyttää kunkin konfuusiomatriisin koko datajoukosta, koulutusdatajoukosta ja validointidatajoukosta (koulutusdatajoukon ulkopuolelle jätetty datajoukon osajoukko). Tässä tapauksessa koko datajoukon konfuusiomatriisi näyttää tarkkuuden olevan hyvä, mutta siinä on jonkin verran virheitä. Niitä esiintyy erityisesti silloin, kun malli luulee, että pieni prosenttiosuus datajoukosta on ON-tilassa, vaikka kyseinen data onkin todellisuudessa CLOGGED-tilassa, kuten alkuperäiseen datajoukkoon on merkitty (kuva 14).

Kuva 14: Kehittäjät voivat tarkastella tämän kaltaisia konfuusiomatriiseja koko datajoukosta. (Kuvan lähde: Stephen Evanczuk, NXP:n ML_State_Monitor.ipynb Jupyter Notebookin käyttäminen)

Myöhemmässä koodiosassa malli muunnetaan useisiin eri mallityyppeihin ja -muotoihin, joita eIQ-kehitysympäristön tukemat eri päättelykoneet käyttävät (kuva 15).

Kuva 15: NXP:n ML_State_Monitor.ipynb Jupyter Notebook havainnollistaa, miten kehittäjät voivat tallentaa koulutetun mallinsa useina eri mallityyppeinä ja -muotoina. (Kuvan lähde: Stephen Evanczuk, NXP:n ML_State_Monitor.ipynb Jupyter Notebookin käyttäminen)

Päättelykoneen valinta voi olla ratkaisevan tärkeää haluttujen suorituskykyvaatimusten saavuttamiseksi. NXP mittasi tätä tarkoitusta varten mallikoon, koodikoon ja päättelyajan (aika, joka tarvitaan päättelyn suorittamiseen yhdestä syöteobjektista), kun malli muunnettiin erilaisille päättelykoneille, joista yksi toimi 996 megahertsin (MHz) ja yksi 156 MHz:n taajuudella (kuvat 16 ja 17).

Kuva 16: Mallityypin valinta voi vaikuttaa dramaattisesti mallikokoon, vaikka tässä esitetyt dramaattiset erot eivät välttämättä päde suurempiin malleihin. (Kuvan lähde: NXP Semiconductors)

Kuva 17: Syöteobjektin evaluointiin tarvittavassa päättelyajassa on suuria eroja riippuen siitä, ladataanko objekti RAM- tai flash-muistista ja käyttääkö prosessori korkeampaa taajuutta 996 MHz (verrattuna taajuuteen 156 MHz). (Kuvan lähde: NXP Semiconductors)

NXP huomauttaa, että tässä esimerkkisovelluksessa käytetään erittäin pientä mallia, joten näissä kuvissa näkyvät melko selkeät erot saattavat olla huomattavasti pienempiä kompleksisempiin luokitteluihin käytettävässä suuremmassa mallissa.

Järjestelmäratkaisun luonti tilanvalvontaa varten

NXP ML State Monitoring App SW Pack -ohjelmisto tarjoaa mallin kehitystyönkulun interaktiiviseen tutkimiseen tarkoitetun Jupyter Notebookin lisäksi valmiin lähdekoodin mallin toteuttamiseksi NXP:n MIMXRT1170-EVK-evaluointikortilla. Evaluointikortti on rakennettu NXP:n crossover-mikrokontrollerin MIMXRT1176DVMAA ympärille. Se tarjoaa kattavan laitteistoalustan, johon kuuluu lisämuistia ja useita rajapintoja (kuva 18).

Kuva 18: NXP:n evaluointikortti MIMXRT1170-EVK tarjoaa kattavan laitteistoalustan NXP:n i.MX RT1170 -sarjan crossover-mikrokontrolleriin perustuvien sovellusten kehittämiselle. (Kuvan lähde: NXP Semiconductors)

Kehittäjät voivat käyttää NXP:n tuuletintilasovellusta tuulettimen tilan arvioimiseen. Se toteutetaan pinoamalla päällekkäin MIMXRT1170-EVK-evaluointikortti, NXP:n FRDM-STBC-AGM01-anturilisäkortti, Arduino-lisäkortti ja sopiva harjaton 5 voltin DC-tuuletin, kuten Adafruitin 4468 (kuva 19).

Kuva 19: Kehittäjät voivat testata tuulettimen tilaa arvioivaa NXP-esimerkkisovellusta yksinkertaisella pinolla, joka kootaan MIMXRT1170-EVK-evaluointikortille. (Kuvan lähde: NXP Semiconductors)

Kehittäjät voivat käyttää integroitua kehitysympäristöä (IDE) MCUXpresso ja konfiguroida sovelluksen siten, että se kerää ja tallentaa tuuletintiladataa tai suorittaa päättelyn heti kerätyn datan perusteella TensorFlow-, DeepViewRT- tai Glow- päättelykoneella (listaus 2).

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

Listaus 2: Kehittäjät voivat konfiguroida helposti NXP ML State Monitor -esimerkkisovellusta muokkaamalla otsikkotiedoston sensor_collect.h sisältämiä määrityksiä. (Koodin lähde: NXP Semiconductors)

Sovelluksen toiminta on suoraviivaista. Tiedoston main.c päärutiini luo tehtävän nimeltä MainTask, joka on sensor_collect.c-moduulissa sijaitseva rutiini.

Kopioi
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

Listaus 3: MainTask käynnistää NXP ML State Monitor -esimerkkisovelluksessa alitehtävän datan keruuta tai päätelmien suorittamista varten. (Koodin lähde: NXP Semiconductors)

MainTask suorittaa erilaisia alustustehtäviä ennen kuin se käynnistää toisen kahdesta alitehtävästä käyttäjän tiedostossa sensor_collect.h asettamien määritysten mukaan:

• jos SENSOR_COLLECT_ACTION asetetaan arvoon SENSOR_COLLECT_LOG_EXT, MainTask käynnistää alitehtävän SENSOR_Collect_LogExt_Task(), joka kerää dataa ja tallentaa sen SD-kortille, jos se on konfiguroitu
• jos SENSOR_COLLECT_ACTION asetetaan arvoon SENSOR_COLLECT_RUN_INFERENCE, MainTask käynnistää alitehtävän SENSOR_Collect_RunInf_Task(), joka suorittaa tiedostossa sensor_collect.h määritetyn päättelykoneen (Glow, DeepViewRT tai TensorFlow) kerätyn datan perusteella ja näyttää tuloksena saatavan suorituskyky- ja luokitteluarvion

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

Listaus 4: Esimerkkisovellus NXP ML State Monitor havainnollistaa perussuunnittelumallin, joka kerää anturidatan ja suorittaa valitun päättelykoneen kerätyllä datalla. (Koodin lähde: NXP Semiconductors)

Koska NXP ML State Monitor App SW Pack tarjoaa täydellisen lähdekoodin sekä täyden joukon tarvittavia ohjaimia ja väliohjelmistoja, kehittäjät voivat helposti laajentaa sovellusta lisäämällä siihen toimintoja tai käyttää sitä oman asiakaskohtaisen kehitystyönsä lähtökohtana.

Yhteenveto

Koneoppimisen toteuttaminen reunakäyttöä varten älytuotteissa sekä IoT- ja muissa sovelluksissa voi tarjota tehokkaita toimintoja. Kehittäjillä on kuitenkin usein vaikeuksia soveltaa yritystasoiseen käyttöön kehitettyjä koneoppimistyökaluja ja -menetelmiä. NXP:n crossover-prosessoreista ja erikoistuneista mallikehitysohjelmistoista koostuvan kehitysalustan avulla sekä koneoppimisasiantuntijat että kehittäjät, joilla on vain vähän tai ei lainkaan koneoppimiskokemusta, voivat luoda tehokkaammin koneoppimissovelluksia, jotka on tarkoitettu erityisesti vastaamaan tehokkaan reunasuorituskyvyn vaatimuksiin.