Industrial process root cause analysis method based on graph neural network and knowledge graph

Abstract

The invention relates to an industrial process root cause analysis method based on a graph neural network and a knowledge graph. The invention relates to the technical field of industrial process fault diagnosis and root cause analysis. The method comprises the following steps: constructing a prior industrial knowledge graph; designing a time sequence diagram auto-encoder, and capturing time sequence dependency and spatial correlation between variables in industrial time sequence data; feature learning is carried out through a graph convolutional network, optimization is carried out in combination with a loss function, and training is completed; carrying out fault contribution degree calculation, and quantifying the fault contribution degree through the reconstruction error of each variable; root cause reasoning is carried out through a ripple fault propagation algorithm, after propagation is completed, final fault quantities of all variable nodes are extracted to form propagation simulation vectors, and similarity matching and root cause sorting are completed. According to the method, multi-time-scale fault propagation modeling is realized, the time sequence characteristics of fault propagation are simulated through the time delay parameters with specific relations, and the accuracy of root cause positioning is improved.

Description

TECHNICAL FIELD

[0001] The application relates to the technical field of industrial process fault diagnosis and root cause analysis, and is an industrial process root cause analysis method based on a graph neural network and a knowledge graph. BACKGROUND

[0002] With the increasing complexity of modern industrial systems, root cause analysis of equipment failure has become a key technology for industrial process monitoring. Traditional fault detection methods mainly focus on fault identification and classification, while root cause analysis needs to further determine the origin of the fault to provide accurate guidance for maintenance decisions. Existing root cause analysis methods are mainly divided into three categories: contribution-based methods, causal reasoning-based methods and knowledge-driven methods. Contribution-based methods such as principal component analysis contribution map and reconstruction-based contribution method identify key variables by calculating the contribution of variables to fault detection indicators. Causal reasoning-based methods such as transfer entropy and Granger causality trace fault propagation paths by analyzing the causal relationship between variables. Knowledge-driven methods such as dynamic Bayesian networks and knowledge graphs use expert knowledge and historical data for reasoning.

[0003] However, these methods have certain limitations: contribution-based methods lack domain knowledge and are not sufficiently interpretable; causal reasoning-based methods require a large amount of historical data and are difficult to implement online; knowledge-driven methods often fail to effectively integrate real-time data features. The rapid development of graph neural networks provides a new technical approach to solving the above challenges. Compared with traditional deep learning methods, graph neural networks can naturally process graph-structured data, learn node and edge representations through a message passing mechanism, and extract deep features while preserving graph structure information. This feature makes graph neural networks particularly suitable for processing complex relationship networks between variables in industrial processes. Existing methods have limitations in effectively combining domain knowledge and industrial data, making it difficult to provide accurate online root cause diagnosis. Efficient uncertainty modeling and real-time performance remain challenges to be addressed. SUMMARY

[0004] The application provides an industrial process root cause analysis method (GNN-RCA) based on a graph neural network and a knowledge graph, which learns fault features using a graph neural network and combines a knowledge graph for fault propagation reasoning to achieve accurate root cause identification. The application is used for fault root cause analysis of industrial process systems, providing accurate fault source positioning and propagation path analysis for industrial process monitoring and equipment maintenance decisions.

[0005] The application provides the following technical solutions: An industrial process root cause analysis method based on a graph neural network and a knowledge graph, the method comprising the following steps: Step 1: Construct a prior industrial knowledge graph; Step 2: Design a time-series autoencoder to capture the temporal dependencies and spatial correlations between variables in industrial time-series data; Step 3: Perform feature learning through a graph convolutional network and optimize it using a loss function to complete the training; Step 4: After training is completed, the fault contribution is calculated, and the fault contribution is quantified by the reconstruction error of each variable; Step 5: Perform root cause reasoning using the ripple fault propagation algorithm. After propagation is complete, extract the final fault values ​​of all variable nodes to form a propagation simulation vector, and complete similarity matching and root cause sorting.

[0006] Preferably, step 1 specifically comprises: Constructing a priori industrial knowledge graph:

[0007] Physical entities include equipment, fluids, and substances. For process variables of data entities; Relation types include State / State_of, Output, Contain / Contained_by, and Generate. Design a path-based weight calculation method for any two variable nodes. and The weight calculation formula is:

