A Motor Fault Diagnosis Method and System Based on Hybrid Graph Neural Network and Path Graph

Abstract

This application relates to the field of mechanical fault detection technology, and discloses a method and system for motor fault diagnosis based on hybrid graph neural networks and path graphs. The method includes: step S1, acquiring time-series data of the motor and constructing a path graph; step S2, performing hierarchical feature extraction through the hybrid graph neural network model; step S3, performing dynamic graph pooling operations to downsample the graph structure, and globally aggregating the downsampled graphs to form an embedding vector set; step S4, fusing the embedding vector set to generate a unified graph-level feature representation; and step S5, outputting the fault diagnosis result of the motor by a classifier. This invention effectively models the inherent evolutionary logic and structural dependencies of signals by constructing a path graph of the motor's time-series data and using a hybrid graph neural network to extract features, thus overcoming the shortcomings of insufficient modeling in existing technologies and improving diagnostic accuracy.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of mechanical fault detection, in particular to a motor fault diagnosis method and system based on a hybrid graph neural network and a path graph. BACKGROUND

[0002] As a core device that converts electrical energy into mechanical energy, electric motors are the cornerstone of modern industrial systems. From driving conveyor belts and processing equipment on large production lines to powering precision instruments, electric motors are ubiquitous. The stability and reliability of their performance are directly related to the efficiency and safety of the entire industrial production process. Therefore, effective monitoring and maintenance of electric motors have become a fundamental and crucial task in the field of industrial automation.

[0003] In the field of highly automated and intelligent industrial robots, the importance of electric motors is further magnified. Industrial robot systems, especially their joints and end effectors, rely heavily on high-performance servo motors to perform precise, high-speed and complex dynamic operations. These systems usually operate in continuous and dynamic conditions, and any minor motor faults, such as bearing wear, rotor imbalance or winding short circuit, can quickly accumulate and cause the robot's motion accuracy to decline, system performance to deteriorate, or even completely stop, resulting in significant economic losses and potential safety hazards. Therefore, developing real-time and accurate fault diagnosis technology for industrial robot motors has irreplaceable value for ensuring their stable operation and preventive maintenance.

[0004] However, existing motor fault diagnosis techniques still have significant limitations in dealing with complex dynamic conditions. Many traditional methods rely on extracting static features from signals and comparing them with fixed thresholds, which makes it difficult to capture dynamic temporal information during the fault evolution process, especially for early, weak or intermittent faults. In addition, these methods often analyze individual sensor channels (such as voltage, current, temperature, etc.) in isolation, lacking an effective mechanism to jointly model the complex internal relationships between signals and the evolution logic of signals over time. In fact, the interrelationships between different physical quantities and their trends over time are exactly the key to revealing subtle fault patterns. Therefore, existing technologies have obvious shortcomings in fully utilizing the temporal dynamics and structural dependencies contained in the data, resulting in diagnostic accuracy that cannot meet the needs of modern intelligent manufacturing. SUMMARY

[0005] To overcome the shortcomings of the prior art, the present application provides a motor fault diagnosis method and system based on a hybrid graph neural network and a path graph, which solves the problem of insufficient utilization of temporal dynamics and structural dependencies contained in the data in the prior art, resulting in diagnostic accuracy that cannot meet the needs of modern intelligent manufacturing.

[0006] To achieve the above object, the application is implemented by the following technical scheme: a motor fault diagnosis method based on a hybrid graph neural network and a path graph, comprising the following steps:

[0007] Step S1, acquiring time series data of a motor, and constructing a path graph according to the time series data;

[0008] Step S2, inputting the path graph into a hybrid graph neural network model, and performing hierarchical feature extraction on the path graph through a spectral domain convolution layer and a spatial domain convolution layer contained in the hybrid graph neural network model;

[0009] Step S3, performing a dynamic graph pooling operation to downsample the graph structure at at least two different stages in the hierarchical feature extraction process, and performing global aggregation on the downsampled graph to generate respective graph-level embedding vectors, thereby forming an embedding vector set;

[0010] Step S4, fusing all embedding vectors in the embedding vector set to generate a unified graph-level feature representation;

[0011] Step S5, inputting the unified graph-level feature representation into a classifier to output a fault diagnosis result of the motor.

[0012] By converting time series data into a graph structure and using a hybrid graph neural network for multi-scale feature extraction and fusion, the time dependence and structured information in the data can be fully mined, and accurate and automated diagnosis of the motor operating state can be achieved.

[0013] Preferably, in step S1, the step of constructing a path graph specifically comprises:

[0014] The time series data is segmented into time window data segments using a sliding window;

[0015] The time window data segments are divided into a plurality of ordered time slices;

[0016] Each time slice is created as a node of the path graph, wherein the features of the node are determined by the sensor data corresponding to the time slice;

[0017] According to the order of the time slices, directed edges are created between adjacent nodes to form a path graph structure with a time evolution direction.

[0018] By dividing the data within the time window into slices and connecting them in time sequence into a directed graph, the internal dynamic evolution process of one-dimensional time series signals can be explicitly encoded into the topological structure of the graph, effectively converting the data from the time domain to the graph domain, and providing a suitable input for subsequent graph neural network processing.

[0019] Preferably, in the step S2, the mixed graph neural network model adopts a sequential architecture, wherein the spectral domain convolution layer is located before the spatial domain convolution layer, for capturing the global topological dependency of the time series data.

