Fault tree analysis and troubleshooting methods based on size model collaboration and graph database
By collaborating with a visual mini-model and a graph database, fault tree images are identified and converted into graph database nodes. Combined with a text-based reasoning model, a structured troubleshooting solution is generated. This solves the problems of scattered fault tree data and reliance on manual intervention, enables unified querying and consistency verification of fault propagation paths, and improves the accuracy and reliability of troubleshooting.
Patent Information
- Application Number
- CN202611609665.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-10-19
- Publication Date
- 2026-11-17
AI Technical Summary
The existing fault tree data is scattered, the troubleshooting process relies on manual experience, and the generated troubleshooting solutions lack consistency constraints, resulting in omissions of fault causes, unreasonable troubleshooting order, and long cycles.
Fault tree images are identified using a visual small model, converted into nodes and directed edges in a graph database, and combined with semantic embedding vectors. The graph database query tool is then used to traverse the fault propagation path, and a structured troubleshooting solution is generated by combining a text reasoning large model, followed by consistency verification.
It improves the unified management and retrieval capabilities of fault knowledge, narrows down the range of fault causes, generates troubleshooting solutions with logical consistency and on-site feasibility, and reduces the risk of missing fault tree nodes and connection errors.
Smart Images

Figure CN123115455A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of intelligent fault diagnosis and maintenance technology, specifically to a fault tree analysis and troubleshooting method based on large and small model collaboration and graph database. Background Technology
[0002] Fault tree analysis is an analytical method that analyzes the causes of equipment system failures step by step based on the failure phenomena, and determines the failure propagation path and failure combination through the causal relationship between events. It has been widely used in the fields of fault diagnosis, reliability analysis and maintenance support of complex equipment.
[0003] Currently, equipment troubleshooting primarily relies on maintenance personnel consulting technical manuals, maintenance records, fault tree data, and expert experience to manually compare and systematically check fault phenomena. Existing fault tree data is typically stored in the form of images, documents, or scattered records, lacking a unified connection between fault events, logical relationships, and historical maintenance experience, making it difficult to continuously query and reuse fault propagation paths. When on-site experts cannot provide timely guidance, maintenance personnel often rely on personal experience for trial-and-error troubleshooting, which can easily lead to missed fault causes, unreasonable troubleshooting sequences, and prolonged troubleshooting cycles. Furthermore, existing troubleshooting methods based on general text generation models lack definite fault tree data constraints, potentially resulting in missing event nodes, incorrect logical relationships, or inconsistencies between the generated results and the actual fault tree. Therefore, how to uniformly manage fault tree knowledge, determine fault propagation paths based on fault phenomena, and generate troubleshooting solutions that are both logically consistent and field-executable has become a pressing technical problem in this field. To this end, a fault tree analysis and troubleshooting method based on large and small model collaboration and graph databases is urgently needed. Summary of the Invention
[0004] To address the shortcomings of existing technologies, this invention provides a fault tree analysis and troubleshooting method based on big-small model collaboration and graph database, which solves the problems of scattered fault tree data, reliance on manual experience in the troubleshooting process, and lack of consistency constraints in the generated troubleshooting solutions in existing technologies.
[0005] To achieve the above objectives, the present invention provides the following technical solution:
[0006] A fault tree analysis and troubleshooting method based on size model collaboration and graph database includes the following steps:
[0007] Step S1: Obtain the fault tree image and fault phenomenon text. Perform visual recognition on the fault tree image using a visual small model. Extract the event nodes and logical relationships between events in the fault tree. Divide the event nodes into top events, middle events, and bottom events. Convert the event nodes and logical relationships into nodes and directed edges in the graph database. Associate semantic embedding vectors with the event nodes.
[0008] Step S2: Vectorize the fault phenomenon text, match the obtained query vector with the semantic embedding vector of the event node in the graph database, and filter the top event corresponding to the fault phenomenon text.
[0009] Step S3: Based on the top event, a predefined graph database query tool is called through the MCP protocol to traverse the fault tree along the directed relationship from parent event to child event, obtain the fault propagation path, and limit the traversal process based on the preset maximum retrieval depth; according to the event nodes and logical relationships in the fault propagation path, the fault tree is logically expanded and fault combination reduction is performed to obtain the minimum cut set corresponding to the top event and its associated fault event information.
[0010] Step S4: Using a large text reasoning model, tasks are arranged and results are summarized for the top event, fault propagation path, minimum cut set and historical maintenance cases to generate a structured troubleshooting plan that includes fault cause analysis, maintenance operation steps, fault troubleshooting priority, tools and spare parts and safety precautions.
[0011] Step S5: Compare the fault tree structure, event nodes, and logical relationships in the structured troubleshooting scheme with the fault tree data in the graph database. Based on the comparison results, perform a consistency check on the structured troubleshooting scheme and output the fault tree structure and structured troubleshooting scheme that pass the consistency check.
[0012] Further, in step S1, the event nodes and logical relationships are converted into nodes and directed edges in a graph database, and the semantic embedding vectors associated with the event nodes include:
[0013] The system uses a visual mini-model to identify text regions, event nodes, and connections between nodes in fault tree images, and outputs structured recognition results that include event names, event types, original node identifiers, and logical relationships.
[0014] The event names are vectorized using an embedding model to obtain the semantic embedding vectors of the corresponding event nodes.
[0015] Based on the structured recognition results, event nodes are created in the graph database, and the unique identifier, original node identifier, node name, node type, occurrence probability, semantic embedding vector, creation time and update time of the event node are stored as node attributes.
[0016] Based on the identified logical relationship between the parent and child events, a directed edge is established from the parent event to the child event, and the logical relationship is stored as the logical type attribute of the directed edge.
[0017] Furthermore, the step S2 of filtering the top event corresponding to the fault phenomenon text includes:
[0018] Input the fault phenomenon text into the embedded model to obtain the query vector corresponding to the fault phenomenon text;
[0019] The similarity between the query vector and the semantic embedding vector of the event node in the graph database is calculated, and the nodes are sorted from high to low according to the similarity. The top event is selected according to the preset retrieval return quantity parameter.
[0020] The maximum similarity in the top event is compared with a preset similarity threshold. When the maximum similarity is less than the similarity threshold, the fault phenomenon text is rewritten or expanded, and the top event retrieval is re-executed.
[0021] The top events and corresponding similarity information obtained from the re-retrieval are returned to the large text reasoning model to determine the starting node for subsequent fault propagation path retrieval.
[0022] Furthermore, the logical expansion in step S3 includes:
[0023] The current traversed node, the set of fault propagation paths, the set of minimum cut set candidates, and the set of historical maintenance cases are maintained as fault tree reasoning state information.
[0024] When performing fault tree traversal, the fault tree expansion method is determined based on the logic type associated with the current event node. Specifically, when the logic type is an OR gate, the corresponding sub-events are traversed separately, and when the logic type is an AND gate, the corresponding sub-events are traversed as a fault combination that participates in the traversal.
[0025] After each expansion operation, update the current traversed node and the set of fault propagation paths, and take any of the following conditions as the termination condition: reaching the preset maximum search depth, the current node being the bottom event, or no new node or new historical maintenance case being generated for a preset number of consecutive times.
[0026] After the termination condition is met, the set of fault propagation paths obtained by traversal is passed to the minimal cut set calculation tool for fault combination reduction.
[0027] Furthermore, after the termination condition is met, the set of fault propagation paths obtained through traversal is passed to the minimal cut set computation tool for fault combination reduction, including:
[0028] Logically reduce the bottom events and their logical relationships in the set of fault propagation paths to obtain the minimum cut set that leads to the occurrence of the top event;
[0029] Based on the occurrence probabilities of the bottom events in the minimum cut set, calculate the fault combination information corresponding to the minimum cut set, and obtain the occurrence probability of the top event;
[0030] Based on the contribution information of the bottom event to the probability of the top event, the priority of troubleshooting the bottom event is determined.
[0031] Furthermore, the process of generating the structured troubleshooting solution in step S4 includes:
[0032] The text reasoning model generates multiple sub-tasks based on the text of fault phenomena, including at least top event query, fault propagation path retrieval, minimum cut set calculation, and historical maintenance case retrieval.
[0033] The multiple subtasks are assigned to the corresponding fault tree path retrieval tool, minimum cut set calculation tool and historical experience retrieval tool, and the retrieval depth, retrieval return quantity and inference execution parameters are configured for each subtask;
[0034] The execution progress, return results, and exception information of each subtask are recorded through a global state diagram, and it is determined whether to continue calling the corresponding tool or perform manual query based on the global state diagram.
[0035] After the completion of the multiple sub-tasks, the text reasoning big model summarizes the return results of each sub-task and generates a structured troubleshooting solution.
[0036] Furthermore, the historical experience retrieval tool retrieves at least one type of unstructured maintenance knowledge from historical maintenance records, equipment manuals, technical manuals, and fault diagnosis case databases. The retrieval includes at least one of vector retrieval and full-text retrieval. The retrieved historical maintenance cases are associated with fault propagation paths and minimum cut sets to generate fault diagnosis steps and fault cause analysis in the structured troubleshooting solution.
[0037] Further, the consistency check in step S5 includes:
[0038] Structural consistency verification: Traverse the directed edges stored in the graph database and compare the parent event, child event and edge direction corresponding to the directed edge with the fault tree structure in the structured troubleshooting scheme;
[0039] Node consistency verification: Match the event nodes in the structured troubleshooting solution with the corresponding event nodes in the graph database, and verify the node name, node type and node association relationship;
[0040] Logical consistency verification: Based on the logic types and fault propagation paths stored in the graph database, verify whether the logic gate combination in the structured troubleshooting scheme is consistent with the minimum cut set reduction result;
[0041] If any of the structural consistency check, node consistency check, or logical consistency check fails to meet the preset check conditions, the corresponding structured troubleshooting solution will be marked as a result to be corrected and prohibited from being used as the final output that passes the consistency check.
[0042] Furthermore, the structured troubleshooting scheme in step S4 includes:
[0043] Generate a fault tree structure diagram based on the fault propagation path and the logical relationship between events;
[0044] Generate logic gate type descriptions and event connection relationships based on the event nodes and directed edges in the fault tree structure diagram;
[0045] Basic event summary information is generated based on the minimum cut set and the probability of occurrence of the base event, and associated with the fault investigation priority.
[0046] Based on the fault propagation path, historical maintenance cases, and the aforementioned fault investigation priorities, maintenance operation steps, required tools and spare parts, and safety precautions are generated.
[0047] Furthermore, it also includes a fault tree knowledge update step, which includes:
[0048] The fault tree image is stored as the original knowledge carrier in the object storage service, and the fault tree image is associated with the event nodes and directed edges in the graph database.
[0049] When a new fault tree image or historical maintenance case is received, new fault knowledge is obtained through a visual mini-model or historical experience retrieval tool. Based on the semantic similarity and logical relationship between the new fault knowledge and existing event nodes, the update or supplementation of the relationship between the new event nodes and existing event nodes is determined.
[0050] The newly added or updated fault knowledge is written into the graph database, and the corresponding update information is saved for use in subsequent fault tree queries and troubleshooting solution generation.
[0051] Compared with existing technologies, the beneficial effects of this invention are as follows: This invention uses a visual small model to perform structured recognition of fault tree images, converting scattered image-based fault knowledge into graph structure data including event nodes, node types, event relationships, and logic gate attributes. It also combines semantic embedding vectors to achieve semantic matching between fault phenomenon text and the top event of the fault tree, thereby improving the unified management, retrieval, and reuse capabilities of fault knowledge. This invention uses a predefined graph database query tool to perform restricted traversal of fault propagation paths, reducing the number of irrelevant fault nodes entering the reasoning process and lowering the system load caused by repeated and invalid queries. Through minimum cut set calculation, fault probability analysis, and bottom event importance analysis, it can narrow down the range of candidate fault causes and form a basis for fault investigation priorities, reducing the need for maintenance personnel to conduct trial-and-error troubleshooting. This invention also utilizes a large text reasoning model to perform task arrangement and comprehensive analysis of graph database retrieval results and historical maintenance cases, generating a structured troubleshooting plan that includes fault causes, maintenance steps, tools and spare parts, and safety precautions, improving the readability and on-site applicability of the troubleshooting results. Meanwhile, by verifying structural consistency, node consistency, and logical consistency, data constraints and error interception are applied to the generated results, reducing problems such as missing fault tree nodes, incorrect connection directions, and confusion of logic gates, thereby improving the accuracy, reliability, and traceability of the fault tree structure and troubleshooting solutions. Attached Figure Description
[0052] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0053] Figure 1 This is a flowchart of a fault tree analysis and troubleshooting method based on size model collaboration and graph database.
[0054] Figure 2 This is a general framework diagram of a fault tree analysis and troubleshooting method based on size model collaboration and graph database.
[0055] Figure 3 This diagram illustrates a fault propagation path search algorithm for a fault tree analysis and troubleshooting method based on size model collaboration and graph database.
[0056] Figure 4 This paper generates a demonstration diagram for an embedded representation of a fault tree analysis and troubleshooting method based on size model collaboration and graph database.
[0057] Figure 5This is a schematic diagram of the collaborative reasoning process of a fault tree analysis and troubleshooting method based on big-small model collaboration and graph database.
[0058] Figure 6 This diagram illustrates the minimum cut set accuracy of a fault tree analysis and troubleshooting method based on size model collaboration and graph database.
[0059] Figure 7 This is a schematic diagram of the end-to-end response time of a fault tree analysis and troubleshooting method based on size model collaboration and graph database.
[0060] Figure 8 This is a schematic diagram illustrating the node generation accuracy of a fault tree analysis and troubleshooting method based on size model collaboration and graph database.
[0061] Figure 9 This is a schematic diagram comparing the number of steps called by an MCP tool, which is a fault tree analysis and troubleshooting method based on a combination of large and small models and a graph database. Detailed Implementation
[0062] The embodiments of the present invention / invention are described in detail below with reference to the accompanying drawings.
[0063] Example 1
[0064] A fault tree analysis and troubleshooting method based on size model collaboration and graph database includes the following steps, the process of which is as follows: Figure 1 As shown:
[0065] Step S1: Obtain the fault tree image and fault phenomenon text. Perform visual recognition on the fault tree image using a visual small model. Extract the event nodes and logical relationships between events in the fault tree. Divide the event nodes into top events, middle events, and bottom events. Convert the event nodes and logical relationships into nodes and directed edges in the graph database. Associate semantic embedding vectors with the event nodes.
[0066] Step S2: Vectorize the fault phenomenon text, match the obtained query vector with the semantic embedding vector of the event node in the graph database, and filter the top event corresponding to the fault phenomenon text.
[0067] Step S3: Based on the top event, a predefined graph database query tool is called through the MCP protocol to traverse the fault tree along the directed relationship from parent event to child event, obtain the fault propagation path, and limit the traversal process based on the preset maximum retrieval depth; according to the event nodes and logical relationships in the fault propagation path, the fault tree is logically expanded and fault combination reduction is performed to obtain the minimum cut set corresponding to the top event and its associated fault event information.
[0068] Step S4: Using a large text reasoning model, tasks are arranged and results are summarized for the top event, fault propagation path, minimum cut set and historical maintenance cases to generate a structured troubleshooting plan that includes fault cause analysis, maintenance operation steps, fault troubleshooting priority, tools and spare parts and safety precautions.
[0069] Step S5: Compare the fault tree structure, event nodes, and logical relationships in the structured troubleshooting scheme with the fault tree data in the graph database. Based on the comparison results, perform a consistency check on the structured troubleshooting scheme and output the fault tree structure and structured troubleshooting scheme that pass the consistency check.
[0070] In specific implementation, such as Figure 2 As shown, the overall framework of the method of this invention includes a data layer, a model layer, a scheduling layer, a tool layer, and a storage layer. The data layer receives fault tree images and fault phenomenon text input by maintenance personnel; the model layer includes a visual small model, an embedded model, and a text reasoning large model; the tool layer includes a graph database query tool, a minimum cut set calculation tool, a historical experience retrieval tool, and an object storage service interface; the scheduling layer is used to orchestrate the calling process of the text reasoning large model to each tool; the storage layer includes a graph database, a vector index, and an object storage service.
[0071] For ease of explanation, the equipment system will be represented as:
[0072] E = (F, R);
[0073] Where F represents the set of components, and R represents the relationships between components. The fault tree can be represented as:
[0074] T = (V, E, G);
[0075] Where V represents the set of event nodes consisting of the top event, intermediate events, and bottom events; E represents the directed edge connecting the event nodes; and G represents the logical relationships such as AND gates and OR gates associated with the directed edge. The set of fault symptoms observed by maintenance personnel is represented as follows:
[0076] O = {o1, o2, ..., o} n};
[0077] Based on the fault symptom set O, search for possible fault causes in the fault tree and historical maintenance cases, and generate a troubleshooting plan:
[0078] P = (M, W, A);
[0079] Where M represents the maintenance operation steps, W represents the required tools and spare parts, and A represents safety precautions. In the complete output including the fault tree diagram, the troubleshooting solution is represented as:
[0080] P = (T, M, W, A);
[0081] Where T represents the fault tree structure diagram.
[0082] In one specific embodiment, the system receives a fault tree image set, fault phenomenon text (query_text), the top_k number of retrieved results, the maximum retrieval depth (max_depth), and a similarity threshold. If a user uploads a fault tree image, a visual mini-model first performs structured recognition; if the target fault tree is already stored in a graph database, image recognition can be skipped, and retrieval and inference can be performed directly based on the fault phenomenon text. The visual mini-model is responsible for identifying event names, event types, connection directions, and logical relationships from the fault tree image. The embedding model is responsible for converting event names and fault phenomenon text into semantic embedding vectors. The text inference big model does not directly guess the fault tree structure from the image, but instead uses the MCP protocol to call predefined tools to obtain the top event, fault propagation path, and node attributes from the graph database, and combines the minimum cut set calculation results and historical maintenance cases to generate a structured troubleshooting solution.
[0083] like Figure 3 As shown, the fault propagation path search starts from the top event matching the fault phenomenon text and traverses layer by layer along the direction from parent event to child event until the bottom event is reached, the max_depth is reached, or no new nodes or new historical maintenance cases are generated for a preset number of consecutive queries. By introducing max_depth to limit the tree depth of a single query, a balance can be struck between fault tree integrity, context window capacity, and graph database query efficiency, avoiding the increased graph database load caused by unbounded traversal. Using only a small visual model can solve the problem of fault tree image structuring, but it cannot automatically generate troubleshooting solutions based on the fault descriptions of maintenance personnel. Adding a graph database on top of visual recognition can further solve the problems of unified storage of fault knowledge and fault propagation path traversal, but it still cannot complete natural language intent understanding and task planning. Further adding an embedding model and a large text reasoning model can associate the fault phenomenon text with the top event and perform comprehensive reasoning on the path, minimum cut set, and historical maintenance cases. Finally, adding consistency verification can further solve the problem that the node, edge direction, or logical gate relationship generated by the large text reasoning model may deviate from the original fault tree.
[0084] Therefore, this implementation ultimately solves the technical problems of scattered fault knowledge, difficulty in continuously querying fault propagation relationships, reliance on personal experience in the troubleshooting process, and lack of consistency constraints in the generated results during equipment troubleshooting. The resulting technical effects include: converting discrete fault tree images into queryable and reusable structured knowledge; narrowing the scope of fault causes; prioritizing fault investigation based on the contribution information of underlying events; outputting a structured troubleshooting plan including maintenance operation steps, tools and spare parts, and safety precautions; and improving the reliability of the fault tree structure using consistency checks.
[0085] Further, in step S1, the event nodes and logical relationships are converted into nodes and directed edges in a graph database, and the semantic embedding vectors associated with the event nodes include:
[0086] The system uses a visual mini-model to identify text regions, event nodes, and connections between nodes in fault tree images, and outputs structured recognition results that include event names, event types, original node identifiers, and logical relationships.
[0087] The event names are vectorized using an embedding model to obtain the semantic embedding vectors of the corresponding event nodes.
[0088] Based on the structured recognition results, event nodes are created in the graph database, and the unique identifier, original node identifier, node name, node type, occurrence probability, semantic embedding vector, creation time and update time of the event node are stored as node attributes.
[0089] Based on the identified logical relationship between the parent and child events, a directed edge is established from the parent event to the child event, and the logical relationship is stored as the logical type attribute of the directed edge.
[0090] In practice, the fault tree image is first saved to an object storage service to preserve the original knowledge carrier and support subsequent re-identification, result tracing, and manual comparison. A visual mini-model reads the fault tree image and, utilizing its visual encoding and language understanding capabilities, simultaneously identifies text regions, event boxes, connecting lines, connection directions, and logic gates within the image, outputting a structured recognition result. This structured recognition result includes at least the event name, event type, original node identifier, and the logical relationship between parent and child events. Event types are categorized into top events, intermediate events, and bottom events according to their role in the fault tree. Top events represent fault phenomena at the machine or system level; intermediate events represent intermediate links in the fault propagation process; and bottom events represent fault causes that no longer propagate downwards. In this implementation, the visual mini-model undertakes the image structuring task, and its output serves as input to the embedding model and graph database, preventing the large text reasoning model from directly generating an unverified fault tree based on the image content. The embedding model vectorizes each event name, converting discrete event names into continuous semantic embedding vectors. Event names and semantic embedding vectors are written together into the graph database, enabling nodes in the graph database to participate in both graph traversal and semantic-based vector retrieval.
[0091] The graph database employs an attribute graph model. Each fault tree event corresponds to a node, with node attributes including: a unique identifier (id), an original node identifier (idInGraph), a node name (name), a node type (type), an occurrence probability (prob), a semantic embedding vector (Embedding), a creation time (createdAt), and an update time (updateAt). The unique identifier is generated using a UUID; the original node identifier stores the node identifiers identified by the visual mini-model from the current fault tree image, supporting the correspondence and tracing between graph database nodes and the original image. Before creating a node, the new event is compared with existing events. If the identification result corresponds to an existing event, the existing event is associated or updated; if the identification result corresponds to a new event, a new node is created and a unique identifier is assigned. The UUID is used for unique references to nodes in the database, and the semantic embedding and logical association of event names are used to help determine whether events in different fault tree images correspond to existing events, thereby reducing the duplicate storage of the same event in multiple fault tree images. Directed edges are established between parent and child events, pointing from the parent event to the child event. For example, the top event points to the intermediate or bottom event that caused it, and the intermediate event continues to point to its corresponding subordinate event. Logical relationships such as AND gates and OR gates are stored as logical type attributes of directed edges. This direction is consistent with the top-down decomposition direction of the fault tree, enabling graph database query tools to reliably traverse from the top event to the bottom event.
[0092] Traditional optical character recognition (OCR) can only extract characters from images, failing to reliably represent the node where the character is located, the direction of parent-child connections, and the type of logic gates. Due to this lack of structural relationships, the recognized text cannot be directly used for fault propagation path analysis. This implementation adds node classification, directed edge, and logic type attributes to visual recognition, transforming the visual information in the image into fault knowledge that can be processed by a graph database. Furthermore, by adding semantic embedding vectors, the same node simultaneously possesses graph relationship query capabilities and semantic matching capabilities, providing a unified data foundation for subsequent top-event retrieval and large-scale text reasoning model calling tools.
[0093] Furthermore, the step S2 of filtering the top event corresponding to the fault phenomenon text includes:
[0094] Input the fault phenomenon text into the embedded model to obtain the query vector corresponding to the fault phenomenon text;
[0095] The similarity between the query vector and the semantic embedding vector of the event node in the graph database is calculated, and the nodes are sorted from high to low according to the similarity. The top event is selected according to the preset retrieval return quantity parameter.
[0096] The maximum similarity in the top event is compared with a preset similarity threshold. When the maximum similarity is less than the similarity threshold, the fault phenomenon text is rewritten or expanded, and the top event retrieval is re-executed.
[0097] The top events and corresponding similarity information obtained from the re-retrieval are returned to the large text reasoning model to determine the starting node for subsequent fault propagation path retrieval.
[0098] In practice, maintenance personnel input text such as "insufficient power," "alarm light on," or other fault symptoms. The embedding model converts the fault symptom text into a query vector and compares the query vector with the semantic embedding vector of the top event node in the graph database. For example... Figure 4 As shown, discrete natural language text, after being processed by the embedding model, is mapped into a vector representation capable of mathematical computation, thereby enabling maintenance personnel to establish a semantic connection between the on-site descriptions and the standardized event names in the fault tree. Let the query vector be... In the graph database, the semantic embedding vector of the top event node is b, and the cosine distance between them is:
[0099]
[0100] in, Representing vectors The angle between vector b and the vector 'b'. The result is the cosine distance; the smaller the cosine distance, the closer the two vectors are. When sorting by cosine similarity, a higher similarity indicates a greater relevance between the fault description text and the top event. In practice, the sorting can be based on whether the vector retrieval interface returns cosine similarity or cosine distance, sorting by similarity from high to low or cosine distance from low to high respectively, ensuring semantic consistency of the sorting results. After sorting, the top event is selected according to 'top_k'. 'Top_k' controls the number of top events entering the context of the large-scale text reasoning model in a single vector retrieval, preventing nodes with low relevance from entering subsequent path traversal processes, thereby reducing interference from irrelevant nodes to the large-scale text reasoning model and reducing the query pressure on the graph database.
[0101] In the top event, the maximum similarity is compared with a preset similarity threshold. When the maximum similarity is lower than the similarity threshold, it indicates that the current fault phenomenon text fails to form a sufficiently reliable semantic correspondence with the existing top event. At this time, the text reasoning big model performs query rewriting or expanded retrieval according to the MCP protocol and scheduling layer, and re-invokes the vector retrieval tool. After the re-retrieval, the top event, corresponding similarity, and node identifier are returned to the text reasoning big model, which determines the starting node of the fault propagation path.
[0102] Direct string matching can only find events with identical or highly similar names, making it difficult to handle discrepancies between spoken descriptions and standardized event names. By adding an embedding model, the inconsistency in natural language expression can be addressed; by further increasing the top_k constraint, weakly relevant nodes can be prevented from entering subsequent inference; and by adding a low-confidence kernel return mechanism, query rewriting or expanded retrieval can be performed when a suitable node is not found in the initial search. Therefore, this implementation improves the recall capability of top events while controlling the number of nodes entering the context of the large text inference model and providing a clear starting position for subsequent graph traversal.
[0103] Furthermore, the logical expansion in step S3 includes:
[0104] The current traversed node, the set of fault propagation paths, the set of minimum cut set candidates, and the set of historical maintenance cases are maintained as fault tree reasoning state information.
[0105] When performing fault tree traversal, the fault tree expansion method is determined based on the logic type associated with the current event node. Specifically, when the logic type is an OR gate, the corresponding sub-events are traversed separately, and when the logic type is an AND gate, the corresponding sub-events are traversed as a fault combination that participates in the traversal.
[0106] After each expansion operation, update the current traversed node and the set of fault propagation paths, and take any of the following conditions as the termination condition: reaching the preset maximum search depth, the current node being the bottom event, or no new node or new historical maintenance case being generated for a preset number of consecutive times.
[0107] After the termination condition is met, the set of fault propagation paths obtained by traversal is passed to the minimal cut set calculation tool for fault combination reduction.
[0108] In practical implementation, the fault tree reasoning state at step t is represented as:
[0109] S t =(N t P t C t H t );
[0110] in, Indicates the currently visited event node; P t C represents the set of fault propagation paths that have been recorded so far. t H represents the currently collected candidate set of minimum cut sets; t This represents the set of similar historical repair cases that have been retrieved so far. State S t The set of executable actions is represented as A(S) t This includes retrieval, expansion, and reduction actions.
[0111] The retrieval action calls the graph database query tool via the MCP protocol to obtain the set of child nodes corresponding to the current node. The expansion action processes child nodes according to the logical type associated with the current node: when the logical type is an OR gate, each child event forms a branch that can lead to the parent event, and therefore each branch is traversed downwards; when the logical type is an AND gate, the corresponding child events need to participate in the fault combination of the parent event, and therefore they are traversed downwards together within the same fault combination. The reduction action simplifies the minimum cut set candidate set, deleting candidates that do not constitute the simplest fault combination, resulting in the minimum cut set that leads to the top event. After each expansion, the current node and the fault propagation path set are updated; when a new minimum cut set candidate is found, C is updated. t Update H when new historical repair cases are found. t The large-scale text-based reasoning model reads the aforementioned states through a global state graph to determine whether the current path is complete and whether further calls to the graph database query tool are needed. Fault tree reasoning terminates when any of the following conditions are met: the traversal depth reaches or exceeds `max_depth`; the current node is a bottom event; or no new nodes or new historical maintenance cases are generated for two consecutive steps. These termination conditions are set because fault trees may contain deep paths or abnormal connections. Without limiting the traversal process, the large-scale text-based reasoning model might repeatedly call the tool and increase the graph database load. Limiting the maximum retrieval depth controls the query range; judging by bottom events allows for timely termination of the current branch when the fault cause has reached the lowest level; and judging by no new information for two consecutive steps avoids repeated queries with no valid results.
[0112] Traversing only directed edges can yield node paths, but it cannot correctly distinguish between "any sub-event causing a parent event" and "multiple sub-events occurring together causing a parent event." By determining the expansion method through additional logic gate types, the causal logic in the fault tree can be preserved. By further maintaining the inference state and termination conditions, the continuity of paths, candidate minimum cut sets, and historical maintenance cases between multiple tool calls can be guaranteed, and invalid calls can be restricted. Based on this, passing the path set to the minimum cut set calculation tool can provide a complete, structured, and logically meaningful input for fault combination reduction.
[0113] Furthermore, after the termination condition is met, the set of fault propagation paths obtained through traversal is passed to the minimal cut set computation tool for fault combination reduction, including:
[0114] Logically reduce the bottom events and their logical relationships in the set of fault propagation paths to obtain the minimum cut set that leads to the occurrence of the top event;
[0115] Based on the occurrence probabilities of the bottom events in the minimum cut set, calculate the fault combination information corresponding to the minimum cut set, and obtain the occurrence probability of the top event;
[0116] Based on the contribution information of the bottom event to the probability of the top event, the priority of troubleshooting the bottom event is determined.
[0117] In practice, the minimal cut set calculation tool reads the base events, AND gate relationships, and OR gate relationships from the fault propagation path set and performs logical reduction on candidate fault combinations. A minimal cut set is the simplest fault combination that leads to the top event and from which no base event can be further deleted. For example, when event A is caused by both cause B and cause C, the corresponding minimal cut set is {B, C}. Through minimal cut set reduction, the numerous propagation paths in the complete fault tree can be converged into the simplest base event combinations that maintenance personnel need to focus on checking, thereby reducing the scope of trial-and-error troubleshooting.
[0118] Let the total number of minimum cut sets be r, and the j-th minimum cut set be K. j The probability of the top event is Q. The probability of the top event is calculated based on the probability of the union of the events of each minimal cut set:
[0119]
[0120] By applying inclusion-exclusion to the intersection probability of the minimal cut sets, we avoid directly recalculating when multiple minimal cut sets have events with a common base.
[0121] Let X i For the i-th base event, p i For the bottom event X i The probability of occurrence of the j-th minimal cut set. In the implementation where the probability of the basic event can be calculated by product, the probability of occurrence of the j-th minimal cut set is:
[0122]
[0123] After obtaining the probabilities of each minimum cut set and the probability of the top event, the priority of troubleshooting is determined based on the contribution of the bottom events to the probability of the top event. Bottom event X i The importance of Fussell-Vesely is:
[0124]
[0125] The numerator of the formula contains the base event X. i The sum of the minimum cut set probabilities, where Q is the probability of the top event. According to FV... i The contribution information is used to sort the base events, and base events with greater contributions are given priority to enter the investigation step.
[0126] Even with only the fault propagation path identified, maintenance personnel still need to determine which combinations are most worthy of priority investigation from a large number of basic events. Adding a minimal cut set reduction can solve the problem of too many fault combinations; further calculating the occurrence probability of fault combinations and top events based on the minimal cut set provides a probabilistic basis; and incorporating Fussell-Vesely importance can convert the contribution information of basic events to top events into fault investigation priorities. Therefore, the above steps sequentially achieve a progressive effect from "finding all possible causes" to "obtaining the simplest fault combinations" and then to "determining the priority order for investigation."
[0127] Furthermore, the process of generating the structured troubleshooting solution in step S4 includes:
[0128] The text reasoning model generates multiple sub-tasks based on the text of fault phenomena, including at least top event query, fault propagation path retrieval, minimum cut set calculation, and historical maintenance case retrieval.
[0129] The multiple subtasks are assigned to the corresponding fault tree path retrieval tool, minimum cut set calculation tool and historical experience retrieval tool, and the retrieval depth, retrieval return quantity and inference execution parameters are configured for each subtask;
[0130] The execution progress, return results, and exception information of each subtask are recorded through a global state diagram, and it is determined whether to continue calling the corresponding tool or perform manual query based on the global state diagram.
[0131] After the completion of the multiple sub-tasks, the text reasoning big model summarizes the return results of each sub-task and generates a structured troubleshooting solution.
[0132] In specific implementation, such as Figure 5 As shown, the collaborative reasoning between the visual small model and the text-based reasoning large model includes fault tree structuring by the visual small model, data storage in the graph database, and tool invocation and solution generation by the text-based reasoning large model. The visual small model and the text-based reasoning large model are deployed separately. The visual small model is responsible for fault tree node extraction and logical relationship identification, while the text-based reasoning large model is responsible for top event query planning, node logic sorting, fault tree generation, and troubleshooting solution generation. The embedded model is responsible for the mathematical expression of user intent and event names.
[0133] The intelligent agent adopts a three-layer structure: top, middle, and bottom. The top layer is handled by a large text reasoning model, which receives the text describing the fault phenomenon and breaks it down into tasks. Taking an electric air pump failure as an example, the subtasks generated by the large text reasoning model include: querying the top events related to the electric air pump; obtaining the complete fault propagation path for each top event; calculating the minimum cut set of the bottom events; retrieving similar cases from historical maintenance examples; and summarizing the fault tree and structured troubleshooting solutions. The middle layer includes a fault tree path retrieval tool, a minimum cut set calculation tool, and a historical experience retrieval tool. The fault tree path retrieval tool receives `query_text`, `top_k`, and `max_depth`, first calling the embedding model to obtain the query vector, and then performing top event retrieval and top-down path traversal. The minimum cut set calculation tool performs logical reduction on the path data and forms a fault investigation priority. The historical experience retrieval tool searches for processing records related to the current fault phenomenon, fault propagation path, or bottom events from unstructured maintenance knowledge. The bottom layer includes a graph database, object storage, vector index, embedding model, and visual mini-models. The graph database stores event nodes, logical relationships, and occurrence probabilities; the object storage stores the original fault tree images; the vector index stores the semantic embedding vectors corresponding to event names and provides fast matching; the embedding model connects natural language input with graph database nodes; and the visual mini-model is responsible for the structured recognition of newly added fault tree images.
[0134] The scheduling layer maintains a global state graph, recording the execution progress, return results, and exception information of each subtask. When the similarity of the top event is insufficient, the global state graph records the current search results and triggers query rewriting or search expansion. When the path traversal does not reach the bottom event and does not reach max_depth, the graph database query tool can continue to be called. When no new nodes or new cases are added for two consecutive steps, the search is terminated. When the tool returns an exception or cannot obtain usable results, the corresponding task is transferred to manual query.
[0135] In existing technologies, if only the text-based reasoning model generates troubleshooting solutions, its reasoning process lacks a definite data source, potentially leading to issues such as missing nodes, logic gate errors, or repeated database calls. This implementation restricts the text-based reasoning model's access to the graph database through predefined tools. The text-based reasoning model is responsible for planning and summarizing, the graph database query tool handles deterministic data reading, the minimal cut set computation tool handles fault combination reduction, and the historical experience retrieval tool handles unstructured knowledge retrieval. This establishes clear input-output relationships between different models and tools, prevents the text-based reasoning model from generating unstable graph database query commands on its own, and reduces the risk of frequent retries, database deadlocks, or abnormal load.
[0136] Furthermore, the historical experience retrieval tool retrieves at least one type of unstructured maintenance knowledge from historical maintenance records, equipment manuals, technical manuals, and fault diagnosis case databases. The retrieval includes at least one of vector retrieval and full-text retrieval. The retrieved historical maintenance cases are associated with fault propagation paths and minimum cut sets to generate fault diagnosis steps and fault cause analysis in the structured troubleshooting solution.
[0137] In practice, the historical experience retrieval tool receives retrieval tasks generated by the text-based reasoning model and uses the fault phenomenon text, top event, event names in the fault propagation path, and bottom events in the minimum cut set as retrieval criteria to perform vector or full-text searches on historical maintenance records, equipment manuals, technical manuals, and fault diagnosis case libraries. Vector search is used to discover maintenance cases with different wording but similar semantics, while full-text search is used to find explicit content such as equipment names, event names, or maintenance operations. The retrieved historical maintenance cases are returned to the top-level text-based reasoning model and associated with the current fault propagation path and minimum cut set. The text-based reasoning model only uses historical maintenance content that matches the current fault cause and propagation path for fault cause analysis and maintenance operation steps, avoiding directly incorporating cases unrelated to the current top event into the structured troubleshooting plan.
[0138] Fault trees in graph databases can explain "which events lead to the top event through what logical relationships," but their basic nodes and edges cannot fully provide on-site maintenance operations. By adding historical experience retrieval, unstructured knowledge such as "how to inspect, how to repair, and what tools and spare parts are needed" can be further obtained. By associating historical maintenance cases with minimal cut sets, maintenance suggestions can be tailored to specific base events and fault combinations, rather than providing generalized suggestions based solely on fault symptoms. Historical maintenance cases can also serve as a data source for updating fault tree knowledge. Confirmed new experience knowledge can supplement event information or relationships in the graph database, enabling the retrieval of similar faults and the generation of troubleshooting solutions to reuse existing handling experience, thus forming a process where fault knowledge continuously expands with the accumulation of maintenance cases.
[0139] Further, the consistency check in step S5 includes:
[0140] Structural consistency verification: Traverse the directed edges stored in the graph database and compare the parent event, child event and edge direction corresponding to the directed edge with the fault tree structure in the structured troubleshooting scheme;
[0141] Node consistency verification: Match the event nodes in the structured troubleshooting solution with the corresponding event nodes in the graph database, and verify the node name, node type and node association relationship;
[0142] Logical consistency verification: Based on the logic types and fault propagation paths stored in the graph database, verify whether the logic gate combination in the structured troubleshooting scheme is consistent with the minimum cut set reduction result;
[0143] If any of the structural consistency check, node consistency check, or logical consistency check fails to meet the preset check conditions, the corresponding structured troubleshooting solution will be marked as a result to be corrected and prohibited from being used as the final output that passes the consistency check.
[0144] In practice, after the large text reasoning model completes the structured troubleshooting solution, it does not directly output it as the final result. Instead, the consistency verification process verifies the fault tree structure, nodes, and logical relationships separately.
[0145] The structural consistency check reads all directed edges involved in the query from the graph database, obtaining the parent event, child event, and edge direction for each edge, and compares them with the fault tree structure graph generated by the text reasoning model. If a directed edge in the graph database points from a parent event to a child event, but the generated result shows the opposite direction, missing connections, or newly added non-existent connections, then this check fails. The node consistency check extracts event nodes from the generated result and matches them with corresponding nodes in the graph database based on the node's unique identifier, node name, node type, and node association. The node consistency check is used to detect omissions of top, intermediate, or bottom events, incorrect node names, incorrect node types, and incorrect node affiliation paths. The logical consistency check reads the logical type of the directed edges, checks whether the combination of AND and OR gates in the generated result is consistent with the graph database, and checks whether the fault combination obtained from this logical combination is consistent with the reduction result of the minimum cut set calculation tool. For example, when a parent event in a database connects two child events through an AND gate, the generated result cannot represent the two child events as independent OR gate branches; when a parent event in a database connects multiple child events through an OR gate, the generated result cannot require all child events to occur simultaneously.
[0146] While a large text-based reasoning model can organize data returned from a graph database into an easily readable fault tree and troubleshooting solution, generative models may alter node positions, omit connections, or confuse logic gates during the organization process. For this reason, this implementation adds structural consistency checks, node consistency checks, and logical consistency checks after solution generation. Structural consistency checks address edge connection and direction deviation issues; node consistency checks address node omissions and node type deviations; and logical consistency checks further address inconsistencies between fault combinations and minimum cut sets. If any check fails to meet the preset check conditions, the corresponding result is marked as a result to be corrected and is not included in the final fault tree structure output. Only results that pass the checks are provided to maintenance personnel. This ensures that the readability of the large text-based reasoning model is constrained by the deterministic knowledge of the graph database and the minimum cut set calculation results, improving the credibility and traceability of the structured troubleshooting solution.
[0147] Furthermore, the structured troubleshooting scheme in step S4 includes:
[0148] Generate a fault tree structure diagram based on the fault propagation path and the logical relationship between events;
[0149] Generate logic gate type descriptions and event connection relationships based on the event nodes and directed edges in the fault tree structure diagram;
[0150] Basic event summary information is generated based on the minimum cut set and the probability of occurrence of the base event, and associated with the fault investigation priority.
[0151] Based on the fault propagation path, historical maintenance cases, and the aforementioned fault investigation priorities, maintenance operation steps, required tools and spare parts, and safety precautions are generated.
[0152] In practice, after summarizing the results of each subtask, the large-scale text reasoning model generates a troubleshooting plan according to a unified structure. The fault tree structure diagram is expressed in Mermaid form, arranging the top, intermediate, and bottom events in the direction from parent to child events, and identifying AND and OR gate relationships based on the logical types returned by the graph database. After the Mermaid content is generated, it also needs to undergo consistency verification to avoid the generated structure deviating from the graph database.
[0153] The logic gate type descriptions and event connections are output in tabular form. Each item in the table corresponds to a node and directed edge in the graph database, and at least describes the parent event, child event, and corresponding logic type, enabling maintenance personnel to clearly understand the node connections while viewing the fault tree structure diagram. Basic event summary information includes the base event in the fault tree, event type, probability of occurrence, corresponding minimal cut set, and fault investigation priority. Fault investigation priority is determined based on the fault combination information of the minimal cut set, the probability of occurrence of the base event, and the contribution information of the base event to the probability of occurrence of the top event. Maintenance personnel can first investigate the base events or minimal cut sets with higher probability of occurrence and contribution information, and then address the fault causes with lower priority.
[0154] Fault path analysis starts from the top event and explains the causal relationships between the top, intermediate, and bottom events step by step according to each fault propagation path, clearly identifying the logic gates in the path. Maintenance operation steps are generated by combining fault propagation paths, minimal cut sets, historical maintenance cases, and fault investigation priorities, arranged according to the principle of "important first, secondary second," while also providing the necessary tools and spare parts and safety precautions. Outputting only the fault tree structure can show the relationships between fault causes, but maintenance personnel still need to convert the fault tree into on-site operations themselves. Adding logic gate explanations and basic event summaries clarifies fault combinations and bottom event attributes. Further adding fault investigation priorities, maintenance operation steps, tools and spare parts, and safety precautions converts the fault tree structure into a directly readable and executable troubleshooting plan. Therefore, this implementation method not only reproduces the fault tree but also transforms the structured knowledge in the graph database, the results of minimal cut set calculations, and historical maintenance experience into a complete output for the maintenance field.
[0155] Furthermore, it also includes a fault tree knowledge update step, which includes:
[0156] The fault tree image is stored as the original knowledge carrier in the object storage service, and the fault tree image is associated with the event nodes and directed edges in the graph database.
[0157] When a new fault tree image or historical maintenance case is received, new fault knowledge is obtained through a visual mini-model or historical experience retrieval tool. Based on the semantic similarity and logical relationship between the new fault knowledge and existing event nodes, the update or supplementation of the relationship between the new event nodes and existing event nodes is determined.
[0158] The newly added or updated fault knowledge is written into the graph database, and the corresponding update information is saved for use in subsequent fault tree queries and troubleshooting solution generation.
[0159] In practice, the object storage service is used to store the original fault tree image uploaded by the user, and the graph database is used to store the event nodes and directed edges extracted from the image. The original image is associated with the nodes and directed edges in the graph database, so that subsequent query results can be traced back to the original fault tree image, and visual recognition and manual verification can be re-performed on the same image.
[0160] When a new fault tree image is received, the visual mini-model extracts the event name, event type, original node identifier, and logical relationship, and embeds the model to generate the corresponding semantic embedding vector. The system compares the newly added fault knowledge with existing nodes for semantic similarity and logical association. For existing events, it supplements the source image, update time, or association; for new events, it creates new event nodes and generates unique identifiers; for missing parent-child connections between existing nodes, it supplements the directed edges from the parent event to the child event and their logical types. When a new historical maintenance case is received, the historical experience retrieval tool extracts maintenance knowledge related to fault phenomena, event nodes, fault propagation paths, or minimum cut sets. Confirmed new knowledge is used to update existing event information or supplement the associations between fault events, and the corresponding update information is saved for subsequent top event retrieval, path traversal, and structured troubleshooting solution generation.
[0161] While a single construction of a fault tree knowledge base can solve the query problem for currently entered fault trees, it cannot cover newly emerging fault trees and new maintenance experiences. Adding object storage and associating with original images can solve the problems of knowledge source tracing and re-identification. Further adding knowledge updates based on semantic similarity and logical relationships can reduce duplicate nodes and supplement new fault propagation relationships. Continuously associating historical maintenance cases with the fault tree can expand the coverage of troubleshooting solutions. Therefore, this implementation method enables the fault tree knowledge base to be updated as fault tree images and maintenance cases are continuously entered. The newly added recognition results of the visual mini-model continue to serve as input to the graph database, and the updated graph database provides new query basis for the text reasoning large model, thus forming a continuous collaborative relationship between the visual mini-model, the graph database, the historical experience retrieval tool, and the text reasoning large model.
[0162] Example 2
[0163] This embodiment is used to verify the fault tree reproduction, minimum cut set analysis and troubleshooting solution generation effects of the fault tree analysis and troubleshooting method based on big-small model collaboration and graph database under different fault tree test cases.
[0164] This embodiment uses the Neo4j graph database as the fault tree knowledge storage and retrieval component, and employs the APOC plugin to extend the graph database's graph traversal and data processing capabilities. A visual mini-model uses a visual language model with visual encoding capabilities to identify event nodes, node types, logic gates, and node connections in the fault tree images. A text-based reasoning model is used to perform fault phenomenon understanding, top event retrieval, fault propagation path analysis, minimum cut set result summarization, and structured troubleshooting solution generation. The object storage service uses MinIO to store the original fault tree images. Agent scheduling and tool orchestration are implemented using the Deerflow framework, and the graph database and object storage service are deployed in Docker containers. The hardware platform in this embodiment uses an NVIDIA DGX Spark personal computer, which includes an Arm architecture processor, unified memory, and an NVIDIA GB10 chip. Test data includes 63 fault tree images obtained from the public network. After visual mini-model recognition, node semantic merging, and duplicate node elimination, a total of 562 event nodes and 509 directed connections were obtained. Each event node stores the event name, event type, probability of occurrence, semantic embedding vector, and source information. Parent events and child events are connected by directed edges pointing from the parent event to the child event, and the logic gate type is stored as the logic type attribute of the directed edge.
[0165] During testing, the fault tree image is first input into the visual mini-model to obtain the structured fault tree recognition result, which is then written to the graph database. Subsequently, the top event name or the corresponding fault phenomenon text is input into the system. The system generates a query vector through an embedded model and performs similarity matching on the top event nodes in the graph database, selecting the top event with the highest similarity as the starting node of the fault propagation path. The text-based reasoning model calls a predefined graph database query tool via the MCP protocol to perform a restricted traversal of the fault tree from parent event to child event. For child events connected by OR gates, the system establishes fault propagation branches; for child events connected by AND gates, the system treats the corresponding child events as a combined fault. After completing the path traversal, the minimum cut set calculation tool reduces the base events and logical relationships, and returns the minimum cut set, base event occurrence probability, and fault investigation priority to the text-based reasoning model. The text-based reasoning model further combines historical maintenance cases to generate a structured troubleshooting solution, which is then output after verification of structural consistency, node consistency, and logical consistency.
[0166] This embodiment selects six top events for reproduction testing: service offline, email server offline, security system intrusion, quadcopter drone collision, electric pump with no traffic, and hacker attack. The test results are shown in Table 1.
[0167] Table 1. Fault tree reproduction test results based on each top event input.
[0168]
[0169] As shown in Table 1, the six test cases involve a total of 56 standard event nodes. The method of this invention correctly identified and reproduced 53 event nodes, with an overall node hit rate of 94.6%. Among them, the four test cases of service offline, email server offline, quadcopter drone collision, and hacker attack achieved full node hits. A small number of nodes were missed in the test cases of "security system intrusion" and "electric pump has no flow," mainly occurring in fault trees with many logical branches and large event node sizes.
[0170] In terms of minimal cutset analysis, the six test cases contained a total of 33 standard minimal cutsets, of which the method of this invention identified 31, resulting in an overall minimal cutset hit rate of 93.9%. The method of this invention and the NetworkX graph theory calculation results were consistent in most test cases, with only one minimal cutset missing in each of the two complex test cases: "Security system intrusion" and "Electric pump has no flow." The system combines the minimal cutset calculation results with the probability of occurrence of bottom events and the Fussell-Vesely importance analysis results to generate a priority for bottom event fault investigation, and performs a correlation retrieval of historical maintenance cases accordingly. Regarding response time, the average response time for the six test cases was 32.7 seconds, the shortest response time was 20 seconds, and the longest response time was 39 seconds. The response time includes the total time spent on fault phenomenon text processing, top event vector retrieval, graph database path traversal, minimal cutset calculation, historical maintenance case retrieval, large text inference model generation, and consistency verification. Test results show that the method of the present invention can not only reproduce the fault tree structure, but also generate a structured troubleshooting solution that includes fault cause analysis, troubleshooting steps, fault troubleshooting priority, tools and spare parts, and safety precautions.
[0171] Example 3
[0172] This embodiment is used to perform ablation verification on the minimum cut set computation capability, model structure selection of the large text reasoning model, and calling efficiency of the predefined graph database query tool of the present invention.
[0173] This embodiment selects 10 fault tree test cases with different tree depths and logical complexities to compare the hybrid retrieval method using a large model and graph database employed in this invention with the graph network retrieval method based on the NetworkX graph theory computing library. During the test, the fault tree image is first identified by a visual small model and written to the Neo4j graph database. The text inference large model calls a predefined graph database query tool via the MCP protocol to obtain the fault propagation path corresponding to the top event. Subsequently, the minimal cut set calculation tool performs logical expansion, set combination, deduplication, and reduction based on the AND gates, OR gates, and bottom events in the fault propagation path, and compares the reduction result with a manually verified standard minimal cut set. NetworkX 3.61 is used as a control algorithm to calculate the minimal cut set based on the same fault tree structure. Figure 6 As shown, the hybrid retrieval method combining the large model and graph database achieved an average minimum cut set accuracy of approximately 91% across 10 test cases, which is close to that of the graph network-based retrieval method. For test cases with fewer logical branches and lower tree depth, both methods were able to obtain the standard minimum cut set relatively completely. For test cases with greater tree depth and more logical branches, some fault propagation paths were longer, leading to a small number of missed bottom event combinations in the hybrid retrieval method. In test case 8, there were self-connections among the bottom events of the fault tree. The graph network-based retrieval method triggered a maximum recursion error during network recursion calculation, failing to complete the corresponding minimum cut set calculation. The hybrid retrieval method combining the large model and graph database discovered the anomaly in the fault propagation relationship through consistency verification and reread the relevant nodes and logical relationships under the task orchestration of the text reasoning large model, re-reducing the abnormal path, and finally obtaining a fault tree structure and minimum cut set result consistent with the manually verified result.
[0174] This embodiment demonstrates that the present invention stores the nodes and logical relationships of the fault tree in a graph database and performs deterministic logical reduction on the fault propagation path returned by the graph database using a minimal cutset calculation tool. This limits the semantic understanding capability of the text-based reasoning model to the scope of the explicit fault tree data. Compared to methods that rely solely on the text-based reasoning model to directly generate minimal cutsets, the present invention can constrain the generation process using parent-child relationships and logical gate attributes in the graph database. Compared to methods that rely solely on network computing libraries for recursive calculations, the present invention can identify and verify abnormal connections and incomplete paths through the text-based reasoning model, scheduling layer, and consistency verification mechanism. After completing the minimal cutset calculation, the text-based reasoning model generates a structured troubleshooting plan based on the minimal cutsets, the probability of occurrence of the underlying events, the importance of the underlying events, and historical maintenance cases. This structured troubleshooting plan includes at least: a fault tree structure diagram, a list of minimal cutsets, a summary of underlying events, fault investigation priorities, maintenance operation steps, required tools and spare parts, and safety precautions. Before the final output, the scheduling layer calls the consistency verification module to verify the fault tree structure, event nodes, and logical gate relationships to ensure that the output results are consistent with the fault tree data stored in the graph database.
[0175] This embodiment further compares the end-to-end response time, node generation accuracy, and number of MCP tool calls between the MoE text reasoning large model and the Dense text reasoning large model in fault tree reasoning and structured troubleshooting solution generation tasks. This embodiment uses Qwen3.6-35B-A3B as the MoE text reasoning large model and Qwen3.8-28B as the Dense text reasoning large model. Both models perform task orchestration through the Deerflow framework and call graph database query tools via the MCP protocol. For Qwen3.8-28B, three reasoning modes—Flash, Thinking, and Ultra—are set; Qwen3.6-35B-A3B uses its default task planning and reasoning mode.
[0176] like Figure 7 As shown, in 10 top-event test cases, the average end-to-end response time of Qwen3.6-35B-A3B is 36.2 seconds. The average response time of Qwen3.8-28B in Ultra inference mode is 209.3 seconds, and in thinking mode it is 297.3 seconds. Because Qwen3.8-28B generates longer inference processes in some test cases, the tool invocation and text generation times increase. In contrast, Qwen3.6-35B-A3B uses a MoE structure for dynamic expert routing of input tasks, activating fewer parameters on each input tag, thus reducing end-to-end response time while maintaining fault tree inference performance.
[0177] like Figure 8As shown, Qwen3.6-35B-A3B achieved an average node accuracy of 93% across 10 generated test cases. Qwen3.8-28B achieved an average node accuracy of 85% in reasoning mode and 78% in Ultra mode. The test results indicate that a more complex reasoning mode or a longer reasoning process does not necessarily lead to more accurate fault tree node generation. For tasks requiring continuous execution of graph database retrieval, path expansion, and troubleshooting solution summarization, an excessively long reasoning process may introduce irrelevant content and increase the risk of missing nodes or shifted logical relationships.
[0178] like Figure 9 As shown, when Qwen3.6-35B-A3B completes a fault tree reasoning and structured troubleshooting solution generation task, it calls the predefined graph database query tool an average of about 5 to 6 times. This number of calls matches the average depth of the test fault trees. Qwen3.8-28B calls the tool an average of about 7 to 8 times in both Thinking Mode and Ultra Mode, with a significant increase in the number of calls in some test cases. For example, in the second generation test case, Qwen3.8-28B calls the graph database query tool 28 times in Thinking Mode, increasing the query load on the graph database.
[0179] Therefore, this embodiment verifies the following results: First, the combination of the text-based reasoning model and the graph database can complete fault tree path analysis and minimum cut set reasoning; Second, the MoE text-based reasoning model has a lower end-to-end response time and fewer tool calls in the fault tree continuous reasoning task of this embodiment; Third, when comprehensively evaluating the generation quality, response time, and graph database load, the MoE text-based reasoning model with dynamic task planning capabilities is more suitable for performing the fault tree analysis and structured troubleshooting solution generation task of this invention.
[0180] The above embodiments are merely preferred embodiments of the present invention and are not intended to limit the technical solutions of the present invention. Any technical solution that can be implemented based on the above embodiments without creative effort should be considered to fall within the scope of protection of the patent of the present invention.
Claims
1. A fault tree analysis and troubleshooting method based on size model collaboration and graph database, characterized in that, Includes the following steps: Step S1: Obtain the fault tree image and fault phenomenon text. Perform visual recognition on the fault tree image using a visual small model. Extract the event nodes and logical relationships between events in the fault tree. Divide the event nodes into top events, middle events, and bottom events. Convert the event nodes and logical relationships into nodes and directed edges in the graph database. Associate semantic embedding vectors with the event nodes. Step S2: Vectorize the fault phenomenon text, match the obtained query vector with the semantic embedding vector of the event node in the graph database, and filter the top event corresponding to the fault phenomenon text. Step S3: Based on the top event, a predefined graph database query tool is called through the MCP protocol to traverse the fault tree along the directed relationship from parent event to child event, obtain the fault propagation path, and limit the traversal process based on the preset maximum retrieval depth; according to the event nodes and logical relationships in the fault propagation path, the fault tree is logically expanded and fault combination reduction is performed to obtain the minimum cut set corresponding to the top event and its associated fault event information. Step S4: Using a large text reasoning model, tasks are arranged and results are summarized for the top event, fault propagation path, minimum cut set and historical maintenance cases to generate a structured troubleshooting plan that includes fault cause analysis, maintenance operation steps, fault troubleshooting priority, tools and spare parts and safety precautions. Step S5: Compare the fault tree structure, event nodes, and logical relationships in the structured troubleshooting scheme with the fault tree data in the graph database. Based on the comparison results, perform a consistency check on the structured troubleshooting scheme and output the fault tree structure and structured troubleshooting scheme that pass the consistency check.
2. The fault tree analysis and troubleshooting method based on size model collaboration and graph database as described in claim 1, characterized in that, In step S1, the event nodes and logical relationships are converted into nodes and directed edges in a graph database, and semantic embedding vectors are associated with the event nodes, including: The system uses a visual mini-model to identify text regions, event nodes, and connections between nodes in fault tree images, and outputs structured recognition results that include event names, event types, original node identifiers, and logical relationships. The event names are vectorized using an embedding model to obtain the semantic embedding vectors of the corresponding event nodes. Based on the structured recognition results, event nodes are created in the graph database, and the unique identifier, original node identifier, node name, node type, occurrence probability, semantic embedding vector, creation time and update time of the event node are stored as node attributes. Based on the identified logical relationship between the parent and child events, a directed edge is established from the parent event to the child event, and the logical relationship is stored as the logical type attribute of the directed edge.
3. The fault tree analysis and troubleshooting method based on size model collaboration and graph database as described in claim 1, characterized in that, The step S2 of filtering the top events corresponding to the fault phenomenon text includes: Input the fault phenomenon text into the embedded model to obtain the query vector corresponding to the fault phenomenon text; The similarity between the query vector and the semantic embedding vector of the event node in the graph database is calculated, and the nodes are sorted from high to low according to the similarity. The top event is selected according to the preset retrieval return quantity parameter. The maximum similarity in the top event is compared with a preset similarity threshold. When the maximum similarity is less than the similarity threshold, the fault phenomenon text is rewritten or expanded, and the top event retrieval is re-executed. The top events and corresponding similarity information obtained from the re-retrieval are returned to the large text reasoning model to determine the starting node for subsequent fault propagation path retrieval.
4. The fault tree analysis and troubleshooting method based on size model collaboration and graph database as described in claim 1, characterized in that, The logical expansion in step S3 includes: The current traversed node, the set of fault propagation paths, the set of minimum cut set candidates, and the set of historical maintenance cases are maintained as fault tree reasoning state information. When performing fault tree traversal, the fault tree expansion method is determined based on the logic type associated with the current event node. Specifically, when the logic type is an OR gate, the corresponding sub-events are traversed separately, and when the logic type is an AND gate, the corresponding sub-events are traversed as a fault combination that participates in the traversal. After each expansion operation, update the current traversed node and the set of fault propagation paths, and take any of the following conditions as the termination condition: reaching the preset maximum search depth, the current node being the bottom event, or no new node or new historical maintenance case being generated for a preset number of consecutive times. After the termination condition is met, the set of fault propagation paths obtained by traversal is passed to the minimal cut set calculation tool for fault combination reduction.
5. The fault tree analysis and troubleshooting method based on size model collaboration and graph database according to claim 4, characterized in that, After the termination condition is met, the set of fault propagation paths obtained through traversal is passed to the minimal cut set calculation tool for fault combination reduction, including: Logical reduction is performed on the bottom events and their logical relationships in the set of fault propagation paths to obtain the minimum cut set that leads to the occurrence of the top event; Based on the occurrence probabilities of the bottom events in the minimum cut set, calculate the fault combination information corresponding to the minimum cut set, and obtain the occurrence probability of the top event; Based on the contribution information of the bottom event to the probability of the top event, the priority of troubleshooting the bottom event is determined.
6. The fault tree analysis and troubleshooting method based on size model collaboration and graph database according to claim 1, characterized in that, The process of generating the structured troubleshooting solution in step S4 includes: The text reasoning model generates multiple sub-tasks based on the text of fault phenomena, including at least top event query, fault propagation path retrieval, minimum cut set calculation, and historical maintenance case retrieval. The multiple subtasks are assigned to the corresponding fault tree path retrieval tool, minimum cut set calculation tool and historical experience retrieval tool, and the retrieval depth, retrieval return quantity and inference execution parameters are configured for each subtask; The execution progress, return results, and exception information of each subtask are recorded through a global state diagram, and it is determined whether to continue calling the corresponding tool or perform manual query based on the global state diagram. After the completion of the multiple sub-tasks, the text reasoning big model summarizes the return results of each sub-task and generates a structured troubleshooting solution.
7. The fault tree analysis and troubleshooting method based on size model collaboration and graph database according to claim 6, characterized in that, The historical experience retrieval tool retrieves at least one type of unstructured maintenance knowledge from historical maintenance records, equipment manuals, technical manuals, and fault diagnosis case databases. The retrieval includes at least one of vector retrieval and full-text retrieval. The retrieved historical maintenance cases are associated with fault propagation paths and minimum cut sets to generate fault diagnosis steps and fault cause analysis in the structured troubleshooting solution.
8. The fault tree analysis and troubleshooting method based on size model collaboration and graph database according to claim 1, characterized in that, The consistency check in step S5 includes: Structural consistency verification: Traverse the directed edges stored in the graph database and compare the parent event, child event and edge direction corresponding to the directed edge with the fault tree structure in the structured troubleshooting scheme; Node consistency verification: Match the event nodes in the structured troubleshooting solution with the corresponding event nodes in the graph database, and verify the node name, node type and node association relationship; Logical consistency verification: Based on the logic types and fault propagation paths stored in the graph database, verify whether the logic gate combination in the structured troubleshooting scheme is consistent with the minimum cut set reduction result; If any of the structural consistency check, node consistency check, or logical consistency check fails to meet the preset check conditions, the corresponding structured troubleshooting solution will be marked as a result to be corrected and prohibited from being used as the final output that passes the consistency check.
9. The fault tree analysis and troubleshooting method based on size model collaboration and graph database according to claim 1, characterized in that, The structured troubleshooting scheme in step S4 includes: Generate a fault tree structure diagram based on the fault propagation path and the logical relationship between events; Generate logic gate type descriptions and event connection relationships based on the event nodes and directed edges in the fault tree structure diagram; Basic event summary information is generated based on the minimum cut set and the probability of occurrence of the base event, and associated with the fault investigation priority. Based on the fault propagation path, historical maintenance cases, and the aforementioned fault investigation priorities, maintenance operation steps, required tools and spare parts, and safety precautions are generated.
10. The fault tree analysis and troubleshooting method based on size model collaboration and graph database according to claim 1, characterized in that, It also includes a fault tree knowledge update step, which includes: The fault tree image is stored as the original knowledge carrier in the object storage service, and the fault tree image is associated with the event nodes and directed edges in the graph database. When a new fault tree image or historical maintenance case is received, new fault knowledge is obtained through a visual mini-model or historical experience retrieval tool. Based on the semantic similarity and logical relationship between the new fault knowledge and existing event nodes, the update or supplementation of the relationship between the new event nodes and existing event nodes is determined. The newly added or updated fault knowledge is written into the graph database, and the corresponding update information is saved for use in subsequent fault tree queries and troubleshooting solution generation.
