Créez, formez et déployez des modèles Amazon Lookout for Equipment à l'aide de Python Toolbox

La maintenance prédictive peut être un moyen efficace d'éviter les pannes de machines industrielles et les temps d'arrêt coûteux en surveillant de manière proactive l'état de votre équipement, afin que vous puissiez être alerté de toute anomalie avant que les pannes d'équipement ne se produisent. L'installation de capteurs et de l'infrastructure nécessaire pour la connectivité, le stockage, l'analyse et l'alerte des données sont les éléments fondamentaux pour activer les solutions de maintenance prédictive. Cependant, même après avoir installé l'infrastructure ad hoc, de nombreuses entreprises utilisent des analyses de données de base et des approches de modélisation simples qui sont souvent inefficaces pour détecter les problèmes suffisamment tôt pour éviter les temps d'arrêt. De plus, la mise en œuvre d'une solution d'apprentissage automatique (ML) pour votre équipement peut être difficile et prendre du temps.

Avec Amazon Lookout pour l'équipement, vous pouvez analyser automatiquement les données des capteurs de votre équipement industriel afin de détecter un comportement anormal de la machine, sans aucune expérience en ML requise. Cela signifie que vous pouvez détecter les anomalies de l'équipement avec rapidité et précision, diagnostiquer rapidement les problèmes et prendre des mesures pour réduire les temps d'arrêt coûteux.

Lookout for Equipment analyse les données de vos capteurs et systèmes, telles que la pression, le débit, les RPM, la température et la puissance, pour former automatiquement un modèle spécifique à votre équipement en fonction de vos données. Il utilise votre modèle ML unique pour analyser les données de capteur entrantes en temps réel et identifie les signes avant-coureurs qui pourraient entraîner des pannes de la machine. Pour chaque alerte détectée, Lookout for Equipment identifie les capteurs spécifiques qui indiquent le problème et l'ampleur de l'impact sur l'événement détecté.

Avec pour mission de mettre le ML entre les mains de chaque développeur, nous souhaitons présenter un autre module complémentaire à Lookout for Equipment : un boîte à outils Python open source qui permet aux développeurs et aux spécialistes des données de créer, former et déployer des modèles Lookout for Equipment de la même manière que ce à quoi vous êtes habitué Amazon Sage Maker. Cette bibliothèque est un wrapper au-dessus de l'API python Lookout for Equipment boto3 et est fournie pour démarrer votre voyage avec ce service. Si vous avez des suggestions d'amélioration ou des bogues à signaler, veuillez signaler un problème avec la boîte à outils GitHub référentiel.

Dans cet article, nous fournissons un guide étape par étape pour l'utilisation de la boîte à outils Python open source Lookout for Equipment à partir d'un bloc-notes SageMaker.

Configuration de l'environnement

Pour utiliser la boîte à outils open source Lookout for Equipment à partir d'un bloc-notes SageMaker, nous devons accorder au bloc-notes SageMaker les autorisations nécessaires pour appeler les API Lookout for Equipment. Pour cet article, nous supposons que vous avez déjà créé une instance de bloc-notes SageMaker. Pour obtenir des instructions, reportez-vous à Premiers pas avec les instances de bloc-notes Amazon SageMaker. L'instance de bloc-notes est automatiquement associée à un rôle d'exécution.

1. Pour trouver le rôle qui est attaché à l'instance, sélectionnez l'instance sur la console SageMaker.
   
2. Sur l'écran suivant, faites défiler vers le bas pour trouver le Gestion des identités et des accès AWS (IAM) rôle attaché à l'instance dans le Autorisations et cryptage .
3. Choisissez le rôle pour ouvrir la console IAM.
   

Ensuite, nous attachons une stratégie en ligne à notre rôle SageMaker IAM.

4. Sur le Permissions l'onglet du rôle que vous avez ouvert, choisissez Ajouter une stratégie en ligne.
   
5. Sur le JSON onglet, entrez le code suivant. Nous utilisons une action joker (lookoutequipment:*) pour le service à des fins de démonstration. Pour les cas d'utilisation réels, fournissez uniquement les autorisations requises pour exécuter les appels d'API SDK appropriés.

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

