Utilizați învățarea automată pentru a detecta anomaliile și pentru a anticipa timpul de nefuncționare cu Amazon Timestream și Amazon Lookout for Equipment

Ultimul deceniu al revoluției Industry 4.0 a arătat valoarea și importanța învățării automate (ML) pe verticală și medii, cu un impact mai mare asupra producției decât orice altă aplicație. Organizațiile care implementează o strategie de tehnologie operațională (OT) mai automatizată, fiabilă și mai rentabilă au deschis calea, recunoscând beneficiile ML în prevederea defecțiunilor liniei de asamblare pentru a evita timpii de nefuncționare costisitoare și neplanificate. Totuși, rămân provocări pentru echipele de toate dimensiunile să demonstreze rapid și cu puțin efort, valoarea detectării anomaliilor bazate pe ML, pentru a-i convinge pe proprietarii de management și finanțare să aloce bugetul necesar pentru implementarea acestor noi tehnologii. Fără acces la oamenii de știință de date pentru instruirea modelelor sau la specialiști în ML pentru a implementa soluții la nivel local, adoptarea a părut inaccesabilă pentru echipele din fabrică.

Acum, echipele care colectează semnale de date ale senzorilor de la mașinile din fabrică pot debloca puterea unor servicii precum Amazon Timestream, Amazon Lookout pentru echipamente, și AWS IoT Core pentru a rula cu ușurință și a testa un sistem complet pregătit pentru producție la marginea locală pentru a ajuta la evitarea evenimentelor catastrofale de întrerupere. Lookout for Equipment folosește modelul dvs. unic ML pentru a analiza datele senzorilor primite în timp real și pentru a identifica cu precizie semnele de avertizare timpurie care ar putea duce la defecțiuni ale mașinii. Aceasta înseamnă că puteți detecta anormalitățile echipamentelor cu viteză și precizie, puteți diagnostica rapid problemele, puteți lua măsuri pentru a reduce timpii de nefuncționare costisitoare și puteți reduce alertele false. Echipele de răspuns pot fi alertate cu puncte specifice despre care senzorii indică problema și amploarea impactului asupra evenimentului detectat.

În această postare, vă arătăm cum puteți configura un sistem pentru a simula evenimentele din fabrica dvs. cu un model antrenat și a detecta un comportament anormal folosind Timestream, Lookout for Equipment și AWS Lambdas funcții. Pașii din această postare subliniază Consola de administrare AWS Interfața de utilizare, care arată modul în care oamenii tehnici fără cunoștințe de dezvoltator sau abilități puternice de codificare pot construi un prototip. Utilizarea semnalelor senzorilor simulate vă va permite să vă testați sistemul și să câștigați încredere înainte de a trece la producție. În cele din urmă, în acest exemplu, folosim Serviciul de notificare simplă Amazon (Amazon SNS) pentru a arăta cum echipele pot primi notificări cu privire la evenimentele prezise și pot răspunde pentru a evita efectele catastrofale ale defecțiunilor liniei de asamblare. În plus, echipele pot folosi Amazon QuickSight pentru analize suplimentare și tablouri de bord pentru raportare.

Prezentare generală a soluțiilor

Pentru a începe, colectăm mai întâi un set de date istorice din citirile senzorului din fabrică, ingeram datele și antrenăm modelul. Cu modelul antrenat, ne-am configurat apoi Simulator de dispozitiv IoT pentru a publica semnale MQTT la un subiect care va permite testarea sistemului pentru a identifica setările de producție dorite înainte ca datele de producție să fie utilizate, menținând costurile scăzute.

Următoarea diagramă ilustrează arhitectura soluției noastre.

Fluxul de lucru conține următorii pași:

