🔗

Graph Neural Networks

Industrial Predictive Maintenance via Sensor Relationship Modeling

Status

Production Ready

Framework

PyTorch Geometric

Role

Research Lead

Problem Statement

Traditional sequence models struggle with industrial equipment degradation:

Sensor Dependencies Ignored: LSTM treats 21 sensors independently, misses cascading failures
No Fault Propagation Modeling: When one component fails, it affects others. Sequential models can't capture this
Flat Architecture: All sensors weighted equally, but some are more critical to engine health
Poor Generalization: Models don't learn transferable sensor relationships across engines

Insight: Turbofan engines are systems of interacting components. Model them as graphs where sensors are nodes and correlations are edges.

Graph Construction & Modeling

Step 1: Correlation-Based Graph

Compute Pearson correlation matrix on multivariate sensor time series. Threshold at τ = 0.3 to create sparse adjacency matrix:

A_ij = 1 if |corr(sensor_i, sensor_j)| > τ

Step 2: Node Features from Time Series

Each node represents a sensor's sliding time-window. Feature matrix H contains normalized sensor values across time steps. Represents temporal state of each component.

Step 3: PyTorch Geometric Format

Convert NetworkX graphs to PyG Data objects with edge indices, node features, and edge weights. 21 sensors = 21 nodes. Dynamic graphs for each time step.

GNN Architectures Implemented

1. Graph Convolutional Network (GCN)

Aggregates information from neighboring sensors:

H^(l+1) = σ(Ď^-½ÂĎ^-½H^(l)W^(l))

Where Â = A + I (adjacency with self-loops), Ď = degree matrix, W^(l) = learnable weights

2. Graph Attention Network (GAT)

Dynamically weights sensor importance during aggregation:

h_i^(l+1) = σ(Σ_j∈N(i) α_ijWh_j^(l))

α_ij = attention coefficient. GAT learns which sensors are critical to engine failure prediction as degradation progresses.

3. Custom Message Passing Neural Network (MPNN)

Generalizes graph convolution with arbitrary message and update functions. Concatenates sender features, receiver features, and correlation coefficients before MLP transformation.

Key Innovation: Attention Interpretability

Why GAT Matters for Maintenance:

• Model learns which sensors become critical as engine degrades
• Attention weights reveal fault propagation pathways
• Explainable predictions: "Engine failing because compressor temperature + pressure correlate with imminent failure"
• Enables targeted maintenance: Fix high-attention sensors first

Real Finding: High-Pressure Compressor outlet temperature and bypass duct pressure consistently show highest attention near failure threshold.

Dataset: NASA CMAPSS Turbofan

Dataset Characteristics

• 100 engines with degradation trajectories
• 21 sensors + 3 operational settings
• ~200K time steps total
• Ground truth RUL (Remaining Useful Life)

Task: RUL Prediction

• Predict cycles until failure
• Regression target: RUL ∈ [0, max_cycles]
• Challenge: Sparse failure events
• Industrial relevance: Schedule maintenance proactively

Experimental Results

GNN vs Baseline Performance

GNN models (GCN, GAT) significantly outperform sequential baselines on RUL prediction:

• LSTM: ~15% RMSE error (baseline)
• 1D-CNN: ~13% RMSE error
• GCN: ~8% RMSE error ✓
• GAT: ~7% RMSE error ✓ (best)

Key Findings

• GNN captures cascading fault propagation LSTM misses
• Attention visualization reveals critical sensor paths
• Sparse graph topology (τ=0.3) optimal for generalization
• Model transfers across different engine types

Tech Stack

Core ML Stack

• PyTorch (deep learning)
• PyTorch Geometric (GNN ops)
• NetworkX (graph construction)
• Pandas/NumPy (data processing)

Deployment & Visualization

• Streamlit (interactive dashboard)
• Matplotlib/Seaborn (graphs)
• Scikit-learn (baselines)
• Docker (containerization)

Deliverables

Streamlit Dashboard

Visualize sensor degradation trends, inferred sensor relationship graph topology, and predicted RUL vs ground truth for any engine.

Modular Python Package

`src/` directory with data pipeline, graph construction, model implementations, training loop, and evaluation utilities.

Jupyter Notebooks

Interactive EDA, visualization, and experiment notebooks for research reproducibility and knowledge sharing.

Future Improvements

• Dynamic Edge Generation: Adjacency matrix evolves during inference as engine degrades

• Spatio-Temporal Graph Convolutions (ST-GCN): Interleave temporal and spatial convolutions explicitly

• Bayesian Uncertainty Quantification: Confidence intervals around RUL predictions for safety-critical decisions

• Transfer Learning: Pre-train on diverse engine types, fine-tune on specific aircraft

Links & Resources

View on GitHub