Vorhersage von Düsentriebwerksausfällen mit Python und AutoML

In der Luftfahrt ist „Dinge kaputt machen" keine Option.

Wenn ein Server abstürzt, wird er neu gestartet. Wenn ein Düsentriebwerk während des Fluges ausfällt, sind die Folgen katastrophal. Aus diesem Grund vollzieht die Luftfahrtindustrie einen Wandel von Preventive Maintenance (planmäßiger Austausch von Teilen, unabhängig davon, ob sie benötigt werden oder nicht) zu Predictive Maintenance (PdM) (Austausch von Teilen genau bevor sie ausfallen).

Für Data Scientists ist dies das ultimative Zeitreihen-Regressionsproblem. Das Ziel ist es, die Remaining Useful Life (RUL) eines Triebwerks basierend auf Sensordaten (Temperatur, Druck, Vibration) zu berechnen.

Traditionell erforderte dies komplexe Physikmodelle oder manuell abgestimmte Deep Learning-Architekturen (LSTMs). In letzter Zeit hat sich jedoch Automated Machine Learning (AutoML) so weit entwickelt, dass es manuelle Abstimmungen übertreffen kann.

In diesem Leitfaden, basierend auf einer Analyse mit dem NASA C-MAPSS-Datensatz, erstellen wir eine Pipeline zur Vorhersage von Triebwerksausfällen unter Verwendung zweier Open-Source-Schwergewichte: AWS AutoGluon und H2O.ai.

Die PdM-Pipeline

Wir klassifizieren hier nicht nur Bilder; wir haben es mit multivariaten Zeitreihendaten zu tun. Die Pipeline erfordert die Transformation von rohen Sensorlogs in ein Regressionsziel (RUL).

Phase 1: Die Daten (NASA C-MAPSS)

Wir verwenden den bekannten NASA Commercial Modular Aero-Propulsion System Simulation (C-MAPSS)-Datensatz. Er enthält simulierte Run-to-Failure-Daten.

• Input: 21 Sensoren (Gesamttemperatur, Druck am Lüftereinlass, Kerndrehzahl usw.).
• Target: Remaining Useful Life (RUL).

Berechnung der RUL

Der Datensatz gibt uns die RUL nicht explizit; er gibt uns den aktuellen Zyklus. Wir müssen das Ziel berechnen.

Die Logik: RUL = MaxZyklusdesTriebwerks - AktuellerZyklus

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: Die Metrik (Warum Genauigkeit falsch ist)

Bei der vorausschauenden Wartung funktioniert einfache „Genauigkeit" nicht. Wir müssen messen, wie weit entfernt unsere Vorhersage ist.

Wir verlassen uns auf RMSE (Root Mean Square Error).

• Wenn das Triebwerk noch 50 Tage hat und wir 45 vorhersagen, beträgt der Fehler 5.
• Wenn wir 100 vorhersagen, beträgt der Fehler 50 (große Strafe).

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)

Hinweis: Die Analyse hebt auch RMSLE (Logarithmic Error) hervor. Dies ist entscheidend, da eine Unterschätzung der Lebensdauer (Vorhersage eines früheren Ausfalls) sicher ist, eine Überschätzung (Vorhersage eines späteren Ausfalls als die Realität) jedoch gefährlich ist. RMSLE behandelt relative Fehler über verschiedene Skalen hinweg besser.

Phase 3: Das AutoML-Duell

Wir haben zwei Frameworks getestet, um zu sehen, welches die komplexen, verrauschten Sensordaten ohne umfangreiche manuelle Abstimmung besser verarbeiten kann.

Kandidat 1: AutoGluon (Der Gewinner)

AutoGluon (entwickelt von AWS) verwendet eine Strategie des Stacking und Ensembling mehrerer Modelle (Neural Nets, LightGBM, CatBoost) automatisch.

Der 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']}")

Kandidat 2: H2O AutoML

H2O ist ein Veteran in diesem Bereich und bekannt für seine skalierbaren verteilten Computing-Fähigkeiten.

Der 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: Die Ergebnisse

Die Analyse ergab eine massive Diskrepanz in der Leistung bei diesem spezifischen Sensordatensatz.

| Bibliothek | Metrik | Ziel: RUL | Ergebnis (niedriger ist besser) | |----|----|----|----| | AutoGluon | RMSE | RUL | 14,07 | | H2O | RMSE | RUL | 44,85 |

**Analyse: \ AutoGluon übertraf H2O deutlich (14,07 vs. 44,85). Im Kontext von Düsentriebwerken ist eine Fehlertoleranz von 14 Zyklen für die Planung der Wartung akzeptabel. Eine Fehlertoleranz von 44 Zyklen macht das Modell unbrauchbar.

Warum hat AutoGluon gewonnen?

1. Stacking: AutoGluon zeichnet sich durch mehrschichtiges Stacking aus und kombiniert die Stärken baumbasierter Modelle und neuronaler Netzwerke.
2. Feature Handling: Es hat das rohe Sensorrauschen besser verarbeitet, ohne manuelle Entrauschungsschritte zu erfordern.

Fazit: Hören Sie auf zu tunen, beginnen Sie mit dem Stacking

Für industrielle Anwendungen mit komplexen multivariaten Daten ist AutoML nicht mehr nur ein Prototyping-Tool – es ist eine Produktionsfähigkeit.

Durch den Wechsel von manueller Modellauswahl zu einem automatisierten Ensemble-Ansatz wie AutoGluon können Entwickler die Engineering-Zeit von Wochen auf Stunden reduzieren und gleichzeitig eine überlegene Genauigkeit erzielen.

Wichtige Erkenntnis für Entwickler: Beim Aufbau von Industrial IoT-Apps konzentrieren Sie Ihre Bemühungen auf Phase 1 (Data Engineering), die Bereinigung der Sensorlogs und die Berechnung der korrekten RUL. Überlassen Sie die Modellauswahl dem AutoML.

\