Rotating machinery fault diagnosis method based on star-anchor screening and split graph convolutional network

Abstract

This invention discloses a method for fault diagnosis of rotating machinery based on lightweight star-anchor screening and a flow-gated graph convolutional network. The method first maps vibration time-series signals into a node feature matrix and constructs a candidate adjacency matrix containing nearest neighbor edges and sequence prior edges. Star-anchor screening is used to score the node pair features of candidate edges, filtering core nodes and effective edges to generate sparse effective adjacencies. A graph convolutional network with a flow-gated mechanism is constructed, dividing the input features into propagation branches and bypass branches based on channel global statistics. Only effective channels undergo graph propagation aggregation on sparse adjacencies, and the node features are output after linear fusion with bypass branches. The fault category is then output via graph-level aggregation and a classifier. This invention achieves channel-structure dual sparsity collaborative optimization, balancing high diagnostic accuracy, noise robustness, and lightweight design. It is adaptable to edge deployment and suitable for fault diagnosis of rotating machinery such as bearings and gearboxes.

Description

Technical Field

[0001] This invention relates to the field of rotating machinery condition monitoring and intelligent diagnosis technology, specifically to a rotating machinery fault diagnosis method based on star-anchor screening and flow-diversion graph convolutional network. Background Technology

[0002] Bearings, gears, and other rotating components are critical load-bearing units in aero-engines, rail transportation, and industrial equipment, and their service condition directly affects the overall safety and operational continuity. Due to prolonged exposure to high-speed, heavy-load, variable-load, and complex coupled excitation environments, the vibration response of rotating components often exhibits significant non-stationarity and strong noise characteristics, and the degradation process is phased, random, and condition-dependent. In practical engineering, factors such as differences in sensor installation locations, variations in structural transmission paths, and environmental disturbances commonly exist, causing the same fault type to exhibit significant domain shifts and characteristic drifts under different operating conditions. This makes the generalization ability of diagnostic models across operating conditions and noise disturbances a critical bottleneck.

[0003] Existing fault diagnosis methods have evolved from manual features to deep learning representations. Traditional methods rely on manual processes such as time-domain, frequency-domain, and envelope spectrum features. While these methods offer some physical interpretability, they often require experience-driven parameter selection and are sensitive to strong noise and non-stationary signals. Deep learning methods improve feature representation capabilities through end-to-end learning, but in engineering deployments, they generally face challenges such as large model size, high computational and storage overhead, and inference latency that fails to meet online monitoring requirements. Especially in edge or embedded scenarios, computational and memory constraints make it difficult for high-capacity networks to operate stably for extended periods, exacerbating the conflict between lightweight design and high accuracy.

[0004] To address the need for lightweight architectures, existing technologies typically focus on network structure design, parameter compression, and pruning quantization. However, most pruning strategies in practice employ a multi-stage process of training, pruning, and fine-tuning, or use continuously differentiable metrics during training but a discrete structure for deployment during inference. Such methods easily introduce inconsistencies between the training and inference structures, leading to performance degradation and decreased stability after deployment. Furthermore, if channel pruning relies solely on local statistics or single-layer thresholding, it may disrupt the consistency of cross-layer feature flows, resulting in the erroneous deletion of crucial discriminative information and thus exhibiting more significant accuracy degradation under increased noise or changing operating conditions.

[0005] In recent years, graph convolutional networks have been used in rotating machinery fault diagnosis to enhance the ability to characterize global structural information due to their ability to explicitly model the relationships between sample fragments, sensor channels, or features. Although graph methods have advantages in relationship modeling, existing approaches still have several prominent problems. First, graph structure construction usually relies on k-nearest neighbors or similarity thresholds. The resulting adjacency relationships are prone to unstable connections and an increase in pseudo-correlated edges under the influence of sample noise and domain offset, leading to noise diffusion during graph propagation and reduced clarity of discrimination boundaries. Second, graph convolutional propagation often performs homogeneous neighborhood aggregation on all channels in the channel dimension, ignoring the differences in the contribution of different channels to fault discrimination. This results in redundant propagation in the channel dimension, and the computational cost increases synchronously with the number of channels and edges, making it difficult to meet real-time requirements. Third, graph structure sparsity and channel sparsity are often handled separately, lacking a unified end-to-end collaborative learning mechanism. Especially when training and deployment are separated, the combination of structural pruning and channel pruning is more likely to cause structural mismatch and accuracy regression.

[0006] In summary, existing technologies still struggle to simultaneously meet the following engineering and methodological requirements in rotating machinery fault diagnosis: maintaining stable diagnostic accuracy under conditions of high noise, non-stationarity, and changing operating conditions; significantly reducing the number of model parameters and inference computations under deployability constraints; suppressing redundancy propagation and noise diffusion in graph relationship modeling; and ensuring consistency between the structure learned during training and the structure executed during inference. Therefore, there is an urgent need for a fault diagnosis method that can collaboratively achieve channel-level and structure-level lightweighting within a unified framework, while also considering robustness and deployability, to meet the practical needs of online monitoring and edge deployment of rotating machinery. Summary of the Invention

[0007] To address three main problems in existing graph neural network fault diagnosis—propagation pollution caused by pseudo-related edges in candidate graphs, computational redundancy resulting from full aggregation of redundant channels, and inconsistencies between training and deployment structures—this invention proposes a rotating machinery fault diagnosis method based on star-anchor sieving and a split-graph convolutional network. Starting with sequence patching combined with graph node alignment, this invention simultaneously learns a freezeable sparse topology and a freezeable channel set within the graph domain, ensuring a deterministic inference path and controllable complexity. The specific steps are as follows: S1. Collect the vibration time-series signal of rotating machinery and map the vibration time-series signal into a node feature matrix containing several nodes; S2. Select the nearest neighbor edge and the sequence prior edge for each node, and construct a candidate adjacency matrix A containing the candidate edges; S3. Construct node pair features on the candidate edges of the candidate adjacency matrix A, determine the edge retention probability based on the node pair features, and filter the nodes and edges to obtain sparse effective adjacencies. S4. Construct a graph convolutional network with a branching gating mechanism. In each graph convolutional layer, determine the channel gating vector based on the channel global statistics of node features. Divide the node feature matrix of the graph convolutional network into a propagation branch that performs graph propagation aggregation on sparse effective adjacency and a bypass branch that preserves the original representation through identity mapping. S5. Linearly fuse the propagation branch aggregation results with the bypass branch to output node features; S6. Node features are aggregated at the graph level to obtain a sample-level representation vector, which is used to determine the probability distribution of fault categories; S7. Select the category with the highest probability in the fault category probability distribution as the fault diagnosis result.

[0008] Further, in step S1, mapping the vibration time series signal into a node feature matrix containing several nodes specifically includes: dividing each vibration time series signal into P local patches of a fixed length L to construct a labeled sample set; mapping each local patch after division into a node feature vector to obtain a node feature matrix containing N nodes.

[0009] 3. A method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that step S2 specifically includes: performing nearest neighbor search on nodes based on node feature similarity, selecting several nearest neighbor edges for each node, introducing sequential prior edges, taking the union of the nearest neighbor edges and the sequential prior edges to obtain a candidate edge set, and constructing a candidate adjacency matrix A containing the candidate edges based on the candidate edge set.