[0020] By using the sequential processing mode of spectral domain convolution first and then spatial domain convolution, the overall trend and long-range dependency of the signal can be grasped from a global perspective first, and then the fine features of the local neighborhood are focused on, realizing the hierarchical and progressive extraction of data features from global to local.

[0021] Preferably, the mixed graph neural network model sequentially includes two graph convolution network layers as the spectral domain convolution layer, and a graph sampling and aggregation network layer as the spatial domain convolution layer, and after each of the graph convolution network layer and the graph sampling and aggregation network layer, a batch normalization layer and a rectified linear unit activation function layer are further included.

[0022] By stacking the graph convolution network (GCN) and the graph sampling and aggregation network (GraphSAGE), and supplemented by batch normalization and ReLU activation function, a stable network model capable of extracting deep nonlinear features can be constructed, realizing effective and deep abstraction of path graph features.

[0023] Preferably, in the step S3, the dynamic graph pooling operation is a Top-K pooling operation, which is used to calculate the importance scores of nodes in the path graph through a learnable scoring function, and retain the associated edges of the nodes with the highest importance scores in a preset proportion, to obtain a down-sampled graph.

[0024] By using the Top-K pooling operation based on the learnable score, the most important node information for the diagnosis task can be intelligently identified and retained, while the graph is down-sampled, realizing adaptive simplification of the graph structure and effectively increasing the receptive field of the subsequent convolution layer.

[0025] Preferably, in the step S3, the step of globally aggregating the down-sampled path graph specifically includes: aggregating the node features through a global mean pooling layer to generate a graph-level embedding vector for the nodes retained in the down-sampled graph.

[0026] By globally mean-pooling the features of all remaining nodes in the down-sampled graph, the dispersed node-level features can be aggregated into a single vector of fixed dimension representing the entire graph, realizing the conversion from node representation to graph-level representation, and preparing for the subsequent classification task.

[0027] Preferably, in the step S4, the step of fusing all the embedding vectors in the embedding vector set comprises: fusing the graph-level embedding vectors generated in the hierarchical feature extraction process by performing element-wise summation to generate the unified graph-level feature representation.

[0028] By performing element-wise summation on the multiple graph-level embedding vectors generated in different feature extraction stages, the feature information from different network depths and different scales can be effectively integrated to generate a more robust final graph-level feature representation that takes into account global and local, low-level and high-level information.

[0029] Preferably, in the step S2, the training of the hybrid graph neural network model comprises: using a focal loss function as the objective function to balance the normal state and the fault state in the training data.

[0030] By using a focal loss function as the objective function of model training, the loss weight of a large number of normal samples (easy-to-classify samples) can be dynamically reduced during the training process, so that the model pays more attention to learning the features of the few but more critical fault samples, effectively solving the data class imbalance problem.

[0031] Preferably, during the training process, the sensitivity of the model to the fault state is enhanced by setting a positive sample weight.

[0032] By setting a weight greater than 1 for the fault sample (positive sample) in the loss function, the punishment intensity when the model misjudges the fault sample as a normal sample can be significantly increased, so that the model is forced to improve the recognition sensitivity to the fault state and reduce the false negative rate.

[0033] The motor fault diagnosis system based on a hybrid graph neural network and a path graph comprises:

[0034] A data acquisition and graph construction module is configured to acquire time series data of a motor and construct a path graph.

[0035] A feature extraction module is configured with a hybrid graph neural network model comprising a spectral domain convolution layer and a spatial domain convolution layer, and is configured to perform hierarchical feature extraction on the path graph.

[0036] A pooling and fusion module is configured to perform dynamic graph pooling during hierarchical feature extraction, generate and fuse graph-level embedding vectors from the feature extraction stage, and generate a unified graph-level feature representation.

[0037] A classification and diagnosis module is configured to receive the unified graph-level feature representation and output a fault diagnosis result of the motor.

[0038] The present application provides a motor fault diagnosis method and system based on a hybrid graph neural network and a path graph.

[0039] 1. This invention constructs a path graph of the time series data of the motor and uses a hybrid graph neural network for feature extraction. This can generate the time series data of the signal into a graph topology structure and process it by synergistically using spectral and spatial convolution. This can solve the shortcomings of the invention in effectively modeling the inherent evolution logic and structural dependencies of the signal, and improve the accuracy of the diagnostic results.

[0040] 2. This invention performs dynamic graph pooling and global aggregation multiple times during the hierarchical feature extraction process, and finally fuses multi-scale graph-level embedding vectors to generate a unified feature representation that takes into account both global overview and local details, thereby achieving more comprehensive detection of fault modes. Compared with existing technologies that typically extract single-scale feature vectors at the end of the model, the solution of this invention overcomes the shortcomings of its single perspective, which easily leads to the loss of key information and low diagnostic accuracy.

[0041] 3. This invention forces the model to focus on a small number of but crucial fault samples by using a focus loss function and weighting positive samples. Compared with the common practice in the prior art of using a standard loss function for training, which leads to the model being biased towards the majority class of samples, this invention can effectively solve the problem of inaccurate model detection caused by data class imbalance. At the same time, this invention can improve the sensitivity of the invention to early and rare faults, thereby reducing the risk of missed detection. Attached Figure Description

[0042] Figure 1 This is a schematic diagram of the method flow of the present invention;

[0043] Figure 2 This is a schematic diagram of the SAGECN structure of the present invention;

