Aircraft Engine Remaining Useful Life

This experiment compared recurrent and temporal-convolutional neural networks for aircraft-engine remaining useful life (RUL); on the thesis test split, TCN produced the lowest regression error (RMSE 11.14 cycles), while GRU was marginally strongest on failure-window classification.

Research question

Which of four neural-network architectures—vanilla RNN, LSTM, GRU, or TCN—best predicts the remaining useful life of a turbofan engine, both across the full RUL range and in the safety-critical window of 30 cycles or fewer?

Approach

The experiments use all four subsets of NASA's simulated C-MAPSS turbofan degradation dataset (FD001–FD004). Preprocessing standardizes the sensor and operating-condition features, reduces them to 12 principal components, adds normalized cycle age, and constructs 64-cycle windows. The resulting inputs contain 13 features per time step.

Each architecture is trained as a regression model with extra weight on low-RUL observations and an asymmetric quantile-style loss. Training uses a maximum of 750 epochs, a 20% validation split, early stopping, learning-rate reduction, and a batch size of 1,024. Evaluation includes RMSE and R² over the full test range, the same metrics for true RUL ≤ 30, and thresholded accuracy, precision, recall, and F1.

The cleaned notebooks are ordered as a workflow:

1. 01_data_preparation.ipynb
2. 02_rnn.ipynb
3. 03_lstm.ipynb
4. 04_gru.ipynb
5. 05_tcn.ipynb
6. 06_thesis_tcn_evaluation.ipynb, an archival evaluation of the final thesis checkpoint

Useful final plots and metric outputs from the original runs remain in the notebooks. Routine mount messages, model-diagram output, and long epoch logs were removed.

Results

The values below are the final values reported in the thesis. Timing was measured in Google Colab and is hardware-dependent.

Model	RMSE ↓	R² ↑	RMSE at RUL ≤ 30 ↓	Accuracy ↑	F1 ↑	Training time (s) ↓
RNN	12.84	87.19%	3.21	96.66%	94.77%	635
LSTM	12.25	88.33%	3.24	96.86%	95.15%	495
GRU	11.17	90.29%	4.15	98.04%	96.86%	507
TCN	11.14	90.35%	2.88	97.84%	96.64%	358

Interpretation

TCN was the best overall candidate in this experiment: it had the lowest full-range and critical-window regression error and the shortest recorded training time. GRU's classification accuracy and F1 were slightly higher, so the result is a trade-off rather than a universal win on every metric.

These results suggest that a dilated causal convolutional model can be competitive with, and in this setup preferable to, recurrent models for C-MAPSS RUL estimation. They do not prove that TCN will generalize to measurements from real engines or that it will improve maintenance outcomes in production.

Reproduction

The official NASA page currently notes that C-MAPSS is unavailable for download. If you already have an authorized copy, place these 12 files in data/raw/:

train_FD001.txt  test_FD001.txt  RUL_FD001.txt
train_FD002.txt  test_FD002.txt  RUL_FD002.txt
train_FD003.txt  test_FD003.txt  RUL_FD003.txt
train_FD004.txt  test_FD004.txt  RUL_FD004.txt

Create an environment and launch Jupyter:

cd aircraft-engine-rul
python -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install -r requirements.txt
jupyter lab

Run notebook 01 once, then run notebooks 02–05 independently. Models are written to artifacts/, which is intentionally ignored by Git. GPU-backed Colab or a comparable environment is recommended; CPU training can be slow.

Notebook 06 documents the canonical thesis checkpoint and retains its original outputs. Re-executing it requires the non-distributed checkpoint at artifacts/tcn_thesis.keras; notebook 05 is the reproducible training path for a new TCN checkpoint. Because the historical file contains a serialized Lambda layer, notebook 06 must only be used with the trusted checkpoint you created—not with a downloaded or untrusted model file.

Limitations

• C-MAPSS is simulated run-to-failure data and does not capture the full operational, maintenance, and sensor complexity of a deployed engine fleet.
• Architecture tuning and final comparison use a single dataset split and a single recorded seed rather than repeated trials with uncertainty intervals.
• The RUL ≤ 30 classification is derived by thresholding a regression output, not trained and calibrated as an independent classifier, as the goal was using one model for both tasks

Attribution

• Dataset: NASA C-MAPSS Aircraft Engine Simulator Data.
• Dataset methodology: A. Saxena, K. Goebel, D. Simon, and N. Eklund, “Damage Propagation Modeling for Aircraft Engine Run-to-Failure Simulation”, PHM 2008.
• LSTM: S. Hochreiter and J. Schmidhuber, “Long Short-Term Memory”, 1997.
• GRU: K. Cho et al., “Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation”, 2014.
• TCN design context: S. Bai, J. Z. Kolter, and V. Koltun, “An Empirical Evaluation of Generic Convolutional and Recurrent Networks for Sequence Modeling”, 2018.
• Implementation uses NumPy, pandas, scikit-learn, Matplotlib, seaborn, and TensorFlow/Keras. No pretrained model or third-party model implementation is included.