Prever falhas em motores a jato com Python e AutoML

Na aviação, "quebrar coisas" não é uma opção.

Se um servidor falha, reinicia-se. Se um motor a jato falha a meio do voo, as consequências são catastróficas. É por isso que a indústria da aviação está a mudar de Manutenção Preventiva (substituir peças num calendário, independentemente de necessitarem ou não) para Manutenção Preditiva (PdM) (substituir peças exatamente antes de avariarem).

Para os Cientistas de Dados, este é o problema de regressão de séries temporais por excelência. O objetivo é calcular a Vida Útil Restante (RUL) de um motor com base em dados de sensores (temperatura, pressão, vibração).

Tradicionalmente, isto exigia modelos físicos complexos ou arquiteturas de Deep Learning ajustadas manualmente (LSTMs). Mas recentemente, Automated Machine Learning (AutoML) amadureceu ao ponto de poder superar o ajuste manual.

Neste guia, baseado na análise usando o conjunto de dados NASA C-MAPSS, vamos construir um pipeline para prever falhas de motor usando dois pesos pesados de código aberto: AWS AutoGluon e H2O.ai.

O Pipeline de PdM

Não estamos apenas a classificar imagens aqui; estamos a lidar com dados de séries temporais multivariadas. O pipeline requer transformar registos brutos de sensores num alvo de regressão (RUL).

Fase 1: Os Dados (NASA C-MAPSS)

Estamos a usar o famoso conjunto de dados NASA Commercial Modular Aero-Propulsion System Simulation (C-MAPSS). Contém dados simulados de execução até falha.

• Input: 21 Sensores (Temperatura Total, Pressão na Entrada do Ventilador, Velocidade do Núcleo, etc.).
• Target: Vida Útil Restante (RUL).

Calcular a RUL

O conjunto de dados não nos dá explicitamente a RUL; dá-nos o ciclo atual. Temos de calcular o alvo.

A Lógica: RUL = CicloMáximodoMotor - CicloAtual

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: A Métrica (Porque é que a Precisão está Errada)

Na manutenção preditiva, a simples "Precisão" não funciona. Precisamos de medir quão longe está a nossa previsão.

Baseamo-nos no RMSE (Root Mean Square Error).

• Se o motor tem 50 dias restantes, e prevemos 45, o erro é 5.
• Se prevemos 100, o erro é 50 (Penalização 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: A análise também destaca o RMSLE (Logarithmic Error). Isto é crucial porque subprever a vida (prever falha mais cedo) é seguro, mas sobreprever (prever falha mais tarde do que a realidade) é perigoso. O RMSLE lida melhor com erros relativos em diferentes escalas.

Fase 3: O Confronto AutoML

Testámos duas frameworks para ver qual conseguia lidar melhor com os dados complexos e ruidosos dos sensores sem ajuste manual extensivo.

Concorrente 1: AutoGluon (O Vencedor)

O AutoGluon (desenvolvido pela AWS) usa uma estratégia de stacking e ensembling de múltiplos modelos (Neural Nets, LightGBM, CatBoost) automaticamente.

O Código:

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

Concorrente 2: H2O AutoML

O H2O é um veterano no espaço, conhecido pelas suas capacidades de computação distribuída escalável.

O Código:

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: Os Resultados

A análise revelou uma disparidade massiva no desempenho quando aplicada a este conjunto de dados de sensores específico.

| Biblioteca | Métrica | Target: RUL | Resultado (Menor é Melhor) | |----|----|----|----| | AutoGluon | RMSE | RUL | 14.07 | | H2O | RMSE | RUL | 44.85 |

**Análise: \ O AutoGluon superou o H2O significativamente (14.07 vs 44.85). No contexto de motores a jato, uma margem de erro de 14 ciclos é aceitável para agendar manutenção. Uma margem de erro de 44 ciclos torna o modelo inútil.

Porque é que o AutoGluon ganhou?

1. Stacking: O AutoGluon destaca-se no stacking multi-camada, combinando os pontos fortes de modelos baseados em árvores e redes neuronais.
2. Gestão de Características: Lidou melhor com o ruído bruto dos sensores sem exigir passos manuais de redução de ruído.

Conclusão: Pare de Ajustar, Comece a Empilhar

Para aplicações industriais envolvendo dados multivariados complexos, o AutoML já não é apenas uma ferramenta de prototipagem—é uma capacidade de produção.

Ao mudar da seleção manual de modelos para uma abordagem automatizada de ensemble como o AutoGluon, os programadores podem reduzir o tempo de engenharia de semanas para horas, alcançando ao mesmo tempo uma precisão superior.

Conclusão Principal para Programadores: Ao construir aplicações Industrial IoT, concentre o seu esforço na Fase 1 (Engenharia de Dados) limpando os registos dos sensores e calculando a RUL correta. Deixe o AutoML tratar da seleção do modelo.

\