[0044] Figure 3 This is a schematic diagram of the node pooling process of the present invention;

[0045] Figure 4 This is a schematic diagram of the path graph construction process of the present invention;

[0046] Figure 5 This is a schematic diagram of the system architecture of the present invention. Detailed Implementation

[0047] The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0048] To better understand the present invention, the above content will be described in detail below with reference to specific embodiments.

[0049] Example 1, please refer to the appendix. Figures 1-4 This invention provides a motor fault diagnosis method based on a hybrid graph neural network and path graph, comprising the following steps:

[0050] Step S1: Obtain the time series data of the motor and construct a path diagram based on the time series data;

[0051] In this embodiment, the timing data of the motor is first obtained, and a path graph that can characterize its dynamic behavior is constructed based on the data.

[0052] Specifically, firstly, sensor data from one or more motor devices to be diagnosed during continuous operation is acquired. This data constitutes multi-channel time-series data. The sensor data may include, but is not limited to, physical quantities reflecting the motor's operating state, such as motor temperature, motor output voltage, and motor position.

[0053] After obtaining the raw time series data, the sliding window technique is used to segment the long series data.

[0054] Typically, a sliding window is defined as having a fixed window length and a step size. The window length determines the number of data points contained in each analysis unit, while the step size controls the degree of overlap between adjacent analysis units. By sliding this window along the entire time series data, the original long series is divided into a series of fixed-length, manageable time window segments suitable for constructing a single graph.

[0055] In this embodiment, any time window data segment obtained by the sliding window segmentation is constructed as an independent path graph.

[0056] Specifically, the construction process further includes dividing the time window data segment into several ordered time slices.

[0057] In the structure of the path graph, each time slice is abstracted as a graph node.

[0058] The initial characteristics of each node are composed of multi-channel sensor data within its corresponding time slice.

[0059] Alternatively, if the sensor data contains three feature channels, then the features of each node are composed of the data from these three channels within that time slice.

[0060] Finally, based on the inherent temporal order of the time slices, a directed edge is created between adjacent nodes to form a path graph structure with a clear direction of temporal evolution. This can intuitively reflect the unidirectional dependency of the signal as it evolves over time and effectively capture the inherent dynamic characteristics of sequence data.

[0061] To facilitate the mathematical processing of subsequent graph neural network models, the constructed path graph can be formally represented by a specific set of data structures.

[0062] In graph data, node features are represented using a node feature matrix.

[0063] The dimension of the node feature matrix is ​​determined by the number of nodes and the number of feature channels.

[0064] Furthermore, the edge structure of the path graph is defined by an edge index matrix and an edge weight vector.

[0065] Specifically, the edge index matrix is ​​used to describe the connectivity between nodes in the graph, explicitly indicating the starting and ending nodes of each directed edge.

[0066] The edge weight vector is used to describe the strength of the relationship between nodes. In some embodiments, the weights of all edges can be uniformly set to the same value to indicate that the evolution strength is equal across time steps.

[0067] To handle multiple path graph samples simultaneously during batch training of the model, this embodiment introduces a batch-level assignment vector. This vector indicates which graph sample each node belongs to, ensuring that graph-level pooling and other operations are correctly performed on the batch data.

[0068] Therefore, this step transforms the original time-series signals into a series of structured and formalized path graphs, which not only preserves the inherent time dependencies of the data but also greatly simplifies the complexity of graph construction, providing an ideal data foundation for subsequent efficient and accurate end-to-end fault diagnosis using hybrid graph neural networks.

[0069] Step S2: Input the path graph into the hybrid graph neural network model, and extract hierarchical features from the path graph through the spectral domain convolutional layer and the spatial domain convolutional layer contained in the hybrid graph neural network model;

[0070] In this embodiment, after converting the original time-series data into a structured path graph in step S1, this step uses a hybrid graph neural network model to perform deep, hierarchical feature learning on the input path graph. This model cleverly concatenates different types of graph convolutional layers—spectral domain convolutional layers and spatial domain convolutional layers—to obtain global topological dependencies and local neighborhood information, thus providing accurate feature representations for subsequent fault diagnosis.

[0071] Specifically, the hybrid graph neural network model employs a sequential architecture. This means that the input path graph data will flow sequentially through each processing unit in the model. Specifically, the feature extraction module of this model consists of three convolutional blocks: the first two convolutional blocks use spectral domain convolution, and the last convolutional block uses spatial domain convolution.

[0072] Spectral domain convolutional layers are placed in the initial stage of the model, and their main function is to process the graph signal from a global perspective. This processing method is based on graph spectral theory and can effectively capture the long-range dependencies between all nodes in the graph. For path graphs, this means that the model can perceive the overall trend and topological structure within the entire time window of data.

[0073] Specifically, the hybrid graph neural network model includes:

[0074] First convolutional block: a graph convolutional network (GCN) layer;

[0075] The second convolutional block: a graph convolutional network (GCN) layer;

[0076] Third convolutional block: a graph sampling and aggregation network layer.

[0077] In one possible implementation, the first two convolutional blocks use Graph Convolutional Network (GCN) layers as spectral domain convolutional layers. Based on graph theory, the GCN layer updates the feature representation of each node through a propagation rule that aggregates the features of a node with the features of its neighboring nodes, effectively capturing the global topological dependencies between all nodes in the graph.

