First release of AGTF30 Prognostics

.gitattributes

@@ -0,0 +1,2 @@
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text

A320neo_protocol.xml

@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  a320neo_protocol.xml
+  FlightGear Generic Output Protocol — Airbus A320neo (CFM LEAP-1A)
+  
+  Place this file in:
+    <fg-root>/Protocol/a320neo_protocol.xml
+  
+  Launch FlightGear with:
+    --generic=socket,out,10,127.0.0.1,5500,udp,a320neo_protocol
+  
+  15 comma-separated fields per packet, ASCII, newline-terminated.
+  
+  JSBSim engine property paths are identical across aircraft models —
+  only the physical operating ranges differ between B787 and A320neo.
+  
+  Author: Mohammed Bello Sani
+-->
+<PropertyList>
+  <generic>
+    <output>
+      <binary_mode>false</binary_mode>
+      <line_separator>\n</line_separator>
+      <var_separator>,</var_separator>
+
+      <!-- [00] EGT proxy for T45 / T25 / T3 — engine exhaust gas temp degF -->
+      <chunk>
+        <node>/engines/engine[0]/egt-degf</node>
+        <type>double</type>
+        <format>%.3f</format>
+      </chunk>
+
+      <!-- [01] N2 core shaft speed percent (HPT proxy) -->
+      <chunk>
+        <node>/engines/engine[0]/n2</node>
+        <type>double</type>
+        <format>%.6f</format>
+      </chunk>
+
+      <!-- [02] EGT again — inter-turbine temperature proxy T25 -->
+      <chunk>
+        <node>/engines/engine[0]/egt-degf</node>
+        <type>double</type>
+        <format>%.3f</format>
+      </chunk>
+
+      <!-- [03] N1 fan shaft speed percent (LPT proxy) -->
+      <chunk>
+        <node>/engines/engine[0]/n1</node>
+        <type>double</type>
+        <format>%.6f</format>
+      </chunk>
+
+      <!-- [04] EGT again — compressor exit temperature proxy T3 -->
+      <chunk>
+        <node>/engines/engine[0]/egt-degf</node>
+        <type>double</type>
+        <format>%.3f</format>
+      </chunk>
+
+      <!-- [05] Thrust lbf — combustor inlet pressure proxy Pt3 -->
+      <chunk>
+        <node>/engines/engine[0]/thrust-lbs</node>
+        <type>double</type>
+        <format>%.3f</format>
+      </chunk>
+
+      <!-- [06] Thrust lbf — static pressure proxy Ps3 -->
+      <chunk>
+        <node>/engines/engine[0]/thrust-lbs</node>
+        <type>double</type>
+        <format>%.3f</format>
+      </chunk>
+
+      <!-- [07] N2 repeated for sensor slot N2 -->
+      <chunk>
+        <node>/engines/engine[0]/n2</node>
+        <type>double</type>
+        <format>%.4f</format>
+      </chunk>
+
+      <!-- [08] N1 repeated for sensor slot N1 -->
+      <chunk>
+        <node>/engines/engine[0]/n1</node>
+        <type>double</type>
+        <format>%.4f</format>
+      </chunk>
+
+      <!-- [09] N1 again as N3 proxy (2-spool: no N3 in JSBSim) -->
+      <chunk>
+        <node>/engines/engine[0]/n1</node>
+        <type>double</type>
+        <format>%.4f</format>
+      </chunk>
+
+      <!-- [10] Net thrust lbf — Fnet -->
+      <chunk>
+        <node>/engines/engine[0]/thrust-lbs</node>
+        <type>double</type>
+        <format>%.2f</format>
+      </chunk>
+
+      <!-- [11] Altitude ft — context -->
+      <chunk>
+        <node>/position/altitude-ft</node>
+        <type>double</type>
+        <format>%.1f</format>
+      </chunk>
+
+      <!-- [12] Airspeed kt — context -->
+      <chunk>
+        <node>/velocities/airspeed-kt</node>
+        <type>double</type>
+        <format>%.2f</format>
+      </chunk>
+
+      <!-- [13] Heading deg — context -->
+      <chunk>
+        <node>/orientation/heading-deg</node>
+        <type>double</type>
+        <format>%.2f</format>
+      </chunk>
+
+      <!-- [14] Sim elapsed seconds — context -->
+      <chunk>
+        <node>/sim/time/elapsed-sec</node>
+        <type>double</type>
+        <format>%.2f</format>
+      </chunk>
+
+    </output>
+  </generic>
+</PropertyList>

README.md

