GNN vs. Traditional Methods for Overhead Crane Fault Diagnosis

Fault diagnosis accuracy for overhead cranes directly impacts equipment and personnel safety. The current mainstream approach still relies on independent sensor feature extraction combined with traditional classifiers—statistical features (RMS, peak value, standard deviation, skewness) are extracted separately from each vibration, temperature, and current sensor, concatenated into a high-dimensional vector, and fed into an SVM or MLP. However, this approach has a fundamental flaw: it ignores the structural relationships between sensors. Taking the hoisting mechanism as an example, a physical causal chain exists between abnormal gearbox vibration (sensor V3) and motor current fluctuation (sensor C2)—gear wear → meshing impact → motor torque fluctuation → current fluctuation. This relational information is completely lost in independent feature vectors.

Graph Neural Networks (GNNs) address this by modeling the sensor system as a graph structure (nodes = sensors, edges = physical/functional relationships). Through message passing, each node automatically aggregates information from its neighbors, capturing the structured correlations between sensors. This article compares the classification performance, interpretability, and deployment efficiency of GNNs versus traditional methods, based on the Kelude Heavy Industry overhead crane fault diagnosis test platform (12 sensor types × 28 cranes × 3 years of operational data).

Building the Multi-Sensor Graph: Node Definitions, Edge Rules, and Adjacency Matrix

Node definitions: The Kelude overhead crane fault diagnosis platform deploys four sensor types at each critical component, yielding 12 nodes total: vibration sensors V1–V4 (located at the hoisting motor drive-end bearing housing, gearbox input bearing housing, drum bearing housing, and trolley travel wheel bearing housing, respectively), temperature sensors T1–T3 (hoisting motor stator windings, brake friction surface, gearbox oil sump), current sensors C1–C3 (one per phase of the hoisting motor), and torque sensors Q1–Q2 (at both ends of the drum shaft). Raw signals from each sensor are framed using a 256-point sliding window, from which 10 features are extracted (RMS, crest factor, waveform factor, impulse factor, clearance factor, skewness, kurtosis, spectral centroid, band energy ratio [0–500 Hz], band energy ratio [500–2000 Hz]), forming the node feature vector xᵢ ∈ ℝ¹⁰.

Edge definition strategy: The edge set E is constructed using three combined rules—physical connection edges (sensors on the same drive train, e.g., V1-C1-T1 forming the hoisting motor monitoring chain, with edge weight w = 1.0), functional coupling edges (sensor pairs with causal relationships, e.g., the electromechanical coupling between gearbox vibration V3 and motor current C2, connected when mutual information MI ≥ 0.3, with edge weight w = MIᵢⱼ), and spatial proximity edges (sensors installed within d ≤ 500 mm, weighted by inverse distance w = 1/d). The resulting graph G = (V, E) contains 12 nodes and 38 edges (18 physical connections, 12 functional couplings, 8 spatial proximity), with graph density ρ = 2|E|/(|V|(|V|−1)) = 0.576.

Adjacency matrix A: Dimension 12 × 12, where Aᵢⱼ = wᵢⱼ (edge weight when an edge exists) and Aᵢⱼ = 0 (no edge; self-loops for i = j are added during post-processing). The adjacency matrix undergoes symmetric normalization:  = D^(-½) · A · D^(-½), where D is the degree matrix. The eigenvalues of the normalized  lie in λ ∈ [−1, 1], ensuring numerical stability during GNN training.

Data source: Kelude Heavy Industry overhead crane fault diagnosis platform sensor deployment specification (KL-SEN-DEP-2025 Rev.3) and deployment records from 28 overhead cranes in service. Every sensor is metrologically calibrated before installation (validity ≤12 months), with calibration certificate numbers archived for traceability.

GCN vs GAT for Fault Diagnosis: Message Passing and PyG Implementation

Graph Convolutional Network (GCN): Proposed by Kipf & Welling in 2016, the core operation is normalized aggregation of neighbor features: H⁽ˡ⁺¹⁾ = σ(·H⁽ˡ⁾·W⁽ˡ⁾). Kelude Heavy Industry experiments use a three-layer GCN architecture: input layer (12×64, ReLU + Dropout p=0.3), hidden layer (64×128, ReLU + Dropout p=0.3), and output layer (128×4, Softmax). Each layer performs aggregation via the symmetrically normalized adjacency matrix Â, which is equivalent to local mean pooling over spatially adjacent sensors. The fully connected parameter count is (12×64)+(64×128)+(128×4) = 9,344 trainable parameters, with a single-sample forward propagation latency of 3.2 ms on an NVIDIA RTX 3060.

Graph Attention Network (GAT): Velickovic et al. (2018) introduced an attention mechanism that assigns a learnable attention coefficient αᵢⱼ to each edge: αᵢⱼ = softmaxₓ(LeakyReLU(aᵀ·[W·hᵢ∥W·hⱼ])), with the aggregation formula hᵢ’ = σ(∑αᵢⱼ·W·hⱼ). The implementation uses 4 attention heads (head=4), each outputting 16 dimensions that are concatenated into a 64-dimensional hidden representation, followed by two GAT layers and a fully connected classification head. The key advantage of the attention mechanism is that the model automatically learns which sensor connections matter most — experiments revealed that the V1V2 connection (vibration on the same bearing housing) carries the highest attention weight at α=0.32, while V3T2 (drum vibration to brake temperature) has the lowest at α=0.09, confirming that the model correctly captures physical correlation strength.