6. Selectionnez Politique de révision.
7. Donnez un nom à la stratégie et créez la stratégie.

En plus de la stratégie en ligne précédente, sur le même rôle IAM, nous devons configurer une relation d'approbation pour permettre à Lookout for Equipment d'assumer ce rôle. Le rôle SageMaker dispose déjà de l'accès aux données approprié pour Service de stockage simple Amazon (Amazon S3); autoriser Lookout for Equipment à assumer ce rôle garantit qu'il a le même accès aux données que votre ordinateur portable. Dans votre environnement, vous avez peut-être déjà un rôle spécifique garantissant que Lookout for Equipment a accès à vos données, auquel cas vous n'avez pas besoin d'ajuster la relation d'approbation de ce rôle commun.

8. Dans notre rôle SageMaker IAM sur le Relations de confiance onglet, choisissez Modifier la relation de confiance.
9. Sous le document de stratégie, remplacez l'intégralité de la stratégie par le code suivant :

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

10. Selectionnez Mettre à jour la politique de confiance.

Nous sommes maintenant prêts à utiliser la boîte à outils Lookout for Equipment dans notre environnement de bloc-notes SageMaker. La boîte à outils Lookout for Equipment est un package Python open source qui permet aux scientifiques des données et aux développeurs de logiciels de créer et de déployer facilement des modèles de détection d'anomalies de séries chronologiques à l'aide de Lookout for Equipment. Voyons ce que vous pouvez réaliser plus facilement grâce à la boîte à outils !

Dépendances

Au moment de la rédaction de cet article, la boîte à outils nécessite les éléments suivants installés :

• Python(>= 3.6)
• boto3 (> = 1.17.48)
• démarquage
• numpy
• pandas
• flèche
• s3fs

Après avoir satisfait ces dépendances, vous pouvez installer et lancer la boîte à outils Lookout for Equipment avec la commande suivante à partir d'un terminal Jupyter :

pip install lookoutequipment

La boîte à outils est maintenant prête à être utilisée. Dans cet article, nous montrons comment utiliser la boîte à outils en formant et en déployant un modèle de détection d'anomalies. Un cycle de vie de développement ML typique consiste à créer l'ensemble de données pour la formation, à former le modèle, à déployer le modèle et à effectuer une inférence sur le modèle. La boîte à outils est assez complète en termes de fonctionnalités qu'elle fournit, mais dans cet article, nous nous concentrons sur les capacités suivantes :

• Préparer le jeu de données
• Former un modèle de détection d'anomalies à l'aide de Lookout for Equipment
• Créez des visualisations pour l'évaluation de votre modèle
• Configurer et démarrer un planificateur d'inférence
• Visualiser les résultats des inférences du planificateur

Voyons comment nous pouvons utiliser la boîte à outils pour chacune de ces fonctionnalités.

Préparer le jeu de données

Lookout for Equipment nécessite la création et l'intégration d'un ensemble de données. Pour préparer l'ensemble de données, procédez comme suit :

1. Avant de créer l'ensemble de données, nous devons charger un exemple d'ensemble de données et le télécharger sur un Service de stockage simple Amazon (Amazon S3). Dans cet article, nous utilisons le expander ensemble de données:

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

Le retour data objet représente un dictionnaire contenant les éléments suivants :

• • Un DataFrame de données d'entraînement
  • Une étiquette DataFrame
  • Les dates et heures de début et de fin de la formation
  • Les dates et heures de début et de fin de l'évaluation
  • Une description des balises DataFrame

Les données de formation et d'étiquette sont téléchargées depuis le répertoire cible vers Amazon S3 à l'emplacement du compartiment/préfixe.

2. Après avoir téléchargé l'ensemble de données dans S3, nous créons un objet de LookoutEquipmentDataset classe qui gère le jeu de données :

   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()

La access_role_arn fourni doit avoir accès au compartiment S3 où les données sont présentes. Vous pouvez récupérer l'ARN du rôle de l'instance de bloc-notes SageMaker à partir du précédent Configuration de l'environnement section et ajoutez une stratégie IAM pour accorder l'accès à votre compartiment S3. Pour plus d'informations, voir Écriture de stratégies IAM: comment accorder l'accès à un compartiment Amazon S3.