@@ -0,0 +1,16 @@
+# Real-Time Probabilistic Health Monitoring (AGTF30)
+
+This repository contains the official implementation of the CNN-BiLSTM-Attention prognostic framework as described in:
+*"Real-Time Probabilistic Health Monitoring of Turbofan Turbine Blades via CNN-BiLSTM-Attention with Physics-Informed Flight Simulator Integration"* (Ene et al., 2026).
+
+## Model Performance (Test Set)
+| Metric | Value |
+| :--- | :--- |
+| **Test RMSE** | 3.352 cycles |
+| **R² Score** | 0.993 |
+| **NASA Score** | 346.38 |
+
+## Getting Started
+1. **Clone the repo:**
+   ```bash
+   git clone [https://huggingface.co/SM-Bello/AGTF30-Turbofan-Prognostics](https://huggingface.co/SM-Bello/AGTF30-Turbofan-Prognostics)

agtf30_blade_model.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3427f5f0511ea11a82eb2b22be1d3bb0dfbd9743611d60273c232d849961e41
+size 3948965

agtf30_scaler_params.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a7f87a314b5ca1bbe5d038405a80062ce80f4dfba5942b2c20274df58c487895
+size 2004

cmapss_model.py

@@ -0,0 +1,115 @@
+"""
+cmapss_model.py
+===============
+CNN-BiLSTM-Attention model with MC Dropout for RUL prediction.
+Used for both C-MAPSS and AGTF30 turbine blade datasets.
+
+Author: Mohammed Bello Sani
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+
+class CNNBiLSTMAttention(nn.Module):
+    """
+    CNN + Bidirectional LSTM + Self-Attention + MC Dropout
+    """
+    def __init__(self, hp):
+        super().__init__()
+        self.hp = hp
+        n_features = hp['n_features']
+        cnn_filters = hp['cnn_filters']
+        kernel_size = hp.get('cnn_kernel', 3)
+        lstm_hidden = hp['lstm_hidden']
+        lstm_layers = hp['lstm_layers']
+        fc_hidden = hp.get('fc_hidden', 64)
+        dropout = hp.get('mc_dropout', 0.5)
+
+        # CNN feature extractor
+        cnn_layers = []
+        in_channels = n_features
+        for i, filters in enumerate(cnn_filters):
+            cnn_layers.append(nn.Conv1d(in_channels, filters, kernel_size, padding='same'))
+            cnn_layers.append(nn.BatchNorm1d(filters))
+            cnn_layers.append(nn.GELU())
+            cnn_layers.append(nn.Dropout(dropout * 0.5))  # lighter dropout in CNN
+            in_channels = filters
+        self.cnn = nn.Sequential(*cnn_layers)
+        self.cnn_out_dim = cnn_filters[-1]
+
+        # BiLSTM
+        self.lstm = nn.LSTM(
+            input_size=self.cnn_out_dim,
+            hidden_size=lstm_hidden,
+            num_layers=lstm_layers,
+            batch_first=True,
+            bidirectional=True,
+            dropout=hp.get('lstm_dropout', 0.3) if lstm_layers > 1 else 0
+        )
+        lstm_out_dim = lstm_hidden * 2  # bidirectional
+
+        # Self-Attention
+        self.attn_heads = hp.get('attn_heads', 4)
+        self.attn = nn.MultiheadAttention(
+            embed_dim=lstm_out_dim,
+            num_heads=self.attn_heads,
+            dropout=dropout * 0.3,
+            batch_first=True
+        )
+        self.attn_norm = nn.LayerNorm(lstm_out_dim)
+
+        # Fully connected regressor
+        self.fc = nn.Sequential(
+            nn.Linear(lstm_out_dim, fc_hidden),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(fc_hidden, 1)
+        )
+
+        # MC Dropout layers are already included; we keep them active during inference
+        self.dropout_rate = dropout
+
+    def forward(self, x):
+        # x shape: (batch, seq_len, features)
+        # Permute for CNN: (batch, features, seq_len)
+        x_cnn = x.permute(0, 2, 1)
+        x_cnn = self.cnn(x_cnn)            # (batch, filters, seq_len)
+        x_cnn = x_cnn.permute(0, 2, 1)     # (batch, seq_len, filters)
+
+        # BiLSTM
+        lstm_out, _ = self.lstm(x_cnn)     # (batch, seq_len, lstm_hidden*2)
+
+        # Self-Attention
+        attn_out, _ = self.attn(lstm_out, lstm_out, lstm_out)
+        attn_out = self.attn_norm(attn_out + lstm_out)  # residual
+
+        # Global average pooling over time dimension
+        pooled = attn_out.mean(dim=1)       # (batch, lstm_out_dim)
+
+        # Final prediction
+        out = self.fc(pooled).squeeze(-1)   # (batch,)
+        return out
+
+    def predict_with_uncertainty(self, x, n_samples=100):
+        """
+        Monte Carlo Dropout inference.
+        Returns mean and standard deviation.
+        """
+        self.train()  # keep dropout active
+        preds = []
+        with torch.no_grad():
+            for _ in range(n_samples):
+                preds.append(self.forward(x).cpu().numpy())
+        preds = np.stack(preds, axis=0)
+        mean = preds.mean(axis=0)
+        std = preds.std(axis=0)
+        return mean, std
+
+
+# Compatibility: if the old code expects the model to be loaded via torch.load,
+# we need to ensure the class is defined in this module.
+if __name__ == '__main__':
+    print("CNNBiLSTMAttention model definition ready.")

requirements.txt

@@ -0,0 +1,7 @@
+torch
+numpy
+pandas
+scikit-learn
+matplotlib
+scipy
+h5py

train_agtf30.py

@@ -0,0 +1,102 @@
+"""
+Modified train_agtf30.py
+Boosted architecture for higher tracking accuracy.
+"""
+import sys, os, time, warnings
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.preprocessing import MinMaxScaler
+import matplotlib.pyplot as plt
+
+# Replace with your actual path
+sys.path.insert(0, r'C:\Users\User\Desktop\Steph')
+from cmapss_model import CNNBiLSTMAttention
+
+# ─────────────────────────────────────────────────────────
+# CONFIG
+# ─────────────────────────────────────────────────────────
+DATA_FILE   = r'C:\Users\User\Desktop\Steph\archive\AGTF30\AGTF30\agtf30_blade_dataset.csv'
+MODEL_OUT   = r'C:\Users\User\Desktop\Steph\archive\AGTF30\AGTF30\agtf30_blade_model.pt'
+SCALER_OUT  = r'C:\Users\User\Desktop\Steph\archive\AGTF30\AGTF30\agtf30_scaler_params.npz'
+
+SENSOR_NAMES = ['T45','Pt45','T25','Pt25','T3','Pt3','Ps3','N2','N1','N3','Fnet']
+HP = {
+    'n_features'  : 11,
+    'cnn_filters' : [64, 128], # Increased depth
+    'cnn_kernel'  : 3,
+    'cnn_dropout' : 0.25,
+    'lstm_hidden' : 128,
+    'lstm_layers' : 2,
+    'lstm_dropout': 0.3,
+    'attn_heads'  : 8,          # More heads for better focus
+    'fc_hidden'   : 128,        # Wider FC layer
+    'mc_dropout'  : 0.3,
+    'window_size' : 30,
+    'batch_size'  : 64,         # Smaller batch for better gradients
+    'epochs'      : 200,
+    'lr'          : 1e-3,       # Adjusted LR
+    'weight_decay': 1e-4
+}
+
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# ─────────────────────────────────────────────────────────
+# 1. LOAD & PREP
+# ─────────────────────────────────────────────────────────
+df = pd.read_csv(DATA_FILE)
+# Compute RUL
+max_cycles = df.groupby('engine_id')['cycle'].max().reset_index()
+max_cycles.columns = ['engine_id','max_cycle']
+df = df.merge(max_cycles, on='engine_id')
+df['RUL'] = (df['max_cycle'] - df['cycle']).clip(upper=125)
+
+# Normalization
+scaler = MinMaxScaler()
+df[SENSOR_NAMES] = scaler.fit_transform(df[SENSOR_NAMES])
+
+# ─────────────────────────────────────────────────────────
+# 2. IMPROVED DATA SAMPLING
+# ─────────────────────────────────────────────────────────
+def create_dataset(data, window_size):
+    X, y = [], []
+    for eid, grp in data.groupby('engine_id'):
+        vals = grp[SENSOR_NAMES].values
+        rul = grp['RUL'].values
+        # Sample EVERY cycle, not just the last one
+        for i in range(len(vals) - window_size + 1):
+            X.append(vals[i:i+window_size])
+            y.append(rul[i+window_size-1])
+    return torch.tensor(np.array(X), dtype=torch.float32), torch.tensor(np.array(y), dtype=torch.float32)
+
+engines = df['engine_id'].unique()
+np.random.shuffle(engines)
+split = int(len(engines)*0.85)
+train_loader = DataLoader(TensorDataset(*create_dataset(df[df['engine_id'].isin(engines[:split])], 30)), batch_size=64, shuffle=True)
+val_loader   = DataLoader(TensorDataset(*create_dataset(df[df['engine_id'].isin(engines[split:])], 30)), batch_size=64)
+
+# ─────────────────────────────────────────────────────────
+# 3. TRAIN
+# ─────────────────────────────────────────────────────────
+model = CNNBiLSTMAttention(HP).to(DEVICE)
+optimizer = optim.Adam(model.parameters(), lr=HP['lr'])
+criterion = nn.MSELoss()
+
+print("Training started...")
+for epoch in range(HP['epochs']):
+    model.train()
+    for Xb, yb in train_loader:
+        optimizer.zero_grad()
+        loss = criterion(model(Xb.to(DEVICE)).squeeze(), yb.to(DEVICE))
+        loss.backward()
+        optimizer.step()
+    
+    # Validation loop omitted for brevity, just verify output
+    if epoch % 10 == 0:
+        print(f"Epoch {epoch} finished.")
+
+torch.save({'model_state': model.state_dict(), 'hp': HP}, MODEL_OUT)
+print("Training complete and saved.")