In industriële IoT is het uitvoeren van machine learning (ML) -modellen op randapparatuur noodzakelijk voor veel gebruiksscenario's, zoals voorspellend onderhoud, kwaliteitsverbetering, realtime monitoring, procesoptimalisatie en beveiliging. De energiesector investeert bijvoorbeeld zwaar in ML om de stroomtoevoer te automatiseren, het verbruik te bewaken, de efficiëntie te optimaliseren en de levensduur van hun apparatuur te verlengen.
Windenergie is een van de meest populaire hernieuwbare energiebronnen. Volgens de Global Wind Energy Council, In 22,893 werden wereldwijd 2019 windturbines geïnstalleerd, geproduceerd door 33 leveranciers en goed voor meer dan 63 GW aan windenergiecapaciteit. Met een dergelijke schaalgrootte hebben energiebedrijven een efficiënt platform nodig om hun windturbinevloten en de ML-modellen die op de apparaten draaien, te beheren en te onderhouden. Een commerciële windturbine kost ongeveer 3 à 4 miljoen dollar. Als een turbine buiten dienst is, kost dat $ 800-1,600 per dag en resulteert in een totaal verlies van 7.5 megawatt, wat genoeg energie is om ongeveer 2,500 huishoudens van stroom te voorzien.
Een windturbine is een complex stuk techniek en bestaat uit veel sensoren die door een monitoringmechanisme kunnen worden gebruikt om gegevens vast te leggen zoals trillingen, temperatuur, windsnelheid en luchtvochtigheid. U kunt met deze gegevens een ML-model trainen, het inzetten op een edge-apparaat dat is aangesloten op de sensoren van de turbine, en anomalieën in realtime aan de edge voorspellen. Het zou de operationele kosten van uw vloot turbines verlagen. Maar stel je de moeite voor om deze oplossing op een vloot van duizenden of miljoenen apparaten te houden. Hoe bedient, beveiligt, implementeert, voert en bewaakt u ML-modellen op een groot aantal apparaten aan de rand?
Amazon SageMaker Edge Manager kan u helpen deze vraag te beantwoorden. Met de service kunt u ML-modellen optimaliseren, beveiligen, bewaken en onderhouden op vloten van slimme camera's, robots, personal computers, industriële apparatuur, mobiele apparaten en meer. Met Edge Manager kunt u de levenscyclus van elk ML-model op elk apparaat in uw apparaatpark beheren voor maximaal duizenden of miljoenen apparaten. De service biedt een softwareagent die op edge-apparaten draait en een beheerinterface op het AWS-beheerconsole.
In dit bericht laten we zien hoe u Edge Manager kunt gebruiken om een robuuste end-to-end-oplossing te creëren die de levenscyclus beheert van ML-modellen die worden geïmplementeerd in een windturbinevloot. Maar in plaats van echte windturbines te gebruiken, leer je hoe je je eigen vloot van mini 3D-geprinte windturbines kunt bouwen. Dit is een doe-het-zelf open-source, open-hardwareproject dat is gemaakt om te demonstreren hoe je een ML at the edge-oplossing kunt bouwen met Amazon Sage Maker. U kunt het gebruiken als een platform om te leren, te experimenteren en inspiratie op te doen.
De volgende secties behandelen de volgende onderwerpen:
- De specificaties van het windturbinepark
- Hoe u elke Jetson Nano configureert
- Hoe een anomaliedetectiemodel te bouwen met SageMaker
- Hoe u uw eigen mini-windturbinepark kunt runnen
Het windturbinepark
Het windturbinepark dat voor dit project is gemaakt, heeft vijf mini 3D-geprinte windturbines die via USB zijn verbonden met vijf verschillende Jetson Nanos. De Jetson Nanos zijn verbonden met internet via Ethernet-kabels die zijn aangesloten op een kabelmodem. Een ventilator die voor de boerderij is geplaatst, produceert de wind om een buitenconditie na te bootsen. De volgende afbeelding laat zien hoe het windpark is georganiseerd.
De mini windturbine
De mini-windturbine van dit project is een mechanisch apparaat geïntegreerd met een microcontroller (Arduino) en enkele sensoren. Het is gemodelleerd met FreeCAD, een open-source tool voor het ontwerpen van industriële onderdelen. Deze onderdelen werden vervolgens 3D-geprint met PETG (plastic filament type) en geassembleerd met de elektronische componenten. De basis is statisch, wat betekent dat de turbine zelf niet uitlijnt met de windrichting. Deze beperking was belangrijk om het project te vereenvoudigen.
Elke turbine heeft één spanningsgenerator (kleine motor) en zeven verschillende sensoren:
- Trilling (MPU6050: 6-assige accelerometer / gyroscoop)
- Infrarood rotatie-encoder (rotaties per seconde)
- Versnellingsbak temperatuur (MPU6050)
- Omgevingstemperatuur (BME680)
- Atmosferische druk (BME680)
- Luchtvochtigheid (BME680)
- Luchtkwaliteit (BME680)
An Arduino Mini Pro is verantwoordelijk voor de koppeling met deze sensoren en het verzamelen van gegevens ervan. Deze gegevens worden gestreamd via de seriële pinnen (TX, RX). Een FTDI-apparaat die dit seriële signaal omzet naar USB is de brug tussen de Arduino en de Jetson Nano. Een Python-applicatie die op Jetson Nano draait, ontvangt via deze bridge de ruwe data van de sensoren.
Een microservo werd aangepast en omgevormd tot een spanningsgenerator. De interne versnellingsbak verhoogt het generator- (motor) toerental vijf keer om een (lage) spanning tussen 0-3.3 V te produceren. Deze generator is ook verbonden met de Arduino via een analoge ingangspen. Deze informatie wordt ook meegestuurd met de meetwaarden van de sensor.
De frequentie waarmee de gegevens worden verzameld, is afhankelijk van de sensor. Alle signalen van de BME650 worden elke 150 milliseconden verzameld, de rotatie-encoder elke 1 seconde en de spanningsgenerator en de trillingssensor elke 50 milliseconden.
Als u meer wilt weten over deze technische details en wilt leren hoe u uw eigen mini-windturbine kunt bouwen, raadpleeg dan de GitHub-repository.
Het edge-apparaat
Elke jetson nano heeft een ingebouwde GPU met 128-core NVIDIA Maxwell ™ en een Quad-core ARM® A57 CPU die draait op 1.43 GHz. Deze hardware is voldoende om een Python-applicatie uit te voeren die de gegevens van de sensoren van de turbine verzamelt en formatteert en vervolgens de Edge Manager-agent API om de voorspellingen te krijgen. Deze applicatie vergelijkt de voorspelling met een drempel om te controleren op afwijkingen in de gegevens. Het model wordt in realtime aangeroepen.
. SalieMaker Neo compileert het ML-model voor Jetson Nano, een runtime (DLR) geoptimaliseerd voor dit doelapparaat is opgenomen in het implementatiepakket. Deze runtime detecteert automatisch dat het op een Jetson Nano draait en laadt het model rechtstreeks in de GPU van het apparaat voor maximale prestaties.
De Edge Manager-agent wordt ook gedistribueerd als een Linux-applicatie (arm64) die kan worden uitgevoerd als achtergrondproces (daemon) op uw Jetson Nano. Het maakt gebruik van de runtime die SageMaker Neo bevat in het compilatiepakket om te communiceren met het geoptimaliseerde model en het te presenteren als een goed gedefinieerde API. Deze API is geïntegreerd met de lokale applicatie via een low latency protocol (grpc + unix socket).
De clouddiensten
Nu u enkele details weet over de fysieke hardware die wordt gebruikt om het windturbinepark te ontwikkelen, is het tijd om te kijken welke AWS-services de oplossing aan de cloudzijde ondersteunen. Een minimale, zelfstandige installatie om een model geïmplementeerd en draaiend te krijgen op de Edge Manager-agent vereist alleen SageMaker en niets meer. In dit project werden echter andere services gebruikt met twee belangrijke kenmerken: een mechanisme voor over-the-air (OTA) -implementatie en een dashboard voor het volgen van de anomalieën in bijna realtime.
Samengevat zijn de componenten die nodig zijn voor dit project:
- Een apparatenpark (Edge Manager), dat een of meer geregistreerde apparaten organiseert en bestuurt via de agent (draait op elk apparaat)
- One IoT-ding per apparaat en IoT-dingengroep, dat wordt gebruikt door het OTA-mechanisme om via MQTT met de apparaten te communiceren
- AWS IoT regels, en een AWS Lambda functie om toepassingslogboeken op te halen en te filteren en ze op te nemen in Amazon Elasticsearch-service (Amazone ES)
- Een Lambda-functie om de modelstatistieken te analyseren die door de agent zijn vastgelegd bij het opnemen in Amazon ES
- Een Elasticsearch-server met Kibana, die dashboards heeft voor het bewaken van de anomalieën (optioneel)
- SageMaker voor het bouwen, compileren en verpakken van het ML-model
Het volgende diagram illustreert deze architectuur.
Alles samenvoegen
Nu we alle componenten van ons windturbinepark hebben, is het tijd om de stappen te begrijpen die we moeten nemen om al deze bewegende delen te integreren, een model op onze edge-apparaten te implementeren en een applicatie draaiende te houden en afwijkingen in realtime te voorspellen.
Het volgende diagram toont alle stappen die bij het proces betrokken zijn.
De oplossing bestaat uit de volgende stappen:
- De datawetenschapper verkent de dataset en ontwerpt een anomaliedetectiemodel (auto-encoder) met PyTorch, met behulp van SageMaker Studio.
- Het model is getraind met een SageMaker-trainingstaak.
- Met Neo is het model geoptimaliseerd (gecompileerd) naar Jetson Nano.
- Edge Manager maakt een implementatiepakket met het gecompileerde model.
- De datawetenschapper creëert een IoT-taak die een melding stuurt van het nieuwe model dat beschikbaar is voor de edge-apparaten.
- De applicatie die op Jetson Nano draait, voert het volgende uit:
- Ontvangt deze melding en downloadt het modelpakket van het Amazon eenvoudige opslagservice (Amazon S3) emmer.
- Pakt het model uit en laadt het met behulp van de Edge Manager-agent-API (LoadModel).
- Leest de sensoren van de windturbine, bereidt de gegevens voor, roept het ML-model op en legt enkele modelstatistieken vast met behulp van de Edge Manager-agent-API.
- Vergelijkt de voorspelling met een basislijn om mogelijke afwijkingen te detecteren.
- Stuurt de onbewerkte sensorgegevens naar een AWS IoT-onderwerp.
- Via een regel leest AWS IoT het onderwerp van de app-logboeken en exporteert het de gegevens naar Amazon ES.
- Een Lambda-functie legt de modelstatistieken (gemiddelde gemiddelde fout) vast die door de agent zijn geëxporteerd en neemt de gegevens op in Amazon ES.
- De operator gebruikt een Kibana-dashboard om eventuele anomalieën te controleren.
Configureer uw edge-apparaat
De Edge Manager-agent gebruikt certificaten die zijn verstrekt door AWS IoT-kern om andere AWS-services te verifiëren en te bellen. Op die manier moet u eerst een IoT-ding maken en vervolgens een edge-apparatenpark. Maar eerst moet u enkele basisbronnen voorbereiden om uw oplossing te ondersteunen.
Maak vereiste bronnen
Voordat u begint, moet u configureren AWS-opdrachtregelinterface op uw werkstation eerst (indien nodig) en vervolgens om de volgende bronnen aan te maken:
- Een S3-bucket om de vastgelegde gegevens op te slaan
- An AWS Identiteits- en toegangsbeheer (IAM) -rol voor uw apparaten
- Een IoT-ding om toe te wijzen aan uw Edge Manager-apparaat
- Een IoT-beleid om de machtigingen van de tijdelijke referenties van het edge-apparaat te beheren
- Maak een nieuwe bucket voor de oplossing.
Elke keer dat u CaptureData aanroept in de agent-API, uploadt het de tensoren (invoer en voorspellingen) naar deze bucket.
Vervolgens creëer je je IAM-rol.
- Maak op de IAM-console een rol met de naam WindTurbineFarm zodat de apparaten toegang hebben tot bronnen in uw account.
- Voeg machtigingen toe aan deze rol om bestanden te uploaden naar de S3-bucket die u hebt gemaakt.
- Voeg de volgende vertrouwde entiteiten toe aan de rol:
amazonaws.com
iot.amazonaws.com
amazonaws.com
Gebruik de volgende code (geef de naam op voor de S3-bucket, uw AWS-account en regio):
U bent nu klaar om uw IoT-ding te maken, dat u later toewijst aan uw Edge Manager-apparaat.
- Op de AWS IoT Core-console, onder Beheren, kiezen Things
- Kies creëren.
- Geef uw apparaat een naam (voor dit bericht, edge-device-0).
- Maak een nieuwe groep of kies een bestaande groep (voor dit bericht, WindTurbineFarm).
- Maak een certificaat aan.
- Download de certificaten, inclusief de root-CA.
- Activeer het certificaat.
U maakt nu uw beleid, dat de machtigingen van de tijdelijke inloggegevens van het edge-apparaat regelt.
- Op de AWS IoT Core-console, onder Veilig Bestellen, kiezen Policies.
- Kies creëren.
- Geef het beleid een naam (voor dit bericht, WindTurbine).
- Kies Geavanceerde modus.
- Voer het volgende beleid in, met uw AWS-account en regio:
- Kies creëren.
Ten slotte voegt u het beleid toe aan het certificaat.
- Op de AWS IoT Core-console, onder Veilig Bestellen, kiezen Certificaten.
- Selecteer het certificaat dat u heeft gemaakt.
- Op de Acties menu, kies Beleid bijvoegen.
- Selecteer het beleid WindTurbine.
- Kies hechten.
Nu is uw IoT-ding klaar om te worden gekoppeld aan een edge-apparaat. Herhaal deze stappen (behalve voor het maken van het beleid) voor elk extra apparaat in uw apparatenpark. Voor een productieomgeving met honderden of duizenden apparaten past u gewoon een andere aanpak toe, waarbij u geautomatiseerde scripts en parameterbestanden gebruikt om alle IoT-zaken te voorzien.
Creëer de edge-vloot
Voer de volgende stappen uit om uw edge-vloot te maken:
- Op de SageMaker-console, onder Edge-inferentie, kiezen Edge-apparaatvloten.
- Kies Maak apparatenpark aan.
- Voer een naam in voor het apparaat (voor dit bericht,
WindTurbineFarm
). - Voer het ARN in van de IAM-rol die u in de vorige stappen hebt gebruikt (
arn:aws:iam::<<AWS_ACCOUNT_ID>>:role/WindTurbineFarm
). - Voer de S3-bucket-URI van de uitvoer in (
s3://<<NAME_OF_YOUR_BUCKET>>/wind_turbine_data/
). - Kies Verzenden.
Nu moet u een nieuw apparaat aan de vloot toevoegen.
- Op de SageMaker-console, onder Edge-inferentie, kiezen Edge-apparaten.
- Kies Registreer apparaten.
- Voor Apparaateigenschappen, voer de naam in van het apparatenpark dat u heeft gemaakt (
WindTurbineFarm
). - Kies Volgende.
- Voor Toestelnaam, voer een unieke naam in voor je apparaat (voor dit bericht gebruiken we dezelfde naam als ons IoT-ding,
edge-device-wind-turbine-00000000000
). - Voor IoT-naam, voer de naam in van het ding dat je eerder hebt gemaakt (
edge-device-0
). - Kies Verzenden.
Herhaal het registratieproces voor al uw andere apparaten. Nu kunt u SSH naar uw Jetson Nano sturen en de configuratie van uw apparaat voltooien.
Bereid het randapparaat voor
Voordat u begint met het configureren van uw Jetson Nano, moet u eerst installeren Jet Pack 4.4.1 in je Nano. Dit is de versie die u gebruikt om deze demo te bouwen, uit te voeren en te testen.
Het modelvoorbereidingsproces voor uw doelapparaat is erg gevoelig met betrekking tot de versies van de bibliotheken die op uw apparaat zijn geïnstalleerd. Omdat het doelapparaat bijvoorbeeld een Jetson Nano is, optimaliseert Neo het model en de runtime voor een bepaalde versie van de TensorRT en CUDA. De looptijd (libdlr.so
) is fysiek gekoppeld aan de versies die u opgeeft in de compilatietaak. Dit betekent dat als u uw model compileert met Neo voor JetPack 4.4.1, het niet werkt met JetPack 3.x. en vice versa.
- Met JetPack 4.4.1 draaiend op uw Jetson Nano, kunt u beginnen met het configureren van uw apparaat met de volgende opdrachten:
- Download de Linux ARMv8-versie van de Edge Manager-agent.
- Kopieer het pakket naar uw Jetson Nano (
scp
). Maak een map voor de agent en pak het pakket uit in uw homedirectory:
- Kopieer de AWS IoT Core-certificaten die u in de vorige sectie voor uw ding hebt ingericht naar de directory
~/agent/certificates/iot
in uw Jetson Nano.
U zou de volgende bestanden in deze map moeten zien:
- pem - CA-root
- < > -public.pem.key - Publieke sleutel
- < > -private.pem.key - Prive sleutel
- < > -certificate.pem.crt - Certificaat
- Haal het basiscertificaat op dat is gebruikt om het implementatiepakket te ondertekenen dat is gemaakt door Edge Manager. De agent gebruikt dit om het model te valideren.
- Kopieer dit certificaat naar de directory
~/agent/certificates/root
in uw Jetson Nano.
Vervolgens maakt u het Edge Manager-agentconfiguratiebestand.
- Open een leeg bestand met de naam ~ / agent / sagemaker_edge_config.json en voer de volgende code in:
Geef de informatie op voor de volgende bronnen:
- SAGEMAKER_EDGE_DEVICE_NAME - De unieke naam van uw apparaat die u eerder heeft gedefinieerd.
- AWS_REGION - De regio waar u uw edge-apparaat heeft gemaakt.
- LINUX_USER - De Linux-gebruikersnaam die u gebruikt in Jetson Nano.
- CERT_PREFIX - Het voorvoegsel van de certificaatbestanden die u hebt gemaakt toen u uw IoT-apparaat in de vorige sectie inrichtte.
- CREDENTIALS_ENDPOINT_HOST - Uw eindpunthost. U kunt dit eindpunt verkrijgen via het AWS-opdrachtregelinterface (AWS CLI). (Installeer de AWS CLI als u deze nog niet heeft). Gebruik inloggegevens van hetzelfde account en dezelfde regio die u in de vorige secties hebt gebruikt (dit is niet de schaduw-URL van het IoT-ding). Voer vervolgens de volgende opdracht uit om de eindpunthost op te halen:
- S3_BUCKET - De naam van de S3-bucket die u in de vorige sectie hebt gebruikt om uw edge-apparatenpark te configureren.
- Sla het bestand met al deze wijzigingen op.
Nu bent u klaar om de Edge Manager-agent in uw Jetson Nano uit te voeren.
- Voer de volgende opdrachten uit om de agent te testen:
De volgende schermafbeelding toont uw uitvoer.
De agent is nu aan het rennen. Na een paar minuten kunt u de hartslag van het apparaat zien, gerapporteerd op de console. Om het te zien op de SageMaker-console, onder Edge-inferentie, kiezen Edge-apparaten en kies uw apparaat.
Configureer de applicatie
Nu is het tijd om de applicatie in te stellen die op het edge-apparaat draait. Deze applicatie is verantwoordelijk voor het volgende:
- Haal de tijdelijke inloggegevens op met behulp van het certificaat
- Luister naar de OTA-update-onderwerpen om te zien of een nieuw modelpakket klaar is om te worden geïmplementeerd
- Implementeer het beschikbare modelpakket op het edge-apparaat
- Laad het model indien nodig bij de agent
- Voer een oneindige lus uit:
- Lees de sensorgegevens
- Formatteer de invoergegevens
- Roep het ML-model op en leg enkele statistieken van de voorspelling vast
- Vergelijk de voorspellingen MAE (gemiddelde gemiddelde fout) met de basislijn
- Publiceer onbewerkte gegevens naar een IoT-onderwerp (MQTT)
Om de applicatie te installeren, moet u eerst het aangepaste AWS IoT-eindpunt ophalen. Kies op de AWS IoT Core-console Instellingen. Kopieer het eindpunt en gebruik het in de volgende code:
De applicatie voert zoiets uit als de volgende schermafbeelding.
Optioneel: voer deze applicatie uit met de parameter –test-mode als je alleen een test wilt uitvoeren zonder dat er een windturbine is aangesloten op het edge device.
Als alles goed is gegaan, blijft de applicatie wachten op een nieuw model. Het is tijd om een nieuw model te trainen en in de Jetson Nano te implementeren.
Train en implementeer het ML-model
Dit bericht laat zien hoe afwijkingen in de componenten van een windturbine kunnen worden opgespoord. Er zijn veel manieren om dit te doen met de gegevens die door de sensoren worden verzameld. Om dit voorbeeld zo eenvoudig mogelijk te houden, bereidt u een model voor dat trillingen, windsnelheid, rotatie (per seconde) en de geproduceerde spanning analyseert om te bepalen of er een anomalie bestaat of niet. Daarvoor trainen we een auto-encoder gebruik PyTorch op SageMaker en bereid het voor op implementatie op uw Jetson Nano.
Deze modelarchitectuur heeft twee voordelen: er is geen toezicht, dus we hoeven onze gegevens niet te labelen en u kunt gegevens verzamelen van windturbines die perfect werken. Daarom is uw model getraind om te detecteren wat u als normaal gedrag van uw windturbines beschouwt. Wanneer er een defect optreedt in een deel van de turbine, treedt er een afwijking op in de sensordata, die door het model wordt geïnterpreteerd als abnormaal gedrag (een anomalie).
De volgende schermafbeelding is een voorbeeld van de onbewerkte gegevens die zijn vastgelegd door de turbinesensoren.
De gegevens hebben de volgende kenmerken:
- nanoId - ID van het edge-apparaat dat de gegevens heeft verzameld
- turbine-ID - ID van de turbine die deze gegevens heeft geproduceerd
- arduino_tijdstempel - Tijdstempel van de Arduino die deze turbine bediende
- nanoVrijmem: Hoeveelheid vrij geheugen in bytes
- gebeurtenisTijd - Tijdstempel van de rij
- rPS - Rotatie van de rotor in rotaties per seconde
- spanning - Spanning geproduceerd door de generator in milivolt
- qw, qx, qy, qz - Quaternion hoekversnelling
- gx, gy, gz - Versnelling van de zwaartekracht
- bijl, ay, az - Lineaire versnelling
- versnellingsbaktemp - Binnentemperatuur
- amtemp - Buitentemperatuur
- vochtigheid - Lucht vochtigheid
- druk - Luchtdruk
- gas - Luchtkwaliteit
- windsnelheid_rps - Windsnelheid in rotaties per seconde
De geselecteerde functies op basis van onze doelen zijn: qx
,qx
,qy
,qz
(hoekversnelling), wind_speed_rps
, rps
en voltage
. De volgende afbeelding is een voorbeeld van de functie qx
. De gegevens die door de versnellingsmeter worden geproduceerd, bevatten te veel lawaai, dus we moeten deze eerst opschonen.
De hoeksnelheid (quaternion) wordt eerst omgezet naar Euler Angles (rollen, stampen, gieren). Vervolgens dempen we alle functies met Wavelets (PyWavelets), en normaliseer ze. De volgende schermafbeelding toont de signalen na deze transformaties.
Ten slotte passen we een schuifvenster toe op deze resulterende dataset (zes kenmerken) om de temporele relatie tussen buurmetingen vast te leggen en de invoertensor van ons ML-model te creëren. Het gemiddelde interval tussen twee opeenvolgende monsters is ongeveer 50 milliseconden. Elk tijdvenster (van ons schuifraam) wordt vervolgens omgezet in een tensor, met behulp van de volgende structuur:
- strekspier - 6 features x 10 stappen (100 samples) = 6 × 100
- Stap voor - Groep tijdstappen
- Tijd stap - Groep intervallen (time_step = 20 = ~ 5 seconden)
- interval - Groep monsters (interval = 5 = ~ 250 milliseconden)
- Hervormde tensor - 6x10x10
Interval
, time step
en step
zijn hyperparameters die u tijdens de training kunt aanpassen. Het uiteindelijke resultaat is een gegevensstroom, gecodeerd als een multidimensionale tensor (die een paar seconden in het verleden vertegenwoordigt). De getrainde autoencoder probeert de invoertensor opnieuw te creëren als de uitvoer (voorspelling). Door de MAE tussen de input en output te meten en deze te vergelijken met een vooraf gedefinieerde drempel, kun je mogelijke anomalieën identificeren.
Een belangrijk aspect van deze benadering is dat het de lineaire en niet-lineaire correlaties tussen de kenmerken extraheert, om de effecten van het ene kenmerk op het andere beter te begrijpen, zoals windsnelheid op de rotatie of geproduceerde spanning.
Nu is het tijd om dit experiment uit te voeren.
- Ten eerste, moet je stel uw Studio-omgeving in als je er nog geen hebt.
- Kloon de GitHub-opslagplaats
https://github.com/aws-samples/amazon-sagemaker-edge-manager-demo
in een Studio-terminal.
De repository bevat een map met de naam 03_Notebooks
met twee Jupyter-notitieboekjes.
- Volg de instructies in het eerste notitieboekje om de dataset voor te bereiden. Omdat de acceleratordata een signaal is, bevat het ruis, dus voer je een denoise-mechanisme uit om de data op te schonen.
De uiteindelijke dataset heeft slechts zes kenmerken: rollen, stampen, gieren (omgezet van een viertal naar Euler-hoeken), wind_speed_rps, rps (rotaties per seconde), spanning (geproduceerd door de generator).
- Volg de instructies in het tweede notitieblok om het model te trainen, in te pakken en te implementeren:
- Gebruik SageMaker om uw PyTorch-autoencoder (gebaseerd op CNN) te trainen.
- Voer een batchvoorspelling uit om MAE en drempelwaarde te berekenen die door de app worden gebruikt om te bepalen of de voorspelling een anomalie is of niet.
- Compileer het model naar Jetson Nano met Neo.
- Maak een implementatiepakket met Edge Manager.
- Maak een IoT-taak die een JSON-document publiceert naar een onderwerp waarnaar wordt geluisterd door de toepassing die op uw Jetson Nano wordt uitgevoerd.
De applicatie haalt het pakket op, pakt het uit, laadt het model in de Edge Manager-agent en deblokkeert het uitvoeren van de applicatie.
Beide notebooks zijn erg gedetailleerd, dus volg de stappen zorgvuldig, waarna je een anomaliedetectiemodel hebt om in je Jetson Nano te implementeren.
Compilatietaak en modeloptimalisatie
Een van de belangrijkste stappen van het hele proces is de modeloptimalisatiestap in de tweede notebook. Wanneer u een model compileert met SageMaker Neo, optimaliseert het niet alleen het model om de voorspellingsprestaties in het doelapparaat te verbeteren, maar zet het ook het originele model om in een tussenweergave. Na deze conversie hoef je het originele framework (PyTorch, TensorFlow, MXNet) niet meer te gebruiken. Deze weergave wordt vervolgens geïnterpreteerd door een lichte looptijd (DLR), die wordt meegeleverd met het model van Neo. Zowel de runtime als het geoptimaliseerde model zijn bibliotheken, gecompileerd als native programma's voor een specifiek operationeel systeem en architectuur. In het geval van Jetson Nano is het besturingssysteem een Linux-distro en de architectuur: ARM8 64 bits. De looptijd gebruikt in dit geval TensorRT voor maximale prestaties op de GPU van de Jetson.
Wanneer u een compilatietaak start op Neo, moet u enkele parameters specificeren die verband houden met de installatie van uw doelapparaat, bijvoorbeeld:
- trt-ver - 7.1.3
- cuda-ver - 10.2
- gpu-code - sm_53
De GPU van de Jetson Nano is een NVIDIA Maxwell, architectuurversie 53, dus de parameter gpu-code is hetzelfde voor alle compilatietaken. Trt-ver en cuda-ver zijn echter afhankelijk van de versie van de TensorRT en CUDA die op uw Nano zijn geïnstalleerd. Toen u uw edge-apparaat aan het voorbereiden was, installeerde u uw Jetson Nano met JetPack 4.4.1. Dit zorgt ervoor dat het model dat u optimaliseert met Neo, compatibel is met uw Jetson Nano.
Visualiseer de resultaten
De dashboardconfiguratie valt buiten het bereik van dit bericht. Zie voor meer informatie Analyseer door apparaten gegenereerde gegevens met AWS IoT en Amazon Elasticsearch Service.
Nu je model is geïmplementeerd en draait op je Jetson Nano, is het tijd om via een dashboard naar het gedrag van je windturbines te kijken. De applicatie die u op de Jetson Nano hebt geïmplementeerd, verzamelt enkele logboeken en stuurt deze naar twee verschillende plaatsen:
- Het IoT MQTT-onderwerp
wind-turbine/logs/<<iot_thing_name>>
bevat de app-logs en onbewerkte gegevens die zijn verzameld van de windturbinesensoren - De S3-emmer
s3://<<S3_BUCKET>>/wind_turbine_data
bevat de statistieken van het ML-model
U kunt deze gegevens ophalen en opnemen in Amazon ES of een andere database. Vervolgens kunt u uw favoriete rapportage gebruiken om dashboards voor te bereiden.
De volgende visualisatie toont drie verschillende maar gecorreleerde dingen voor elk van de vijf turbines: de rotatiesnelheid (in RPS), de geproduceerde spanning en de gedetecteerde afwijkingen voor spanning, rotatie en trillingen.
Er werd wat geluid geïnjecteerd in de ruwe data van de turbines om storingen te simuleren.
De volgende visualisatie toont een aggregatie van de snelheid van de turbines en geproduceerde spanningsafwijkingen in de loop van de tijd.
Conclusie
Het is geen gemakkelijke taak om de levenscyclus van een ML-model dat op een groot aantal apparaten wordt geïmplementeerd, veilig en betrouwbaar te handhaven. Met Edge Manager kunt u echter de implementatie-inspanning en operationele kosten van een dergelijke oplossing verminderen. Met een demo zoals het mini-windturbinepark kunt u uw ML-pijplijn ook experimenteren, optimaliseren en automatiseren met de diensten en expertise van AWS.
Om een oplossing voor uw eigen behoeften te bouwen, haalt u de code en artefacten die in dit project worden gebruikt op uit het GitHub repo. Als je meer wilt oefenen met Edge Manager, bekijk dan het end-to-end workshop voor Edge Manager on Studio.
Over de auteur
Samir Araújo is een AI / ML Solutions Architect bij AWS. Hij helpt klanten bij het creëren van AI / ML-oplossingen die hun zakelijke uitdagingen oplossen met behulp van AWS. Hij heeft gewerkt aan verschillende AI / ML-projecten met betrekking tot computervisie, natuurlijke taalverwerking, prognoses, ML aan de rand en meer. Hij speelt graag met hardware- en automatiseringsprojecten in zijn vrije tijd, en hij heeft een bijzondere interesse voor robotica.
- 3d
- versneller
- toegang
- Account
- Accounting
- Actie
- Extra
- Amazone
- Amazon Sage Maker
- onregelmatigheidsdetectie
- api
- gebruiken
- Aanvraag
- APT
- architectuur
- rond
- geautomatiseerde
- Automatisering
- AWS
- Baseline
- BRUG
- bouw
- bedrijfsdeskundigen
- kabels
- Bellen
- camera's
- gevallen
- certificaat
- certificaten
- Cloud
- CNN
- code
- Het verzamelen van
- commercieel
- Bedrijven
- Berekenen
- Computer visie
- computers
- consumptie
- Camper ombouw
- Kosten
- Raad
- Wij creëren
- Geloofsbrieven
- Actueel
- Klanten
- dashboards
- gegevens
- data scientist
- Database
- dag
- levering
- Opsporing
- ontwikkelen
- systemen
- diy
- echo
- rand
- doeltreffendheid
- Elasticsearch
- Elektronica
- Endpoint
- energie-niveau
- Engineering
- Milieu
- uitrusting
- experiment
- exporteren
- export
- extracten
- boerderij
- Kenmerk
- Voordelen
- einde
- Voornaam*
- VLOOT
- volgen
- Achtergrond
- Gratis
- functie
- Git
- GitHub
- Globaal
- GPU
- Groep
- Hardware
- Home
- Hoe
- How To
- HTTPS
- Honderden
- IAM
- identificeren
- Identiteit
- beeld
- Inclusief
- industrieel
- industrieel materiaal
- Industrieel IoT
- -industrie
- informatie
- belang
- Internet
- betrokken zijn
- iot
- IT
- Jobomschrijving:
- Vacatures
- sleutel
- taal
- lancering
- LEARN
- leren
- licht
- Lijn
- linux
- lokaal
- machine learning
- management
- kaart
- Metriek
- miljoen
- ML
- Mobile
- mobiele toestellen
- model
- Grensverkeer
- Meest populair
- nano
- Natuurlijke taal
- Natural Language Processing
- NEO
- Geluid
- laptops
- notificatie
- Nvidia
- werkzaam
- Overige
- Buiten
- prestatie
- Persoonlijke computers
- plastic
- platform
- Plugged
- beleidsmaatregelen
- Populair
- energie
- voorspelling
- Voorspellingen
- druk
- privaat
- geproduceerd
- productie
- Programma's
- project
- projecten
- publiek
- publiceren
- Python
- pytorch
- kwaliteit
- Rauw
- ruwe data
- real-time
- verminderen
- hernieuwbare energie
- hulpbron
- Resources
- Resultaten
- robotica
- robots
- Rollen
- reglement
- lopen
- lopend
- RX
- sagemaker
- Scale
- veiligheid
- gekozen
- sensor
- Diensten
- reeks
- Shadow
- Eenvoudig
- ZES
- Klein
- slim
- So
- Software
- Oplossingen
- OPLOSSEN
- snelheid
- begin
- gestart
- Statement
- mediaopslag
- shop
- sudo
- leveranciers
- ondersteuning
- system
- doelwit
- Technisch
- tijdelijk
- tensorflow
- proef
- niet de tijd of
- onderwerpen
- Trainingen
- turbine
- bijwerken
- URI
- usb
- Snelheid
- visie
- visualisatie
- Wikipedia
- wind
- windenergie
- windenergie
- windmolen
- Mijn werk
- X