Predicción de fallos en motores de avión con Python y AutoML

En la aviación, "romper cosas" no es una opción.

Si un servidor falla, lo reinicias. Si un motor a reacción falla a mitad del vuelo, las consecuencias son catastróficas. Por eso la industria de la aviación está cambiando del Mantenimiento Preventivo (reemplazar piezas según un calendario, las necesiten o no) al Mantenimiento Predictivo (PdM) (reemplazar piezas exactamente antes de que se rompan).

Para los científicos de datos, este es el problema de regresión de series temporales definitivo. El objetivo es calcular la Vida Útil Restante (RUL) de un motor basándose en datos de sensores (temperatura, presión, vibración).

Tradicionalmente, esto requería modelos físicos complejos o arquitecturas de Deep Learning ajustadas manualmente (LSTMs). Pero recientemente, el Aprendizaje Automático Automatizado (AutoML) ha madurado hasta el punto de poder superar el ajuste manual.

En esta guía, basada en análisis utilizando el conjunto de datos NASA C-MAPSS, construiremos un pipeline para predecir fallas de motor usando dos pesos pesados de código abierto: AWS AutoGluon y H2O.ai.

El Pipeline de PdM

No estamos simplemente clasificando imágenes aquí; estamos tratando con datos de series temporales multivariadas. El pipeline requiere transformar registros de sensores sin procesar en un objetivo de regresión (RUL).

Fase 1: Los Datos (NASA C-MAPSS)

Estamos utilizando el famoso conjunto de datos NASA Commercial Modular Aero-Propulsion System Simulation (C-MAPSS). Contiene datos simulados de ejecución hasta falla.

• Entrada: 21 Sensores (Temperatura Total, Presión en Entrada del Ventilador, Velocidad del Núcleo, etc.).
• Objetivo: Vida Útil Restante (RUL).

Calculando el RUL

El conjunto de datos no nos da explícitamente el RUL; nos da el ciclo actual. Tenemos que calcular el objetivo.

La Lógica: RUL = CicloMáximodelMotor - CicloActual

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 Métrica (Por Qué la Precisión es Incorrecta)

En el mantenimiento predictivo, la simple "Precisión" no funciona. Necesitamos medir qué tan alejada está nuestra predicción.

Nos basamos en el RMSE (Error Cuadrático Medio de la Raíz).

• Si al motor le quedan 50 días, y predecimos 45, el error es 5.
• Si predecimos 100, el error es 50 (Penalización 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: El análisis también destaca el RMSLE (Error Logarítmico). Esto es crucial porque subpredecir la vida (predecir falla antes) es seguro, pero sobrepredecir (predecir falla más tarde que la realidad) es peligroso. El RMSLE maneja mejor los errores relativos a través de diferentes escalas.

Fase 3: El Enfrentamiento AutoML

Probamos dos frameworks para ver cuál podría manejar mejor los datos de sensores complejos y ruidosos sin ajuste manual extenso.

Contendiente 1: AutoGluon (El Ganador)

AutoGluon (desarrollado por AWS) utiliza una estrategia de apilamiento y ensamblaje de múltiples modelos (Redes Neuronales, LightGBM, CatBoost) automáticamente.

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

Contendiente 2: H2O AutoML

H2O es un veterano en el espacio, conocido por sus capacidades escalables de computación distribuida.

El 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: Los Resultados

El análisis reveló una disparidad masiva en el rendimiento cuando se aplicó a este conjunto de datos de sensores específico.

| Biblioteca | Métrica | Objetivo: RUL | Resultado (Menor es Mejor) | |----|----|----|----| | AutoGluon | RMSE | RUL | 14.07 | | H2O | RMSE | RUL | 44.85 |

**Análisis: \ AutoGluon superó a H2O significativamente (14.07 vs 44.85). En el contexto de motores a reacción, un margen de error de 14 ciclos es aceptable para programar mantenimiento. Un margen de error de 44 ciclos hace que el modelo sea inútil.

¿Por qué ganó AutoGluon?

1. Apilamiento: AutoGluon sobresale en el apilamiento multicapa, combinando las fortalezas de modelos basados en árboles y redes neuronales.
2. Manejo de Características: Manejó mejor el ruido de los sensores sin procesar sin requerir pasos manuales de eliminación de ruido.

Conclusión: Deja de Ajustar, Comienza a Apilar

Para aplicaciones industriales que involucran datos multivariados complejos, AutoML ya no es solo una herramienta de prototipado, es una capacidad de producción.

Al cambiar de la selección manual de modelos a un enfoque automatizado de ensamblaje como AutoGluon, los desarrolladores pueden reducir el tiempo de ingeniería de semanas a horas mientras logran una precisión superior.

Conclusión Clave para Desarrolladores: Al construir aplicaciones de IoT Industrial, concentra tu esfuerzo en la Fase 1 (Ingeniería de Datos) limpiando los registros de sensores y calculando el RUL correcto. Deja que AutoML maneje la selección del modelo.

\