Jetmotor Falen Voorspellen met Python en AutoML

In de luchtvaart is "dingen kapot maken" geen optie.

Als een server crasht, herstart je hem. Als een straalmotor halverwege de vlucht uitvalt, zijn de gevolgen catastrofaal. Daarom schakelt de luchtvaartsector over van Preventief Onderhoud (onderdelen volgens een schema vervangen, ongeacht of ze het nodig hebben of niet) naar Predictief Onderhoud (PdM) (onderdelen precies vervangen voordat ze kapot gaan).

Voor Data Scientists is dit het ultieme Time Series regressieprobleem. Het doel is om de Resterende Bruikbare Levensduur (RUL) van een motor te berekenen op basis van sensorgegevens (temperatuur, druk, trillingen).

Traditioneel vereiste dit complexe fysica-modellen of handmatig afgestelde Deep Learning architecturen (LSTM's). Maar recentelijk is Automated Machine Learning (AutoML) zodanig volwassen geworden dat het handmatige afstemming kan overtreffen.

In deze handleiding, gebaseerd op analyse met de NASA C-MAPSS dataset, bouwen we een pipeline om motoruitval te voorspellen met behulp van twee open-source zwaargewichten: AWS AutoGluon en H2O.ai.

De PdM Pipeline

We classificeren hier niet alleen afbeeldingen; we werken met multivariate tijdreeksgegevens. De pipeline vereist het transformeren van ruwe sensorlogboeken naar een regressiedoel (RUL).

Fase 1: De Data (NASA C-MAPSS)

We gebruiken de beroemde NASA Commercial Modular Aero-Propulsion System Simulation (C-MAPSS) dataset. Deze bevat gesimuleerde run-to-failure data.

• Input: 21 Sensoren (Totale Temperatuur, Druk bij Ventilatorinlaat, Kernsnelheid, enz.).
• Doel: Resterende Bruikbare Levensduur (RUL).

De RUL Berekenen

De dataset geeft ons niet expliciet de RUL; het geeft ons de huidige cyclus. We moeten het doel berekenen.

De Logica: RUL = MaxCyclusvanMotor - HuidigeCyclus

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

Fase 2: De Metriek (Waarom Nauwkeurigheid Verkeerd is)

Bij predictief onderhoud werkt simpele "Nauwkeurigheid" niet. We moeten meten hoe ver onze voorspelling ernaast zit.

We vertrouwen op RMSE (Root Mean Square Error).

• Als de motor nog 50 dagen heeft, en we voorspellen 45, is de fout 5.
• Als we 100 voorspellen, is de fout 50 (Enorme straf).

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)

Opmerking: De analyse benadrukt ook RMSLE (Logaritmische Fout). Dit is cruciaal omdat het onderschatten van de levensduur (eerder falen voorspellen) veilig is, maar het overschatten (later falen voorspellen dan de werkelijkheid) gevaarlijk is. RMSLE behandelt relatieve fouten beter over verschillende schalen.

Fase 3: De AutoML Confrontatie

We hebben twee frameworks getest om te zien welke de complexe, ruizige sensorgegevens beter kon verwerken zonder uitgebreide handmatige afstemming.

Kandidaat 1: AutoGluon (De Winnaar)

AutoGluon (ontwikkeld door AWS) gebruikt een strategie van stacking en ensembling van meerdere modellen (Neural Nets, LightGBM, CatBoost) automatisch.

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

Kandidaat 2: H2O AutoML

H2O is een veteraan in het veld, bekend om zijn schaalbare gedistribueerde rekencapaciteiten.

De 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()}")

Fase 4: De Resultaten

De analyse onthulde een enorm verschil in prestaties bij toepassing op deze specifieke sensordataset.

| Bibliotheek | Metriek | Doel: RUL | Resultaat (Lager is Beter) | |----|----|----|----| | AutoGluon | RMSE | RUL | 14,07 | | H2O | RMSE | RUL | 44,85 |

**Analyse: \ AutoGluon presteerde significant beter dan H2O (14,07 vs 44,85). In de context van straalmotoren is een foutmarge van 14 cycli acceptabel voor het plannen van onderhoud. Een foutmarge van 44 cycli maakt het model nutteloos.

Waarom won AutoGluon?

1. Stacking: AutoGluon blinkt uit in multi-layer stacking, waarbij de sterke punten van tree-based modellen en neurale netwerken worden gecombineerd.
2. Feature Handling: Het verwerkte de ruwe sensorruis beter zonder handmatige denoising-stappen te vereisen.

Conclusie: Stop met Afstemmen, Begin met Stacking

Voor industriële toepassingen met complexe multivariate gegevens is AutoML niet langer alleen een prototyping-tool—het is een productiecapaciteit.

Door over te schakelen van handmatige modelselectie naar een geautomatiseerde ensemble-aanpak zoals AutoGluon, kunnen ontwikkelaars de engineeringtijd terugbrengen van weken naar uren terwijl ze superieure nauwkeurigheid bereiken.

Belangrijkste Conclusie voor Ontwikkelaars: Focus bij het bouwen van Industrial IoT-apps je inspanning op Fase 1 (Data Engineering) het opschonen van de sensorlogboeken en het berekenen van de juiste RUL. Laat de AutoML de modelselectie afhandelen.

\