[0078] As a preferred implementation, the third convolutional layer uses a GraphSAGE layer as a spatial domain convolutional layer. Unlike GCN layers, GraphSAGE layers operate directly on the neighborhoods of nodes in the spatial domain of the graph, focusing more on efficiently aggregating feature information from local neighborhoods.

[0079] Specifically, the GraphSAGE layer updates node features through a two-stage process: first, it samples a fixed number of neighboring nodes from the neighborhood of each target node; then, it aggregates the features of these neighboring nodes through an aggregation function (such as mean aggregation, maximum aggregation, or long short-term memory network aggregation) and combines the aggregated information with the target node's own features to generate a new feature representation of the target node.

[0080] After clarifying the forward propagation architecture of the hybrid graph neural network model, the technical solution of this invention also needs to define the learning and optimization process of its parameters, i.e., the model training strategy. In practical industrial applications, motor fault diagnosis tasks generally face a severe challenge: data class imbalance. Typically, the amount of data from motors in normal operation is far greater than the amount of data when a fault occurs. If a standard loss function is used for model training, the model will easily bias towards the normal class, which has a larger sample size, resulting in insufficient ability to identify the scarce fault classes.

[0081] To address this technical challenge, this embodiment employs a specific objective function and weighting strategy during model training to ensure that the model can effectively learn the characteristics of the minority class (i.e., the fault class), thereby improving the accuracy and reliability of diagnosis.

[0082] Specifically, the training of the hybrid graph neural network model uses the focus loss function as its objective function.

[0083] Focus loss is an improvement on the standard cross-entropy loss function. It introduces a dynamic modulation factor to reduce the contribution weight of a large number of easily classifiable samples (usually the majority class) to the total loss, so that the model can focus more on those difficult-to-classify samples (usually the minority class) during training.

[0084] To further enhance the model's sensitivity to fault states, the loss function is weighted by setting positive sample weights during training.

[0085] Generally, this weight is set to a number greater than 1, and its purpose is to artificially increase the penalty for misclassification of positive samples.

[0086] As an example, if the ratio of normal samples to faulty samples in the training dataset is 100:1, then the sample weights can be set to 100. Under this setting, the loss incurred by the model misclassifying a faulty sample as a normal sample will be the result of multiplying the weights (e.g., by 100).

[0087] Therefore, the hybrid graph neural network model can be forced to pay more attention to the correct classification of fault samples during the optimization process, thereby improving the accuracy of motor fault identification.

[0088] Therefore, by using the focus loss function in combination with positive sample weights, the impact of data class imbalance can be overcome during model training, guiding the model to focus on learning rare but critical fault modes and improving the accuracy of motor fault diagnosis.

[0089] Finally, in summary, in the complete process of step S2, a path graph obtained from step S1 is first passed through two GCN convolutional blocks, whose node feature dimensions are successively increased to (e.g., 64 dimensions) and (e.g., 128 dimensions). Subsequently, the output feature map is input into a GraphSAGE convolutional block, where the node feature dimensions are further increased to (e.g., 256 dimensions). Through this hierarchical and hybrid feature extraction process, the original node features are gradually abstracted and refined into deeper and more informative feature representations, providing high-quality input for subsequent graph pooling and fault classification steps.

[0090] Step S3: In at least two different stages of the hierarchical feature extraction process, dynamic graph pooling operation is performed to downsample the graph structure, and the downsampled graphs are globally aggregated to generate their respective graph-level embedding vectors, thereby forming an embedding vector set.

[0091] In this embodiment, after the hierarchical feature extraction of the path graph is completed in step S2, node-level feature representations can be obtained. These features, scattered across various nodes, are then aggregated into a unified, fixed-dimensional graph-level representation.

[0092] Specifically, the graph is first intelligently downsampled using Top-K pooling, and then the remaining node features in the downsampled graph are aggregated into a single vector using global mean pooling. This process is repeated at multiple stages of the network.

[0093] As a preferred implementation, the dynamic graph pooling operation is performed after different convolutional blocks of the hybrid graph neural network model.

[0094] Typically, pooling layers are inserted between two convolutional blocks. For example, in the model architecture described in this invention, a Top-K pooling layer is inserted after the first GCN convolutional block, and another Top-K pooling layer is inserted after the second GCN convolutional block.

[0095] Specifically, the dynamic graph pooling operation is Top-K pooling. This operation uses a learnable scoring function to calculate the importance score of each node in the graph and retains the most important nodes accordingly.

[0096] The importance score is calculated as follows:

[0097] ;

[0098] In the formula, It is the node feature matrix input to the current Top-K pooling layer; It is a learnable projection vector; Indicates the projection vector The L2 norm is used to normalize the projection results; It is the calculated node importance score vector, and its dimension is the same as the number of nodes in the graph.

[0099] After obtaining the importance scores of all nodes, the system selects the node with the highest score based on a preset pooling ratio.

[0100] ;

[0101] In the formula, This is the actual number of nodes that need to be retained; It is a sorting function that returns a score vector. The highest value The node index corresponding to each score; It is a set containing the indices of all the selected k nodes.

[0102] Based on the obtained index The system constructs a new downsampled graph. The node features and adjacency relationships of the new graph are obtained in the following way:

[0103] ;

[0104] ;

[0105] In the formula:

[0106] It is the original adjacency matrix; It is the Sigmoid activation function; These are the original node features; This represents the Hadamard product, which is element-wise multiplication. It is the node feature matrix of the new image after downsampling, which is obtained by indexing and selecting from the weighted original feature matrix; It is the adjacency matrix of the new graph after downsampling, obtained by modifying the original adjacency matrix. The selection is achieved by using row and column indexes, preserving the original connection relationships between the selected nodes.