1. Utilizați date eșantion pentru a instrui modelul Lookout for Equipment și datele furnizate etichetate pentru a îmbunătăți acuratețea modelului. Cu o frecvență de eșantionare de 5 minute, putem antrena modelul în 20-30 de minute.
2. Rulați un Formarea AWS Cloud șablon pentru a activa Simulatorul IoT și creați o simulare pentru a publica un subiect MQTT în formatul semnalelor de date ale senzorului.
3. Creați o acțiune de regulă IoT pentru a citi subiectul MQTT și a trimite încărcătura utilă a subiectului către Timestream pentru stocare. Acestea sunt seturile de date în timp real care vor fi utilizate pentru deducerea cu modelul ML.
4. Configurați o funcție Lambda declanșată de Amazon EventBridge pentru a converti datele în format CSV pentru Lookout for Equipment.
5. Creați o funcție Lambda pentru a analiza fișierul de ieșire al modelului Lookout for Equipment Serviciul Amazon de stocare simplă (Amazon S3) și, dacă se prevede un eșec, trimiteți un e-mail la adresa configurată. În plus, utilizați AWS Adeziv, Amazon Atenași QuickSight pentru a vizualiza contribuțiile datelor senzorului la evenimentul de defecțiune prezis.

Cerințe preliminare

Aveți nevoie de acces la un cont AWS pentru a configura mediul pentru detectarea anomaliilor.

Simulați datele și ingerați-le în AWS Cloud

Pentru a vă configura datele și asimilarea, parcurgeți următorii pași:

1. Descărcați fișierul de antrenament subsystem-08_multisensor_training.csv și fișierul de etichete labels_data.csv. Salvați fișierele local.
2. Pe consola Amazon S3 din Regiunea preferată, creați o găleată cu un nume unic (de exemplu, l4e-training-data), folosind opțiunile de configurare implicite.
3. Deschide găleata și alege Încărcați, Apoi Adăugați fișiere.
   
4. Încărcați datele de antrenament într-un folder numit /training-data și datele etichetei într-un folder numit /labels.

Apoi, creați modelul ML pentru a fi antrenat cu datele din bucket-ul S3. Pentru a face acest lucru, mai întâi trebuie să creați un proiect.

5. Pe consola Lookout for Equipment, alegeți Creați un proiect.
   
6. Denumiți proiectul și alegeți Creați un proiect.
7. Pe Adăugați un set de date pagina, specificați locația compartimentului dvs. S3.
8. Utilizați setările implicite pentru Creați un nou rol și Activați CloudWatch Logs.
9. Alege După numele fișierului pentru Metoda de detectare a schemei.
10. Alege Începeți ingerarea.

Ingestia durează câteva minute.

11. Când asimilarea este completă, puteți examina detaliile setului de date alegând Vizualizați setul de date.
12. Derulați în jos pe pagină și examinați Detalii prin senzor secţiune.
13. Derulați în partea de jos a paginii pentru a vedea că gradul senzorului pentru datele de la trei dintre senzori este etichetat Low.
14. Selectați toate înregistrările senzorului, cu excepția celor trei cu grad scăzut.
15. Alege Creați model.
    
16. Pe Specificați detaliile modelului pagina, dați un nume modelului și alegeți Pagina Următoare →.
17. Pe Configurați datele de intrare pagina, introduceți valori pentru setările de instruire și evaluare și o frecvență de eșantionare (pentru această postare, 1 minut).
18. Sari peste Detectarea timpului de oprire setări și alegeți Pagina Următoare →.
    
19. Pe Furnizați etichete de date pagina, specificați locația folderului S3 unde se află datele etichetei.
20. Selectați Creați un nou rol.
21. Alege Pagina Următoare →.
    
22. Pe Revizuiește și antrenează-te pagina, alege Începeți antrenamentul.

Cu o frecvență de eșantionare de 5 minute, modelul ar trebui să dureze 20-30 de minute pentru a construi.

În timp ce modelul se construiește, putem configura restul arhitecturii.

Simulați datele senzorului

1. Alege Lansați Stack pentru a lansa un șablon CloudFormation pentru a configura semnalele senzorilor simulate folosind Simulator IoT.
2. După ce șablonul a fost lansat, navigați la consola CloudFormation.
3. Pe Stive pagina, alege IoTDeviceSimulator pentru a vedea detaliile stivei.
4. Pe ieşiri filă, găsiți fișierul ConsoleURL cheie și valoarea URL corespunzătoare.
   