[0008] in, It is a join variable and The set of all paths It is a path p Length, It is a path length decay parameter. It is a relation type r Importance weights.

[0009] Preferably, step 2 specifically comprises: Design a time-series autoencoder to simultaneously capture temporal dependencies and spatial correlations between variables in industrial time-series data, based on given original time-series data. Select window size Windowed data is obtained through sliding window operations. The encoder extracts temporal features through a one-dimensional convolutional layer:

[0010] in, and are weight and bias parameters of the convolutional layer; The maximum pooling layer reduces the feature dimension to: .

[0011] Preferably, the step 3 is specifically: The graph convolutional layer aggregates neighbor node information through a message passing mechanism based on the constructed variable adjacency matrix A:

[0012] wherein, is a normalized adjacency matrix, is a degree matrix, is a weight parameter of the graph convolutional layer; The network training adopts a joint loss function containing a reconstruction loss and a graph regularization loss:

[0013] The reconstruction loss adopts a mean square error to ensure accurate reconstruction of the input data:

[0014] The graph regularization loss maintains the similarity of adjacent variable node embedding representations:

[0015] wherein, is a variable i corresponding node embedding vector, is a variable i and j a connection weight between and.

[0016] Preferably, the step 4 is specifically: After the training is completed, the reconstruction error of each variable is used to quantify the fault contribution degree:

[0017] When the system is normally running, the trained autoencoder can accurately reconstruct the observation values of all variables; when some variables are abnormal, the reconstruction error thereof increases.

[0018] Preferably, the step 5 is specifically: The ripple fault propagation algorithm is implemented to perform root cause reasoning, and each candidate root cause entity is initialized as an initial fault quantity corresponding to the fault contribution of the variable, and other entities start from zero, and for a relationship triple , the propagation quantity is calculated as:

[0019] Three attenuation functions are defined as follows:

[0020]

[0021] .

[0022] After the propagation is completed, the final fault quantities of all variable nodes are extracted to form a propagation simulation vector The possibility of the candidate root cause is evaluated by calculating the cosine similarity between the propagation simulation vector and the fault contribution vector obtained by the time series autoencoder By calculating the similarity scores of all candidate root cause entities and sorting them, a root cause ranking list is obtained.

[0023] An industrial process root cause analysis system based on a graph neural network and a knowledge graph, the system comprising:

[0024] A graph construction module constructs a priori industrial knowledge graph; A design module designs a time series autoencoder to capture the temporal dependence in industrial time series data and the spatial correlation between variables; An optimization module performs feature learning through a graph convolution network and optimizes through a joint loss function to complete training; A fault contribution degree calculation module calculates the fault contribution degree after training, and quantifies the fault contribution degree through the reconstruction error of each variable; A root cause ranking module performs root cause reasoning through a ripple fault propagation algorithm, extracts the final fault quantities of all variable nodes to form a propagation simulation vector after the propagation is completed, and completes similarity matching and root cause ranking. A computer readable storage medium having a computer program stored thereon, the program being executed by a processor to implement an industrial process root cause analysis method based on a graph neural network and a knowledge graph.

[0025] A computer device comprising a memory and a processor, the memory storing a computer program, and the processor implementing an industrial process root cause analysis method based on a graph neural network and a knowledge graph when executing the computer program.

[0026] The present application has the following beneficial effects:

[0027] The present application develops a comprehensive root cause analysis framework, which cooperatively integrates a graph neural network and a knowledge graph, effectively connects field professional knowledge and real-time data features to enhance fault diagnosis capability.

[0028] ​This invention designs a time-series graph autoencoder that uses the graph structure relationship between variables to learn fault contribution, and shows superior performance compared with traditional rule-based classification methods.

[0029] This invention improves the ripple fault propagation algorithm by performing systematic root cause reasoning by simulating the fault propagation mechanism within a constructed knowledge graph structure.

[0030] This invention enables multi-timescale fault propagation modeling, and improves the accuracy of root cause localization by simulating the temporal characteristics of fault propagation through relational time delay parameters.