[0107] Finally, after obtaining the downsampled graph through Top-K pooling, this embodiment immediately performs a global aggregation operation on it to generate the graph-level embedding vector for this stage.

[0108] Alternatively, the global aggregation operation is specifically global mean pooling.

[0109] Specifically, this operation averages the feature vectors of all retained nodes in the downsampled graph element by element, thereby aggregating the node feature matrix into a multidimensional graph-level embedding vector.

[0110] Furthermore, this combination operation, performed once after the first convolutional block and once after the second convolutional block, generates two graph-level embedding vectors at different scales. The first embedding vector captures shallower features, while the second embedding vector captures deeper, more abstract features. These two embedding vectors together constitute the aforementioned embedding vector set, providing rich and diverse information for subsequent feature fusion steps.

[0111] Step S4: Merge all the embedding vectors in the embedding vector set to generate a unified graph-level feature representation;

[0112] In this embodiment, step S3 successfully generated a set containing multiple graph-level embedding vectors by pooling and aggregating the graph at different depths and scales. Each vector in this set describes the motor's operating state from a unique perspective. To form a comprehensive and singular discrimination criterion that can be submitted to the final classifier, the technical solution of this invention proceeds to step S4, the core task of which is to efficiently fuse all the information in the aforementioned set of embedding vectors to generate a unified graph-level feature representation.

[0113] In this step, the fusion process aims to combine graph-level embedding vectors from different feature extraction stages. These vectors each contain semantic information at different levels. For example, embedding vectors extracted by shallower networks may focus more on local and detailed features, while embedding vectors extracted by deeper networks may represent more global and abstract features. By fusing them, the model can utilize this multi-scale information simultaneously, thereby gaining a more robust and comprehensive understanding of the motor state.

[0114] As a preferred implementation, the fusion step specifically involves performing an element-wise summation operation on all graph-level embedding vectors in the embedding vector set.

[0115] Specifically, the mathematical expression for this fusion operation is as follows:

[0116] ;

[0117] The definitions of each parameter are as follows:

[0118] It is the first graph-level embedding vector generated through global aggregation after the first dynamic graph pooling stage; It is the second graph-level embedding vector generated through global aggregation after the second dynamic graph pooling stage; This represents an element-wise addition operation between vectors; It is the final generated unified graph-level feature representation that integrates information from multiple stages.

[0119] It is important to note that a prerequisite for performing element-wise summation is that the vectors involved in the operation (i.e., ...) must be in a state of equilibrium. and The graph-level embedding vectors generated at different stages must have the same dimension. In one possible implementation, to ensure dimensionality consistency, a linear projection layer (i.e., a fully connected layer) can be used to map the graph-level embedding vectors generated at different stages to the same predefined dimensional space after each global aggregation operation or before the fusion operation. For example, if... The dimension is 64. If the dimension is 128, then each element can be mapped to a uniform 128-dimensional form through a linear layer before performing a summation operation. This dimension alignment is a key technical detail that ensures the fusion operation can be performed correctly.

[0120] Compared to other fusion strategies (such as feature concatenation), element-wise summation has the advantages of low computational cost and no introduction of additional parameters, making it an efficient and effective feature fusion mechanism. It assumes that features from different stages are semantically aligned, and that they can enhance each other's representational capabilities through summation.

[0121] In general, this step generates a unified graph-level feature representation. This vector is considered a highly condensed and information-rich numerical description of the motor's operating status corresponding to the current time window data segment. This vector will then be passed to the subsequent classification and diagnostic module as the final basis for determining whether the motor has a fault and the type of fault.

[0122] In other embodiments, other fusion strategies well known to those skilled in the art may be used instead. Alternatively, one could... and The vector is concatenated along the feature dimension to form a longer vector, and then dimensionality reduction and information integration are performed through one or more linear layers. However, element-wise summation is preferred in the specific technical solution of this invention due to its simplicity and effectiveness.

[0123] Step S5: Input the unified graph-level feature representation into the classifier to output the fault diagnosis result of the motor.

[0124] In this embodiment, after outputting the graph-level feature representation in step S4, it is transformed into a clear and practically meaningful motor fault diagnosis conclusion.

[0125] Specifically, the unified graph-level feature representation is input into a classifier. The classifier's role is to learn and establish a mapping relationship between this high-level feature and different motor health states (including normal states and various fault states).

[0126] As a preferred implementation, the classifier is specifically a multilayer perceptron (MLP). An MLP is a classic feedforward neural network, and due to its powerful nonlinear classification capabilities, it is well-suited for processing the complex feature vectors extracted in the preceding steps of this invention.

[0127] Specifically, this multilayer perceptron is composed of several fully connected layers stacked together.

[0128] In one possible implementation, the architecture of the MLP may include two hidden layers and one output layer.

[0129] First, the unified graph-level feature representation generated in step S4, which may undergo a final linear projection transformation, is used as the input to the MLP.

[0130] The input vector first passes through a fully connected layer, which maps it from the original feature dimension to a new dimensional space. This is followed by a non-linear activation function, such as a rectified linear unit (ReLU), to enhance the model's expressive power.

[0131] The output of the first hidden layer is then fed into a second fully connected layer for further feature transformation and abstraction. Similarly, a ReLU activation function follows this.

