Amazon Lookout for Equipment-modellen bouwen, trainen en implementeren met behulp van de Python Toolbox

Voorspellend onderhoud kan een effectieve manier zijn om storingen van industriële machines en dure uitvaltijd te voorkomen door proactief de toestand van uw apparatuur te bewaken, zodat u op eventuele afwijkingen kunt worden gewaarschuwd voordat er storingen optreden. Het installeren van sensoren en de benodigde infrastructuur voor dataconnectiviteit, opslag, analyse en waarschuwingen zijn de fundamentele elementen voor het mogelijk maken van voorspellende onderhoudsoplossingen. Maar zelfs na het installeren van de ad-hocinfrastructuur gebruiken veel bedrijven basisgegevensanalyses en eenvoudige modelleringsbenaderingen die vaak niet effectief zijn in het vroeg genoeg detecteren van problemen om downtime te voorkomen. Ook kan het implementeren van een machine learning (ML)-oplossing voor uw apparatuur moeilijk en tijdrovend zijn.

met Amazon Lookout voor apparatuur, kunt u automatisch sensorgegevens voor uw industriële apparatuur analyseren om abnormaal machinegedrag te detecteren, zonder dat ML-ervaring vereist is. Dit betekent dat u afwijkingen aan apparatuur snel en nauwkeurig kunt detecteren, snel problemen kunt diagnosticeren en actie kunt ondernemen om dure uitvaltijd te verminderen.

Lookout for Equipment analyseert de gegevens van uw sensoren en systemen, zoals druk, stroomsnelheid, RPM's, temperatuur en vermogen, om automatisch een specifiek model voor uw apparatuur te trainen op basis van uw gegevens. Het gebruikt uw unieke ML-model om inkomende sensorgegevens in realtime te analyseren en vroege waarschuwingssignalen te identificeren die tot machinestoringen kunnen leiden. Voor elke gedetecteerde waarschuwing geeft Lookout for Equipment aan welke specifieke sensoren het probleem aangeven en hoe groot de impact op de gedetecteerde gebeurtenis is.

Met een missie om ML in handen te geven van elke ontwikkelaar, willen we nog een add-on voor Lookout for Equipment presenteren: een open source Python-toolbox waarmee ontwikkelaars en datawetenschappers Lookout for Equipment-modellen kunnen bouwen, trainen en implementeren, net zoals u gewend bent Amazon Sage Maker. Deze bibliotheek is een wrapper bovenop de Lookout for Equipment boto3 python API en wordt geleverd om uw reis met deze service een vliegende start te geven. Mocht je verbetersuggesties of bugs te melden hebben, dien dan een probleem in via de toolbox GitHub-repository.

In dit bericht bieden we een stapsgewijze handleiding voor het gebruik van de open-source Python-toolbox van Lookout for Equipment vanuit een SageMaker-notebook.

Omgeving instellen

Om de open-source Lookout for Equipment-toolbox van een SageMaker-notebook te gebruiken, moeten we de SageMaker-notebook de benodigde machtigingen verlenen voor het aanroepen van Lookout for Equipment-API's. Voor dit bericht gaan we ervan uit dat je al een SageMaker-notebookinstantie hebt gemaakt. Raadpleeg voor instructies: Aan de slag met Amazon SageMaker Notebook-instanties. Het notebook-exemplaar wordt automatisch gekoppeld aan een uitvoeringsrol.

1. Om de rol te vinden die aan de instantie is gekoppeld, selecteert u de instantie op de SageMaker-console.
   
2. Scroll op het volgende scherm naar beneden om de . te vinden AWS Identiteits- en toegangsbeheer (IAM)-rol gekoppeld aan de instantie in de Machtigingen en encryptie pagina.
3. Kies de rol om de IAM-console te openen.
   

Vervolgens voegen we een inline-beleid toe aan onze SageMaker IAM-rol.

4. Op de machtigingen tabblad van de rol die je hebt geopend, kies Inline beleid toevoegen.
   