[0010] Further, step S3 specifically includes: performing star-anchor screening structure sparsification on the candidate adjacency matrix A, restricting the candidate edges of each node to the sequence neighborhood, and constructing node pair features for the candidate edges, which are then evaluated by a lightweight scoring function. Candidate edges are scored to obtain edge scores. Edge retention is performed on the corresponding sequence neighborhood of each node to form a binary directed mask M. The binary directed mask M is then applied to the candidate adjacency matrix A to obtain sparse effective adjacency, which is used for subsequent graph propagation. Among them, the star anchor is a radial local receptive field constructed based on the anchor point in a star-shaped network. The sequence neighborhood limits the range of nodes corresponding to temporally adjacent segments for each node's candidate edges.

[0011] Furthermore, based on the pairwise characteristics of nodes, the edge retention probability is determined to filter nodes and edges, resulting in sparse and effective adjacencies, including: The paired features of the nodes of the candidate edges are input into a lightweight scoring function and mapped to the edge retention probability via a sigmoid function. The mathematical expression of this function is as follows: (1) in, These are paired features used for scoring; For the first i The feature vector of each node; For the first j The feature vector of each node; It is a lightweight scoring function; Edge retention probability score; Scoring is based on scalar values. These are learnable, scoreable weights; For learnable rating bias; For activation functions; During the training phase, differentiable relaxation is used for end-to-end optimization, mathematically expressed as follows: (2) in, To preserve variables for the edges after differentiability relaxation; Output the score function for the candidate edges; It follows a standard Logistic distribution with a location parameter of 0 and a scale parameter of 1, introducing randomness to allow sampling of different structures during the training phase; To control the degree of relaxation.

[0012] During the training phase, probability calculations are performed on each node within its corresponding candidate neighbor set to obtain a binary directed mask M, forming a sparse and efficient adjacency graph structure, the mathematical expression of which is as follows: (3) in, For sorting ranking operators; Let v be a central node; v be a node adjacent to the central node; and r be any neighboring node in the candidate neighborhood set. Preserve the probability for the edge; To set The ranking after sorting by probability from largest to smallest; It is a binary directed mask.

[0013] Furthermore, step S4 specifically includes: generating channel-level gating vectors in each graph convolutional layer based on the global channel statistics of node features. Differentiable relaxed soft gates are generated through differentiable gating. The input features of the graph convolutional network are divided into propagation branches according to channel importance. and side roads Only for the propagation branch Perform graph propagation aggregation on sparse effective adjacencies, and bypass branches. The original representation is preserved through identity mapping; the outputs of the propagation branch and the bypass branch are fused through a learnable weight matrix as the output of the graph convolutional layer.

[0014] Furthermore, the channel gating vector in step S4 Differentiable gating is used to generate differentiable relaxed soft gates during the training phase. The channel importance statistics use the global average activation of all nodes in the graph along the channel dimension as the channel description, and the mathematical expression is as follows: (4) in, For the first i All channel characteristics of each node; N The number of nodes; C Number of channels; u For channel C Average activation across the entire image; A differentiable relaxed gate logit is obtained through lightweight mapping; during the training phase, a differentiable relaxed soft gate is generated using Gumbel Sigmoid relaxation. The mathematical expression is as follows: (5) in, s To obtain gated values ​​using lightweight mapping; For gating weights; This is a gated paranoia term; It is a differentiable, relaxable soft gate value; Control the degree of relaxation; It follows a standard Logistic distribution with a location parameter of 0 and a scale parameter of 1, introducing randomness to allow sampling of different structures during the training phase; For activation functions; The k channels with the highest probabilities are obtained, retained, and used in graph propagation. The mathematical expression for this is as follows: (6) in, z For the determined channel-level gate value; To spread the message, For direct access to a side road; This indicates element-wise multiplication. This is the activation function.

[0015] Furthermore, in step S5, the propagation branch and the bypass branch are linearly fused using a learnable weight matrix and then superimposed with biases to obtain the layer output, as mathematically expressed below: (8) in, These are node features obtained by performing graph convolution only on the gated reserved channels; For learnable weights, It is a non-linear activation function; For the first The node feature matrix of the layer; This is the linear transformation weight matrix used for the fusion of the two branches; b This is the bias vector.

[0016] Furthermore, the fault diagnosis results in step S7 include atlas representation and classification output, mathematically expressed as follows: (9) in, The sample-level representation after one training epoch; These are learnable weights; For learnable bias; The results are output for classification.

[0017] Furthermore, the edge retention probability is determined based on a lightweight scoring function. During the training phase of the graph convolutional network, the method also includes: The lightweight scoring function and the diversion gating mechanism were trained and optimized. The training objective function includes a classification loss and lightweight constraint terms. The lightweight constraint terms include a channel utilization penalty term and a structural sparsity penalty term, which are used to simultaneously constrain the channel retention ratio and the edge retention ratio. The mathematical expression is as follows: (10) (11) (12) in, For classification loss; It is a learnable scalar; Incentive coefficient for channel utilization; These are sparse regularization coefficients; For the candidate edge set; This is the channel penalty coefficient; For channel utilization; This is the structural penalty coefficient; For structural utilization rate.

[0018] Compared with the prior art, the present invention achieves the following technical effects: 1. This invention reduces the computational overhead of redundant channels participating in neighborhood aggregation by channel diversion gating.

[0019] 2. This invention explicitly learns deployable sparse topologies through structural sparsification.

[0020] 3. This invention reduces the structural inconsistency problem caused by multi-stage pruning by using a single-stage process that is decoupled through training and deduction.

[0021] 4. This invention can significantly reduce the number of parameters and computational load in experimental datasets while maintaining high diagnostic accuracy, and also has better robustness under noise disturbances. Attached Figure Description

[0022] For ease of explanation, the present invention will be described in detail below with reference to specific embodiments and accompanying drawings.

[0023] Figure 1 This is a flowchart illustrating the specific implementation of the present invention.

[0024] Figure 2 A diagram illustrating the pruning architecture for training and inference.

[0025] Figure 3 This is a schematic diagram of the principle of flow graph convolution.

[0026] Figure 4 The results are shown for four ablation experiments on a self-built dataset; (a) is the training accuracy curve; (b) is the validation accuracy curve; (c) is the training loss curve; and (d) is the validation loss curve.

[0027] Figure 5 The following are the confusion matrices for four ablation experiments under a self-built dataset: (a) is the confusion matrix of the proposed method; (b) is the graph convolution confusion matrix with splitting and no pruning; (c) is the graph convolution confusion matrix with pruning and no splitting; and (d) is the graph convolution confusion matrix.

[0028] Figure 6 The graph structures formed by the nodes of the unpruned model and the model with redundant edges removed are compared; where (a) is the graph structure before pruning; and (b) is the graph structure after pruning.

[0029] Figure 7 The results show the comparison of nine lightweight methods; where (a) is the training loss curve; (b) is the training accuracy curve; (c) is the test loss curve; and (d) is the test accuracy curve.

[0030] Figure 8 Let t-SNE represent the inter-class separability of each model; where (a) Proposed method; (b) Resnet18; (c) Msresnet; (d) Mobilenetv2; (e) Mcswint; (f) Mobilenet; (g) Liconvformer; (h) Convformer-small; (i) Clformer.

[0031] Figure 9For inference efficiency and latency analysis; where (a) Throughput Scaling by Batch; (b) ModelSize vs Latency.

[0032] Figure 10 The results are the noise robustness test results; where (a) is the diagnostic accuracy of each model; and (b) is the relative accuracy reduction rate of each model. Detailed Implementation

[0033] The following are specific embodiments of the present invention, described in conjunction with the accompanying drawings, to further illustrate the technical solutions of the present invention. However, the present invention is not limited to these embodiments. Specific details, such as particular configurations, are provided in the following description merely to aid in a comprehensive understanding of the embodiments of the present invention. Therefore, those skilled in the art should understand that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of the present invention.