5. Alegeți adresa URL pentru a deschide pagina de conectare a IoT Device Simulator.
6. Creați un nume de utilizator și o parolă și alegeți CONECTARE.
7. Salvați-vă acreditările în cazul în care trebuie să vă conectați din nou mai târziu.
   
8. Din bara de meniu IoT Device Simulator, alegeți Tipuri de dispozitive.
9. Introduceți un nume de tip de dispozitiv, cum ar fi My_testing_device.
10. Introduceți un subiect MQTT, cum ar fi factory/line/station/simulated_testing.
11. Alege Adăugați un atribut.
    
12. Introduceți valorile pentru atribut signal5, așa cum se arată în următoarea captură de ecran.
13. Alege Economisiți.
    
14. Alege Adăugați un atribut din nou și adăugați atributele rămase pentru a se potrivi cu datele semnalului eșantion, așa cum se arată în tabelul următor.

15. Pe Simulările fila, alegeți Adăugați simulare.
16. Dați un nume simulării.
17. Specifica Tipul de simulare as Utilizator creat, Tip dispozitiv ca dispozitiv creat recent, Interval de transmisie a datelor ca 60, și Durata transmiterii datelor ca 3600.
18. În cele din urmă, începeți simularea pe care tocmai ați creat-o și vedeți sarcinile utile generate pe Detalii de simulare pagina prin alegere Vizualizare.

Acum că semnalele sunt generate, putem configura IoT Core pentru a citi subiectele MQTT și a direcționa încărcăturile utile către baza de date Timestream.

19. Pe consola IoT Core, sub Dirijarea mesajelor în panoul de navigare, alegeți Reguli.
20. Alege Creați o regulă.
21. Introduceți un nume de regulă și alegeți Pagina Următoare →.
22. Introduceți următoarea instrucțiune SQL pentru a extrage toate valorile din subiectul MQTT publicat:

SELECT signal5, signal6, signal7, signal8, signal48, signal49, signal78, signal109, signal120, signal121 FROM 'factory/line/station/simulated_testing'

23. Alege Pagina Următoare →.
24. Pentru Reguli acțiuni, căutați tabelul Timestream.
25. Alege Creați o bază de date Timestream.

Se deschide o filă nouă cu consola Timestream.

26. Selectați Baza de date standard.
27. Denumiți baza de date sampleDB Și alegeți Creați o bază de date.

Sunteți redirecționat către consola Timestream, unde puteți vizualiza baza de date pe care ați creat-o.

28. Reveniți la fila IoT Core și alegeți sampleDB pentru Numele bazei de date.
29. Alege Creați tabel Timestream pentru a adăuga un tabel la baza de date unde vor fi stocate semnalele de date ale senzorului.
30. Pe consola Timestream Creați tabel fila, alegeți sampleDB pentru Numele bazei de date, introduce signalTable pentru Numele tabeluluiși alegeți Creați tabel.
31. Reveniți la fila consolei IoT Core pentru a finaliza regula de rutare a mesajelor IoT.
32. Intrați Simulated_signal pentru Numele dimensiunilor și 1 pentru Valoarea dimensiunilor, Apoi alegeți Creați un nou rol.

33. Denumiți rolul TimestreamRole Și alegeți Pagina Următoare →.
34. Pe Examinați și creați pagina, alege Crea.

Ați adăugat acum o acțiune de regulă în IoT Core care direcționează datele publicate către subiectul MQTT către o bază de date Timestream.

Interogare Timestream pentru analiză

Pentru a interoga Timestream pentru analiză, parcurgeți următorii pași:

1. Validați că datele sunt stocate în baza de date navigând la consola Timestream și alegând Editorul interogărilor.
2. Alege Selectați tabelul, apoi alegeți meniul de opțiuni și Previzualizează datele.
3. Alege Alerga pentru a interoga tabelul.