5. Op de JSON tabblad, voer de volgende code in. We gebruiken een wildcard-actie (lookoutequipment:*) voor de service voor demo-doeleinden. Geef voor echt gebruik alleen de vereiste machtigingen op om de juiste SDK API-aanroepen uit te voeren.

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "lookoutequipment:*" ], "Resource": "*" } ] }

6. Kies Controleer het beleid.
7. Geef een naam op voor het beleid en maak het beleid.

Naast het voorgaande inline-beleid moeten we voor dezelfde IAM-rol een vertrouwensrelatie opzetten zodat Lookout for Equipment deze rol kan vervullen. De SageMaker-rol heeft al de juiste gegevenstoegang tot: Amazon eenvoudige opslagservice (Amazon S3); Als Lookout for Equipment deze rol op zich neemt, zorgt u ervoor dat het dezelfde toegang tot de gegevens heeft als uw notebook. In uw omgeving heeft u mogelijk al een specifieke rol om ervoor te zorgen dat Lookout for Equipment toegang heeft tot uw gegevens. In dat geval hoeft u de vertrouwensrelatie van deze algemene rol niet aan te passen.

8. Binnen onze SageMaker IAM-rol op de Vertrouwensrelaties tabblad, kies Vertrouwensrelatie bewerken.
9. Vervang onder het polisblad de hele polis door de volgende code:

    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "lookoutequipment.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }

10. Kies Vertrouwensbeleid bijwerken.

Nu zijn we helemaal klaar om de Lookout for Equipment-toolbox in onze SageMaker-notebookomgeving te gebruiken. De Lookout for Equipment-toolbox is een open-source Python-pakket waarmee datawetenschappers en softwareontwikkelaars eenvoudig tijdreeks-anomaliedetectiemodellen kunnen bouwen en implementeren met behulp van Lookout for Equipment. Laten we eens kijken wat u gemakkelijker kunt bereiken dankzij de toolbox!

afhankelijkheden

Op het moment van schrijven moet de toolbox het volgende geïnstalleerd hebben:

• Python(>=3.6)
• boto3 (>= 1.17.48)
• markdown
• numpy
• panda's
• pyromaan
• s3fs

Nadat u aan deze afhankelijkheden hebt voldaan, kunt u de toolbox Lookout for Equipment installeren en starten met de volgende opdracht vanaf een Jupyter-terminal:

pip install lookoutequipment

De gereedschapskist is nu klaar voor gebruik. In dit bericht laten we zien hoe u de toolbox kunt gebruiken door een anomaliedetectiemodel te trainen en in te zetten. Een typische ML-ontwikkelingslevenscyclus bestaat uit het bouwen van de gegevensset voor training, het trainen van het model, het implementeren van het model en het uitvoeren van gevolgtrekkingen op het model. De toolbox is vrij uitgebreid wat betreft de functionaliteiten die het biedt, maar in dit bericht richten we ons op de volgende mogelijkheden:

• De dataset voorbereiden
• Een anomaliedetectiemodel trainen met Lookout for Equipment
• Visualisaties maken voor uw modelevaluatie
• Configureer en start een inferentieplanner
• Resultaten van planner-inferenties visualiseren

Laten we eens kijken hoe we de toolbox voor elk van deze mogelijkheden kunnen gebruiken.

De dataset voorbereiden

Voor Lookout for Equipment moet een dataset worden gemaakt en verwerkt. Voer de volgende stappen uit om de dataset voor te bereiden:

1. Voordat we de dataset maken, moeten we een voorbeelddataset laden en uploaden naar een Amazon eenvoudige opslagservice (Amazon S3) emmer. In dit bericht gebruiken we de expander dataset:

   from lookoutequipment import dataset data = dataset.load_dataset(dataset_name='expander', target_dir='expander-data')
   dataset.upload_dataset('expander-data', bucket, prefix)

De teruggekeerden data object vertegenwoordigt een woordenboek dat het volgende bevat:

• • Een trainingsgegevens DataFrame
  • Een label DataFrame
  • De start- en einddatum van de training
  • De begin- en einddatum van de evaluatie
  • Een tags beschrijving DataFrame