[0132] After undergoing nonlinear transformation through one or more hidden layers, the feature vector is finally fed into the output layer of the MLP, which is a linear fully connected layer with the number of output nodes set to be exactly the same as the total number of motor state categories to be diagnosed.

[0133] As an example, if the diagnostic objective of this invention is to distinguish between four states of a motor: "normal operation", "bearing outer ring fault", "rotor bar breakage fault" and "winding short circuit fault", then the number of neurons in the output layer should be set to 4.

[0134] Each output neuron corresponds to a category, and its output value (usually called logit) represents the raw score of the input sample belonging to that category.

[0135] To facilitate understanding and decision-making, these raw scores are typically fed into a Softmax function. This function normalizes the score vector into a probability distribution where each element has a value between 0 and 1, and the sum of all elements is 1.

[0136] Ultimately, the system selects the category with the highest probability value as the final output of this diagnosis. This result clearly indicates the motor's operating status within the current analysis time window.

[0137] Finally, step S5 uses a structured classifier to decode the abstract graph-level feature representation into specific fault categories, completing the end-to-end mapping from raw data to the final diagnostic conclusion, thereby providing direct and reliable decision support for equipment maintenance and management.

[0138] Example 2, please refer to the appendix. Figure 5 This invention provides a motor fault diagnosis system based on a hybrid graph neural network and path graph, comprising:

[0139] The data acquisition and graph construction module is used to acquire time-series data of the motor and construct a path graph.

[0140] In this embodiment, the module acquires multi-channel time-series data of the motor and transforms it into a series of path graphs using a mechanism based on time evolution order. Its core principle lies in using a sliding window technique to segment the long-series data, dividing the data within each window into several ordered time slices. Subsequently, each time slice is constructed as a node in the graph, its initial characteristics determined by the sensor data within that time slice; the connection relationships between nodes strictly follow the chronological order of the time slices, forming a unidirectional path graph structure capable of characterizing the dynamic properties of the signal.

[0141] The feature extraction module is configured with a hybrid graph neural network model containing spectral domain convolutional layers and spatial domain convolutional layers, used to perform hierarchical feature extraction on the path graph;

[0142] In this embodiment, the module receives the path graph constructed by the aforementioned module and performs hierarchical and deep convolutional operations on the node features of the graph using a configured hybrid graph neural network model. The key technical feature of this module lies in its hybrid and sequential architecture. It first utilizes spectral domain convolutional layers (such as GCN) to capture topological dependencies and long-range correlations within the entire time window from a global perspective; subsequently, it uses spatial domain convolutional layers (such as GraphSAGE) to efficiently aggregate the local neighborhood information of nodes. Through this combination of spectral and spatial domains, the module can extract more discriminative deep-level features layer by layer.

[0143] The pooling and fusion module is used to perform dynamic graph pooling operations during the hierarchical feature extraction process, generating and fusing graph-level embedding vectors from the feature extraction stage to generate a unified graph-level feature representation;

[0144] In this embodiment, this module is responsible for downsampling the graph and integrating multi-scale information during feature extraction, ultimately generating a unified feature representation that can represent the entire path graph. Its key technologies are: first, performing dynamic graph pooling (such as Top-K pooling) at different stages of feature extraction, using a learnable scoring function to intelligently select the subset of nodes most important to the diagnostic task, thereby achieving graph downsampling and increasing the receptive field; second, performing global aggregation (such as global mean pooling) on ​​the downsampling graph to obtain the graph-level embedding vector for that stage; and third, fusing multiple graph-level embedding vectors generated at different stages (such as through element-wise summation) to aggregate multi-scale feature information from different levels of abstraction.

[0145] The classification and diagnosis module is used to receive the unified graph-level feature representation and output the fault diagnosis results of the motor.

[0146] In this embodiment, the module receives the unified graph-level feature representation and outputs the final motor health status diagnosis result. Its working principle is to use a classifier (such as a multilayer perceptron, MLP) to non-linearly map the input, high-dimensional feature vector to a predefined fault category space. Through its internal fully connected layers and non-linear activation functions, the module learns the complex relationship between features and fault labels, and finally outputs the predicted probability of each category through a softmax function, thereby completing the transformation from abstract features to specific diagnostic conclusions.

[0147] Example 3, please refer to the appendix. Figure 2 Based on Examples 1 and 2, it can be seen that the hybrid graph neural network model combines spectral domain graph convolution with spatial domain neighborhood aggregation mechanism for fault diagnosis. This model sequentially integrates two GCN layers and one GraphSAGE layer to form a multi-stage feature extraction pipeline with enhanced expressive power.

[0148] Specifically, the model's input is a series of path graphs constructed using a sliding window strategy. Each path graph encodes a time series of sensor data segments, where nodes correspond to fixed-length time intervals, and edges reflect their temporal relationships. The set of directed edges is constructed temporally to preserve causal dependencies. Each node is represented by a multi-dimensional feature vector that captures location, temperature, and voltage signals.

[0149] The first two layers of the GCN operate in the spectral domain, using a normalized graph Laplacian operator to propagate global structural information. Specifically, the graph convolution operation in the first layer is defined as: ;

[0150] In the formula, This is the input matrix for the first layer. It is the adjacency matrix of the path graph, used to represent the connection relationships between nodes. for The angle matrix, This represents a non-linear activation function, such as the ReLU function. It is the result of graph convolution operations and activation functions, calculated as the first... The layer's output, i.e., the updated node feature matrix, Indicates the first The trainable weight matrix of the layer.