Acum că datele sunt stocate în flux, puteți utiliza Lambda și EventBridge pentru a extrage date din tabel la fiecare 5 minute, pentru a le formata și a le trimite la Lookout for Equipment pentru rezultate de inferență și predicție.

4. În consola Lambda, alegeți Funcție Creare.
5. Pentru Runtime, alege Python 3.9.
6. Pentru Sursa stratului, Selectați Specificați un ARN.
7. Introduceți ARN-ul corect pentru regiunea dvs. din resursă aws panda.
8. Alege Adăuga.

9. Introduceți următorul cod în funcție și editați-l pentru a potrivi calea S3 cu o găleată cu folderul /input (creați un folder pentru aceste fișiere de flux de date dacă nu sunt deja prezente).

Acest cod folosește awswrangler bibliotecă pentru a formata cu ușurință datele în formularul CSV necesar necesar pentru Lookout for Equipment. Funcția Lambda denumește, de asemenea, în mod dinamic fișierele de date, după cum este necesar.

import json
import boto3
import awswrangler as wr
from datetime import datetime
import pytz

def lambda_handler(event, context):
    # TODO implement
    UTC = pytz.utc
    my_date = datetime.now(UTC).strftime('%Y-%m-%d-%H-%M-%S')
    print(my_date)
      
    df = wr.timestream.query('SELECT time as Timestamp, max(case when measure_name = 'signal5' then measure_value::double/1000 end) as "signal-005", max(case when measure_name = 'signal6' then measure_value::double/1000 end) as "signal-006", max(case when measure_name = 'signal7' then measure_value::double/1000 end) as "signal-007", max(case when measure_name = 'signal8' then measure_value::double/1000 end) as "signal-008", max(case when measure_name = 'signal48' then measure_value::double/1000 end) as "signal-048", max(case when measure_name = 'signal49' then measure_value::double/1000 end) as "signal-049", max(case when measure_name = 'signal78' then measure_value::double/1000 end) as "signal-078", max(case when measure_name = 'signal109' then measure_value::double/1000 end) as "signal-109", max(case when measure_name = 'signal120' then measure_value::double/1000 end) as "signal-120", max(case when measure_name = 'signal121' then measure_value::double/1000 end) as "signal-121" 
    FROM ""."" WHERE time > ago(5m) group by time order by time desc')
    print(df)
    
    s3path ="s3:///input/_%s.csv" % my_date
    
    wr.s3.to_csv(df, s3path, index=False)
    
    return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')
    }

10. Alege Lansa.
11. Pe Configuraţie fila, alegeți Configurație generală.
12. Pentru Pauză, alege 5 minute.
13. În Prezentare generală a funcției secțiune, pentru a alege Adăugați declanșatorul cu EventBridge ca sursă.
14. Selectați Creați o nouă regulă.
15. Denumiți regula eventbridge-cron-job-lambda-read-timestream și adăugați rate(5 minutes) pentru Exprimarea programului.
16. Alege Adăuga.
    
17. Adăugați următoarea politică la rolul dvs. de execuție Lambda:

    {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Action": "s3:PutObject",
                "Resource": "arn:aws:s3:::/*"
            },
            {
                "Effect": "Allow",
                "Action": [
                    "timestream:DescribeEndpoints",
                    "timestream:ListTables",
                    "timestream:Select"
                ],
                "Resource": "*"
            }
        ]
    }

Prevede anomaliile și anunță utilizatorii

Pentru a configura predicția și notificarea anomaliilor, parcurgeți următorii pași:

1. Reveniți la pagina de proiect Lookout for Equipment și alegeți Programează inferența.
2. Denumiți programul și specificați modelul creat anterior.
3. Pentru Date de intrare, specificați S3 /input locația în care fișierele sunt scrise folosind funcția Lambda și declanșatorul EventBridge.
4. set Frecvența de încărcare a datelor la 5 minute si pleaca Timp de întârziere compensat at 0 minute.
5. Setați o cale S3 cu /output ca folder și lăsați alte valori implicite.
6. Alege Programează inferența.