La component_root_dir Le paramètre doit indiquer l'emplacement dans Amazon S3 où les données de formation sont stockées.

Après avoir lancé les API précédentes, notre jeu de données a été créé.

3. Ingérez les données dans l'ensemble de données :

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

Maintenant que vos données sont disponibles sur Amazon S3, la création d'un ensemble de données et l'ingestion des données qu'il contient ne sont plus qu'une question de trois lignes de code. Vous n'avez pas besoin de créer manuellement un long schéma JSON ; la boîte à outils détecte la structure de votre fichier et la construit pour vous. Une fois vos données ingérées, il est temps de passer à la formation !

Former un modèle de détection d'anomalies

Une fois les données ingérées dans l'ensemble de données, nous pouvons démarrer le processus de formation du modèle. Voir le code suivant :

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)

Avant de lancer la formation, nous devons spécifier les périodes de formation et d'évaluation dans l'ensemble de données. Nous définissons également l'emplacement dans Amazon S3 où les données étiquetées sont stockées et définissons le taux d'échantillonnage sur 5 minutes. Après le lancement de la formation, le poll_model_training interroge l'état de la tâche de formation toutes les 5 minutes jusqu'à ce que la formation soit réussie.

Le module de formation de la boîte à outils Lookout for Equipment vous permet de former un modèle avec moins de 10 lignes de code. Il crée toutes les chaînes de requête de création de longueur nécessaires à l'API de bas niveau en votre nom, vous évitant ainsi de créer de longs documents JSON sujets aux erreurs.

Une fois le modèle formé, nous pouvons soit vérifier les résultats sur la période d'évaluation, soit configurer un planificateur d'inférence à l'aide de la boîte à outils.

Évaluer un modèle formé

Une fois qu'un modèle est formé, le DécrireModèle L'API de Lookout for Equipment enregistre les métriques associées à la formation. Cette API renvoie un document JSON avec deux champs d'intérêt pour tracer les résultats de l'évaluation : labeled_ranges ainsi que predicted_ranges, qui contiennent respectivement les anomalies connues et prévues dans la plage d'évaluation. La boîte à outils fournit des utilitaires pour les charger dans un Pandas DataFrame :

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)

L'avantage de charger les plages dans un DataFrame est que nous pouvons créer de belles visualisations en traçant l'un des signaux de série chronologique d'origine et ajouter une superposition des événements anormaux étiquetés et prédits en utilisant le TimeSeriesVisualization classe de la boîte à outils :

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()

Ces quelques lignes de code génèrent un tracé avec les fonctionnalités suivantes :

• Un graphique linéaire pour le signal sélectionné ; la partie utilisée pour l'apprentissage du modèle apparaît en bleu tandis que la partie d'évaluation est en gris
• La moyenne mobile apparaît sous la forme d'une fine ligne rouge superposée sur la série temporelle
• Les libellés sont affichés dans un ruban vert intitulé « Anomalies connues » (par défaut)
• Les événements prédits sont affichés dans un ruban rouge intitulé "Événements détectés"

La boîte à outils effectue toutes les tâches lourdes de localisation, de chargement et d'analyse des fichiers JSON tout en fournissant des visualisations prêtes à l'emploi qui réduisent encore le temps nécessaire pour obtenir des informations à partir de vos modèles de détection d'anomalies. À ce stade, la boîte à outils vous permet de vous concentrer sur l'interprétation des résultats et de prendre des mesures pour offrir une valeur commerciale directe à vos utilisateurs finaux. En plus de ces visualisations de séries chronologiques, le SDK fournit d'autres graphiques tels qu'une comparaison d'histogramme des valeurs de vos signaux entre les heures normales et anormales. Pour en savoir plus sur les autres fonctionnalités de visualisation que vous pouvez utiliser immédiatement, consultez le Recherchez la documentation de la boîte à outils de l'équipement.

Horaire d'inférence

Voyons comment planifier des inférences à l'aide de la boîte à outils :

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()

Ce code crée un planificateur qui traite un fichier toutes les 5 minutes (correspondant à la fréquence de téléchargement définie lors de la configuration du planificateur). Après environ 15 minutes, nous devrions avoir des résultats disponibles. Pour obtenir ces résultats du scheduler dans un Pandas DataFrame, il suffit de lancer la commande suivante :