[0034] It should be noted that, unless otherwise specified, the embodiments and features described in this invention can be combined with each other.

[0035] The embodiments of the present invention will be further described in detail below with reference to the accompanying drawings.

[0036] Example 1 like Figure 1 As shown, this invention provides a method for diagnosing rotating machinery faults based on a lightweight star-sieve flow-diversion graph convolutional network, including the following: S1. Collect the vibration time sequence signal of the rotating machinery and map the vibration time sequence signal into a node feature matrix containing several nodes.

[0037] The aforementioned vibration timing signals include vibration acceleration signals, velocity signals, displacement signals, or multi-sensor fusion signals of rotating machinery.

[0038] This application uses vibration acceleration signals as an example for illustration. Vibration acceleration signals or multi-channel time-series signals of rotating machinery (bearings, gearboxes, etc.) under different states are collected, and each sample is labeled with a corresponding health status or fault type label. After collection, mean removal, detrend detrending, z-score outlier removal, normalization, and alignment by sample length are performed to obtain the required samples, ensuring that each sample has consistent data dimensions when entering subsequent segmentation and mapping.

[0039] Furthermore, a patch-to-node mapping is performed on each sample. The samples are segmented according to a fixed window length and step size, with each sample signal divided into P local segments of a fixed length. The fixed length is set to L, and the step size to S. A labeled sample set is constructed, and all the segmented samples are randomly divided into training, validation, and test sets in a 6:2:2 ratio to ensure no temporal overlap or data leakage between different sets. During the partitioning process, the distribution of fault types in each set is kept balanced to avoid data leakage, ultimately resulting in a standardized labeled time-series sample set.

[0040] Each local segment after the above division is mapped to a node feature vector, resulting in a node feature matrix containing N nodes.

[0041] S2. Select the nearest neighbor edge and the sequence prior edge for each node, and construct a candidate adjacency matrix A containing the candidate edges.

[0042] This application constructs a candidate graph based on node feature similarity for subsequent pruning and star-based flow division. Specifically, it performs nearest neighbor search on nodes based on node feature similarity, calculates their feature similarity, and selects k nearest neighbor edges for each node. Simultaneously, it introduces sequential prior edges, and takes the union of the nearest neighbor edges and the sequential prior edges to obtain a candidate edge set. A candidate adjacency matrix A is generated based on the candidate edge set. In some embodiments, the aforementioned feature similarity can be Gaussian kernel similarity.

[0043] In other embodiments, a normalized adjacency matrix for graph propagation is obtained by symmetrizing and degree-normalizing the candidate adjacency matrix A. Finally, candidate graphs are obtained. Normalized adjacency matrix. It provides a set of candidate adjacent edges to serve as a carrier for subsequent structural sparsification.

[0044] S3. Construct node pair features on the candidate edges of the above candidate adjacency matrix A, and perform node edge screening based on the edge retention probability determined by the above node pair features to obtain sparse effective adjacency.

[0045] like Figure 2 As shown, this application introduces StarSift K explicit structural sparsification at the graph structure level. By learning edge preserving probabilities and performing probability calculations for each node, a sparse directed mask is obtained. Combined with a single-stage pruning architecture that decouples training and inference, the channel gating and structural mask are discretized and frozen after training, thereby obtaining a lightweight model that can be directly deployed.

[0046] Specifically, the saliency score of all nodes is calculated, and the nodes with the highest scores are selected to form a star graph set. Candidate edges for each node are restricted to their sequential neighborhood, and pairwise features are constructed for each candidate edge. This is achieved using a lightweight scoring function. Candidate edges are scored to obtain edge scores. For each node, edge preservation is performed in its sequential neighborhood to form a binary directed mask M. The binary directed mask M is applied to the candidate adjacency matrix A to obtain sparse and effective adjacencies for subsequent graph propagation.

[0047] Specifically, a star graph set is constructed to constrain the candidate connection range with salient nodes as the structural center, reducing the candidate edge search space and suppressing the introduction of weakly related edges, thereby achieving controllable sparsity of the adjacency structure while ensuring the effectiveness of graph propagation. The sequence domain limits the candidate edges of each node to the range of nodes corresponding to temporally adjacent segments.

[0048] The node pairwise features of the candidate edges are input into a lightweight scoring function and mapped to the edge retention probability via a sigmoid function. The mathematical expression of this function is as follows: (1) in, These are paired features used for scoring; For the first i The feature vector of each node; For the first j The feature vector of each node; It is a lightweight scoring function; Edge retention probability score; Scoring is based on scalar values. These are learnable, scoreable weights; For learnable rating bias; For activation functions; Differentiable relaxation is used for end-to-end optimization during the training phase, and its mathematical expression is as follows: (2) in, To preserve variables for the edges after differentiability relaxation; Output the score function for the candidate edges; It follows a standard Logistic distribution with a location parameter of 0 and a scale parameter of 1, introducing randomness to allow sampling of different structures during the training phase; To control the degree of relaxation.

[0049] During the training phase, probability calculations are performed on each node within its candidate neighbor set to obtain a binary mask M, thereby forming a sparse directed graph structure, the mathematical expression of which is as follows: (3) in, For sorting ranking operators; Let v be a central node; v be a node adjacent to the central node; and r be any neighboring node in the candidate neighborhood set. Preserve the probability for the edge; To set The ranking after sorting by probability from largest to smallest; It is a binary directed mask.

[0050] S4. Construct a graph convolutional network with a branching gating mechanism. In each graph convolutional layer, determine the channel gating vector based on the channel global statistics of node features. Divide the input features of the graph convolutional network into propagation branches that perform graph propagation aggregation on sparse effective adjacencies and bypass branches that preserve the original representation through identity mapping.

[0051] like Figure 3 The diagram shown is a schematic of the graph convolutional network provided in an embodiment of this application. This application introduces a branching gating system during the graph convolution propagation stage to divide the channel into propagation branches that participate in neighborhood aggregation and bypass branches that maintain the original representation.

[0052] Specifically, in each graph convolutional layer, a channel-level gating vector is generated based on the global channel statistics of node features. Differentiable relaxed soft gates are generated through differentiable gating. The node features are divided into propagation branches according to the importance of the channel. and side roads Only for the propagation branch Graph propagation aggregation is performed on valid adjacencies, bypassing branches. The original representation is preserved through identity mapping. The outputs of the two branches are fused using a learnable weight matrix to serve as the output of the graph convolutional layer.

[0053] Among them, the channel gating vector Differentiable gating is used to generate differentiable relaxed soft gates during the training phase. The channel importance statistics use the global average activation of all nodes in the graph along the channel dimension as the channel description, and its mathematical expression is as follows: (4) in, For the first Layer input features; N The number of nodes; C u is the number of channels; u is the number of channels. C Average activation across the entire image.

[0054] A differentiable relaxed gate logit is obtained through lightweight mapping; during the training phase, a differentiable relaxed soft gate is generated using Gumbel Sigmoid relaxation. Its mathematical expression is as follows: (5) in, s To obtain gated values ​​using lightweight mapping; For gating weights; This is a gated paranoia term; It is a differentiable, relaxable soft gate value; Control the degree of relaxation; It follows a standard Logistic distribution with a location parameter of 0 and a scale parameter of 1, introducing randomness to allow sampling of different structures during the training phase; This is the activation function.

[0055] We obtain the k channels with the highest probabilities and retain them for graph propagation, so that only the retained channels participate in graph propagation. The mathematical expression is as follows: (6) in, z For the determined channel-level gate value; To spread the message, For direct access to a side road; This indicates element-wise multiplication. This is the activation function.