După 5 minute, verificați S3 /output calea pentru a verifica fișierele de predicție sunt create. Pentru mai multe informații despre rezultate, consultați Revizuirea rezultatelor inferenței.

În cele din urmă, creați o a doua funcție Lambda care declanșează o notificare folosind Amazon SNS atunci când este prezisă o anomalie.

7. În consola Amazon SNS, alegeți Creați subiect.
8. Pentru Nume si Prenume, introduce emailnoti.
9. Alege Crea.
10. În Detalii secțiune, pt Tip, Selectați Standard.
11. Alege Creați subiect.
    
12. Pe Abonamentele fila, creați un abonament cu Tipul de e-mail as Protocol și o adresă de e-mail a punctului final pe care o puteți accesa.
13. Alege Creați abonament și confirmați abonamentul când sosește e-mailul.
14. Pe Subiect fila, copiați ARN-ul.
    
15. Creați o altă funcție Lambda cu următorul cod și introduceți subiectul ARN în MY_SYS_ARN:

    import boto3
    import sys
    import logging
    import os
    import datetime
    import csv
    import json
    
    MY_SNS_TOPIC_ARN = 'MY_SNS_ARN'
    client = boto3.client('s3')
    logger = logging.getLogger()
    logger.setLevel(logging.DEBUG)
    sns_client = boto3.client('sns')
    lambda_tmp_dir = '/tmp'
    
    def lambda_handler(event, context):
        
        for r in event['Records']:
            s3 = r['s3']
            bucket = s3['bucket']['name']
            key = s3['object']['key']
        source = download_json(bucket, key)
        with open(source, 'r') as content_file:
            content = json.load(content_file)
            if content['prediction'] == 1 :
                Messages = 'Time: ' + str(content['timestamp']) + 'n' + 'Equipment is predicted failure.' + 'n' + 'Diagnostics: '
                # Send message to SNS
                for diag in content['diagnostics']:
                    Messages = Messages + str(diag) + 'n'
        
                sns_client.publish(
                    TopicArn = MY_SNS_TOPIC_ARN,
                    Subject = 'Equipment failure prediction',
                    Message = Messages
                )
    
    def download_json(bucket, key):
        local_source_json = lambda_tmp_dir + "/" + key.split('/')[-1]
        directory = os.path.dirname(local_source_json)
        if not os.path.exists(directory):
            os.makedirs(directory)
        client.download_file(bucket, key.replace("%3A", ":"), local_source_json)
        return local_source_json

16. Alege Lansa pentru a implementa funcția.

Când Lookout for Equipment detectează o anomalie, valoarea de predicție este 1 în rezultate. Codul Lambda folosește fișierul JSONL și trimite o notificare prin e-mail la adresa configurată.

17. În Configuraţie, alege Permisiuni și Nume rol.
18. Alege Atașați politicile și adăugați AmazonS3FullAccess și AmazonSNSFullAccess la rol.
19. În cele din urmă, adăugați un declanșator S3 la funcție și specificați /output găleată.

După câteva minute, veți începe să vedeți că e-mailurile ajung la fiecare 5 minute.

Vizualizați rezultatele inferenței

După ce Amazon S3 stochează rezultatele predicției, putem folosi Catalogul de date AWS Glue cu Athena și QuickSight pentru a crea tablouri de bord de raportare.

1. Pe consola AWS Glue, alegeți crawlere în panoul de navigare.
2. Alege Creați un crawler.
3. Dați un nume crawler-ului, cum ar fi inference_crawler.
4. Alege Adăugați o sursă de date și selectați calea găleții S3 cu results.jsonl fișiere.
5. Selectați Accesați cu crawlere toate subfolderele.
6. Alege Adăugați o sursă de date S3.
7. Alege Creați un nou rol IAM.
8. Creați o bază de date și furnizați un nume (de exemplu, anycompanyinferenceresult).
9. Pentru Programul crawlerului, alege La cerere.
10. Alege Pagina Următoare →, Apoi alegeți Creați un crawler.
11. Când crawler-ul este complet, alegeți Rulați crawlerul.

