Previsione del Guasto del Motore a Reazione con Python e AutoML

Nell'aviazione, "rompere le cose" non è un'opzione.

Se un server si blocca, lo riavvii. Se un motore a reazione si guasta in volo, le conseguenze sono catastrofiche. Ecco perché l'industria aeronautica sta passando dalla Manutenzione Preventiva (sostituzione di parti secondo un programma, che ne abbiano bisogno o meno) alla Manutenzione Predittiva (PdM) (sostituzione di parti esattamente prima che si rompano).

Per i Data Scientist, questo è il problema di regressione di serie temporali per eccellenza. L'obiettivo è calcolare la Vita Utile Residua (RUL) di un motore basandosi sui dati dei sensori (temperatura, pressione, vibrazione).

Tradizionalmente, questo richiedeva modelli fisici complessi o architetture di Deep Learning sintonizzate manualmente (LSTM). Ma di recente, l'Automated Machine Learning (AutoML) è maturato al punto da poter superare la sintonizzazione manuale.

In questa guida, basata sull'analisi utilizzando il dataset NASA C-MAPSS, costruiremo una pipeline per prevedere il guasto del motore utilizzando due pesi massimi open-source: AWS AutoGluon e H2O.ai.

La Pipeline PdM

Non stiamo solo classificando immagini qui; stiamo lavorando con dati di serie temporali multivariate. La pipeline richiede la trasformazione dei log grezzi dei sensori in un target di regressione (RUL).

Fase 1: I Dati (NASA C-MAPSS)

Stiamo utilizzando il famoso dataset NASA Commercial Modular Aero-Propulsion System Simulation (C-MAPSS). Contiene dati simulati di funzionamento fino al guasto.

• Input: 21 Sensori (Temperatura Totale, Pressione all'Ingresso della Ventola, Velocità del Nucleo, ecc.).
• Target: Vita Utile Residua (RUL).

Calcolo della RUL

Il dataset non ci fornisce esplicitamente la RUL; ci fornisce il ciclo corrente. Dobbiamo calcolare il target.

La Logica: RUL = MaxCycleofEngine - CurrentCycle

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: La Metrica (Perché l'Accuratezza è Sbagliata)

Nella manutenzione predittiva, la semplice "Accuratezza" non funziona. Dobbiamo misurare quanto sia distante la nostra previsione.

Ci affidiamo all'RMSE (Root Mean Square Error).

• Se il motore ha 50 giorni rimanenti e prevediamo 45, l'errore è 5.
• Se prevediamo 100, l'errore è 50 (Penalità enorme).

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)

Nota: L'analisi evidenzia anche l'RMSLE (Errore Logaritmico). Questo è cruciale perché sottostimare la vita (prevedere il guasto prima) è sicuro, ma sovrastimare (prevedere il guasto dopo la realtà) è pericoloso. L'RMSLE gestisce meglio gli errori relativi su scale diverse.

Fase 3: Il Confronto AutoML

Abbiamo testato due framework per vedere quale potesse gestire meglio i dati dei sensori complessi e rumorosi senza una sintonizzazione manuale estensiva.

Contendente 1: AutoGluon (Il Vincitore)

AutoGluon (sviluppato da AWS) utilizza una strategia di stacking ed ensembling di più modelli (Neural Nets, LightGBM, CatBoost) automaticamente.

Il Codice:

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

Contendente 2: H2O AutoML

H2O è un veterano nel settore, noto per le sue capacità di calcolo distribuito scalabili.

Il Codice:

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: I Risultati

L'analisi ha rivelato una disparità massiccia nelle prestazioni quando applicata a questo specifico dataset di sensori.

| Library | Metric | Target: RUL | Result (Lower is Better) | |----|----|----|----| | AutoGluon | RMSE | RUL | 14.07 | | H2O | RMSE | RUL | 44.85 |

**Analisi: \ AutoGluon ha superato significativamente H2O (14,07 vs 44,85). Nel contesto dei motori a reazione, un margine di errore di 14 cicli è accettabile per programmare la manutenzione. Un margine di errore di 44 cicli rende il modello inutile.

Perché AutoGluon ha vinto?

1. Stacking: AutoGluon eccelle nello stacking multi-livello, combinando i punti di forza dei modelli basati su alberi e delle reti neurali.
2. Gestione delle Feature: Ha gestito meglio il rumore grezzo dei sensori senza richiedere passaggi manuali di denoising.

Conclusione: Smetti di Sintonizzare, Inizia lo Stacking

Per le applicazioni industriali che coinvolgono dati multivariati complessi, AutoML non è più solo uno strumento di prototipazione—è una capacità di produzione.

Passando dalla selezione manuale del modello a un approccio ensemble automatizzato come AutoGluon, gli sviluppatori possono ridurre il tempo di ingegnerizzazione da settimane a ore, ottenendo al contempo un'accuratezza superiore.

Punto chiave per gli sviluppatori: Quando si costruiscono app IoT industriali, concentra i tuoi sforzi sulla Fase 1 (Data Engineering) pulendo i log dei sensori e calcolando la RUL corretta. Lascia che l'AutoML gestisca la selezione del modello.

\