[0056] In step S4, the graph propagation of the propagation branches uses a longitude-normalized adjacency matrix for neighborhood aggregation, mathematically expressed as follows: (7) Where A is the basic adjacency matrix; m is a learnable sparse mask matrix; To expand the adjacency matrix; It is a symmetric normalized adjacency matrix; The weighted degree of each node; This is the angle matrix. Bypass branches directly transmit the channel features that did not participate in the aggregation.

[0057] S5. Linearly fuse the propagation branch aggregation results with the bypass branch to output node features.

[0058] In this embodiment, the propagation branch and the bypass branch are linearly fused using a learnable weight matrix and then superimposed with a bias to obtain the layer output, as expressed mathematically below: (8) in, These are node features obtained by performing graph convolution only on the gated reserved channels; For learnable weights, It is a non-linear activation function; For the first The node feature matrix of the layer; This is the linear transformation weight matrix used for the fusion of the two branches; b This is the bias vector.

[0059] This application follows a causal order of determining the structure first and then propagating, placing the StarSift K (Star Anchor Screening) before the SplitStream GConv (Split Graph Convolutional Layer). StarSift K learns the edge probabilities at each central node, generating a directed binary mask as an effective adjacency. Considering the balance between receptive field and complexity, this embodiment sets the SplitStream GConv to three layers. The SplitStream GConv propagates messages only on the retained channels based on channel gating; unretained channels retain their original representations through direct branches. The output of this layer is obtained by linearly fusing the output of the propagation branch with the features of the bypass branch. The output is the node features after propagation via SplitStream split gating, and after multiple layers are stacked, the final node representation is formed, providing a feature foundation for subsequent classification.

[0060] In this embodiment, the graph convolution output is classified using global mean aggregation and a multilayer perceptron. The optimizer jointly updates the structure scoring function and convolution parameters based on the training loss, and saves the weights and sparse structure after convergence. During testing, the same front-end processing as during training is reused, loading the initial features and a fixed directed mask into the model, eliminating edge scoring and node-level selection to maintain a defined computational path and controllable overhead. The predicted probabilities and labels are obtained through SplitStream GConv, global aggregation, and a classifier. Finally, the results area displays visualizations such as accuracy and macro-average metrics to measure the model's diagnostic performance and stability on different datasets.

[0061] The specific implementation process includes the following steps: S6. Node features are aggregated at the graph level to obtain sample-level representation vectors, in order to determine the probability distribution of fault categories.

[0062] S7. Select the category with the highest probability from the above fault category probability distribution as the fault diagnosis result.

[0063] Specifically, by performing graph-level aggregation on the node features of the last graph convolutional layer, a sample-level representation is obtained as the output. g The sample-level representation is input into the classifier, which outputs a probability distribution of fault categories. The category with the highest probability is taken as the diagnostic result, enabling the identification of types such as healthy status, inner race faults, outer race faults, and rolling element faults. The output of S7 includes atlas representation and classification output, and its mathematical expression is as follows: (9) in, The sample-level representation after one training epoch; These are learnable weights; For learnable bias; Results for classification Furthermore, to learn deployable lightweight structures, this application simultaneously learns channel sparsity and structural sparsity during the training phase. Specifically, a lightweight scoring function and a diversion gating mechanism are used for training optimization. The training objective function includes a classification loss and lightweight constraint terms, where the lightweight constraint terms include a channel utilization penalty term and a structural sparsity penalty term, used to simultaneously constrain the channel retention ratio and the edge retention ratio, mathematically expressed as follows: (10) (11) (12) in, For classification loss; It is a learnable scalar; Incentive coefficient for channel utilization; These are sparse regularization coefficients; For the candidate edge set; This is the channel penalty coefficient; For channel utilization; This is the structural penalty coefficient; For structural utilization rate.

[0064] After training converges, the channel-level gate vector and the binary directed mask M are discretized and frozen.

[0065] This invention employs piecewise sampling to map time-series signals into graph nodes and constructs an initial graph structure using nearest neighbor search. SplitStream gating is introduced into the graph convolutional propagation, using differentiable gating to learn channel retention probabilities during training and obtain deterministic channel retention during inference. StarSift K explicit structural sparsification is introduced at the graph structure level, learning edge retention probabilities and performing probability calculations for each node to obtain a sparse directed mask. A single-stage pruning architecture decouples training and inference, and after training, discretizes and freezes the channel gating and structural mask to obtain a lightweight model that can be directly deployed. Finally, the fault category or health status is output.

[0066] To verify the effectiveness of the method of the present invention, experiments were conducted on multiple rotating machinery fault datasets, which are illustrated in the following examples: Example 2 To verify the effectiveness of this method, it was implemented in PyTorch and used to diagnose bearing and gear faults under different operating conditions. To ensure reproducibility and fair comparison, the training hyperparameters, learning strategies, and computation modes were configured uniformly and remained consistent across all datasets and model comparisons. Specific hyperparameters are shown in Table 1. The specific environment was as follows: PyTorch version 2.6.0; CPU model i5-13600KF; GPU model RTX4060Ti.

[0067] Table 1 Network Hyperparameter Settings

[0068] To evaluate the contribution of each component to the model performance, ablation experiments were conducted on three types of vibration datasets: a self-built bearing dataset collected under fixed speed conditions, the OU-bearing public dataset with variable speed conditions, and the XJTU-gearbox dataset containing both gear and bearing faults. To ensure sufficient and stable input for the model, a sliding window was first used to construct samples from the vibration signals of each dataset: a window with a length of 2048 sampling points and a step size of 2048 was used for the self-built dataset, while a window with a length of 4096 sampling points and a step size of 4096 was used for the other two types of public datasets. These settings ensured that no two samples overlapped. Subsequently, all samples were divided into training, validation, and test sets in a ratio of 0.7 / 0.15 / 0.15.

[0069] A total of 14,880 samples were obtained from the self-built dataset, including 10,416 in the training set, 2,232 in the validation set, and 2,232 in the test set. A total of 29,280 samples were obtained from the OU-bearing dataset, including 20,496 in the training set, 4,392 in the validation set, and 4,392 in the test set. From the XJTU-gearbox dataset, 3,612 were obtained for training, 774 for validation, and 774 for test. The samples from the three datasets were stored independently, as shown in Table 2. z-score normalization was applied to all samples within each dataset. During the training phase, 64 samples were randomly selected from the training set of a single dataset to form a batch input to the model. The model then used the Softmax function in the output layer to obtain diagnostic results for 10 work condition categories.

[0070] Table 2 Sample Division of Each Dataset

[0071] To evaluate whether pruning has a significant impact on diagnostic results, four ablation experiments were designed, including: (1) the complete method, which includes channel splitting of StarSift-K structure selection and SplitStream graph convolution; (2) removing structure pruning, retaining SplitStream graph convolution, and training and inference on the unpruned k-nearest neighbor graph; (3) removing channel splitting, keeping StarSift-K structure selection unchanged, and replacing it with regular graph convolution; and (4) removing both channel splitting and structure pruning, and using regular graph convolution on the unpruned graph. The loss and accuracy curves of the training and testing ends using a self-built dataset are shown below. Figure 4 As shown, the confusion matrix results for each model are as follows: Figure 5 As shown, the specific results of the ablation experiments for each dataset are shown in Tables 3, 4 and 5.

