Memprediksi Kegagalan Mesin Jet dengan Python dan AutoML

Dalam penerbangan, "merusak sesuatu" bukanlah pilihan.

Jika server crash, Anda me-restart-nya. Jika mesin jet gagal saat terbang, konsekuensinya sangat fatal. Inilah mengapa industri penerbangan beralih dari Preventive Maintenance (mengganti suku cadang sesuai jadwal, terlepas dari apakah diperlukan atau tidak) ke Predictive Maintenance (PdM) (mengganti suku cadang tepat sebelum rusak).

Bagi Data Scientist, ini adalah masalah regresi Time Series yang paling menantang. Tujuannya adalah menghitung Remaining Useful Life (RUL) dari mesin berdasarkan data sensor (suhu, tekanan, getaran).

Secara tradisional, ini memerlukan model fisika yang kompleks atau arsitektur Deep Learning yang disetel manual (LSTM). Namun baru-baru ini, Automated Machine Learning (AutoML) telah matang hingga dapat melampaui penyetelan manual.

Dalam panduan ini, berdasarkan analisis menggunakan dataset NASA C-MAPSS, kami akan membangun pipeline untuk memprediksi kegagalan mesin menggunakan dua raksasa open-source: AWS AutoGluon dan H2O.ai.

Pipeline PdM

Kami tidak hanya mengklasifikasikan gambar di sini; kami berurusan dengan data time-series multivariat. Pipeline memerlukan transformasi log sensor mentah menjadi target regresi (RUL).

Fase 1: Data (NASA C-MAPSS)

Kami menggunakan dataset terkenal NASA Commercial Modular Aero-Propulsion System Simulation (C-MAPSS). Dataset ini berisi data simulasi run-to-failure.

• Input: 21 Sensor (Total Temperature, Pressure at Fan Inlet, Core Speed, dll.).
• Target: Remaining Useful Life (RUL).

Menghitung RUL

Dataset tidak secara eksplisit memberikan RUL kepada kami; ia memberikan siklus saat ini. Kami harus menghitung targetnya.

Logikanya: 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: Metrik (Mengapa Akurasi Salah)

Dalam predictive maintenance, "Akurasi" sederhana tidak berhasil. Kami perlu mengukur seberapa jauh prediksi kami melenceng.

Kami mengandalkan RMSE (Root Mean Square Error).

• Jika mesin memiliki sisa 50 hari, dan kami memprediksi 45, errornya adalah 5.
• Jika kami memprediksi 100, errornya adalah 50 (Penalti besar).

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)

Catatan: Analisis juga menyoroti RMSLE (Logarithmic Error). Ini sangat penting karena memprediksi masa pakai lebih pendek (memprediksi gagal lebih awal) aman, tetapi memprediksi berlebihan (memprediksi gagal lebih lambat dari kenyataan) berbahaya. RMSLE menangani error relatif lebih baik di berbagai skala.

Fase 3: Pertarungan AutoML

Kami menguji dua framework untuk melihat mana yang dapat menangani data sensor yang kompleks dan berisik lebih baik tanpa penyetelan manual yang ekstensif.

Pesaing 1: AutoGluon (Pemenang)

AutoGluon (dikembangkan oleh AWS) menggunakan strategi stacking dan ensembling beberapa model (Neural Nets, LightGBM, CatBoost) secara otomatis.

Kodenya:

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

Pesaing 2: H2O AutoML

H2O adalah veteran dalam bidang ini, dikenal dengan kemampuan distributed computing yang skalabel.

Kodenya:

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: Hasil

Analisis mengungkapkan disparitas besar dalam performa ketika diterapkan pada dataset sensor spesifik ini.

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

**Analisis: \ AutoGluon mengungguli H2O secara signifikan (14.07 vs 44.85). Dalam konteks mesin jet, margin error 14 siklus dapat diterima untuk menjadwalkan pemeliharaan. Margin error 44 siklus membuat model tidak berguna.

Mengapa AutoGluon menang?

1. Stacking: AutoGluon unggul dalam multi-layer stacking, menggabungkan kekuatan model berbasis tree dan neural network.
2. Feature Handling: Ia menangani noise sensor mentah lebih baik tanpa memerlukan langkah denoising manual.

Kesimpulan: Berhenti Tuning, Mulai Stacking

Untuk aplikasi industri yang melibatkan data multivariat yang kompleks, AutoML bukan lagi hanya alat prototyping—ini adalah kemampuan produksi.

Dengan beralih dari pemilihan model manual ke pendekatan ensemble otomatis seperti AutoGluon, developer dapat mengurangi waktu engineering dari berminggu-minggu menjadi berjam-jam sambil mencapai akurasi yang superior.

Poin Penting bagi Developer: Saat membangun aplikasi Industrial IoT, fokuskan upaya Anda pada Fase 1 (Data Engineering) membersihkan log sensor dan menghitung RUL yang benar. Biarkan AutoML menangani pemilihan model.

\