De trainings- en labelgegevens worden vanuit de doelmap geüpload naar Amazon S3 op de bucket-/prefixlocatie.

2. Na het uploaden van de dataset in S3, maken we een object van: LookoutEquipmentDataset klasse die de dataset beheert:

   lookout_dataset = dataset.LookoutEquipmentDataset( dataset_name='my_dataset', access_role_arn=role_arn, component_root_dir=f's3://{bucket}/{prefix}training-data'
   ) # creates the dataset
   lookout_dataset.create()

De access_role_arn geleverd moet toegang hebben tot de S3-bucket waar de gegevens aanwezig zijn. U kunt de rol ARN van de SageMaker-notebookinstantie ophalen uit de vorige Omgeving instellen sectie en voeg een IAM-beleid toe om toegang te verlenen tot uw S3-bucket. Voor meer informatie, zie IAM-beleid schrijven: toegang verlenen tot een Amazon S3-bucket.

De component_root_dir parameter moet de locatie in Amazon S3 aangeven waar de trainingsgegevens zijn opgeslagen.

Nadat we de voorgaande API's hebben gelanceerd, is onze dataset gemaakt.

3. Neem de gegevens op in de dataset:

   response = lookout_dataset.ingest_data(bucket, prefix + 'training-data/')

Nu uw gegevens beschikbaar zijn op Amazon S3, is het maken van een dataset en het opnemen van de gegevens daarin slechts een kwestie van drie regels code. U hoeft niet handmatig een lang JSON-schema te bouwen; de toolbox detecteert uw bestandsstructuur en bouwt deze voor u op. Nadat uw gegevens zijn verwerkt, is het tijd om te gaan trainen!

Een anomaliedetectiemodel trainen

Nadat de gegevens in de dataset zijn opgenomen, kunnen we het modeltrainingsproces starten. Zie de volgende code:

from lookoutequipment import model lookout_model = model.LookoutEquipmentModel(model_name='my_model', dataset_name='my_dataset') lookout_model.set_time_periods(data['evaluation_start'],data['evaluation_end'],data['training_start'],data['training_end'])
lookout_model.set_label_data(bucket=bucket,prefix=prefix + 'label-data/',access_role_arn=role_arn)
lookout_model.set_target_sampling_rate(sampling_rate='PT5M') #trigger training job
response = lookout_model.train() #poll every 5 minutes to check the status of the training job
lookout_model.poll_model_training(sleep_time=300)

Voordat we de training starten, moeten we de training- en evaluatieperiodes binnen de dataset specificeren. We stellen ook de locatie in Amazon S3 in waar de gelabelde gegevens worden opgeslagen en stellen de bemonsteringsfrequentie in op 5 minuten. Nadat we de training hebben gelanceerd, poll_model_training peilt elke 5 minuten de status van de trainingstaak totdat de training is geslaagd.

Met de trainingsmodule van de Lookout for Equipment-toolbox kunt u een model trainen met minder dan 10 regels code. Het bouwt namens u alle strings voor het maken van creatieverzoeken die nodig zijn voor de low-level API, zodat u geen lange, foutgevoelige JSON-documenten hoeft te bouwen.

Nadat het model is getraind, kunnen we de resultaten tijdens de evaluatieperiode controleren of een inferentieplanner configureren met behulp van de toolbox.

Evalueer een getraind model

Nadat een model is getraind, BeschrijfModel API van Lookout for Equipment legt de statistieken vast die aan de training zijn gekoppeld. Deze API retourneert een JSON-document met twee interessegebieden om de evaluatieresultaten te plotten: labeled_ranges en predicted_ranges, die respectievelijk de bekende en voorspelde anomalieën in het evaluatiebereik bevatten. De toolbox biedt hulpprogramma's om deze in plaats daarvan in een Pandas DataFrame te laden:

from lookoutequipment import evaluation LookoutDiagnostics = evaluation.LookoutEquipmentAnalysis(model_name='my_model', tags_df=data['data']) predicted_ranges = LookoutDiagnostics.get_predictions()
labels_fname = os.path.join('expander-data', 'labels.csv')
labeled_range = LookoutDiagnostics.get_labels(labels_fname)