12. Pe consola Athena, deschideți editorul de interogări.
13. Alege Editeaza setarile pentru a configura o locație a rezultatului interogării în Amazon S3.
14. Dacă nu aveți un bucket creat, creați unul acum prin consola Amazon S3.
15. Reveniți la consola Athena, alegeți găleata și alegeți Economisiți.
16. Reveniți la Editor din editorul de interogări și rulați o interogare către select * de la /output folderul S3.
17. Examinați rezultatele care arată detectarea anomaliilor așa cum era de așteptat.

18. Pentru a vizualiza rezultatele predicției, navigați la consola QuickSight.
19. Alege Noua analiză și Set de date nou.
20. Pentru Sursa setului de date, alege Athena.
21. Pentru Numele sursei de date, introduce MyDataset.
22. Alege Creați sursa de date.
23. Alegeți tabelul pe care l-ați creat, apoi alegeți Utilizați SQL personalizat.
    
24. Introduceți următoarea interogare:

    with dataset AS 
        (SELECT timestamp,prediction, names
        FROM "anycompanyinferenceresult"."output"
        CROSS JOIN UNNEST(diagnostics) AS t(names))
    SELECT  SPLIT_PART(timestamp,'.',1) AS timestamp, prediction,
        SPLIT_PART(names.name,'',1) AS subsystem,
        SPLIT_PART(names.name,'',2) AS sensor,
        names.value AS ScoreValue
    FROM dataset

25. Confirmați interogarea și alegeți imagina.
26. Alege Masă rotativă.
27. Specifica timestamp-ul și senzor pentru Rânduri.
28. Specifica prezicere și ScoreValue pentru Valori.
    
29. Alege Adăugați vizual pentru a adăuga un obiect vizual.
30. Alege Diagramă cu bare verticale.
31. Specifica Marcaj de timp pentru Axa X, ScoreValue pentru Valoare, și Senzor pentru Grup/Culoare.
32. Schimba ScoreValue la Agregat: mediu.
    

A curăța

Ne ștergerea resurselor poate duce la taxe suplimentare. Pentru a vă curăța resursele, parcurgeți următorii pași:

1. Pe consola QuickSight, alegeți Recent în panoul de navigare.
2. Ștergeți toate resursele pe care le-ați creat ca parte a acestei postări.
3. Navigați către Datasets pagina și ștergeți seturile de date pe care le-ați creat.
4. În consola Lookout for Equipment, ștergeți proiectele, seturile de date, modelele și programele de inferență utilizate în această postare.
5. Pe consola Timestream, ștergeți baza de date și tabelele asociate.
6. Pe consola Lambda, ștergeți declanșatoarele EventBridge și Amazon S3.
7. Ștergeți compartimentele S3, regula IoT Core și simulările și dispozitivele IoT.

Concluzie

În această postare, ați învățat cum să implementați învățarea automată pentru întreținerea predictivă folosind date de streaming în timp real cu o abordare low-code. Ați învățat diferite instrumente care vă pot ajuta în acest proces, folosind servicii AWS gestionate precum Timestream, Lookout for Equipment și Lambda, astfel încât echipele operaționale să vadă valoarea fără a adăuga încărcături de lucru suplimentare pentru cheltuieli generale. Deoarece arhitectura folosește tehnologie fără server, se poate scala în sus și în jos pentru a vă satisface nevoile.

Pentru mai multe resurse de învățare bazate pe date, vizitați Pagina de pornire AWS Blog.

Despre autor

Matt Reed este arhitect senior de soluții în domeniul auto și producție la AWS. Este pasionat să-i ajute pe clienți să rezolve problemele cu tehnologia cool pentru a face viața tuturor mai bună. Lui Matt îi place să meargă cu bicicleta montană, să schieze și să iasă cu prietenii, familia, câinii și pisicile.