[0151] Following the GCN layer, the GraphSAGE module is applied to capture local neighborhood-level interactions through an inductive aggregation scheme, thereby better generalizing to unknown graph topologies. The neighborhood aggregation at this layer is defined as:

[0152] ;

[0153] In the formula, Represents a node The set of adjacent nodes, The function can be implemented as a max pooling, average pooling, or LSTM-based aggregator, and also includes edge weights to enable fine-grained modeling of the influence of each pair of adjacent nodes. Indicates the first Layers, nodes eigenvectors, This represents a trainable weight matrix used to perform a linear transformation on the aggregated feature vectors. Indicates the first Layers, nodes eigenvectors, Represents a node A neighbor node In the The feature vector of the layer.

[0154] To progressively refine the graph structure and focus on the nodes with the most information, a Top-K pooling layer is inserted after each convolutional block. After each pooling stage, global mean pooling is performed to obtain two graph-level embeddings. These are then merged element-wise to generate the final embedding vector:

[0155] ;

[0156] In the formula, This represents the graph-level embedding vector extracted and pooled from the spectral domain convolutional part (GCN layer) of the model. This represents the graph-level embedding vector extracted and pooled from the spatial convolutional part (GraphSAGE layer) of the model. It is the final fused and unified graph-level feature representation obtained by adding the two graph-level embedding vectors from different convolution types element by element.

[0157] This graph-level embedding is then passed to a multilayer perceptron (MLP) classifier for binary classification of exercise health status.

[0158] In the graph neural network encoding stage, the model employs a sequential feature extraction structure, where two GCN layers are followed by a GraphSAGE layer for staged representation learning. The GCN layers aim to capture global topological dependencies between nodes, thus aiding in modeling long-term trends in time series. In contrast, the subsequent GraphSAGE layer focuses on aggregating local neighborhood features, making the model more sensitive to early local perturbations associated with fault occurrence. After feature extraction and downsampling at each stage using Top-K pooling and global mean pooling, the resulting graph-level embeddings are fused through vector summation. A linear transformation is then applied to enhance feature consistency, forming a unified embedding representation of the fault state.

[0159] During the sliding window process, each time window is divided into consecutive time slices, and each time slice forms a node in the graph. Then, directed edges are created between adjacent nodes in chronological order to form a path graph structure that captures the inherent temporal evolution logic in the time series.

[0160] In graph data, node features are represented by matrices. ,in Indicates the number of nodes (i.e., window length). This represents the number of feature channels. The edge structure is defined by the edge index matrix. Definition of edge weight vector These elements collectively describe the connectivity and strength of relationships between nodes. During training, multiple graph samples can be processed in batches, and batch-level assignment vectors can be used to indicate the graph membership of each node, thereby enabling graph-level operations.

[0161] The model outputs a binary classification result, representing the motor's fault state within each graph (i.e., time window). Specifically, the output is a... , where B is the number of graphs in the current batch. A sigmoid function is used to normalize the output to the failure probability of each motor, and a threshold is used to determine the final label. During training, a multi-label binary classification objective is used to enhance the model's ability to jointly predict the failure states of multiple motors at the graph level, especially in cases of class imbalance.

[0162] Example 4, based on Examples 1-3, establishes a comparative experiment to verify the advantages of the motor fault diagnosis method and system based on hybrid graph neural network and path graph proposed in this invention;

[0163] Experimental setup

[0164] Based on the proposed model's single-branch sequential architecture of a graph neural network, two spectral domain GCN layers and one spatial domain GraphSAGE layer are sequentially used as hierarchical feature extraction modules. Each convolutional layer is followed by a batch normalization layer and a ReLU activation function to enhance training stability and nonlinearity. After each stage, a Top-K pooling layer is applied to dynamically select the node with the most information. After pooling, global mean pooling is used to aggregate node features into a graph-level representation. Embeddings from different stages are fused through vector summation and then passed through a linear projection layer. The final unified embedding is then fed into n multilayer perceptrons (MLPs) to perform binary classification faults.

[0165] FocalLoss is used during training to alleviate class imbalance by emphasizing hard-to-classify graph instances and improving fault detection performance. To address label imbalance, positive sample weights (pos-weight) are introduced to enhance the model's sensitivity to fault cases. The optimizer is Adam, with an initial learning rate of 0.0001. A StepLR learning rate scheduler is used, reducing the learning rate to 0.5 times the previous value every 10 epochs, with a minimum learning rate threshold of 1×10⁻⁶. -6 This ensures effective updates later in the training process. The batch size is set to 64, with a maximum training duration of 100 epochs.

[0166] The model architecture and training hyperparameters are summarized in Table 1.

[0167] Table 1: Configuration Instructions

[0168]

[0169] Evaluation indicators

[0170] To comprehensively evaluate the classification performance of graph neural network models in multi-motor fault identification tasks, this paper employs four commonly used multi-label evaluation metrics: accuracy, precision, recall, and F1 score. These metrics reflect the model's predictive ability under different fault states from a complementary perspective, thus providing a comprehensive evaluation of its performance.

[0171] Experimental Results and Analysis