Het voordeel van het laden van de bereiken in een DataFrame is dat we mooie visualisaties kunnen maken door een van de originele tijdreekssignalen te plotten en een overlay van de gelabelde en voorspelde afwijkende gebeurtenissen toe te voegen met behulp van de TimeSeriesVisualization klasse van de gereedschapskist:

from lookoutequipment import plot TSViz = plot.TimeSeriesVisualization(timeseries_df=data['data'], data_format='tabular')
TSViz.add_signal(['signal-001'])
TSViz.add_labels(labeled_range)
TSViz.add_predictions([predicted_ranges])
TSViz.add_train_test_split(data['evaluation_start'])
TSViz.add_rolling_average(60*24)
TSViz.legend_format = {'loc': 'upper left', 'framealpha': 0.4, 'ncol': 3}
fig, axis = TSViz.plot()

Deze paar regels code genereren een plot met de volgende kenmerken:

• Een lijnplot voor het geselecteerde signaal; het deel dat wordt gebruikt voor het trainen van het model wordt blauw weergegeven terwijl het evaluatiedeel grijs is
• Het voortschrijdend gemiddelde verschijnt als een dunne rode lijn die over de tijdreeks wordt gelegd
• De labels worden weergegeven in een groen lint met het label "Bekende anomalieën" (standaard)
• De voorspelde gebeurtenissen worden weergegeven in een rood lint met het label "Gedetecteerde gebeurtenissen"

De toolbox voert al het zware werk uit van het lokaliseren, laden en parseren van de JSON-bestanden en biedt kant-en-klare visualisaties die de tijd om inzichten te verkrijgen uit uw anomaliedetectiemodellen verder verkorten. In dit stadium kunt u zich met de toolbox concentreren op het interpreteren van de resultaten en het ondernemen van acties om directe zakelijke waarde te leveren aan uw eindgebruikers. Naast deze tijdreeksvisualisaties biedt de SDK andere grafieken, zoals een histogramvergelijking van de waarden van uw signalen tussen normale en abnormale tijden. Voor meer informatie over de andere visualisatiemogelijkheden die u direct uit de doos kunt gebruiken, raadpleegt u de Zoek naar documentatie over gereedschapskisten.

Schema gevolgtrekking

Laten we eens kijken hoe we gevolgtrekkingen kunnen plannen met behulp van de toolbox:

from lookout import scheduler #prepare dummy inference data
dataset.prepare_inference_data( root_dir='expander-data', sample_data_dict=data, bucket=bucket, prefix=prefix
) #setup the scheduler
lookout_scheduler = scheduler.LookoutEquipmentScheduler(scheduler_name='my_scheduler',model_name='my_model')
scheduler_params = { 'input_bucket': bucket, 'input_prefix': prefix + 'inference-data/input/', 'output_bucket': bucket, 'output_prefix': prefix + 'inference-data/output/', 'role_arn': role_arn, 'upload_frequency': 'PT5M', 'delay_offset': None, 'timezone_offset': '+00:00', 'component_delimiter': '_', 'timestamp_format': 'yyyyMMddHHmmss' } lookout_scheduler.set_parameters(**scheduler_params)
response = lookout_scheduler.create()

Deze code maakt een planner die elke 5 minuten één bestand verwerkt (komt overeen met de uploadfrequentie die is ingesteld bij het configureren van de planner). Na ongeveer 15 minuten zouden we enkele resultaten moeten hebben. Om deze resultaten van de planner in een Pandas DataFrame te krijgen, hoeven we alleen de volgende opdracht uit te voeren:

results_df = lookout_scheduler.get_predictions()

Vanaf hier kunnen we ook het belang van een functie voor een voorspelling uitzetten met behulp van de visualisatie-API's van de toolbox:

event_details = pd.DataFrame(results_df.iloc[0, 1:]).reset_index()
fig, ax = plot.plot_event_barh(event_details)