[0072] from Figure 4 As can be seen, all four methods converged rapidly within 30 training epochs. TrainAccuracy improved rapidly from 0.7 in the first epoch, exceeding 0.96 between epochs 5 and 10, and approaching 1.0 after epochs 15; TrainLoss decreased synchronously, approaching zero after epochs 15. ValAccuracy remained between 0.96 and 0.98 throughout, with small fluctuations; ValLoss stabilized around 0.08 to 0.12, without continuing to rise with training. The gap between the TrainLoss and ValLoss curves was very small, indicating that the risk of overfitting was controlled. Comparing the four curves, the proposed method showed less fluctuation in the Train and ValLoss curves. Compared to the GCN-Prune and GCN curves, the proposed method was more stable after 15 epochs, and the short-term fluctuations in individual epochs did not change the overall trend; in the Train and ValAccuracy curves, compared to the GCN curve, the proposed method showed larger fluctuations in the last epochs. Overall, it demonstrates a more stable optimization process and better generalization.

[0073] Figure 5 The four confusion matrices show that the main diagonal is almost completely filled with dark colors, indicating that the recall rates for all categories are at a high level. The proposed method presents nearly full diagonal elements across all categories, with off-diagonal elements appearing only sporadically, mainly between adjacent sizes of the same fault type, representing typical confusion for hard-to-distinguish samples. Compared to the baseline GCN and variants of GCN-Prune or GCN-SplitStream, the latter two still exhibit a small number of misclassifications shifting to adjacent categories, while the proposed method further reduces off-diagonal elements on these sensitive pairs. This phenomenon demonstrates that the method not only improves overall accuracy but, more importantly, enhances inter-class discriminative consistency, reducing errors caused by fine-grained differences.

[0074] Table 3 Results of ablation experiments using a self-built dataset

[0075] Table 4 shows the results of ablation experiments on the OU-bearing dataset.

[0076] Table 5 shows the results of ablation experiments on the XJTU-gearbox dataset.

[0077] As can be seen from Tables 3-5, under the baseline configuration of retaining only the GCN backbone and not using pruning or channel splitting, the average accuracies on the self-built dataset, OU-bearing dataset, and XJTU-gearbox dataset are 97.59%, 98.52%, and 98.52%, respectively, and the F1 scores are 97.60%, 99.60%, and 99.86%, respectively. The number of parameters is 0.26M, and the corresponding FLOPs are 3.16M, 6.20M, and 5.10M, respectively. This configuration has the lowest accuracy but the highest computational cost among the four configurations.

[0078] After overlaying Prune onto the GCN backbone, the number of parameters on the three datasets uniformly decreased from 0.26M to 0.18M, ​​a reduction of approximately 30.8%. Simultaneously, FLOPs decreased from 3.16M to 2.68M, from 6.20M to 5.26M, and from 5.10M to 4.32M, respectively, representing reductions of approximately 15.2%, 15.3%, and 15.2%. Based on this, the average accuracy remained at 97.64%, 98.54%, and 99.98%, and the F1 score improved to 97.73%, 99.92%, and 99.92%, indicating that structural pruning significantly reduced model size without sacrificing, and even slightly improved, classification performance.

[0079] Introducing SplitStream without structural pruning resulted in a moderate decrease in model size and computational cost across the three datasets: the number of parameters decreased from 0.26M to 0.24M, a reduction of approximately 7.7%; FLOPs decreased from 3.16M, 6.20M, and 5.10M to 2.72M, 5.34M, and 4.39M, respectively, a reduction of approximately 13%-14%. Based on this, the average accuracy improved from 97.59%, 98.52%, and 98.52% to 97.86%, 98.76%, and 99.98%, representing increases of 0.27, 0.24, and 1.46 percentage points, respectively; and the F1 score improved from 97.60%, 99.60%, and 99.86% to 97.87%, 99.92%, and 99.99%. Notably, on the XJTU-gearbox dataset, the SplitStream configuration achieved near-maximum Accuracy_mean and F1 scores among all configurations. Therefore, channel-level gating can filter effective channels to participate in graph propagation and retain redundant channels through bypass, significantly improving feature utilization efficiency and fault category identification capability. It is a key component for improving model accuracy and robustness.

[0080] When Prune and SplitStream are enabled simultaneously, the number of parameters on all three datasets is uniformly reduced to 0.16M, and FLOPs are reduced to the lowest level among the four configurations, while Accuracy_mean and F1 remain at the optimal or near-optimal levels for each dataset. Based on these results, we can conclude that GCN provides the necessary foundation for graph relationship modeling, Prune is responsible for eliminating redundant edges at the structural level and achieving dominant complexity compression, and SplitStream suppresses redundant features at the channel level and significantly improves diagnostic performance. Without any one of these modules, the model either struggles to achieve its current lightweight level or exhibits significant performance degradation on at least one dataset; therefore, all three are irreplaceable key components in the overall framework. A comparison of the graph structure formed by the nodes of the unpruned model and the model with redundant edges removed is provided. Figure 6 As shown.

[0081] Example 3 Ablation experiments alone can only verify the effectiveness of individual modules and are insufficient to demonstrate the overall advantage of the proposed model on different datasets. Therefore, this invention selects several typical lightweight networks proposed in recent years as controls, including Mcswint, ResNet18, Msrenet, Clformer, Convformer-small, MobileNet, MobileNetV2, Liconvformer, ESC-DGCN, FDGCN, and the method of this invention, to construct a comparative experiment. The comparison results of 10 lightweight methods on the OU-bearing dataset are as follows: Figure 7As shown, detailed values ​​for the three datasets are shown in Tables 6, 7, and 8.

[0082] Table 6. Results of the comparative experiment on the self-built dataset.

[0083] Table 7 shows the results of the comparative experiment on the OU-bearing dataset.

[0084] Table 8 shows the comparative experimental results on the XJTU-gearbox dataset.

[0085] from Figure 7 As can be seen, on the training side, the method of this invention has higher sample efficiency, achieving an accuracy of over 98% within 3-5 epochs, and the training loss is close to zero after 10 epochs. MSResNet and Clformer converge slightly slower, reaching a training accuracy of around 0.96 within 5-8 epochs, followed by the two graph convolutional models ESC-DGCN and FDGCN. ResNet18 and the two MobileNet variants require approximately 10-15 epochs to reach similar levels, while Clformer and conformer-small decrease the slowest, still retaining a training loss of approximately 0.1-0.2 at the end of 30 epochs. This indicates that, with the same training budget, this method can reach high-accuracy platforms more quickly.

[0086] The proposed method also demonstrates significant stability and generalization advantages in validation. Its validation loss remains consistently between 0.5 and 0.1, with validation accuracy consistently around 95%–98% throughout training, exhibiting virtually no oscillations. Using 95% validation accuracy as a threshold, the method reaches this threshold within 3–5 epochs. The validation curves of ESC-DGCN and FDGCN show similar trends to MSResNet and LiConformer, requiring 5–8 epochs to reach this level. ResNet18 and the MobileNet family typically require 8–12 epochs and exhibit a marked decline. Clformer and conformer-small require even longer to stabilize. These observations indicate that the proposed method is more robust in the early stages and maintains a smaller gap between training and validation. The comparison results across the three datasets show that the proposed model consistently achieves the highest or tied-highest Accuracy, F1, and AUC metrics on all three datasets. The model achieves an accuracy of 98.62% on the self-built dataset, and 98.87% and 99.98% on OU-bearing and XJTU-gearbox, respectively. It outperforms the other eight lightweight models under different operating conditions and data structures, demonstrating stable cross-dataset generalization ability. Furthermore, this stability indicates that the network extracts not random features specific to a single test bench, but rather structural representations with stronger commonalities in the failure mechanism: StarSift-K explicitly filters out high-confidence associations that recur under various operating conditions at the node level, while SplitStream-GConv suppresses redundant responses with weak discriminative contributions at the channel level. This allows the model to align key vibration modes even when sensor position, load, and rotational speed change, thus maintaining highly consistent classification performance in cross-dataset tests.