[0031] Experimental results on the Tennessee Eastman Processes benchmark dataset demonstrate that this method significantly outperforms existing methods in root cause identification accuracy while maintaining good interpretability and real-time performance. It improves accuracy compared to traditional methods. Attached Figure Description

[0032] To more clearly illustrate the specific embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the specific embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present invention. For those skilled in the art, other drawings can be obtained from these drawings without creative effort.

[0033] Figure 1 The diagram shows the overall framework of the root cause analysis based on graph neural networks and knowledge graphs of this invention. Detailed Implementation

[0034] The technical solution of the present invention will now be clearly and completely described with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. 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.

[0035] The present invention will be described in detail below with reference to specific embodiments. Specific Implementation Example 1: according to Figure 1 As shown, the specific optimized technical solution adopted by the present invention to solve the above-mentioned technical problems is: The present invention relates to a method for root cause analysis of industrial processes based on graph neural networks and knowledge graphs.

[0037] This invention provides a method for root cause analysis of industrial processes based on graph neural networks and knowledge graphs, the method comprising the following steps: Step 1: Construct a priori industrial knowledge graph; Step 2: Design a time-series autoencoder to capture the temporal dependencies and spatial correlations between variables in industrial time-series data; Step 3: Perform feature learning through a graph convolutional network and optimize it using a loss function to complete the training; Step 4: After training is completed, the fault contribution is calculated, and the fault contribution is quantified by the reconstruction error of each variable; Step 5: Perform root cause reasoning using the ripple fault propagation algorithm. After propagation is complete, extract the final fault values ​​of all variable nodes to form a propagation simulation vector, and complete similarity matching and root cause sorting.

[0038] This invention develops a comprehensive root cause analysis framework that synergistically integrates graph neural networks and knowledge graphs, effectively connecting domain expertise and real-time data features to enhance fault diagnosis capabilities.

[0039] This invention designs a time-series graph autoencoder that uses the graph structure relationship between variables to learn fault contribution, and shows superior performance compared with traditional rule-based classification methods.

[0040] This invention improves the ripple fault propagation algorithm by performing systematic root cause reasoning by simulating the fault propagation mechanism within a constructed knowledge graph structure.

[0041] This invention enables multi-timescale fault propagation modeling, and improves the accuracy of root cause localization by simulating the temporal characteristics of fault propagation through relational time delay parameters.

[0042] Experimental results on the Tennessee Eastman Processes benchmark dataset demonstrate that this method significantly outperforms existing methods in root cause identification accuracy while maintaining good interpretability and real-time performance. It improves accuracy compared to traditional methods. Specific Implementation Example 2: The only difference between Embodiment 2 and Embodiment 1 of this application is that: Step 1 specifically involves: Constructing a priori industrial knowledge graph:

[0044] Physical entities include equipment, fluids, and substances. For process variables of data entities; Relation types include State / State_of, Output, Contain / Contained_by, and Generate. Design a path-based weight calculation method for any two variable nodes. and The weight calculation formula is:

[0045] in, It is a join variable and The set of all paths It is a path p Length, It is a path length decay parameter. It is a relation type r Importance weights. Specific Implementation Example 3: The only difference between Embodiment 3 and Embodiment 2 of this application is that: Step 2 specifically involves: Design a time-series autoencoder to simultaneously capture temporal dependencies and spatial correlations between variables in industrial time-series data, based on given original time-series data. Select window size Windowed data is obtained through sliding window operations. The encoder extracts temporal features through a one-dimensional convolutional layer:

[0047] in, and These are the weights and bias parameters of the convolutional layer; The max pooling layer reduces the feature dimension as follows: . Specific Implementation Example 4: The only difference between Embodiment 4 and Embodiment 3 of this application is that: Step 3 specifically involves: The graph convolutional layer aggregates neighbor node information based on the constructed variable adjacency matrix A through a message passing mechanism:

[0049] in, It is a normalized adjacency matrix. It is a degree matrix. These are the weight parameters of the graph convolutional layer; Joint loss function optimization: The network training uses a joint loss function that includes reconstruction loss and graph regularization loss.

[0050] The reconstruction loss uses mean squared error to ensure accurate reconstruction of the input data.

