Nell'IoT industriale, l'esecuzione di modelli di machine learning (ML) sui dispositivi edge è necessaria per molti casi d'uso, come la manutenzione predittiva, il miglioramento della qualità, il monitoraggio in tempo reale, l'ottimizzazione dei processi e la sicurezza. L'industria energetica, ad esempio, investe molto in ML per automatizzare l'erogazione di energia, monitorare i consumi, ottimizzare l'efficienza e prolungare la durata delle proprie apparecchiature.
L'energia eolica è una delle fonti di energia rinnovabile più popolari. Secondo il Global Wind Energy Council, Nel 22,893 sono state installate 2019 turbine eoliche a livello globale, prodotte da 33 fornitori e con una capacità di oltre 63 GW di energia eolica. Con tale scala, le aziende energetiche hanno bisogno di una piattaforma efficiente per gestire e mantenere le loro flotte di turbine eoliche e i modelli ML in esecuzione sui dispositivi. Una turbina eolica commerciale costa circa 3-4 milioni di dollari. Se una turbina è fuori servizio, costa $ 800-1,600 al giorno e si traduce in una perdita totale di 7.5 megawatt, che è energia sufficiente per alimentare circa 2,500 case.
Una turbina eolica è un'opera di ingegneria complessa ed è composta da molti sensori che possono essere utilizzati da un meccanismo di monitoraggio per acquisire dati come vibrazioni, temperatura, velocità del vento e umidità dell'aria. Potresti addestrare un modello ML con questi dati, distribuirlo a un dispositivo edge collegato ai sensori della turbina e prevedere anomalie in tempo reale sul bordo. Ridurrebbe i costi operativi della vostra flotta di turbine. Ma immagina lo sforzo per mantenere questa soluzione su una flotta di migliaia o milioni di dispositivi. Come gestite, proteggete, distribuite, eseguite e monitorate i modelli ML su una flotta di dispositivi all'edge?
Gestore perimetrale di Amazon SageMaker può aiutarti a rispondere a questa domanda. Il servizio consente di ottimizzare, proteggere, monitorare e mantenere i modelli ML su flotte di fotocamere intelligenti, robot, personal computer, apparecchiature industriali, dispositivi mobili e altro ancora. Con Edge Manager, puoi gestire il ciclo di vita di ogni modello ML su ogni dispositivo nel tuo parco dispositivi fino a migliaia o milioni di dispositivi. Il servizio fornisce un agente software che viene eseguito sui dispositivi perimetrali e un'interfaccia di gestione sul Console di gestione AWS.
In questo post, mostriamo come utilizzare Edge Manager per creare una solida soluzione end-to-end che gestisce il ciclo di vita dei modelli ML distribuiti su una flotta di turbine eoliche. Ma invece di usare vere turbine eoliche, impari come costruire la tua flotta di mini turbine eoliche stampate in 3D. Questo è un progetto open-hardware open source fai-da-te creato per dimostrare come creare una soluzione ML all'edge con Amazon Sage Maker. Puoi usarlo come piattaforma per imparare, sperimentare e trarre ispirazione.
Le sezioni successive trattano i seguenti argomenti:
- Le specifiche del parco eolico
- Come configurare ogni Jetson Nano
- Come costruire un modello di rilevamento delle anomalie utilizzando SageMaker
- Come gestire il tuo mini parco eolico
Il parco eolico
Il parco di turbine eoliche creato per questo progetto ha cinque mini turbine eoliche stampate in 3D collegate a cinque distinti Jetson Nano tramite USB. I Jetson Nanos sono collegati a Internet tramite cavi Ethernet collegati a un modem via cavo. Un ventilatore, posizionato di fronte alla fattoria, produce il vento per simulare una condizione all'aperto. L'immagine seguente mostra come è organizzato il parco eolico.
La mini turbina eolica
La mini turbina eolica di questo progetto è un dispositivo meccanico integrato con un microcontrollore (Arduino) e alcuni sensori. È stato modellato utilizzando FreeCAD, uno strumento open source per la progettazione di parti industriali. Queste parti sono state quindi stampate in 3D utilizzando PETG (tipo di filamento di plastica) e assemblate con i componenti elettronici. La sua base è statica, il che significa che la turbina non si allinea da sola alla direzione del vento. Questa restrizione era importante per semplificare il progetto.
Ogni turbina ha un generatore di tensione (piccolo motore) e sette diversi sensori:
- Vibrazione (MPU6050: accelerometro/giroscopio a 6 assi)
- Encoder di rotazione a infrarossi (rotazioni al secondo)
- Temperatura del cambio (MPU6050)
- Temperatura ambiente (BME680)
- Pressione atmosferica (BME680)
- Umidità dell'aria (BME680)
- Qualità dell'aria (BME680)
An Arduino MiniPro è responsabile dell'interfacciamento con questi sensori e della raccolta dei dati da essi. Questi dati vengono trasmessi in streaming attraverso i pin seriali (TX, RX). Un Dispositivo FTDI che converte questo segnale seriale in USB è il ponte tra Arduino e Jetson Nano. Un'applicazione Python che gira su Jetson Nano riceve i dati grezzi dai sensori attraverso questo bridge.
Un micro servo è stato modificato e trasformato in un generatore di tensione. Il suo cambio interno aumenta la velocità del generatore (motore) di cinque volte per produrre una tensione (bassa) compresa tra 0 e 3.3 v. Questo generatore è anche collegato ad Arduino tramite un pin di ingresso analogico. Queste informazioni vengono inviate anche con le letture del sensore.
La frequenza di raccolta dei dati dipende dal sensore. Tutti i segnali del BME650 vengono raccolti ogni 150 millisecondi, l'encoder di rotazione ogni 1 secondo e il generatore di tensione e il sensore di vibrazione ogni 50 millisecondi.
Se vuoi saperne di più su questi dettagli tecnici e imparare a costruire la tua mini turbina eolica, consulta il Repository GitHub.
Il dispositivo perimetrale
Ogni jetson nano ha una GPU integrata con NVIDIA Maxwell™ a 128 core e una CPU Quad-core ARM® A57 in esecuzione a 1.43 GHz. Questo hardware è sufficiente per eseguire un'applicazione Python che raccoglie e formatta i dati dai sensori della turbina e quindi chiama il Agente Edge Manager API per ottenere le previsioni. Questa applicazione confronta la previsione con una soglia per verificare la presenza di anomalie nei dati. Il modello viene richiamato in tempo reale.
Quando Sage Maker Neo compila il modello ML per Jetson Nano, un runtime (DLR) ottimizzato per questo dispositivo di destinazione è incluso nel pacchetto di distribuzione. Questo runtime rileva automaticamente che è in esecuzione su una Jetson Nano e carica il modello direttamente nella GPU del dispositivo per ottenere le massime prestazioni.
L'agente Edge Manager viene distribuito anche come applicazione Linux (arm64) che può essere eseguita come processo in background (daemon) su Jetson Nano. Utilizza il runtime SageMaker Neo incluso nel pacchetto di compilazione per interfacciarsi con il modello ottimizzato ed esporlo come API ben definita. Questa API è integrata con l'applicazione locale tramite un protocollo a bassa latenza (grpc + unix socket).
I servizi cloud
Ora che conosci alcuni dettagli sull'hardware fisico utilizzato per sviluppare il parco di turbine eoliche, è il momento di vedere quali servizi AWS supportano la soluzione lato cloud. Una configurazione minima e autonoma per ottenere un modello distribuito ed eseguito sull'agente Edge Manager richiede solo SageMaker e nient'altro. Tuttavia, in questo progetto sono stati utilizzati altri servizi con due caratteristiche importanti: un meccanismo per l'implementazione over-the-air (OTA) e un dashboard per il monitoraggio delle anomalie quasi in tempo reale.
In sintesi, i componenti necessari per questo progetto sono:
- Un parco dispositivi (Edge Manager), che organizza e controlla uno o più dispositivi registrati tramite l'agente (in esecuzione su ciascun dispositivo)
- Uno cosa IoT per dispositivo e Gruppo di cose IoT, che viene utilizzato dal meccanismo OTA per comunicare con i dispositivi tramite MQTT
- AWSIoT regole, e un AWS Lambda funzione per ottenere e filtrare i registri dell'applicazione e acquisirli Servizio Amazon Elasticsearch (Amazon ES)
- Una funzione Lambda per analizzare i parametri del modello acquisiti dall'agente e inserirli in Amazon ES
- Un server Elasticsearch con Kibana, che dispone di dashboard per il monitoraggio delle anomalie (opzionale)
- SageMaker per creare, compilare e impacchettare il modello ML
Il diagramma seguente illustra questa architettura.
Mettere tutto insieme
Ora che abbiamo tutti i componenti del nostro parco di turbine eoliche, è giunto il momento di comprendere i passaggi che dobbiamo intraprendere per integrare tutte queste parti mobili, distribuire un modello sui nostri dispositivi periferici e mantenere un'applicazione in esecuzione e prevedere le anomalie in tempo reale.
Il diagramma seguente mostra tutti i passaggi coinvolti nel processo.
La soluzione consiste nei seguenti passaggi:
- Il data scientist esplora il set di dati e progetta un modello di rilevamento delle anomalie (codificatore automatico) con PyTorch, utilizzando Sage Maker Studio.
- Il modello viene addestrato con un lavoro di formazione SageMaker.
- Con Neo, il modello è ottimizzato (compilato) per Jetson Nano.
- Edge Manager crea un pacchetto di distribuzione con il modello compilato.
- Il data scientist crea un processo IoT che invia una notifica del nuovo modello disponibile ai dispositivi perimetrali.
- L'applicazione in esecuzione su Jetson Nano esegue quanto segue:
- Riceve questa notifica e scarica il pacchetto del modello dal file Servizio di archiviazione semplice Amazon (Amazon S3) secchio.
- Decomprime il modello e lo carica utilizzando l'API dell'agente Edge Manager (LoadModel).
- Legge i sensori dalla turbina eolica, prepara i dati, richiama il modello ML e acquisisce alcune metriche del modello utilizzando l'API dell'agente Edge Manager.
- Confronta la previsione con una linea di base per rilevare potenziali anomalie.
- Invia i dati grezzi del sensore a un argomento AWS IoT.
- Attraverso una regola, AWS IoT legge l'argomento dei log dell'app ed esporta i dati in Amazon ES.
- Una funzione Lambda acquisisce i parametri del modello (errore medio medio) esportati dall'agente e inserisce i dati in Amazon ES.
- L'operatore utilizza una dashboard Kibana per verificare eventuali anomalie.
Configura il tuo dispositivo perimetrale
L'agente Edge Manager utilizza i certificati forniti da AWS IoT Core per autenticare e chiamare altri servizi AWS. In questo modo è necessario creare prima un oggetto IoT e poi un parco dispositivi perimetrali. Ma prima devi preparare alcune risorse di base per supportare la tua soluzione.
Crea risorse prerequisite
Prima di iniziare, è necessario configurare Interfaccia della riga di comando di AWS prima nella tua workstation (se necessario) e poi per creare le seguenti risorse:
- Un bucket S3 per archiviare i dati acquisiti
- An Gestione dell'identità e dell'accesso di AWS (IAM) per i tuoi dispositivi
- Una cosa IoT da mappare al tuo dispositivo Edge Manager
- Un criterio IoT per controllare le autorizzazioni delle credenziali temporanee del dispositivo perimetrale
- Crea un nuovo bucket per la soluzione.
Ogni volta che chiami CaptureData nell'API dell'agente, carica i tensori (input e previsioni) in questo bucket.
Successivamente, crei il tuo ruolo IAM.
- Sulla console IAM, crea un ruolo denominato WindTurbineFarm in modo che i dispositivi possano accedere alle risorse nel tuo account.
- Aggiungi le autorizzazioni a questo ruolo per caricare i file nel bucket S3 che hai creato.
- Aggiungi le seguenti entità attendibili al ruolo:
amazonaws.com
iot.amazonaws.com
amazonaws.com
Utilizza il codice seguente (fornisci il nome per il bucket S3, il tuo account AWS e la regione):
Ora sei pronto per creare la tua cosa IoT, che in seguito mapparai sul tuo dispositivo Edge Manager.
- Sulla console AWS IoT Core, sotto gestirescegli Cose
- Scegli Creare.
- Assegna un nome al tuo dispositivo (per questo post, edge-device-0).
- Crea un nuovo gruppo o scegli un gruppo esistente (per questo post, WindTurbineFarm).
- Crea un certificato.
- Scarica i certificati, inclusa la CA radice.
- Attiva il certificato.
Ora crei la tua policy, che controlla le autorizzazioni delle credenziali temporanee del dispositivo perimetrale.
- Sulla console AWS IoT Core, sotto Sicuroscegli Termini e Condizioni.
- Scegli Creare.
- Assegna un nome alla politica (per questo post, WindTurbine).
- Scegli Modalità avanzata.
- Inserisci la seguente policy, fornendo il tuo account AWS e la regione:
- Scegli Creare.
Infine, alleghi la politica al certificato.
- Sulla console AWS IoT Core, sotto Sicuroscegli Certificati.
- Seleziona il certificato che hai creato.
- Sulla Azioni menù, scegliere Allega policy.
- Seleziona la politica WindTurbine.
- Scegli allegare.
Ora il tuo dispositivo IoT è pronto per essere collegato a un dispositivo perimetrale. Ripetere questi passaggi (tranne per la creazione del criterio) per ogni dispositivo aggiuntivo nel parco dispositivi. Per un ambiente di produzione con centinaia o migliaia di dispositivi, è sufficiente applicare un approccio diverso, utilizzando script automatizzati e file di parametri per eseguire il provisioning di tutte le cose IoT.
Crea la flotta perimetrale
Per creare il tuo parco macchine perimetrale, completa i seguenti passaggi:
- Sulla console SageMaker, sotto Inferenza del bordoscegli Flotte di dispositivi perimetrali.
- Scegli Crea parco dispositivi.
- Inserisci un nome per il dispositivo (per questo post,
WindTurbineFarm
). - Inserisci l'ARN del ruolo IAM utilizzato nei passaggi precedenti (
arn:aws:iam::<<AWS_ACCOUNT_ID>>:role/WindTurbineFarm
). - Immettere l'URI del bucket S3 di output (
s3://<<NAME_OF_YOUR_BUCKET>>/wind_turbine_data/
). - Scegli Invio.
Ora devi aggiungere un nuovo dispositivo alla flotta.
- Sulla console SageMaker, sotto Inferenza del bordoscegli Dispositivi Edge.
- Scegli Registra i dispositivi.
- Nel Proprietà dispositivo, inserisci il nome del parco dispositivi che hai creato (
WindTurbineFarm
). - Scegli Avanti.
- Nel Nome del dispositivo, inserisci un nome univoco per il tuo dispositivo (per questo post, usiamo lo stesso nome della nostra cosa IoT,
edge-device-wind-turbine-00000000000
). - Nel Nome IoT, inserisci il nome della cosa che hai creato in precedenza (
edge-device-0
). - Scegli Invio.
Ripetere la procedura di registrazione per tutti gli altri dispositivi. Ora puoi SSH sul tuo Jetson Nano e completare la configurazione del tuo dispositivo.
Preparare il dispositivo perimetrale
Prima di iniziare a configurare la tua Jetson Nano, devi installarla Jetpack 4.4.1 nel tuo Nano. Questa è la versione che usi per creare, eseguire e testare questa demo.
Il processo di preparazione del modello per il tuo dispositivo di destinazione è molto delicato in relazione alle versioni delle librerie installate nel tuo dispositivo. Ad esempio, poiché il dispositivo di destinazione è un Jetson Nano, Neo ottimizza il modello e il runtime su una determinata versione di TensorRT e CUDA. Il tempo di esecuzione (libdlr.so
) è fisicamente collegato alle versioni specificate nel processo di compilazione. Ciò significa che se si compila il modello utilizzando Neo per JetPack 4.4.1, non funziona con JetPack 3.x. e viceversa.
- Con JetPack 4.4.1 in esecuzione su Jetson Nano, puoi iniziare a configurare il tuo dispositivo con i seguenti comandi:
- Scarica la versione Linux ARMv8 dell'agente Edge Manager.
- Copia il pacchetto sulla tua Jetson Nano (
scp
). Crea una cartella per l'agente e decomprimi il pacchetto nella tua home directory:
- Copia nella directory i certificati AWS IoT Core di cui hai eseguito il provisioning per la tua cosa nella sezione precedente
~/agent/certificates/iot
nella tua Jetson Nano.
Dovresti vedere i seguenti file in questa directory:
- PEM – radice CA
- < >-chiave.pem.pubblica - Chiave pubblica
- < >-chiave.pem.privata – Chiave privata
- < >-certificato.pem.crt – Certificato
- Ottieni il certificato radice usato per firmare il pacchetto di distribuzione creato da Edge Manager. L'agente lo usa per convalidare il modello.
- Copia questo certificato nella directory
~/agent/certificates/root
nella tua Jetson Nano.
Successivamente, crei il file di configurazione dell'agente di Edge Manager.
- Apri un file vuoto chiamato ~/agent/sagemaker_edge_config.json e inserisci il codice seguente:
Fornire le informazioni per le seguenti risorse:
- SAGEMAKER_EDGE_DEVICE_NAME – Il nome univoco del dispositivo che hai definito in precedenza.
- REGIONE_AWS – La regione in cui hai creato il tuo dispositivo perimetrale.
- LINUX_UTENTE – Il nome utente Linux che stai utilizzando in Jetson Nano.
- PREFISSO_CERT – Il prefisso dei file di certificato che hai creato durante il provisioning dell'oggetto IoT nella sezione precedente.
- CREDENZIALI_ENDPOINT_HOST – Il tuo host dell'endpoint. Puoi ottenere questo endpoint tramite Interfaccia della riga di comando di AWS (AWS CLI). (Installa l'AWS CLI se non lo hai già). Usa le credenziali dello stesso account e della stessa regione che hai usato nelle sezioni precedenti (questo non è l'URL shadow dell'IoT). Quindi eseguire il comando seguente per recuperare l'host dell'endpoint:
- S3_BENNA – Il nome del bucket S3 utilizzato per configurare il parco dispositivi perimetrali nella sezione precedente.
- Salva il file con tutte queste modifiche.
Ora sei pronto per eseguire l'agente Edge Manager nella tua Jetson Nano.
- Per testare l'agente, eseguire i seguenti comandi:
Lo screenshot seguente mostra l'output.
L'agente è ora in esecuzione. Dopo qualche minuto è possibile vedere il battito cardiaco del dispositivo, riportato sulla console. Per vederlo sulla console SageMaker, sotto Inferenza del bordoscegli Dispositivi perimetrali e scegli il tuo dispositivo.
Configura l'applicazione
Ora è il momento di configurare l'applicazione che viene eseguita sul dispositivo perimetrale. Questa applicazione è responsabile di quanto segue:
- Ottieni le credenziali temporanee usando il certificato
- Ascolta gli argomenti di aggiornamento OTA per vedere se un nuovo pacchetto di modelli è pronto per la distribuzione
- Distribuire il pacchetto modello disponibile sul dispositivo perimetrale
- Caricare il modello sull'agente, se necessario
- Esegui un ciclo infinito:
- Leggi i dati del sensore
- Formatta i dati di input
- Richiama il modello ML e acquisisci alcune metriche della previsione
- Confronta le previsioni MAE (errore medio medio) con la linea di base
- Pubblica dati grezzi in un argomento IoT (MQTT)
Per installare l'applicazione, procurati prima l'endpoint AWS IoT personalizzato. Nella console AWS IoT Core, scegli Impostazioni profilo. Copia l'endpoint e utilizzalo nel codice seguente:
L'applicazione genera qualcosa come il seguente screenshot.
Opzionale: eseguire questa applicazione con il parametro –test-mode se si desidera semplicemente eseguire un test senza una turbina eolica collegata al dispositivo periferico.
Se tutto è andato bene, l'applicazione continua ad attendere un nuovo modello. È ora di addestrare un nuovo modello e implementarlo su Jetson Nano.
Addestrare e distribuire il modello ML
Questo post mostra come rilevare anomalie nei componenti di una turbina eolica. Ci sono molti modi per farlo con i dati raccolti dai suoi sensori. Per mantenere questo esempio il più semplice possibile, si prepara un modello che analizzi la vibrazione, la velocità del vento, la rotazione (al secondo) e la tensione prodotta per determinare se esiste o meno un'anomalia. A tale scopo, formiamo un codificatore automatico utilizzando PyTorch su SageMaker e preparalo per l'implementazione su Jetson Nano.
Questa architettura del modello ha due vantaggi: non è supervisionata, quindi non è necessario etichettare i nostri dati e puoi raccogliere dati da turbine eoliche che funzionano perfettamente. Pertanto, il tuo modello è addestrato per rilevare ciò che consideri il comportamento normale delle tue turbine eoliche. Quando compare un difetto in una qualsiasi parte della turbina, si verifica una deriva sui dati dei sensori, che il modello interpreta come comportamento anomalo (un'anomalia).
Lo screenshot seguente è un esempio dei dati grezzi acquisiti dai sensori della turbina.
I dati hanno le seguenti caratteristiche:
- nanoID - ID del dispositivo periferico che ha raccolto i dati
- ID turbina - ID della turbina che ha prodotto questi dati
- arduino_timestamp - Timestamp dell'Arduino che azionava questa turbina
- nanoFreemem: Quantità di memoria libera in byte
- orario dell'evento - Timestamp della riga
- rps - Rotazione del rotore in giri al secondo
- voltaggio - Tensione prodotta dal generatore in milivolt
- qw, qx, qy, qz - Accelerazione angolare quaternionica
- gx, gy, gz - Accelerazione di gravità
- ascia, ay, az - Accelerazione lineare
- riduttore temp - Temperatura interna
- temp - Temperatura esterna
- umidità - Umidità dell'aria
- pressione - Pressione dell'aria
- gas - Qualità dell'aria
- velocità_del_vento_rps - Velocità del vento in rotazioni al secondo
Le caratteristiche selezionate in base ai nostri obiettivi sono: qx
,qx
,qy
,qz
(accelerazione angolare), wind_speed_rps
, rps
e voltage
. L'immagine seguente è un esempio della funzionalità qx
. I dati prodotti dall'accelerometro sono troppo rumorosi, quindi dobbiamo prima pulirlo.
La velocità angolare (quaternione) viene prima convertita in Angoli di Eulero (rollio, beccheggio, imbardata). Quindi denoiniamo tutte le funzionalità con Wavelets (PyWavelets), e normalizzarli. Lo screenshot seguente mostra i segnali dopo queste trasformazioni.
Infine, applichiamo una finestra scorrevole a questo set di dati risultante (sei caratteristiche) per catturare la relazione temporale tra le letture vicine e creare il tensore di input del nostro modello ML. L'intervallo medio tra due campioni sequenziali è di circa 50 millisecondi. Ogni finestra temporale (della nostra finestra scorrevole) viene quindi convertita in un tensore, utilizzando la seguente struttura:
- tensore – 6 funzioni x 10 passaggi (100 campioni) = 6×100
- step – Gruppo di fasi temporali
- Passo temporale – Gruppo di intervalli (time_step=20 = ~5 secondi)
- Intervallo – Gruppo di campioni (intervallo=5 = ~250 millisecondi)
- Tensore rimodellato – 6×10×10
Interval
, time step
ed step
sono iperparametri che puoi regolare durante l'allenamento. Il risultato finale è un flusso di dati, codificato come un tensore multidimensionale (che rappresenta alcuni secondi nel passato). L'autoencoder addestrato tenta di ricreare il tensore di input come output (previsione). Misurando il MAE tra ingresso e uscita e confrontandolo con una soglia predefinita, è possibile identificare potenziali anomalie.
Un aspetto importante di questo approccio è che estrae le correlazioni lineari e non lineari tra le caratteristiche, per comprendere meglio gli impatti di una caratteristica sull'altra, come la velocità del vento sulla rotazione o la tensione prodotta.
Ora è il momento di eseguire questo esperimento.
- In primo luogo, è necessario configura il tuo ambiente Studio se non ne hai ancora uno.
- Clona il repository GitHub
https://github.com/aws-samples/amazon-sagemaker-edge-manager-demo
all'interno di un terminale Studio.
Il repository contiene una cartella denominata 03_Notebooks
con due taccuini Jupyter.
- Segui le istruzioni nel primo notebook per preparare il set di dati: poiché i dati dell'acceleratore sono un segnale, contengono rumore, quindi esegui un meccanismo di denoise per pulire i dati.
Il set di dati finale ha solo sei caratteristiche: rollio, beccheggio, imbardata (convertito da a quaternion a Angoli di Eulero), wind_speed_rps, rps (rotazioni al secondo), tensione (prodotta dal generatore).
- Segui le istruzioni nel secondo notebook per addestrare, imballare e distribuire il modello:
- Usa SageMaker per addestrare il tuo autoencoder PyTorch (basato su CNN).
- Eseguire una previsione batch per calcolare MAE e soglia usati dall'app per determinare se la previsione è un'anomalia o meno.
- Compila il modello su Jetson Nano usando Neo.
- Crea un pacchetto di distribuzione con Edge Manager.
- Crea un processo IoT che pubblica un documento JSON su un argomento ascoltato dall'applicazione in esecuzione su Jetson Nano.
L'applicazione ottiene il pacchetto, lo decomprime, carica il modello nell'agente Edge Manager e sblocca l'esecuzione dell'applicazione.
Entrambi i notebook sono molto dettagliati, quindi segui attentamente i passaggi, dopodiché avrai un modello di rilevamento delle anomalie da implementare nel tuo Jetson Nano.
Lavoro di compilazione e ottimizzazione del modello
Uno dei passaggi più importanti dell'intero processo è il passaggio di ottimizzazione del modello nel secondo notebook. Quando si compila un modello con SageMaker Neo, non solo si ottimizza il modello per migliorare le prestazioni di previsione nel dispositivo di destinazione, ma si converte anche il modello originale in una rappresentazione intermedia. Dopo questa conversione, non è più necessario utilizzare il framework originale (PyTorch, TensorFlow, MXNet). Questa rappresentazione viene quindi interpretata da un runtime leggero (DLR), che è confezionato con il modello di Neo. Sia il modello runtime che quello ottimizzato sono librerie, compilate come programmi nativi per un sistema operativo e un'architettura specifici. Nel caso di Jetson Nano, il sistema operativo è una distribuzione Linux e l'architettura: ARM8 64 bit. Il runtime in questo caso utilizza TensorRT per le massime prestazioni sulla GPU di Jetson.
Quando avvii un lavoro di compilazione su Neo, devi specificare alcuni parametri relativi alla configurazione del tuo dispositivo di destinazione, ad esempio:
- trt-ver - 7.1.3
- cuda-ver - 10.2
- codice gpu – sm_53
La GPU di Jetson Nano è una NVIDIA Maxwell, architettura versione 53, quindi il parametro gpu-code è lo stesso per tutti i lavori di compilazione. Tuttavia, trt-ver e cuda-ver dipendono dalla versione di TensorRT e CUDA installata sul tuo Nano. Durante la preparazione del dispositivo perimetrale, hai configurato Jetson Nano con JetPack 4.4.1. Questo assicura che il modello che ottimizzi usando Neo sia compatibile con la tua Jetson Nano.
Visualizza i risultati
La configurazione della dashboard non rientra nell'ambito di questo post. Per ulteriori informazioni, vedere Analizza i dati generati dai dispositivi con AWS IoT e Amazon Elasticsearch Service.
Ora che il tuo modello è distribuito e funzionante sulla tua Jetson Nano, è il momento di esaminare il comportamento delle tue turbine eoliche attraverso un dashboard. L'applicazione che hai distribuito su Jetson Nano raccoglie alcuni registri e li invia a due luoghi diversi:
- L'argomento IoT MQTT
wind-turbine/logs/<<iot_thing_name>>
contiene i log dell'app e i dati grezzi raccolti dai sensori delle turbine eoliche - Il secchio S3
s3://<<S3_BUCKET>>/wind_turbine_data
contiene le metriche del modello ML
Puoi ottenere questi dati e acquisirli in Amazon ES o in un altro database. Quindi puoi utilizzare i tuoi rapporti preferiti per preparare dashboard.
La visualizzazione seguente mostra tre cose diverse ma correlate per ciascuna delle cinque turbine: la velocità di rotazione (in RPS), la tensione prodotta e le anomalie rilevate per tensione, rotazione e vibrazione.
Un po' di rumore è stato iniettato nei dati grezzi dalle turbine per simulare i guasti.
La visualizzazione seguente mostra un'aggregazione della velocità delle turbine e delle anomalie di tensione prodotte nel tempo.
Conclusione
Mantenere in modo sicuro e affidabile il ciclo di vita di un modello ML distribuito su una flotta di dispositivi non è un compito facile. Tuttavia, con Edge Manager, puoi ridurre lo sforzo di implementazione e i costi operativi di tale soluzione. Inoltre, con una demo come il mini parco eolico, puoi sperimentare, ottimizzare e automatizzare la tua pipeline ML con i servizi e le competenze forniti da AWS.
Per creare una soluzione per le tue esigenze, ottieni il codice e gli artefatti utilizzati in questo progetto da Repository GitHub. Se vuoi fare più pratica con Edge Manager, dai un'occhiata a workshop end-to-end per Edge Manager su Studio.
L'autore
Samir Araújo è un AI / ML Solutions Architect presso AWS. Aiuta i clienti a creare soluzioni AI / ML che risolvono le loro sfide aziendali utilizzando AWS. Ha lavorato a diversi progetti AI / ML relativi a visione artificiale, elaborazione del linguaggio naturale, previsioni, ML at the edge e altro ancora. Gli piace giocare con i progetti hardware e di automazione nel tempo libero e ha un interesse particolare per la robotica.
- 3d
- acceleratore
- accesso
- Il mio account
- Contabilità
- Action
- aggiuntivo
- Amazon
- Amazon Sage Maker
- rilevamento anomalie
- api
- App
- Applicazioni
- APT
- architettura
- in giro
- Automatizzata
- Automazione
- AWS
- Linea di base
- BRIDGE
- costruire
- affari
- cavi
- chiamata
- telecamere
- casi
- a livello internazionale
- certificato
- Cloud
- CNN
- codice
- Raccolta
- Aziende
- Calcolare
- Visione computerizzata
- computer
- consumo
- Conversione
- Costi
- Consiglio
- Creazione
- Credenziali
- Corrente
- Clienti
- cruscotto
- dati
- scienziato di dati
- Banca Dati
- giorno
- consegna
- rivelazione
- sviluppare
- dispositivi
- fai da te
- eco
- bordo
- efficienza
- elasticsearch
- Elettronica
- endpoint
- energia
- Ingegneria
- Ambiente
- usate
- esperimento
- export
- le esportazioni
- estratti
- fattoria
- caratteristica
- Caratteristiche
- sottile
- Nome
- FLOTTA
- seguire
- Contesto
- Gratis
- function
- Idiota
- GitHub
- globali
- GPU
- Gruppo
- Hardware
- Casa
- Come
- Tutorial
- HTTPS
- centinaia
- IAM
- identificare
- Identità
- Immagine
- Compreso
- industriale
- equipaggiamento industriale
- IoT industriale
- industria
- informazioni
- interesse
- Internet
- coinvolto
- IoT
- IT
- Lavoro
- Offerte di lavoro
- Le
- Lingua
- lanciare
- IMPARARE
- apprendimento
- leggera
- linea
- linux
- locale
- machine learning
- gestione
- carta geografica
- Metrica
- milione
- ML
- Mobile
- dispositivi mobili
- modello
- monitoraggio
- Più popolare
- nano
- Linguaggio naturale
- Elaborazione del linguaggio naturale
- NEO
- Rumore
- computer portatili
- notifica
- Nvidia
- operativo
- Altro
- All'aperto
- performance
- Computer personale
- plastica
- piattaforma
- Collegato
- politica
- Popolare
- energia
- predizione
- Previsioni
- pressione
- un bagno
- Prodotto
- Produzione
- Programmi
- progetto
- progetti
- la percezione
- pubblicare
- Python
- pytorch
- qualità
- Crudo
- dati grezzi
- tempo reale
- ridurre
- energia rinnovabile
- risorsa
- Risorse
- Risultati
- robotica
- robot
- Rotolo
- norme
- Correre
- running
- RX
- sagemaker
- Scala
- problemi di
- selezionato
- sensore
- Servizi
- set
- Shadow
- Un'espansione
- SIX
- piccole
- smart
- So
- Software
- Soluzioni
- RISOLVERE
- velocità
- inizia a
- iniziato
- dichiarazione
- conservazione
- Tornare al suo account
- sudo
- fornitori
- supporto
- sistema
- Target
- Consulenza
- temporaneo
- tensorflow
- test
- tempo
- Argomenti
- Training
- turbina
- Aggiornanento
- URI
- usb
- Velocità
- visione
- visualizzazione
- wikipedia
- vento
- energia eolica
- energia eolica
- turbina eolica
- Lavora
- X