[0087] Based on the three sets of comparisons, the proposed model consistently achieved the highest or tied-highest accuracy, F1 score, and AUC across all three datasets. It achieved an accuracy of 98.62% on the self-built dataset and 98.87% and 99.98% on the OU-bearing and XJTU-gearbox datasets, respectively. Under different operating conditions and structural configurations, it outperformed ten other lightweight models covering convolutional architectures, lightweight transformers, and two graph convolutional networks (ESC-DGCN and FDGCN). This demonstrates the model's stable cross-dataset generalization ability. Furthermore, this stable advantage suggests that the network does not merely capture random features specific to a single testbed, but rather learns structural representations more closely related to underlying failure mechanisms. StarSift-K explicitly selects high-confidence edges that recur under multiple operating conditions at the node level, while SplitStream-GConv suppresses redundant channel responses with weak discriminative contributions. Therefore, the model can still align key vibration modes when sensor position, load, and rotational speed change, thus maintaining highly consistent classification performance across datasets.

[0088] Compared to graph convolutional models such as ESC-DGCN and FDGCN, this model still improves accuracy and F1 score by approximately 0.1%-2% overall across the three datasets, while its parameter count is only about 1.4% of ESC-DGCN and about 0.7% of FDGCN. Simultaneously, the number of FLOPs is reduced from tens of millions or even hundreds of millions to single-digit millions. This indicates that, within a similar graph structure modeling paradigm, this method achieves a more favorable balance between lightweight design and generalization performance.

[0089] Compared to typical convolutional baselines, the proposed method offers advantages in both accuracy and complexity. Taking ResNet18 as an example, its accuracy on three datasets is generally 0.5-1.1 percentage points lower than the proposed method, while the number of parameters is almost an order of magnitude higher. The proposed model's 0.16M parameters correspond to only 4.16% of ResNet18, with FLOPs remaining at the same order of magnitude or even slightly lower. Compared to the MSResNet and MobileNet families, the proposed model achieves higher accuracy and F1 score with a significant reduction in parameters, reflecting higher parameter utilization efficiency. Traditional convolutional networks primarily rely on the repeated sliding of local kernels along the time axis, resulting in the same region often being encoded multiple times by stacked convolutional layers. In contrast, LSS-GCN performs node-level aggregation on the graph structure: through edge selection, time periods with similar degradation patterns are aggregated into a few representative nodes, on which channel gate control is applied. This concentrates a limited number of parameters on the channels most sensitive to structural differences, significantly increasing the contribution of each parameter to the final decision.

[0090] Compared to lightweight transformer-based architectures, this method achieves a better balance between computational cost and performance. Models such as MCswinT, Conformer-small, and LiConformer approach the proposed method on some metrics, but they typically require several to tens of times more flops, making it difficult to meet the inference cost constraints in engineering deployment scenarios. Even compared to Clformer, which has the fewest parameters in the baseline, the proposed model still improves accuracy by about 1-2 percentage points on three datasets, while its parameters and FLOPs remain at a very low lightweight level, resulting in higher diagnostic accuracy within a small model range. From a structural perspective, self-attention modules model global correlations to compensate for the limited receptive field of convolutions. However, for fault diagnosis of vibration sequences of medium length and relatively concentrated frequency bands, the large number of matrix multiplications and soft normalization introduced by global attention cannot be fully translated into effective discriminative information, instead increasing the risk of overfitting and numerical instability. In contrast, this method explicitly establishes long-range dependencies between key time periods at the topological level through graph structure learning, using sparse adjacency to replace dense attention. This significantly compresses the computational graph while preserving necessary long-range interactions, thus achieving higher classification performance with comparable or even lower complexity. Based on the above comparisons, the proposed model achieves the highest classification performance on three datasets simultaneously: self-built data, OU-bearing, and XJTU-gearbox, while maintaining extremely low parameter count and moderate computational cost, placing it at a superior position in the accuracy-complexity trade-off curve. Compared to various existing lightweight convolutional and Transformer structures, this method demonstrates better performance stability and deployment friendliness under multiple datasets and conditions, fully demonstrating the effectiveness of the proposed structure learning and channel splitting design in fault diagnosis tasks.

[0091] Example 4 To evaluate the separability and boundary clarity of different models in the feature space, second-layer test features were extracted for each model on the OU-bearing dataset, and mapped from the high-dimensional representation to a two-dimensional plane using t-distributed random neighbor embeddings (t-SNE). In the visualization, each point corresponds to a sample, and the color represents five classes: healthy tomography, in-race tomography, out-race tomography, spherical tomography, and composite tomography. The results are as follows: Figure 8 As shown.

[0092] from Figure 8Quantitative measurements of intra-class distance (IntraCD) and inter-class centroid distance (InterCD) show that this method has the lowest IntraCD (12.74) and the highest InterCD (74.64) among all models for the five fault categories. This indicates that the intra-class distribution is the most compact and the inter-class separation is the largest in the two-dimensional embedding space; the composite fault cluster also exhibits relatively small intra-class dispersion and a large centroid distance from the other four classes. ResNet18 and MSResNet have IntraCD values ​​of 14.28 and 13.99, and InterCD values ​​of 72.34 and 72.88, respectively. Their overall clustering quality ranks second, with relatively regular cluster formation, but slightly lower intra-class compactness and inter-class separation. The IntraCD values ​​of the convolutional baselines ESC-DGCN and FDGCN are 15.10 and 16.95, respectively, and the InterCD values ​​are 70.51 and 68.39, respectively, which are worse than the method proposed in this invention. They are also slightly lower than ResNet18 and MSResNet in terms of compactness and separation.

[0093] The IntraCD values ​​of MobileNetV2 and MobileNet are between 14.3 and 14.5, while their InterCD values ​​are around 70. Compared to the models mentioned above, their intra-class dispersion is increased, while the inter-class centroid distance is reduced, resulting in a looser decision boundary. MCswint's IntraCD is similar to these two models, but its InterCD further decreases to 68.95, indicating weaker class separation. licconvformer and conformer-small have IntraCD values ​​of 20.71 and 25.65, respectively, far exceeding other models, while their InterCD values ​​are only around 66, indicating the largest intra-class dispersion and the most severe cluster overlap. Clformer has an IntraCD value of 16.42 and an InterCD value of 67.93, with clustering quality falling between the two groups mentioned above. In summary, by combining IntraCD and InterCD, this method achieves the best performance in terms of intra-class compactness and inter-class separation, outperforming not only convolution and transformer-based backbones but also graph convolution. This is consistent with the previously reported accuracy of F1 and AUC, indicating that the model has built a clearer manifold-like structure and a more robust decision boundary during the representation learning phase.

[0094] To further verify the efficiency of the lightweight star-sieve split graph convolution, this section reuses the model pool from the previous comparative experiments, using "throughput vs. batch size" and "parameter count vs. single-sample latency" as the core axes to quantitatively analyze the relationship between network structure and runtime performance. Here, the p50 latency (50th percentile latency) is used as the representative response time, meaning that the end-to-end latency of 50% of requests is no greater than this value. The goal is to evaluate the balance between "lightweight design" and "inference efficiency" of LSS-GCN. The results are as follows... Figure 9 As shown, where Figure 9 (a) The impact of batch size on throughput was plotted. Figure 9 (b) shows the scatter plot relationship between the parameter count and the 50th percentile delay (p50 delay, i.e., median delay) for each sample.