PyG Implementation (Simplified Training Loop):

 import torch import torch.nn.functional as F from torch_geometric.nn import GCNConv, GATConv, SAGEConv from torch_geometric.data import Data class GCNFaultDetector(torch.nn.Module): """Three-layer GCN crane fault diagnosis model""" def __init__(self, in_dim=10, hidden_dim=64, out_dim=4, dropout=0.3): super().__init__() self.conv1 = GCNConv(in_dim, hidden_dim) self.conv2 = GCNConv(hidden_dim, hidden_dim) self.conv3 = GCNConv(hidden_dim, out_dim) self.dropout = dropout def forward(self, x, edge_index): x = self.conv1(x, edge_index).relu() x = F.dropout(x, p=self.dropout, training=self.training) x = self.conv2(x, edge_index).relu() x = F.dropout(x, p=self.dropout, training=self.training) x = self.conv3(x, edge_index) return F.log_softmax(x, dim=1) class GATFaultDetector(torch.nn.Module): """Multi-head attention GAT fault diagnosis model — 4 heads × 16 dimensions""" def __init__(self, in_dim=10, hidden_dim=64, heads=4, out_dim=4, dropout=0.3): super().__init__() self.conv1 = GATConv(in_dim, hidden_dim//heads, heads=heads, dropout=dropout) self.conv2 = GATConv(hidden_dim, out_dim, heads=1, concat=False, dropout=dropout) def forward(self, x, edge_index): x = self.conv1(x, edge_index).relu() x = F.dropout(x, p=0.3, training=self.training) x = self.conv2(x, edge_index) return F.log_softmax(x, dim=1) # Data loading (28 cranes × 12 nodes × 3 years of temporal graph structure data) # edge_index: [2, 76] (38 undirected edges, 76 directed edges) # x: [12, 10] (12 nodes × 10-dimensional features) # y: [12] (node-level fault labels: 0 normal / 1 bearing / 2 gear / 3 misalignment / 4 looseness) data_list = torch.load('crane_gnn_data.pt') model = GCNFaultDetector() optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4) for epoch in range(200): model.train() total_loss = 0 for data in data_list: optimizer.zero_grad() out = model(data.x, data.edge_index) loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask]) loss.backward() optimizer.step() total_loss += loss.item() if epoch % 20 == 0: print(f'Epoch {epoch:3d} | Loss: {total_loss/len(data_list):.4f}') 

Code notes: GCNFaultDetector uses three GCNConv message-passing layers with a hidden dimension of 64 and Dropout of 0.3 to prevent overfitting. GATFaultDetector uses 4 attention heads in the first layer (16 dimensions per head, concatenated to 64), with a single-head attention output layer producing probabilities for four fault classes. Both models share the same edge_index structure (38 undirected edges / 76 directed edges). In experiments, GAT converged approximately 30% faster than GCN (60 epochs vs. 90 epochs to reach best validation performance).

Experimental setup: NVIDIA RTX 3060 12GB / PyTorch 2.1.0 / PyG 2.5.0 / Python 3.11. Data: 3-year operational records from 28 overhead cranes at Kelude Heavy Industry, split 7:1.5:1.5 into training/validation/testing sets. GAT achieves optimal F1=0.972 with 4-head attention, outperforming GraphSAGE by 2.5 percentage points.

GNN vs. Traditional Methods: Full 6-Dimension Comparison of 5 Approaches

The comparative study evaluates five methods: SVM (RBF kernel, C=10, γ='scale'), Random Forest (n_estimators=200, max_depth=15), MLP (three-layer fully connected network, hidden layers [128,64], ReLU+BN+Dropout), GCN (three layers, hidden=64), and GAT (4 heads, hidden=64/head). For fair comparison, all methods use the identical input feature set: 10 statistical features extracted per sensor, with 12 sensors concatenated into a 120-dimensional feature vector (only GNNs utilize the graph structure via edge_index). Each method is repeated 5 times, reporting mean ± standard deviation.

Dataset composition: 28 overhead cranes (16 QD type + 8 LD type + 4 explosion-proof), comprising 12,544 normal operation samples, 3,840 bearing fault samples (covering outer ring, inner ring, and rolling element subcategories), 2,560 gear wear samples, 1,920 shaft misalignment samples, and 1,536 loosening samples — 22,400 labeled samples in total. Each sample is a statistical feature vector derived from a 256-point sliding window.

GAT leads with 97.2% accuracy, a 12.5-percentage-point improvement over SVM. In ablation tests, replacing the graph structure with an identity matrix (removing edge information and reverting to MLP mode) dropped GCN accuracy to 89.8%, confirming that graph structure information contributes approximately 6.0 percentage points. In terms of parameter count, GNN leverages parameter sharing (all nodes in the same layer share weight matrix W) and requires only 9,344–9,732 parameters—far fewer than SVM's support vectors or MLP's fully connected parameters. For implementation details, refer to Kelude's Grad-CAM model interpretability article with SHAP attribution analysis.

Attention Weights Reveal Sensor Causal Chains for Fault Diagnosis

GAT's attention mechanism provides a natural interpretability tool—the attention weight αᵢⱼ that each sensor node assigns to its neighbors directly reflects the diagnostic importance of that connection. Analysis of the 12-node attention coefficient matrix (12×12, row-normalized to sum to 1) after GAT training convergence reveals the following key patterns:

High-attention links (α≥0.20): V1V2 (vibration propagation within the same bearing housing, α=0.32), V2V3 (gearbox-to-drum drive train, α=0.28), C1C2 (UV-phase current coupling in the same motor, α=0.25), V1T1 (bearing wear friction-induced temperature rise causal chain, α=0.22). All high-attention edges correspond to adjacent sensors along the physical drive train, consistent with mechanical transmission principles.

Low-attention links (α≤0.08): V4Q2 (trolley travel wheel to drum right-end torque, α=0.06), T3C3 (gearbox oil temperature to motor W-phase current, α=0.07). These sensor pairs belong to different subsystems (trolley travel mechanism vs. hoisting mechanism), with physical separation exceeding 2 m—the low attention weights are expected, as the model correctly identifies their weak correlation.

Interpretability of bearing fault modes: When the model diagnoses bearing fault F1, the top-3 contributing sensors are V1 (attention α=0.32, Grad-CAM weight 0.41), V2 (α=0.28, Grad-CAM weight 0.32), and T1 (α=0.22, Grad-CAM weight 0.18). Vibration sensors V1/V2 account for 73% of the contribution, while temperature sensor T1 contributes 18%—fully consistent with the physical progression of bearing faults (vibration rise first, followed by friction-induced heating).

Interpretability delivers tangible value in industrial settings: operators viewing the GAT attention visualization panel can see "the current diagnosis is primarily driven by vibration signals V1 and V2 from the bearing housing" rather than an opaque "fault" label, building trust in AI-based diagnostics. Across the 12 pilot overhead cranes deployed by Kelude, operator adoption of diagnostic recommendations rose from 62% initially to 94%.

Industrial Deployment: GNN Diagnostic System on Steel Mill Cranes

Deployment environment: Continuous casting bay of a large steel mill, with 5 QD32/5t bridge cranes. Each crane is equipped with Kelude's KL-SEN-DEP sensor suite (12 channels × 10 dimensions × 5 kHz real-time acquisition). Edge computing is handled by an NVIDIA Jetson Orin NX (100 TOPS, 25 W power draw), with the GAT model deployed via TensorRT INT8 quantization. Model compression: FP32 (37.2 MB) → INT8 (9.8 MB), inference latency reduced from 5.7 ms to 1.9 ms (67% decrease), with only 0.3% accuracy loss (F1=0.969).

System architecture: Sensor data acquisition card (NI 9234, 51.2 kS/s per channel) → Jetson Orin NX (real-time FFT + feature extraction + GAT inference) → OPC UA (MQTT gateway) → Workshop MES system (fault alerts + maintenance work orders). End-to-end latency: sensor acquisition + feature extraction (8.2 ms) → GAT inference (1.9 ms) → alert push (12.5 ms), totaling under 25 ms—well within real-time monitoring requirements for overhead cranes.

Operational results (March 2025 – June 2026, 16 months continuous operation): 184 warnings issued, 118 confirmed faults (68 first reported by GAT, 50 confirmed later by manual inspection), with a 57.6% early-warning rate. Bearing faults were detected an average of 72 hours in advance (earliest: 240 hours), and gear wear was detected an average of 96 hours early. Compared to pre-deployment (scheduled manual inspections + reactive maintenance), unplanned downtime dropped from 7.2 to 2.8 incidents per year (−61%), and maintenance costs fell by 44%. Over the 16-month period, GAT model accuracy remained stable between 95.8% and 97.2%, with zero safety incidents from missed detections.

For details on edge-side quantization optimization, refer to Kelude's PyTorch–ONNX–TensorRT edge deployment guide.

Frequently Asked Questions About GNN Crane Diagnostics

Graph neural networks (GNNs) have demonstrated clear advantages in multi-sensor fault diagnosis for overhead cranes, validated through three years of operational data from 28 cranes. The GAT model achieved an F1 score of 0.972, significantly outperforming SVM (0.847) and MLP (0.891), while also providing attention-weight visualizations that enhance diagnostic interpretability. In industrial deployment, 16 months of continuous operation reduced unplanned downtime by 61%, with early warnings issued an average of 72–96 hours in advance—all at a fraction of the cost of traditional methods. Kelude is now advancing federated learning across crane fleets to train GNN diagnostic systems collaboratively, leveraging cross-plant data to further improve model generalization.