[0051] Graph regularization loss preserves the similarity of the embedding representations of adjacent variable nodes:

[0052] in, It is a variable i The corresponding node embedding vector, It is a variable i and j The connection weights between them. Specific Implementation Example 5: The difference between Embodiment 5 and Embodiment 4 of the present invention lies only in: Step 4 specifically involves: After training, the contribution of faults is quantified by the reconstruction error of each variable:

[0054] When the system is running normally, the trained autoencoder can accurately reconstruct the observed values ​​of all variables; when some variables are abnormal, the reconstruction error increases. Specific Implementation Example Six: The difference between Embodiment Six and Embodiment Five of the present invention lies only in: Step 5 specifically involves: Implement the ripple fault propagation algorithm for root cause reasoning, and classify each candidate root cause entity. The fault contribution of the corresponding variable is used as the initial fault quantity, and other entities start from zero, for relation triples. The propagation volume is calculated as follows:

[0056] The three decay functions are defined as follows:

[0057]

[0058] . Specific Implementation Example 7: The difference between Embodiment Seven and Embodiment Six of the present invention lies only in: After propagation is complete, the final fault values ​​of all variable nodes are extracted to form the propagation simulation vector. The fault contribution vector is obtained by calculating the propagation simulation vector and the timing diagram autoencoder. Cosine similarity between them assesses the likelihood of candidate root causes:

[0060] A root cause ranking list is obtained by calculating and sorting the similarity scores of all candidate root cause entities. Specific Implementation Example 8: The difference between Embodiment 8 and Embodiment 7 of the present invention lies only in: This invention provides an industrial process root cause analysis system based on graph neural networks and knowledge graphs, the system comprising: The graph construction module constructs a priori industrial knowledge graphs. The design module designs a time series autoencoder to capture the temporal dependencies and spatial correlations between variables in industrial time series data. The optimization module learns features through a graph convolutional network and optimizes them using a loss function to complete the training. The fault contribution rate module calculates the fault contribution rate after training and quantifies the fault contribution rate through the reconstruction error of each variable. The root cause ranking module performs root cause reasoning through the ripple fault propagation algorithm. After propagation is completed, the final fault quantity of all variable nodes is extracted to form a propagation simulation vector, thus completing similarity matching and root cause ranking. Specific Implementation Example Nine: The difference between Embodiment Nine and Embodiment Eight of the present invention lies only in: The present invention provides a computer-readable storage medium having a computer program stored thereon, which is executed by a processor to implement an industrial process root cause analysis method based on graph neural networks and knowledge graphs.

[0063] The method includes the following steps: Step 1: Construct a priori industrial knowledge graph; Step 2: Design a time-series autoencoder to capture the temporal dependencies and spatial correlations between variables in industrial time-series data; Step 3: Perform feature learning through a graph convolutional network and optimize it using a loss function to complete the training; Step 4: After training is completed, the fault contribution is calculated, and the fault contribution is quantified by the reconstruction error of each variable; Step 5: Perform root cause reasoning using the ripple fault propagation algorithm. After propagation is complete, extract the final fault values ​​of all variable nodes to form a propagation simulation vector, and complete similarity matching and root cause sorting. Specific Implementation Example 10: The only difference between Embodiment 10 and Embodiment 9 of the present invention is that: The present invention provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement an industrial process root cause analysis method based on graph neural networks and knowledge graphs.

[0065] The method includes the following steps: Step 1: Construct a priori industrial knowledge graph; Step 2: Design a time-series autoencoder to capture the temporal dependencies and spatial correlations between variables in industrial time-series data; Step 3: Perform feature learning through a graph convolutional network and optimize it using a loss function to complete the training; Step 4: After training is completed, the fault contribution is calculated, and the fault contribution is quantified by the reconstruction error of each variable; Step 5: Perform root cause reasoning using the ripple fault propagation algorithm. After propagation is complete, extract the final fault values ​​of all variable nodes to form a propagation simulation vector, and complete similarity matching and root cause sorting. Specific Implementation Example Eleven: The only difference between Embodiment Eleven and Embodiment Ten of this invention is that: This invention provides an industrial process root cause analysis method (GNN-RCA) based on graph neural networks and knowledge graphs. This method uses graph neural networks to learn fault characteristics and combines them with knowledge graphs to perform fault propagation reasoning, thereby achieving accurate root cause identification.