[0095] like Figure 9 As shown in (a), the throughput of all models increases as the batch size increases from 1 to 16, but the growth slopes differ significantly, reflecting their varying capabilities in utilizing parallel computing resources. In the case of large batches, the throughput advantage of this method is approximately 30%-60% compared to ResNet18 and MobileNetV2, and more than double that of MCswint. In the GCN model, the throughput-batch size curve of ESC-DGCN is close to that of the method described in this invention, while FDGCN remains in the middle layers, higher than most transformer-based models, but still lower than the network of this invention and the best convolutional backbone. This indicates that graph structure sparsity and channel segmentation reduce the computational and memory access burden per sample, thus achieving a more significant throughput gain when processing multiple samples in parallel.

[0096] Figure 9(b) describes the relationship between parameter count and p50 latency per sample, which is clearly not strictly monotonic. MobileNet and ResNet18, dominated by standard convolutions, have the largest parameter counts, but exhibit the smallest p50 latency of approximately 1.5 ms due to their highly optimized convolutional kernels. Two GCN-based models, ESC-DGCN and FDGCN, are located in the upper right region of the graph: they have larger parameter counts than ResNet18, but also higher p50 latencies. In contrast, conformer-small, LiConvformer, and Clformer exhibit relatively high latencies despite having far fewer parameters, suggesting that attention blocks and complex multi-branch structures incur additional operator scheduling and memory access overhead. The proposed method ranks lowest among small model clusters: with approximately 0.16M parameters, its p50 latency is shorter than Clformer, LiConvformer, and conformer-small, but still slightly behind the purely convolutional MobileNet and ResNet18, indicating that graph convolutions and gate control operations incur some additional costs in single-sample settings. For MCswint, conformer-small, and licconvformer, which involve multi-head attention and complex branching, self-attention and long sequence interaction operations heavily rely on memory access and operator-level small matrix multiplications. Therefore, even with batch processing, they cannot fully utilize parallelism, resulting in inferior performance in terms of single-sample latency and batch throughput compared to the proposed method.

[0097] This method combines graph structure learning of the forward channel with channel gating. Although StarSift-K and SplitStream-GConv prune invalid edges and redundant channels and significantly reduce the number of effective MAC operations, this model still contains sparse access and conditional execution compared to pure convolutional networks. When the batch size is 1, these operations cannot fully amortize the kernel startup and scheduling overhead, therefore... Figure 9 (b) shows a slightly higher single-sample latency than the best convolutional baseline. For ESC-DGCN and FDGCN, similar graph propagation overhead exists, but without the same degree of structural sparsity, further limiting their competitiveness in terms of single-sample latency and batch throughput. However, as the batch size increases, multiple samples share the same static sparse topology and channel mask, allowing sparse graph convolutions to be merged along the batch dimension. Previously scattered memory accesses are aggregated into regular blocks, and memory and bandwidth costs are amortized, significantly improving computational and bandwidth utilization. Therefore, the proposed method achieves higher latency and batch throughput. Figure 9 (a) shows a steeper throughput-batch size curve.

[0098] Example 5 To verify the diagnostic robustness of lightweight star-sieve split map convolution under complex industrial noise, this section uses the XJTU-gearbox dataset as a test platform (this dataset contains composite faults of gears and bearings, and the interference in the signal is closer to real industrial scenarios). An additive Gaussian noise experiment was designed to systematically evaluate the performance degradation of the model under noise perturbation, and it was compared with 10 mainstream lightweight models.

[0099] Noise intensity set to There are 7 levels in total, where r represents the percentage of noise variance relative to the variance of the original signal in the sample. r=0% represents a clean signal (baseline group), used to measure the model's original diagnostic capability; r=5%-20% corresponds to mild to moderate noise commonly found in industrial scenarios, such as equipment background vibration and electromagnetic interference; r=25%~30% represents extreme noise scenarios, such as concurrent operation of multiple devices and sensor signal attenuation, used to test the model's interference immunity limit. The specific method for generating the noise signal is as follows: For each sample Calculate variance Generate a generator that obeys the given gear r. White noise and order Obtain a noisy signal To ensure data consistency, noisy copies were generated for the training, validation, and test sets, and all models used the same set of noisy data for inference at the same noise level to eliminate the impact of data bias on the results. The diagnostic accuracy and relative accuracy degradation (RAD) of the nine models at different noise levels are shown below. Figure 10 As shown.

[0100] from Figure 10(a) It can be seen that the proposed method maintains almost saturated accuracy across the entire noise range. As r increases from 0% to 30%, the accuracy consistently remains between 98% and 100%, with fluctuations of less than 2%, indicating high invariance to additive Gaussian noise. LiConvformer ranks second overall, maintaining accuracy above 96% for most of the time, with a slight decrease at some high-noise points. When r ≤ 20%, the accuracy of ResNet18, MSResNet, and the MobileNet family typically reaches 93%-98%, but decreases significantly when r ≥ 25%; in particular, MobileNet and MobileNetV2 drop to approximately 85%-93% when r = 30%. Among GCN-based models, ESC-DGCN closely tracks the convolutional baseline across the noise range, while FDGCN experiences a larger drop at noise levels of 25%-30%, falling between convolutional and transformer groups. MCswint and transform-small are more sensitive to noise: their accuracy drops most sharply as r increases from 25% to 30%, with transform-small dropping to around 35%-40% at the highest noise level. Clformer achieves around 95% accuracy in low-noise regions, but drops to around 68% accuracy when r=30%. In terms of average accuracy across all noise levels and the entire range, this method achieves the highest average accuracy and the smallest scaling. Convolution-dominated networks are generally more robust than lightweight Transformer variants, and the severe performance degradation of the two most noise-sensitive Transformer models at high noise levels is consistent with their poor separability in feature space visualization.

[0101] from Figure 10(b) It can be seen that the relative degradation curves between models exhibit a clear stratification as noise intensity increases. The proposed method maintains near-zero degradation at all noise levels; even at the high noise levels of 25% and 30%, the relative decrease remains close to 0.01, indicating that the model is almost insensitive to additive noise. LiConvformer and MCswint exhibit moderate degradation, with values ​​of approximately 0.05 and 0.08, respectively, at 30% noise. ResNet18 and MSResNet exhibit moderate degradation, with values ​​of approximately 0.12 and 0.10, respectively, at 30% noise. ESC-DGCN exhibits a degradation curve comparable to these two convolutional baselines, while FDGCN suffers a slightly larger decrease—approximately 0.12 at 25% noise and approximately 0.18 at 30% noise—but still much milder than Clformer and conformer. At 30% noise, MobileNet and MobileNetV2 show more significant degradation, with values ​​of approximately 0.19 and 0.14, respectively. The degradation was most severe for Clformer and converter-small: Clformer's relative degradation was approximately 0.23 at 25% noise and approximately 0.30 at 30% noise; the small converter reached approximately 0.12 at 20% noise, approximately 0.38 at 25% noise, and approximately 0.63 at 30% noise, exhibiting strong noise sensitivity. Overall, the proposed method exhibited near-zero relative degradation across the entire range, demonstrating stable and repeatable noise robustness.

[0102] In summary, from a modeling perspective, the superior performance of the proposed method in noisy environments primarily stems from the joint design of structure learning and channel segmentation. First, StarSift-K explicitly learns stable topological relationships on clean data, retaining only high-confidence edges that recur across different fault types. During inference, the frozen sparse graph is aggregated, and random Gaussian noise is unlikely to produce consistent perturbations across multiple nodes; therefore, its influence is averaged out during graph convolution, and the relative positions of samples on the manifold remain largely unchanged. Second, SplitStream-GConv employs channel gating, performing neighborhood propagation only on high-signal-to-noise-ratio, high-discriminative channels, while routing noise-sensitive redundant channels to bypass branches, preventing them from participating in aggregation and thus suppressing noise amplified layer by layer in the network. Furthermore, global readout and normalization operations further provide smoothness and scale alignment in both time and the graph domain, ensuring that decision boundaries are primarily determined by stable structural patterns rather than instantaneous amplitude details.

