Global Feature Enhancing and Fusion Framework for Strain Gauge Time Series Classification

AI summary

Overview

Research area: Machine learning for time series classification (TSC), specifically hypergraph neural networks applied to industrial sensor data — Strain Gauge Status (SGS) recognition for aircraft wing static strength testing. Published in the Companion Proceedings of the ACM Web Conference 2025 (WWW Companion '25), DOI 10.1145/3701716.3715229.

Technical level: Advanced. The paper assumes familiarity with 1D/2D convolutional networks, self-attention, hypergraph neural networks, and Gumbel-Softmax reparameterization.

Scope in one sentence: The paper proposes a hypergraph-based framework (GFEF) that extracts three types of global features from strain gauge time series — profile features from curve images, twelve hand-crafted expert features, and features learned from local features — then fuses them to improve classification of strain gauge status.

Author affiliations: Fudan University (Shanghai Key Laboratory of Data Science), Tsinghua University (National Engineering Research Center for Big Data Software; School of Software), and the Aircraft Strength Research Institute of China (National Key Laboratory of Strength and Structural Integrity).

What This Paper Is About

In static strength tests on aircraft wings, strain gauges record loading and unloading sequences that must be labeled as normal or buckling so that failing mechanical components can be replaced before an accident. Business personnel currently classify these sequences manually, which is slow and costly, and the number of strain gauges on large components can reach tens of thousands. The paper treats this as a time series classification problem and argues that conventional CNN-based models fail here because local subsequences of different classes look very similar — so the authors build and fuse global features that describe the whole sequence instead.

Key Contributions

1. A Global Feature Enhancing and Fusion (GFEF) framework for SGS recognition. The framework extracts multi-type global features — profile features from curve images, expert-driven mathematical features, and a global feature learned from local features — and fuses them to enhance time series representations. The authors state this is the first study that fuses multi-type features for SGS recognition.

2. Redundancy and reliability controls. A feature redundancy filtering module based on learnable binary masks (sampled via the Gumbel-Max and Gumbel-Softmax tricks) removes class-redundant feature points, and a data reliability-aware attention mechanism, based on noise perturbation and variance evaluation, down-weights feature types that prove unstable under perturbation.

3. A carefully designed hypergraph interaction module. Key designs are hypergraph construction through random walks (rather than KNN, which the authors show would keep hyperedges within a single feature type), hypergraph attention, and dynamic hyperedges that are re-learned after node updates. The authors report that these high-order interactions generalize better to unseen data than pairwise interactions such as transformer.

4. Validation in a real industrial setting plus public benchmarks. Evaluation covers four groups of aircraft-wing static strength experiments with both offline and online studies, and 92 public UCR datasets.

Main Findings

• Local-only models underperform on SGS data. On Experimental Group 1, single-time-series baselines reach 86.9 (FCNet), 87.533 (ResNet), 87.833 (InceptionTime), 87.033 (OSCNN), 85.642 (FormerTime) and 86.533 (MultiRocket) average accuracy; the proposed method reaches 88.017. In Group 4 the same pattern holds — 88.45 for the proposed method versus 87.925 for the strongest baseline (InceptionTime). Group 2 results are 93.517 (proposed) versus 93.292 (InceptionTime), and Group 3 results are 89.642 (proposed) versus 89.375 (OSCNN).

• Fusing image and expert features with the time series improves accuracy substantially. On Experimental Group 1, the proposed method scores 92.875 accuracy, 92.492 F1 and 92.967 precision, compared with 92.692 accuracy for Adaptive Fusion and 91.892 for CNN Fusion. On Group 2, the proposed method scores 97.517 accuracy, 97.5 F1 and 97.525 precision, against 97.025 accuracy for Transformer Fusion and 96.333 for CNN Fusion.

• The authors claim hypergraph high-order interactions generalize better to unseen data than pairwise interaction models. They state this is demonstrated in experiments and suggested by the better performance on unseen data, and hypothesize the reason is that high-order interactions can quickly establish associations between unseen and trained data.

• Both global-feature insights are reported to be effective. The two insights — constructing global features via feature engineering (profile images and expert features) and learning global features from high-order relationships among local features — are each stated to be effective, and the framework is stated to fuse them effectively.

• Not reported in the available content: the per-method numbers for Experimental Groups 3 and 4 under the fusion setting, the results of the online study, and the specific results across the 92 UCR datasets. The truncated text ends mid-table during the Group 3/Group 4 fusion results.

Methodology in Plain English

1. Turn each sequence into multiple views. A strain time series is converted into a 64×64 three-channel image of its curve (with the axes omitted), in two forms: one unfolded and one folded along the central line of the x-axis so that profile differences are more pronounced and a long sequence can be represented in a shorter image. Four 2D-CNNs extract a profile global feature from these images, motivated by the fact that in practice experts can often classify a curve by looking at it.

2. Encode expert knowledge as twelve numbers. Twelve mathematical features are computed over the whole sequence, listed in Table 1 — including the range, the maximum absolute value, indicator features built from repeated subsequences, the maximum absolute successive difference, fitting variances against fifth-order polynomial fits over different segments, and the quadratic and cubic polynomial coefficients that measure overall curvature, which the authors say helps detect buckling.

3. Build node features for each view. An OSCNN extracts features from the raw time series; each feature set is split into P non-overlapping patches of length L and projected to a high-dimensional space. Each view therefore contributes a set of nodes (Z_ts, Z_img, Z_exp).

4. Filter redundancy and score reliability. A classifier predicts, for every feature point, whether it is class-relevant or class-redundant; a differentiable binary mask (Gumbel-Max followed by Gumbel-Softmax) discards redundant points. Separately, each feature type gets its own intermediate classifier, trained with cross-entropy and constrained by a Jensen-Shannon divergence term against the final classifier. Reliability is measured not by classifier confidence (which can be over-confident) but by how much the classifier's decisions fluctuate under Gaussian noise perturbations at levels {1, 2, 3}; features that fluctuate more get lower weight, since they are assumed to be less important. The scores are passed through softmax.

5. Construct a hypergraph by random walk. Because KNN-based hyperedges can end up containing nodes from only one feature type, the authors learn a shared connection matrix over all nodes (initialized from learnable embeddings, refined by an MLP with three 1D-CNNs) and apply random walks with restart probability α. The top-K nodes plus the node itself form each hyperedge.

6. Propagate and fuse. Hypergraph attention computes importance scores between nodes and hyperedges; hyperedges are updated from their nodes (following UniGNN, with layer normalization), and then — unlike prior methods that keep the initial structure — a new hyperedge structure is learned for updating the nodes, with residual connections. The resulting node features are flattened and sent to a final classifier.

7. Train end to end. The loss sums four cross-entropy losses (for the time-series, image, expert, and final classifiers) plus one Jensen-Shannon divergence loss between the final classifier and the three intermediate classifiers.

Setup details: The industrial data come from four static strength experiments producing 500, 9926, 1747, and 1742 samples, each of length 101. Each group takes turns as the training set and is evaluated on the other three, with the average of the three evaluations reported. Baselines are InceptionTime, OS-CNN, FCNet, ResNet, FormerTime and MultiRocket for single-series TSC, and MLP, CNN, WideDeep, transformer and adaptive fusion for the multi-feature setting. Learning rate is 1e-3, training runs 500 epochs, patch length and stride are 8, P is 16 per feature, K is 12, hidden size is 128 with 1 layer, and c in the random walk equation is 1. Each experiment is run four times with four different seeds and averages with standard deviations are reported, on an NVIDIA GeForce RTX 3090 with PyTorch.

Why This Matters

Impact on research: The paper offers evidence that high-order (hyperedge-based) relationships among feature nodes generalize better to unseen data than the pairwise relationships modeled by transformers in time series work, and it argues that CNNs' poor global-feature extraction can be compensated by fusing feature-engineered global features (curve images, polynomial curvature coefficients) with learned ones. It also introduces a reliability measure based on prediction fluctuation under noise rather than raw classifier confidence.

Real-world applications:

• Early warning of buckling and component failure in aircraft wing static strength tests.
• Structural health monitoring of large mechanical components and structures where strain gauges are deployed at scale.
• Automated replacement scheduling for components at risk under operating conditions.
• General time series classification where different classes share nearly identical local patterns — the public UCR archive is used as a broader test bed.

Industry relevance: The authors note that strain gauge counts can reach tens of thousands on large components and continue to grow as structures become larger and more complex, making manual classification by experienced personnel inefficient and costly. Automating this classification on data already streamed to IoT-based web servers directly targets that bottleneck.

Future Directions

• Report the full benchmark picture. The remaining fusion results for Experimental Groups 3 and 4, the online study results, and the per-dataset outcomes across the 92 UCR datasets are not available in the truncated content; documenting a count of wins/losses or average rank against the baselines would clarify how broadly the framework generalizes.
• Scale to many more classes and gauge counts. The evaluation uses a small number of statuses per experiment; extending to thousands of concurrently monitored gauges is an open engineering question.
• Reduce dependence on hand-crafted expert features. The twelve expert features in Table 1 are domain-specific and include an arbitrary constant A; investigating whether similar curvature information can be learned rather than engineered is a natural extension.
• Evaluate the reliability and redundancy modules in isolation. The paper motivates these modules with theoretical arguments and refers to an ablation study, but the quantitative contribution of each component is not detailed in the available content.

Target Audience

Researchers and practitioners in time series classification, hypergraph neural networks, and industrial IoT analytics; structural health monitoring and aerospace test engineers interested in automating strain gauge status recognition; and machine learning engineers who need to combine heterogeneous feature types (raw series, images, and domain-derived numerical features) without losing semantic consistency.

Authors’ abstract

Strain Gauge Status (SGS) time series recognition is crucial in the field of intelligent manufacturing based on the Internet of Things, as accurate identification helps timely detection of failed mechanical components, avoiding accidents. The loading and unloading sequences generated by strain gauges can be identified through time series classification (TSC) algorithms. Recently, deep learning models, e.g., convolutional neural networks (CNNs) have shown remarkable success in the TSC task, as they can extract discriminative local features from the subsequences to identify the time series. However, we observe that only the local features may not be sufficient for expressing the time series, especially when the local sub-sequences between different time series are very similar, e.g., SGS data of aircraft wings in static strength experiments. Nevertheless, CNNs suffer from the limitation in extracting global features due to the nature of convolution operations. For extracting global features to more comprehensively represent the SGS time series, we propose two insights: (i) Constructing global features through feature engineering. (ii) Learning high-order relationships between local features to capture global features. To realize and utilize them, we propose a hypergraph-based global feature learning and fusion framework, which learns and fuses global features for semantic consistency to enhance the representation of SGS time series, thereby improving recognition accuracy. Our method designs are validated on industrial SGS and public UCR datasets, showing better generalization for unseen data in SGS recognition. The code is available at the link https://github.com/Meteor-Stars/GFEF.