[0067] Invention process: Step 1: Construction of Industrial Knowledge Graph Constructing a priori industrial knowledge graph , including physical entities (Equipment, fluid, substance) and data entities (Process variables) Two types of entities. Relation types include state / state_of, output, contain / contained_by, and generate. Design a path-based weight calculation method for any two variable nodes. and The weight calculation formula is:

[0068] in It is a join variable and The set of all paths It is a path p Length, It is a path length decay parameter. It is a relation type r Importance weights.

[0069] Step 2: Timing Diagram Autoencoder Design Design a time-series graph autoencoder to simultaneously capture temporal dependencies and spatial correlations between variables in industrial time-series data. Given the original time-series data... Select window size Windowed data is obtained through sliding window operations. The encoder extracts temporal features through a one-dimensional convolutional layer:

[0070] in and These are the weights and bias parameters of the convolutional layer. Max pooling layers reduce the feature dimensionality.

[0071] Step 3: Feature Learning in Graph Convolutional Networks Graph convolutional layers aggregate neighbor node information based on a constructed variable adjacency matrix A through a message passing mechanism:

[0072] in It is a normalized adjacency matrix. It is a degree matrix. These are the weight parameters of the graph convolutional layer.

[0073] Step 4: Joint Loss Function Optimization Network training employs a joint loss function that includes reconstruction loss and graph regularization loss:

[0074] The reconstruction loss uses mean squared error to ensure accurate reconstruction of the input data.

[0075] Graph regularization loss preserves the similarity of the embedding representations of adjacent variable nodes:

[0076] in It is a variable i The corresponding node embedding vector, It is a variable i and j The connection weights between them.

[0077] Step 5: Calculation of Fault Contribution After training, the contribution of faults is quantified by the reconstruction error of each variable:

[0078] When the system is running normally, the trained autoencoder can accurately reconstruct the observed values ​​of all variables; when some variables are abnormal, its reconstruction error increases significantly.

[0079] Step Six: Ripple Fault Propagation Algorithm A ripple fault propagation algorithm is implemented for root cause inference. This algorithm assumes that the true root cause entity generates a propagation pattern most similar to the observed fault contribution distribution through knowledge graph relationship paths. The algorithm then considers each candidate root cause entity... The fault contribution of the corresponding variable is used as the initial fault quantity, while other entities start from zero. For relation triples... The propagation volume is calculated as follows:

[0080] The three decay functions are defined as follows:

[0081]

[0082]

[0083] Step 7: Similarity Matching and Root Cause Ranking After propagation is complete, the final fault values ​​of all variable nodes are extracted to form the propagation simulation vector. The fault contribution vector is obtained by calculating the propagation simulation vector and the timing diagram autoencoder. Cosine similarity between them assesses the likelihood of candidate root causes:

[0084] A root cause ranking list is obtained by calculating and sorting the similarity scores of all candidate root cause entities.

[0085] This invention was validated on the Tennessee Eastman Process (TEP) dataset, which contains 52 process variables, covering 41 continuous process measurements and 11 manipulated variables. The comparison table is shown in Table 1.

[0086] Table 1. Overall performance comparison across all 12 fault scenarios:

[0087] Experimental results show that the method of the present invention exhibits superior performance on all evaluation indicators, with an accuracy rate exceeding 90%, establishing a new benchmark for root cause analysis of industrial process systems.

[0088] Experimental results on the Tennessee Eastman Processes benchmark dataset demonstrate that this method significantly outperforms existing methods in root cause identification accuracy while maintaining good interpretability and real-time performance. It improves accuracy compared to traditional methods.

[0089] The above description is merely a preferred embodiment of an industrial process root cause analysis method based on graph neural networks and knowledge graphs. The scope of protection for such a method is not limited to the above embodiments; all technical solutions falling within this framework are within the scope of protection of this invention. It should be noted that for those skilled in the art, any improvements and variations made without departing from the principles of this invention should also be considered within the scope of protection of this invention.

Claims