Het produceert de volgende visualisatie van het belang van de functie op de voorbeeldgegevens.

De toolbox biedt ook een API om de planner te stoppen. Zie het volgende codefragment:

scheduler.stop()

Opruimen

Om alle eerder gemaakte artefacten te verwijderen, kunnen we de delete_dataset API met de naam van onze dataset:

dataset.delete_dataset(dataset_name='my_dataset', delete_children=True, verbose=True)

Conclusie

Wanneer we spreken met industriële en productieklanten, is een veelvoorkomende uitdaging die we horen bij het profiteren van AI en ML de enorme hoeveelheid maatwerk en specifiek ontwikkelings- en datawetenschapswerk dat nodig is om betrouwbare en bruikbare resultaten te verkrijgen. Het trainen van anomaliedetectiemodellen en het krijgen van bruikbare waarschuwingen voor veel verschillende industriële machines is een voorwaarde om onderhoudsinspanningen te verminderen, herwerk of afval te verminderen, de productkwaliteit te verhogen en de algehele apparatuurefficiëntie (OEE) of productlijnen te verbeteren. Tot nu toe vergde dit een enorme hoeveelheid specifiek ontwikkelingswerk, dat in de loop van de tijd moeilijk te schalen en te onderhouden is.

Met Amazon Applied AI-services zoals Lookout for Equipment kunnen fabrikanten AI-modellen bouwen zonder toegang te hebben tot een veelzijdig team van datawetenschappers, data-engineers en procesingenieurs. Met de Lookout for Equipment-toolbox kunnen uw ontwikkelaars nu de tijd die nodig is om inzichten in uw tijdreeksgegevens te onderzoeken en actie te ondernemen verder verkorten. Deze toolbox biedt een gebruiksvriendelijke, ontwikkelaarvriendelijke interface om snel anomaliedetectiemodellen te bouwen met Lookout for Equipment. De toolbox is open source en alle SDK-code is te vinden op de amazon-uitkijk-voor-apparatuur-python-sdk GitHub-opslagplaats. Het is ook verkrijgbaar als een PyPi-pakket.

Dit bericht behandelt slechts enkele van de belangrijkste API's. Geïnteresseerde lezers kunnen de toolbox documentatie om te kijken naar meer geavanceerde mogelijkheden van de toolbox. Probeer het eens en laat ons in de reacties weten wat je ervan vindt!

Over de auteurs

Vikesh Pandey is een Machine Learning Specialist Specialist Solutions Architect bij AWS, die klanten in het VK en de bredere EMEA-regio helpt bij het ontwerpen en bouwen van ML-oplossingen. Naast zijn werk houdt Vikesh ervan om verschillende keukens uit te proberen en buitensporten te beoefenen.

Ioán Catana is een Artificial Intelligence en Machine Learning Specialist Solutions Architect bij AWS. Hij helpt klanten bij het ontwikkelen en schalen van hun ML-oplossingen in de AWS Cloud. Ioan heeft meer dan 20 jaar ervaring, voornamelijk in het ontwerpen van software-architectuur en cloud-engineering.

Michael Hoarau is een AI/ML Specialist Solutions Architect bij AWS die, afhankelijk van het moment, afwisselt tussen data scientist en machine learning architect. Hij is gepassioneerd over het brengen van de kracht van AI/ML naar de werkvloer van zijn industriële klanten en heeft gewerkt aan een breed scala aan ML-use cases, variërend van anomaliedetectie tot voorspellende productkwaliteit of productie-optimalisatie. Als hij klanten niet helpt bij het ontwikkelen van de beste machine learning-ervaringen, geniet hij ervan naar de sterren te kijken, te reizen of piano te spelen.

• Coinsmart. Europa's beste Bitcoin- en crypto-uitwisseling.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. GRATIS TOEGANG.
• CryptoHawk. Altcoin-radar. Gratis proefversie.
• Bron: https://aws.amazon.com/blogs/machine-learning/build-train-and-deploy-amazon-lookout-for-equipment-models-using-the-python-toolbox/