[0172] To verify the effectiveness of the proposed Hybrid Graph Neural Network (SAGECN) model in multi-motor fault diagnosis, a series of comparative experiments were conducted. Different graph neural network models were evaluated under the same conditions, including the same dataset, the same graph construction method, and the same training configuration. The models compared included classic spectral-based methods (GCN, ChebyNet, SGCN) and spatial-based methods (GraphSAGE, GIN, GAT). All models output a one-dimensional binary classification result on each graph, representing the fault state of a single motor within the corresponding time window.

[0173] To ensure fairness and comparability, all models were trained using a uniform input graph structure and consistent hyperparameter settings. Evaluation metrics included accuracy, precision, recall, and F1-score. The F1-score was used as the primary metric to provide a balanced assessment of performance even under imbalanced label conditions.

[0174] The experimental results are shown in Table 2:

[0175] Table 2: Comparison of GNN models in fault diagnosis

[0176]

[0177] Experimental results show that the proposed SAGECN model achieves the best overall performance across all evaluation metrics, including F1 score (0.8803), accuracy (0.9491), precision (0.8312), and recall (0.9357). Compared to individual models such as GCN, GIN, and GraphSAGE, this model shows a continuous improvement, especially in F1 score, indicating a better balance between precision and recall. Notably, ChebyNet achieved the highest recall (0.9415), while GAT achieved the highest accuracy among baseline models (0.9456), suggesting that spectral-based methods are more advantageous in identifying normal patterns, while spatial-based models are better at capturing local anomalies in faults. Our proposed hybrid model fully leverages the advantages of both paradigms, thereby enhancing fault identification capabilities and overall robustness. Table 2 summarizes the detailed performance metrics of all models on the test set, further confirming the powerful capabilities and robustness of the proposed model in handling multi-label, multi-motor fault classification tasks.

[0178] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A motor fault diagnosis method based on a hybrid graph neural network and a path graph, characterized in that, The method comprises the following steps: Step S1, acquiring time series data of the motor, and constructing a path graph according to the time series data; Step S2, inputting the path graph into a hybrid graph neural network model, and performing hierarchical feature extraction on the path graph through a spectral domain convolution layer and a spatial domain convolution layer contained in the hybrid graph neural network model; Step S3, performing a dynamic graph pooling operation to down-sample the graph structure at at least two different stages in the hierarchical feature extraction process, and performing global aggregation on the down-sampled graph to generate respective graph-level embedding vectors, thereby forming an embedding vector set; Step S4, fusing all embedding vectors in the embedding vector set to generate a unified graph-level feature representation; Step S5, inputting the unified graph-level feature representation into a classifier to output a fault diagnosis result of the motor; In the step S1, the step of constructing the path graph specifically comprises: segmenting the time series data into time window data segments using a sliding window; dividing the time window data segments into a plurality of ordered time slices; creating each time slice as a node of the path graph, wherein the features of the node are determined by the sensor data corresponding to the time slice; creating a directed edge between adjacent nodes according to the order of the time slices to form a path graph structure with a time evolution direction; In the step S3, the dynamic graph pooling operation is a Top-K pooling operation, which is used to calculate the importance scores of the nodes in the path graph through a learnable scoring function, and retain the associated edges of the nodes with the highest importance scores in a preset proportion to obtain a down-sampled graph; The hybrid graph neural network model sequentially comprises two graph convolution network layers as the spectral domain convolution layer, and a graph sampling and aggregation network layer as the spatial domain convolution layer, and further comprises a batch normalization layer and a rectified linear unit activation function layer after each graph convolution network layer and the graph sampling and aggregation network layer.

2. The motor fault diagnosis method based on hybrid graph neural network and path graph according to claim 1, characterized in that, In the step S2, the hybrid graph neural network model adopts a sequential architecture, wherein the spectral domain convolution layer is located before the spatial domain convolution layer, and is used to capture the global topological dependency of the time series data.

3. The motor fault diagnosis method based on hybrid graph neural network and path graph according to claim 1, characterized in that, In the step S3, the step of performing global aggregation on the down-sampled path graph specifically comprises: aggregating the node features through a global mean pooling layer to generate a graph-level embedding vector.

4. The motor fault diagnosis method based on hybrid graph neural network and path graph according to claim 1, characterized in that, In the step S4, the step of fusing all embedding vectors in the embedding vector set specifically comprises: fusing the graph-level embedding vectors generated in the hierarchical feature extraction process by performing element-wise summation to generate the unified graph-level feature representation.

5. The motor fault diagnosis method based on hybrid graph neural network and path graph according to claim 1, characterized in that, In the step S2, the training of the hybrid graph neural network model comprises: the training adopts a focal loss function as the objective function to balance the normal state and the fault state in the training data.

6. The motor fault diagnosis method based on hybrid graph neural network and path graph according to claim 5, characterized in that, During the training, the sensitivity of the model to the fault state is enhanced by setting the positive sample weight.

7. The motor fault diagnosis system based on hybrid graph neural network and path graph according to any one of claims 1-6, characterized in that, comprises: The data acquisition and graph construction module is configured to acquire time series data of the motor and construct a path graph. The feature extraction module is configured with a hybrid graph neural network model including a spectral domain convolution layer and a spatial domain convolution layer, and is configured to perform hierarchical feature extraction on the path graph. The pooling and fusion module is configured to perform a dynamic graph pooling operation during the hierarchical feature extraction process, generate and fuse graph-level embedding vectors from the feature extraction stage, and generate a unified graph-level feature representation. The classification and diagnosis module is configured to receive the unified graph-level feature representation and output a fault diagnosis result of the motor.

Images