[0103] Those skilled in the art to which this application pertains may make various modifications or additions to the specific embodiments described, or adopt similar methods to replace them, without departing from the inventive concept of this application or exceeding the scope defined by the appended claims.

Claims

1. A method for fault diagnosis of rotating machinery based on star-anchor screening and flow-diversion graph convolutional networks, characterized in that, Specifically, the following steps are included: S1. Acquire the vibration time-series signal of the rotating machinery and map the vibration time-series signal into a node feature matrix containing several nodes; S2. Select the nearest neighbor edge and the sequence prior edge for each node, and construct a candidate adjacency matrix A containing the candidate edges; S3. Construct node pair features on the candidate edges of the candidate adjacency matrix A, and perform node edge screening based on the node pair features to determine the edge retention probability, thereby obtaining sparse effective adjacency. S4. Construct a graph convolutional network with a branching gating mechanism. In each graph convolutional layer, determine the channel gating vector based on the channel global statistics of node features. Divide the node feature matrix of the graph convolutional network into a propagation branch that performs graph propagation aggregation on sparse effective adjacency and a bypass branch that preserves the original representation through identity mapping. S5. Linearly fuse the propagation branch aggregation results with the bypass branch to output node features; S6. The node features are aggregated at the graph level to obtain a sample-level representation vector, which is used to determine the probability distribution of the fault category; S7. Select the category with the highest probability in the fault category probability distribution as the fault diagnosis result.

2. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, In step S1, mapping the vibration time series signal into a node feature matrix containing several nodes specifically includes: dividing each vibration time series signal into P local patches of a fixed length L to construct a labeled sample set; mapping each local patch after division into a node feature vector to obtain a node feature matrix containing N nodes.

3. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, Step S2 specifically includes: performing a nearest neighbor search on nodes based on node feature similarity, selecting several nearest neighbor edges for each node, and introducing sequential prior edges, taking the union of the nearest neighbor edges and the sequential prior edges to obtain a candidate edge set, and constructing a candidate adjacency matrix A containing the candidate edges based on the candidate edge set.

4. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, Step S3 specifically includes: performing star-anchor screening structure sparsification on the candidate adjacency matrix A, restricting the candidate edges of each node to the sequence neighborhood, and constructing node pair features for the candidate edges, which are then evaluated by a lightweight scoring function. Candidate edges are scored to obtain edge scores. Edge retention is performed on the corresponding sequence neighborhood of each node to form a binary directed mask M. The binary directed mask M is then applied to the candidate adjacency matrix A to obtain sparse effective adjacencies for subsequent graph propagation. The star anchor is a radial local receptive field constructed based on the anchor points in a star-shaped network. The sequence neighborhood limits the range of nodes corresponding to temporally adjacent segments for each node's candidate edges.

5. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, Based on the node pair characteristics, the edge retention probability is determined, and node edges are filtered to obtain sparse effective adjacencies, including: The paired features of the nodes of the candidate edges are input into a lightweight scoring function and mapped to the edge retention probability via a sigmoid function. The mathematical expression of this function is as follows: (1) in, These are paired features used for scoring; For the first i The feature vector of each node; For the first j The feature vector of each node; It is a lightweight scoring function; Edge retention probability score; Scoring is based on scalar values. These are learnable, scoreable weights; For learnable rating bias; For activation functions; During the training phase, differentiable relaxation is used for end-to-end optimization, mathematically expressed as follows: (2) in, To preserve variables for the edges after differentiability relaxation; Output the score function for the candidate edges; It follows a standard Logistic distribution with a location parameter of 0 and a scale parameter of 1, introducing randomness to allow sampling of different structures during the training phase; To control the degree of relaxation; During the training phase, probability calculations are performed on each node within its corresponding candidate neighbor set to obtain a binary directed mask M, forming a sparse and efficient adjacency graph structure, the mathematical expression of which is as follows: (3) in, For sorting ranking operators; Let v be a central node; v be a node adjacent to the central node; and r be any neighboring node in the candidate neighborhood set. Preserve the probability for the edge; To set The ranking after sorting by probability from largest to smallest; It is a binary directed mask.

6. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, Step S4 specifically includes: generating channel-level gating vectors in each graph convolutional layer based on the global channel statistics of node features. Differentiable relaxed soft gates are generated through differentiable gating. The input features of the graph convolutional network are divided into propagation branches according to channel importance. and side roads Only for the propagation branch Perform graph propagation aggregation on sparse effective adjacencies, and bypass branches. The original representation is preserved through identity mapping; the outputs of the propagation branch and the bypass branch are fused through a learnable weight matrix as the output of the graph convolutional layer.

7. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, The channel gating vector in step S4 Differentiable gating is used to generate differentiable relaxed soft gates during the training phase. The channel importance statistics use the global average activation of all nodes in the graph along the channel dimension as the channel description, and the mathematical expression is as follows: (4) in, For the first i All channel characteristics of each node; N The number of nodes; C Number of channels; u For channel C Average activation across the entire image; A differentiable relaxed gate logit is obtained through lightweight mapping; during the training phase, a differentiable relaxed soft gate is generated using Gumbel Sigmoid relaxation. The mathematical expression is as follows: (5) in, s To obtain gated values ​​using lightweight mapping; For gating weights; This is a gated paranoia term; It is a differentiable, relaxable soft gate value; Control the degree of relaxation; It follows a standard Logistic distribution with a location parameter of 0 and a scale parameter of 1, introducing randomness to allow sampling of different structures during the training phase; For activation functions; The k channels with the highest probabilities are obtained, retained, and used in graph propagation. The mathematical expression for this is as follows: (6) in, z For the determined channel-level gate value; To spread the message, For direct access to a side road; This indicates element-wise multiplication. This is the activation function.

8. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, In step S5, the propagation branch and the bypass branch are linearly fused using a learnable weight matrix and then superimposed with a bias to obtain the layer output, as expressed mathematically below: (8) in, These are node features obtained by performing graph convolution only on the gated reserved channels; For learnable weights, It is a non-linear activation function; For the first The node feature matrix of the layer; This is the linear transformation weight matrix used for the fusion of the two branches; b This is the bias vector.

9. The method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, The fault diagnosis result of step S7 includes atlas representation and classification output, which are mathematically expressed as follows: (9) in, The sample-level representation after one training epoch; These are learnable weights; For learnable bias; The results are output for classification.

10. A method for diagnosing rotating machinery faults based on star-anchor screening and flow-diversion graph convolutional networks according to claim 1, characterized in that, The edge preservation probability is determined based on a lightweight scoring function. During the training phase of the graph convolutional network, the method further includes: The lightweight scoring function and the diversion gating mechanism are trained and optimized. The training objective function includes a classification loss and lightweight constraint terms. The lightweight constraint terms include a channel utilization penalty term and a structural sparsity penalty term, which are used to simultaneously constrain the channel retention ratio and the edge retention ratio. The mathematical expression is as follows: （10） （11） （12） in, For classification loss; It is a learnable scalar; Incentive coefficient for channel utilization; These are sparse regularization coefficients; For the candidate edge set; This is the channel penalty coefficient; For channel utilization; This is the structural penalty coefficient; For structural utilization rate.

Images