1. A root cause analysis method for industrial processes based on graph neural networks and knowledge graphs, characterized by: The method includes the following steps: Step 1: Construct a priori industrial knowledge graph; Step 2: Design a time-series autoencoder to capture the temporal dependencies and spatial correlations between variables in industrial time-series data; Step 3: Perform feature learning through a graph convolutional network and optimize it using a loss function to complete the training; Step 4: After training is completed, the fault contribution is calculated, and the fault contribution is quantified by the reconstruction error of each variable; Step 5: Perform root cause reasoning using the ripple fault propagation algorithm. After propagation is complete, extract the final fault values ​​of all variable nodes to form a propagation simulation vector, and complete similarity matching and root cause sorting.

2. The method according to claim 1, characterized in that: Step 1 specifically involves: Constructing a priori industrial knowledge graph: Physical entities include equipment, fluids, and substances. For process variables of data entities; Relation types include State / State_of, Output, Contain / Contained_by, and Generate. Design a path-based weight calculation method for any two variable nodes. and The weight calculation formula is: in, It is a join variable and The set of all paths It is a path p Length, It is a path length decay parameter. It is a relation type r Importance weights.

3. The method according to claim 2, characterized in that: Step 2 specifically involves: Design a time-series autoencoder to simultaneously capture temporal dependencies and spatial correlations between variables in industrial time-series data, based on given original time-series data. Select window size Windowed data is obtained through sliding window operations. The encoder extracts temporal features through a one-dimensional convolutional layer: in, and These are the weights and bias parameters of the convolutional layer; The max pooling layer reduces the feature dimension as follows: 。 4. The method according to claim 3, characterized in that: Step 3 specifically involves: The graph convolutional layer aggregates neighbor node information based on the constructed variable adjacency matrix A through a message passing mechanism: in, It is a normalized adjacency matrix. It is a degree matrix. These are the weight parameters of the graph convolutional layer; Joint loss function optimization: The network training uses a joint loss function that includes reconstruction loss and graph regularization loss. The reconstruction loss uses mean squared error to ensure accurate reconstruction of the input data. Graph regularization loss preserves the similarity of the embedding representations of adjacent variable nodes: in, It is a variable i The corresponding node embedding vector, It is a variable i and j The connection weights between them.

5. The method according to claim 4, characterized in that: Step 4 specifically involves: After training, the contribution of faults is quantified by the reconstruction error of each variable: When the system is running normally, the trained autoencoder can accurately reconstruct the observed values ​​of all variables; When certain variables become abnormal, the reconstruction error increases.

6. The method according to claim 5, characterized in that: Step 5 specifically involves: Implement the ripple fault propagation algorithm for root cause reasoning, and classify each candidate root cause entity. The fault contribution of the corresponding variable is used as the initial fault quantity, and other entities start from zero, for relation triples. The propagation volume is calculated as follows: The three decay functions are defined as follows: 。 7. The method according to claim 6, characterized in that: After propagation is complete, the final fault values ​​of all variable nodes are extracted to form the propagation simulation vector. The fault contribution vector is obtained by calculating the propagation simulation vector and the timing diagram autoencoder. Cosine similarity between them assesses the likelihood of candidate root causes: A root cause ranking list is obtained by calculating and sorting the similarity scores of all candidate root cause entities.

8. A root cause analysis system for industrial processes based on graph neural networks and knowledge graphs, characterized by: The system includes: The graph construction module constructs a priori industrial knowledge graphs. The design module designs a time series autoencoder to capture the temporal dependencies and spatial correlations between variables in industrial time series data. The optimization module learns features through a graph convolutional network and optimizes them using a loss function to complete the training. The fault contribution rate module calculates the fault contribution rate after training and quantifies the fault contribution rate through the reconstruction error of each variable. The root cause ranking module performs root cause reasoning through the ripple fault propagation algorithm. After propagation is completed, the final fault quantity of all variable nodes is extracted to form a propagation simulation vector, thus completing similarity matching and root cause ranking.

9. A computer-readable storage medium having a computer program stored thereon, characterized in that, The program is executed by the processor to implement the method as claimed in any one of claims 1-7.

10. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the processor executes the computer program, it implements the method of any one of claims 1-7.

Images