A method for mining similar faults based on fault atlas
By constructing a fault map and improving the RippleNet model, the problem of low fault diagnosis accuracy in actual mechanical equipment environments was solved, achieving higher fault diagnosis accuracy and recall rate, and assisting maintenance personnel in decision-making.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- TIANJIN DEV ZONE JINGNUOHANHAI DATA TECH CO LTD
- Filing Date
- 2022-10-25
- Publication Date
- 2026-04-21
AI Technical Summary
Existing technologies have low accuracy in fault diagnosis under actual working conditions of mechanical equipment, which increases the difficulty of diagnosis for maintenance personnel. Existing similar fault mining methods based on knowledge graphs have failed to effectively mine entity attributes and relationships.
A similar fault mining method based on fault graphs is adopted. By constructing a fault graph and combining fault nodes and graph relationships, a neighborhood aggregation is performed using an improved RippleNet model to mine similar fault nodes and enrich the diagnostic results.
It improves the accuracy of fault diagnosis. Compared with traditional methods, the precision and recall are improved by 1.41% and 1.23% respectively, and it significantly outperforms other models under certain conditions, providing more comprehensive diagnostic results.
Smart Images
Figure CN115659238B_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of equipment fault diagnosis, and more specifically to a method for similar fault mining based on fault maps. Background Technology
[0002] In the context of Industry 4.0, mechanical equipment is becoming increasingly complex, automated, and intelligent. Failures in certain components can threaten to halt the entire production line, making efficient and accurate equipment fault diagnosis a hot research topic. Due to the complex working environment of mechanical equipment, the actual accuracy of fault diagnosis is far lower than that of laboratory test data. Therefore, it is necessary to provide more information on similar faults to assist maintenance personnel in making fault diagnosis decisions.
[0003] The concept of Knowledge Graph (KG), proposed by Google, is widely used in fields such as knowledge and data representation and complex relationship mining due to its advantages such as strong knowledge association, vivid database display, and convenient querying. A knowledge graph is a multi-relation graph composed of entities and relations, consisting of multiple triplet units represented as <head entity, relation, tail entity>. It is a graph structure network describing entities and attributes connected by entity relations. With the rapid development of large-scale equipment technology, knowledge graphs, due to their strong knowledge association and accurate information matching, have also been applied to the field of fault diagnosis. By representing fault data with knowledge and constructing diagnostic models, fault types can be effectively identified, ultimately achieving intelligent and automated equipment fault diagnosis.
[0004] Integrating knowledge graphs as additional auxiliary information into similarity fault mining methods can improve model accuracy and provide interpretability for the mining methods. There are three main approaches to knowledge graph-based similarity fault mining: embedding vector-based methods, path-based methods, and joint methods. Embedding vector-based methods tend to overlook entity relationships, while path-based methods fail to effectively mine entity attributes. Therefore, this paper proposes a hybrid embedding and path-based similarity fault mining model. Based on the RippleNet model [Wang H, et al. Ripplenet: Propagating userpreferences on the knowledge graph for recommender systems[C] / / Proceedings of the 27th ACM international conference on information and knowledge management], neighborhood aggregation is added for improvement, thereby enriching the diagnostic results and assisting personnel in decision-making. Summary of the Invention
[0005] To address the problems of existing technologies, this invention provides a Similar Fault Mining Method Based on Fault Graph (SFM-FG). First, fault nodes and relationships are determined based on equipment data. A fault graph is constructed by combining fault nodes and graph relationships, and the relationship weights in the graph are determined based on node feature weights and hierarchy. Second, similar fault nodes are mined from the fault graph using an improved RippleNet model based on Neighborhood Aggregation (NA-RippleNet). Finally, similar fault matching is performed to enrich the diagnostic results and assist maintenance personnel in decision-making.
[0006] To solve the above-mentioned technical problems, the technical solution adopted by the present invention is as follows:
[0007] A method for similar fault mining based on fault maps includes the following steps:
[0008] S1: Determine the classification characteristics of the faults based on the equipment data, combine the characteristics as fault nodes at different levels, and define the graph relationships;
[0009] S2: Construct a fault graph by combining fault nodes and graph relationships, and determine the relationship weights in the graph based on the fault nodes and their node levels;
[0010] S3: Using the RippleNet model based on neighborhood aggregation, similar fault nodes are mined in the fault map through ripple diffusion.
[0011] S4: Perform similar fault matching and provide relevant information on similar faults by combining fault maps.
[0012] Furthermore, in step S1, a method based on classification feature combination is used to extract entities and relationships from the graph, as follows:
[0013] 1-1) Summarize the rules for the text description of the device data and extract feature 1, feature 2 up to feature n as the basis for classification;
[0014] 1-2) Select 1 to n classification features sequentially and combine them as fault nodes at different levels, with the first-level fault node being the first-level fault node. F 1 Up to level n fault nodes F n ,in F 1 It contains 1 classification feature.F n It contains n classification features;
[0015] 1-3) Define fault nodes with the same number of features as sibling nodes, fault nodes with fewer features as parent nodes, and fault nodes with more features as child nodes. The relationship between a child node and a parent node with the same feature value and a difference of 1 in node level is called a kinship relationship. The graph relationship is represented by a triple, which is: <child fault node, relationship, parent fault node>.
[0016] Furthermore, in step S2, a fault map is constructed based on the fault nodes and the map relationships, and the relationship weights in the map are determined based on the fault nodes and their node levels. The steps are as follows:
[0017] 2-1) Save the fault nodes and their relationships in the graph using a CSV table;
[0018] The table attributes for faulty nodes include node ID, node type, and node description.
[0019] The graph relationship table attributes include the starting entity node, the starting node label, the ending entity node, the ending node label, and the relationship type.
[0020] 2-2) Import the above CSV table into the Neo4j database using Cypher statements to construct a fault map;
[0021] 2-3) Define the maximum value of the relation weight as S max The number of features is n ;definition W node The combined node weights represent the weights of each classification feature; defined... LevelScore , representing the node hierarchy weight, indicating the weight of each node hierarchy when the faulty nodes are at different levels; W node The formula is:
[0022]
[0023] Comprehensive node weights W node With node level weights LevelScore The relation weights can be calculated. RelScore , RelScore The formula is:
[0024]
[0025] in, a iLet m be the i-th classification feature, m be the number of feature types with different values among faulty nodes, and k be the number of different node levels.
[0026] 2-4) Save the relation weights to a CSV table and import them into the Neo4j database to obtain a fault map with weights.
[0027] The beneficial effects of adopting the above technical solution are as follows:
[0028] (1) The present invention proposes a similar fault mining method based on fault graph. In view of the problem that the actual working environment of the equipment is complex and the diagnostic accuracy is reduced compared with laboratory data, which increases the difficulty of diagnosis for on-site maintenance personnel, the present invention improves the three processes of extracting fault nodes and relationships, constructing graph, and mining similar faults. The improved RippleNet algorithm of the present invention is called a similar fault mining method based on fault graph. Compared with the traditional similar fault mining method, this method not only increases the consideration of constructing fault graph, but also fully mines the fault nodes in the graph.
[0029] (2) Compared with similar fault diagnosis methods, the present invention: 1) proposes a classification feature combination method to extract fault nodes and relationships from equipment data; 2) determines relationship weights based on feature weights and node hierarchy differences, thereby optimizing the fault map; 3) improves the RippleNet model, and combines it with the fault map to mine other fault nodes in the map that are similar to the diagnosed fault nodes through ripple diffusion and neighborhood aggregation.
[0030] (3) The method proposed in this invention was applied to the faulty bearing dataset of Western Reserve University in the United States. Through experimental analysis, the effectiveness of the proposed SFM-FG model for mining similar faults was verified. The accuracy and recall were improved by 1.41% and 1.23% respectively compared with the RippleNet model, 2.9% and 4.37% respectively compared with the KGCN model, and more than 11% and 7.37% respectively compared with the CKE and DKN models, which can realize the mining of similar faults. Attached Figure Description
[0031] Figure 1 This is a flowchart of a similar fault mining method based on fault maps;
[0032] Figure 2 This is a diagram of the RippleNet model, which is improved based on domain aggregation.
[0033] Figure 3 This is a comparison chart of the precision values of each model;
[0034] Figure 4 This is a comparison chart of Recall values for each model;
[0035] Figure 5 This is a comparison chart of Precision values under different Hops;
[0036] Figure 6 It is a graph showing the number of hits and the probability. Detailed Implementation
[0037] The present invention will now be described in further detail with reference to the accompanying drawings and specific embodiments.
[0038] This invention uses industrial machinery and equipment fault diagnosis as a vehicle, and knowledge graphs and the RippleNet algorithm as the main algorithmic framework. The method flow is as follows: Figure 1 As shown, it includes the following steps:
[0039] S1. Determine the classification features of the faults based on the equipment data, combine them as fault nodes at different levels, and define the graph relationships. This step uses a method based on the combination of classification features to extract entities and relationships from the graph. The steps are as follows:
[0040] 1-1) Summarize the rules based on the textual descriptions of the device data and extract features 1 that can be used as classification criteria. f 1 Feature 2 f 2 ) until feature n ( f n );
[0041] 1-2) Select 1 to n classification features sequentially and combine them as fault nodes at different levels, such as level one fault nodes ( F 1 ) to n-level fault node ( F n ),in F 1 It contains 1 classification feature. F n It contains n classification features;
[0042] 1-3) Define faulty nodes with the same number of features as sibling nodes, and faulty nodes with fewer features as parent nodes (e.g., ...). F 1 Fault nodes with more characteristics are subordinate nodes (such as...) F n The relationship between a lower-level node and a higher-level node with the same feature value and a node level difference of 1 is "belongs to". Graph relationships are represented by triples of the form <lower-level fault node, relationship, higher-level fault node>, such as ( F 2 ,belong, F 1 ).
[0043] S2. Construct a fault graph by combining fault nodes and graph relationships, and determine the relationship weights in the graph based on the node feature weights and their levels.
[0044] A fault graph is constructed based on the fault nodes and their relationships. The weights of the relationships in the graph are determined based on the fault nodes and their hierarchical levels, thereby optimizing the fault graph. The steps are as follows:
[0045] 2-1) Save the fault nodes and their relationships in the graph using a CSV table.
[0046] The fault node table attributes include node id (node_id), node type (node_label), and node description (node_describe).
[0047] The graph relationship table attributes include the starting entity node (start_entity), the starting node label (start_label), the ending entity node (end_entity), the ending node label (end_label), and the relationship type (relationship).
[0048] 2-2) Import the above CSV table into the Neo4j database using the Cypher statement to construct a fault map.
[0049] 2-3) Define the maximum value of the relation weight as S max The number of features is n .definition W node , where represents the weight of each categorical feature. Definition LevelScore Here, represents the node hierarchy weight, indicating the weight of each node level when the faulty nodes are at different hierarchical levels. The formula is as follows:
[0050]
[0051] Comprehensive node weights W node With node level weights LevelScore The relation weights can be calculated ( RelScore The formula is as follows:
[0052]
[0053] in, a i Let m be the i-th classification feature, m be the number of feature types with different values among faulty nodes, and k be the number of different node levels.
[0054] 2-4) Save the relation weights to a CSV table and import them into the Neo4j database to obtain a fault map with weights.
[0055] S3. Using a neighborhood-aggregation-based improved RippleNet model, similar fault nodes are mined from the fault map through ripple diffusion. The neighborhood-aggregation-based improved RippleNet model is as follows: Figure 2 As shown, the steps are as follows:
[0056] 3-1) Enter the query fault node u In the fault map, obtain the nodes directly connected to the queried fault node. v u and relationships r ,node v u The set is ;
[0057] 3-2) Using inner product To calculate the weights between faults and relation types ,in The relational weight matrix for each faulty node. d The dimension of a vector is expressed by the following formula.
[0058]
[0059] in These are the various fault nodes in the graph. n and relationships r The vector representation of , Representing relations r For the fault node n The importance of the fault-relationship score.
[0060] Combination For querying faulty nodes u Other related fault nodes v Neighbors The formula is as follows:
[0061]
[0062] in The normalized fault-relationship score is represented by the following formula.
[0063]
[0064] Indicates the fault node v All directly connected faulty nodes e The set, Represents a node e The eigenvectors are denoted by exp, which is an exponential function with the natural constant e as the base. To maintain computational efficiency, in actual calculations, the neighboring nodes of each fault node are used. Perform a fixed-size random sample as the neighborhood of the faulty node. Instead of using all the faulty nodes, that is... After sampling and conversion ;
[0065] 3-3) Identify the fault node v After considering the nodes and their neighborhoods, the representation vectors of the two types of nodes are added together, and then a nonlinear transformation is performed to achieve the aggregation of the two types of vectors, as shown in the following formula.
[0066]
[0067] Where W represents the transformation weights and b represents the bias vector. It is a ReLU nonlinear function, where v is the fault node. v eigenvectors.
[0068] Aggregate vector Its embedding matrix Perform corresponding term matrix multiplication to obtain the weighted head entity. The formula is as follows:
[0069]
[0070] Weighted Head Entity Indicates the fault node v The aggregated representation of the relevant neighborhood is further combined with the weighted head entity, entity relation, and tail entity to calculate v and each triple in the neighborhood. Relevant probability The formula is as follows:
[0071]
[0072] Wherein represents relation eigenvectors, Indicates weighted head entity eigenvectors, v T This is the transpose of the eigenvector matrix v. Correlation probability. In relation vector representation Middle fault node v and weighted head entity The degree of similarity. When different relation types are used for calculation, the fault node v and They may have different similarities, therefore it is necessary to separate the relational data. Add it to the calculation of the association probability;
[0073] 3-4) Calculate the relevant probabilities Then, combine them with the node set respectively. All tail entities Multiplication yields vectors The formula is as follows:
[0074]
[0075] Represents the tail node t i eigenvectors, The first-order fault embedding vector represents the query fault node. u The first round of diffusion results for associated faulty nodes are used to construct the embedding vector of the queried faulty node. u Embedding. (Referring to 3-3) In v Replace with Repeatedly mine to obtain the faulty nodes. u Second-order response This represents the ripple diffusion process from the current node to other associated nodes. It involves a total of... H Secondary diffusion excavation can form H There are vectors o, and each vector is generated during mining. Nodes that are similar to the currently faulty node.
[0076] Since each input vector is the output of the previous mining result, the similarity between the mining result and the target fault gradually weakens as the number of hops increases. H The query fault node is obtained by summing the vectors. u The vector embedding u. The formula is as follows:
[0077]
[0078] 3-5) Combine querying faulty nodes u Embedded vector u and other fault nodes v The embedding vector v is used to calculate the similarity probability between faulty nodes. The formula is as follows.
[0079] ;
[0080] S4: Perform similar fault matching and provide relevant information about similar faults by combining knowledge graphs.
[0081] Based on the above steps, this invention effectively solves the problem of similar fault mining. First, fault nodes and relationships are determined based on equipment data. A fault graph is constructed by combining fault nodes and graph relationships, and the relationship weights in the graph are determined based on node feature weights and hierarchy. Second, a RippleNet model based on neighborhood aggregation is used to mine similar fault nodes in the fault graph. Finally, similar fault matching is performed to enrich the diagnostic results and assist maintenance personnel in decision-making.
[0082] Example 1
[0083] Experimental verification of the knowledge graph-based similar fault mining method of this invention:
[0084] 1. Data Description
[0085] The data used in this experiment is the rolling bearing fault dataset from Case Western Reserve University (CWRU). Several papers, both domestic and international, have already validated their algorithms using this bearing dataset. The manual repair text for this dataset mainly introduces the vibration data, which consists of vibration signals collected by accelerometers at the bearing drive end, fan end, and motor base. The motor loads are 0, 1, 2, and 3 horsepower (hp), corresponding to motor rotation speeds of 1797, 1772, 1750, and 1730 r / min, respectively. Single-point damage faults were created on the bearing inner race, rolling elements, and outer race using electrical discharge machining (EDM). Each fault type includes fault dimensions of 0.007 inches (minor damage), 0.014 inches (moderate damage), and 0.021 inches (severe damage). The damage points on the outer ring of the bearing are located at three positions: 3 o'clock, 6 o'clock, and 12 o'clock, with vibration frequencies of 12 kHz and 48 kHz.
[0086] 2. Extraction of fault nodes and relationships
[0087] This experiment only selected 12kHz data, and the classification features included five categories: vibration end, bearing component location, damage depth, motor load, and damage clock. Combining these classification features yielded fault nodes at different levels, resulting in five levels of fault nodes as follows:
[0088] Level 1 fault nodes: end, there are 2 types;
[0089] Level 2 fault nodes: end_location, with a total of 6 categories;
[0090] Level 3 fault nodes: end_location_size, with a total of 18 categories;
[0091] Level 4 fault nodes: end_location_size_load, with a total of 72 categories;
[0092] Five-level fault nodes (fault_level_5): end_location_size_load_clock, with a total of 97 categories.
[0093] The attributes entered into the knowledge graph include node ID (node_id), node name (node_name), node type (node_label), and node description (node_describe). A selection of nodes is shown in Table 1.
[0094] Table 1 Some Faulty Nodes
[0095]
[0096] The relationship between lower-level fault nodes and higher-level fault nodes is "belongs to" and "contains", which is represented by triples and stored in a CSV table. A selection of fault relationships is shown in Table 2.
[0097] Table 2 Excerpt of Fault Relationship Nodes
[0098]
[0099] 3. Construct a fault map
[0100] Importing the CSV files containing entity nodes from Table 1 and relationship nodes from Table 2 into the Neo4j graph database will generate a knowledge graph composed of the aforementioned fusion rule chains. The import process requires building a graph construction model based on Cypher statements. This model uses a Python program to read the CSV file, parse fault nodes, attributes, and relationships, and then uses the Py2neo package to manipulate the Neo4j graph database, importing node and relationship information to construct the fault graph. A list of methods included in the graph construction module is shown in Table 3.
[0101] The graph database is operated using Py2neo and Cypher, and triples stored in CSV files are imported into Neo4j to construct the graph.
[0102] Table 3 List of methods for constructing graph models
[0103]
[0104] Set similarity Smax With a maximum value of 1 and a total number of feature values n of 5, the feature weight and node level difference are 0.2. The relationship weights of each fault node in the fault map are calculated, and a selection of the relationship weights is shown in Table 4.
[0105] Table 4. Partial Relationship Weights
[0106]
[0107] 4. Similar Fault Discovery
[0108] This paper incorporates mainstream knowledge graph-based models such as CKE, DKN, RippleNet, and KGCN, and conducts Top-K comparison experiments with the NA-RippleNet model, recording the results for K values of 1, 2, 3, 5, 10, 20, and 50. The precision and recall results are shown below. Figure 3 and Figure 4 As shown in the figure. Experimental results demonstrate that the NA-RippleNet model achieves relatively stable and high accuracy in the first 5 similar faults (k=1 to k=5).
[0109] The results show that the NA-RippleNet model improves both precision and recall compared to other models. When k=3, precision and recall are improved by 1.41% and 1.23% respectively compared to the RippleNet model, 2.9% and 4.37% respectively compared to the KGCN model, and more than 11% and 7.37% respectively compared to the CKE and DKN models. When k is any other value greater than 10, NA-RippleNet also outperforms other models. Table 5 shows the specific comparison of precision and recall when k=3.
[0110] Table 5. Comparison of Precision and Recall for Each Model
[0111]
[0112] The parameter section selects the main parameter Hop for comparison, and selects the Top-K results for Hop-1 to Hop-5 respectively, as shown below. Figure 5 As shown, the accuracy is highest when Hop=4 and k=1, but the first 5 k values are relatively stable and the accuracy is highest when the parameter is Hop=3. Therefore, choosing 3 for the number of Hop jumps is more appropriate.
[0113] The system performs similar fault mining on erroneous fault diagnosis results and compares the labels of similar and correct faults. If the labels match, the fault is considered a hit. The experimental test's hit count and probability results are as follows: Figure 6As shown in the figure, in the first three Top-K similarity predictions, the number of hits was relatively large and the hit probability increased rapidly, reaching 80.65% in the Top-3. From k=4 onwards, the number of hits decreased, and the hit probability tended to level off, reaching 85.32% in the Top-10. Therefore, it can be concluded that, based on the fault map and data in this paper, even in the case of diagnostic errors, providing 3 similar faults can guarantee an 80.65% probability of hitting the true fault type.
[0114] In summary, the SFM-FG model provides similar faults for maintenance personnel to reference during fault diagnosis, enriching the diagnostic results and improving the comprehensiveness of fault diagnosis. When the main fault diagnosis result is correct, similar faults are checked as alternative solutions. When the diagnosis is incorrect, the fault is more likely to exist in similar faults, and the true fault can be located by checking similar faults.
[0115] 5. Conclusion
[0116] To address the challenges of complex actual operating environments and increased difficulty in on-site fault diagnosis, a similarity fault mining model based on fault graphs (SFM-FG) is proposed. This model extracts entities and relationships from the graph through a combination of classification features, and calculates relationship weights by integrating feature weights and node hierarchy differences to construct the fault graph. Furthermore, it uses a neighborhood aggregation-based RippleNet module (NA-RippleNet) to mine similar faults, obtaining similar fault nodes to enrich diagnostic results and assist decision-making. Experimental results show that by statistically analyzing error frequencies, the model effectively derives feature weights and relationship weights at different levels. Moreover, NA-RippleNet outperforms traditional models in both precision and recall metrics in Top-K prediction experiments, demonstrating the model's accuracy in mining similar faults. Further effectiveness is confirmed through hit rate experiments.
Claims
1. A method for similar fault mining based on fault maps, characterized in that: Includes the following steps: S1: Determine the classification characteristics of the faults based on the equipment data, combine the characteristics as fault nodes at different levels, and define the graph relationships; S2: Construct a fault graph by combining fault nodes and graph relationships, and determine the relationship weights in the graph based on the fault nodes and their node levels; including: 2-1) Saving the fault nodes and graph relationships in a CSV table; The table attributes for faulty nodes include node ID, node type, and node description. The graph relationship table attributes include the starting entity node, the starting node label, the ending entity node, the ending node label, and the relationship type. 2-2) Import the above CSV table into the Neo4j database using Cypher statements to construct a fault map; 2-3) Define the maximum value of the relation weight as S max The number of features is n ;definition W node The combined node weights represent the weights of each classification feature; defined... LevelScore , representing the node hierarchy weight, indicating the weight of each node hierarchy when the faulty nodes are at different levels; W node The formula is: Comprehensive node weights W node With node level weights LevelScore The relation weights can be calculated. RelScore , RelScore The formula is: in, a i Let m be the i-th classification feature, m be the number of feature types with different values among faulty nodes, and k be the number of different node levels. 2-4) Save the relation weights to a CSV table and import them into the Neo4j database to obtain a fault map with weights; S3: Using the RippleNet model based on neighborhood aggregation, similar fault nodes are mined in the fault map through ripple diffusion. S4: Perform similar fault matching and provide relevant information on similar faults by combining fault maps.
2. The similar fault mining method based on fault map according to claim 1, characterized in that: In step S1, a method based on classification feature combination is used to extract entities and relationships from the graph. The steps are as follows: 1-1) Summarize the rules for the text description of the device data and extract feature 1, feature 2 up to feature n as the basis for classification; 1-2) Select 1 to n classification features sequentially and combine them as fault nodes at different levels, with the first-level fault node being the first-level fault node. F 1 Up to level n fault node F n ,in F 1 It contains one classification feature. F n It contains n classification features; 1-3) Define fault nodes with the same number of features as sibling nodes, fault nodes with fewer features as parent nodes, and fault nodes with more features as child nodes. The relationship between a child node and a parent node with the same feature value and a difference of 1 in node level is called a kinship relationship. The graph relationship is represented by a triple, which is: <child fault node, relationship, parent fault node>.
Citation Information
Patent Citations
Fault diagnosis method and device based on knowledge graph, equipment and medium
CN114491037A