Prédire les pannes de moteur d'avion avec Python et AutoML

Dans l'aviation, « casser des choses » n'est pas une option.

Si un serveur plante, vous le redémarrez. Si un moteur d'avion tombe en panne en plein vol, les conséquences sont catastrophiques. C'est pourquoi l'industrie aéronautique passe de la Maintenance Préventive (remplacement de pièces selon un calendrier, qu'elles en aient besoin ou non) à la Maintenance Prédictive (PdM) (remplacement de pièces exactement avant qu'elles ne se cassent).

Pour les Data Scientists, il s'agit du problème ultime de régression de séries temporelles. L'objectif est de calculer la Durée de Vie Utile Restante (RUL) d'un moteur basée sur des données de capteurs (température, pression, vibration).

Traditionnellement, cela nécessitait des modèles physiques complexes ou des architectures de Deep Learning ajustées manuellement (LSTM). Mais récemment, l'Apprentissage Automatique Automatisé (AutoML) a mûri au point de pouvoir surpasser l'ajustement manuel.

Dans ce guide, basé sur une analyse utilisant le jeu de données NASA C-MAPSS, nous allons construire un pipeline pour prédire la défaillance des moteurs en utilisant deux poids lourds open-source : AWS AutoGluon et H2O.ai.

Le Pipeline PdM

Nous ne classifions pas simplement des images ici ; nous traitons des données de séries temporelles multivariées. Le pipeline nécessite de transformer les journaux de capteurs bruts en une cible de régression (RUL).

Phase 1 : Les Données (NASA C-MAPSS)

Nous utilisons le célèbre jeu de données NASA Commercial Modular Aero-Propulsion System Simulation (C-MAPSS). Il contient des données simulées de fonctionnement jusqu'à défaillance.

• Entrée : 21 Capteurs (Température Totale, Pression à l'Entrée du Ventilateur, Vitesse du Cœur, etc.).
• Cible : Durée de Vie Utile Restante (RUL).

Calcul de la RUL

Le jeu de données ne nous donne pas explicitement la RUL ; il nous donne le cycle actuel. Nous devons calculer la cible.

La Logique : RUL = CycleMaximumduMoteur - CycleActuel

import pandas as pd # Load dataset (Simulated example structure) # Columns: ['unit_number', 'time_in_cycles', 'sensor_1', ... 'sensor_21'] df = pd.read_csv('train_FD001.txt', sep=" ", header=None) # 1. Calculate the maximum life of each engine unit max_life = df.groupby('unit_number')['time_in_cycles'].max().reset_index() max_life.columns = ['unit_number', 'max_life'] # 2. Merge back to original dataframe df = df.merge(max_life, on='unit_number', how='left') # 3. Calculate RUL (The Target Variable) df['RUL'] = df['max_life'] - df['time_in_cycles'] # Drop columns we don't need for training (like max_life) df = df.drop(columns=['max_life']) print(df[['unit_number', 'time_in_cycles', 'RUL']].head())

Phase 2 : La Métrique (Pourquoi la Précision est Incorrecte)

En maintenance prédictive, la simple « Précision » ne fonctionne pas. Nous devons mesurer à quel point notre prédiction s'éloigne de la réalité.

Nous nous appuyons sur le RMSE (Erreur Quadratique Moyenne).

• Si le moteur a 50 jours restants, et que nous prédisons 45, l'erreur est de 5.
• Si nous prédisons 100, l'erreur est de 50 (Pénalité énorme).

import numpy as np def calculate_rmse(y_true, y_pred): """ y_true: The actual Remaining Useful Life y_pred: The model's prediction """ mse = np.mean((y_true - y_pred)**2) return np.sqrt(mse)

Remarque : L'analyse met également en évidence le RMSLE (Erreur Logarithmique). C'est crucial car sous-prédire la durée de vie (prédire une défaillance plus tôt) est sûr, mais sur-prédire (prédire une défaillance plus tard que la réalité) est dangereux. Le RMSLE gère mieux les erreurs relatives à différentes échelles.

Phase 3 : L'Affrontement AutoML

Nous avons testé deux frameworks pour voir lequel pouvait mieux gérer les données de capteurs complexes et bruitées sans ajustement manuel extensif.

Concurrent 1 : AutoGluon (Le Gagnant)

AutoGluon (développé par AWS) utilise une stratégie d'empilement et d'assemblage de plusieurs modèles (Réseaux de Neurones, LightGBM, CatBoost) automatiquement.

Le Code :

from autogluon.tabular import TabularPredictor # AutoGluon handles feature engineering automatically # 'RUL' is our target label calculated in Phase 1 predictor = TabularPredictor(label='RUL', eval_metric='root_mean_squared_error').fit( train_data=df_train, time_limit=600, # Train for 10 minutes presets='best_quality' ) # Inference y_pred = predictor.predict(df_test) results = predictor.evaluate(df_test) print(f"AutoGluon RMSE: {results['root_mean_squared_error']}")

Concurrent 2 : H2O AutoML

H2O est un vétéran dans le domaine, connu pour ses capacités de calcul distribué évolutives.

Le Code :

import h2o from h2o.automl import H2OAutoML h2o.init() # Convert pandas df to H2O Frame hf_train = h2o.H2OFrame(df_train) hf_test = h2o.H2OFrame(df_test) # Train aml = H2OAutoML(max_models=20, seed=1) aml.train(y='RUL', training_frame=hf_train) # Inference preds = aml.predict(hf_test) perf = aml.leader.model_performance(hf_test) print(f"H2O RMSE: {perf.rmse()}")

Phase 4 : Les Résultats

L'analyse a révélé une disparité massive de performance lorsqu'elle est appliquée à cet ensemble de données de capteurs spécifique.

| Bibliothèque | Métrique | Cible : RUL | Résultat (Plus bas est mieux) | |----|----|----|----| | AutoGluon | RMSE | RUL | 14.07 | | H2O | RMSE | RUL | 44.85 |

**Analyse : \ AutoGluon a largement surpassé H2O (14.07 vs 44.85). Dans le contexte des moteurs d'avion, une marge d'erreur de 14 cycles est acceptable pour planifier la maintenance. Une marge d'erreur de 44 cycles rend le modèle inutile.

Pourquoi AutoGluon a-t-il gagné ?

1. Empilement : AutoGluon excelle dans l'empilement multi-couches, combinant les forces des modèles basés sur les arbres et des réseaux de neurones.
2. Gestion des Caractéristiques : Il a mieux géré le bruit des capteurs bruts sans nécessiter d'étapes manuelles de débruitage.

Conclusion : Arrêtez l'Ajustement, Commencez l'Empilement

Pour les applications industrielles impliquant des données multivariées complexes, l'AutoML n'est plus seulement un outil de prototypage—c'est une capacité de production.

En passant de la sélection manuelle de modèles à une approche d'ensemble automatisée comme AutoGluon, les développeurs peuvent réduire le temps d'ingénierie de plusieurs semaines à quelques heures tout en obtenant une précision supérieure.

Point Clé pour les Développeurs : Lors de la construction d'applications IoT Industrielles, concentrez vos efforts sur la Phase 1 (Ingénierie des Données) en nettoyant les journaux de capteurs et en calculant la RUL correcte. Laissez l'AutoML gérer la sélection du modèle.

\