results_df = lookout_scheduler.get_predictions()

À partir de là, nous pouvons également tracer l'importance des caractéristiques pour une prédiction à l'aide des API de visualisation de la boîte à outils :

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

Il produit la visualisation suivante de l'importance des caractéristiques sur les exemples de données.

La boîte à outils fournit également une API pour arrêter le planificateur. Voir l'extrait de code suivant :

scheduler.stop()

Nettoyer

Pour supprimer tous les artefacts créés précédemment, nous pouvons appeler le delete_dataset API avec le nom de notre jeu de données :

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

Conclusion

Lorsque nous parlons aux clients industriels et manufacturiers, un défi commun que nous entendons concernant l'utilisation de l'IA et du ML est la quantité de personnalisation et de travail de développement et de science des données spécifiques nécessaires pour obtenir des résultats fiables et exploitables. Former des modèles de détection d'anomalies et obtenir des avertissements exploitables pour de nombreuses machines industrielles différentes est une condition préalable pour réduire les efforts de maintenance, réduire les reprises ou les déchets, augmenter la qualité des produits et améliorer l'efficacité globale des équipements (OEE) ou les gammes de produits. Jusqu'à présent, cela nécessitait un énorme travail de développement spécifique, difficile à mettre à l'échelle et à maintenir dans le temps.

Les services Amazon Applied AI tels que Lookout for Equipment permettent aux fabricants de créer des modèles d'IA sans avoir accès à une équipe polyvalente de data scientists, d'ingénieurs de données et d'ingénieurs de processus. Désormais, grâce à la boîte à outils Lookout for Equipment, vos développeurs peuvent encore réduire le temps nécessaire pour explorer les informations contenues dans vos données de séries chronologiques et prendre des mesures. Cette boîte à outils fournit une interface conviviale et conviviale pour les développeurs permettant de créer rapidement des modèles de détection d'anomalies à l'aide de Lookout for Equipment. La boîte à outils est open source et tout le code du SDK se trouve sur le amazon-lookout-for-equipment-python-sdk Dépôt GitHub. Il est également disponible en tant que Paquet PyPi.

Cet article ne couvre que quelques-unes des API les plus importantes. Les lecteurs intéressés peuvent consulter le documentation de la boîte à outils pour examiner les capacités plus avancées de la boîte à outils. Essayez-le et dites-nous ce que vous en pensez dans les commentaires !

À propos des auteurs

Vikesh Pandey est spécialiste de l'apprentissage automatique et architecte de solutions spécialisées chez AWS, aidant les clients du Royaume-Uni et de la région EMEA à concevoir et à créer des solutions ML. En dehors du travail, Vikesh aime essayer différentes cuisines et pratiquer des sports de plein air.

Ioan Catane est architecte de solutions spécialisées en intelligence artificielle et en apprentissage automatique chez AWS. Il aide les clients à développer et à faire évoluer leurs solutions ML dans le cloud AWS. Ioan a plus de 20 ans d'expérience, principalement dans la conception d'architecture logicielle et l'ingénierie cloud.

Michaël Hoarau est un architecte de solutions spécialiste AI/ML chez AWS qui alterne entre data scientist et architecte machine learning, selon le moment. Il est passionné par l'apport de la puissance de l'IA/ML aux ateliers de ses clients industriels et a travaillé sur un large éventail de cas d'utilisation ML, allant de la détection d'anomalies à la qualité prédictive des produits ou à l'optimisation de la fabrication. Lorsqu'il n'aide pas les clients à développer les prochaines meilleures expériences d'apprentissage automatique, il aime observer les étoiles, voyager ou jouer du piano.

• Coinsmart. Le meilleur échange Bitcoin et Crypto d'Europe.
• Platoblockchain. Intelligence métaverse Web3. Connaissance amplifiée. ACCÈS LIBRE.
• CryptoHawk. Radar Altcoins. Essai gratuit.
• Source : https://aws.amazon.com/blogs/machine-learning/build-train-and-deploy-amazon-lookout-for-equipment-models-using-the-python-toolbox/