A Knowledge Graph Cascade Retrieval Method and System Based on Expert System Collaboration

Abstract

This invention relates to the field of knowledge graph retrieval technology, specifically disclosing a knowledge graph cascade retrieval method and system based on expert system collaboration. The method includes a parallel execution of a background incremental update closed loop and a front-end real-time query closed loop. Specifically, the method includes: capturing atomic-level incremental events of a multimodal knowledge graph, performing multi-version concurrency control management on the event data, and generating a globally unique data version number. The solution provided by this invention, by constructing a parallel architecture of a background incremental update closed loop and a front-end real-time query closed loop, ensures the version correspondence between the underlying flowing data and the structured query predicates when actually processing business such as high-frequency transaction verification or dynamic equipment troubleshooting, by utilizing multi-version concurrency control and incremental compilation of affected abstract syntax tree branches.

Description

Technical Field

[0001] This invention relates to the field of knowledge graph retrieval technology, and in particular to a knowledge graph cascade retrieval method and system based on expert system collaboration. Background Technology

[0002] In practical applications such as industrial equipment condition monitoring or financial risk assessment, business systems typically rely on knowledge graphs containing multimodal data, including text and images, for information retrieval and logical reasoning. Existing knowledge graph retrieval systems generally employ rule maintenance mechanisms with periodic offline batch updates and a single-level direct matching query mode.

[0003] When the graph data in a business scenario undergoes frequent incremental changes, the offline batch update mechanism can cause the expert rules within the system to fail to adapt to the latest version of the underlying data in a timely manner, resulting in a disconnect between the rule layer and the physical data layer. Furthermore, when receiving natural language retrieval requests, existing systems typically employ indiscriminate computation of all rules or logical mapping of fixed paths, without considering the actual runtime filtering overhead of different query conditions during scheduling.

[0004] Due to the lack of multi-level progressive filtering planning and real-time verification and feedback logic for preliminary search results, the system incurs a lot of ineffective consumption of computing resources when faced with complex multimodal data matching tasks. Furthermore, it cannot implement self-correction when there are deviations in the input query or when the rules are not fully covered, which reduces the retrieval effectiveness in actual operations. Summary of the Invention

[0005] This invention aims to at least partially address one of the technical problems in related technologies. Therefore, the objective of this invention is to propose a knowledge graph cascade retrieval method and system based on expert system collaboration, in order to improve the retrieval accuracy and business continuity of the system in complex and dynamic data environments.

[0006] To achieve the above objectives, a first aspect of the present invention proposes a knowledge graph cascade retrieval method based on expert system collaboration, comprising a parallel execution of a background incremental update closed loop and a front-end real-time query closed loop. The method specifically includes:

[0007] Capture atomic-level incremental events of multimodal knowledge graphs, perform multi-version concurrency control and management on event data, and generate globally unique data version numbers;

[0008] Construct a fine-grained rule dependency graph, calculate the affected expert rule abstract syntax tree branches based on the atomic incremental events, and perform incremental compilation on the affected expert rule abstract syntax tree branches to generate a set of structured query predicates bound to the data version number;

[0009] The performance metrics of the structured query predicate set are monitored in real time, the predicate execution order is adjusted based on the dynamic cost model, and incremental verification is performed on the virtual logical edges generated by expert rules to dynamically update the validity period of the virtual logical edges.

[0010] Receive a natural language retrieval request, extract the data version number corresponding to the natural language retrieval request, decompose the natural language retrieval request into a set of meta-tasks and map them to the set of structured query predicates, and generate the optimal query execution plan for the current version;

[0011] Perform a three-level cascaded retrieval: the first level performs multimodal dynamic pruning based on the graph database and the optimal query execution plan; the second level calls a preset large language model to perform semantic filtering on the results of the first level; and the third level calls a preset modality analysis model to perform feature inference and generate initial retrieval results.

[0012] The initial search results are verified for correctness in multiple dimensions. If the verification passes, the final search results are output. If the verification fails, a correctness verification log is generated, and a hierarchical self-correction mechanism is triggered to re-execute the cascading search.

[0013] To achieve the above objectives, a second aspect of the present invention proposes a knowledge graph cascade retrieval system based on expert system collaboration, comprising:

[0014] The version control and event capture module is used to capture atomic-level incremental events of the multimodal knowledge graph, perform multi-version concurrent control and management of event data, and generate globally unique data version numbers;

[0015] The dependency graph construction and incremental compilation module is used to construct a fine-grained rule dependency graph, calculate the affected expert rule abstract syntax tree branches based on the atomic incremental events, and perform incremental compilation on the affected expert rule abstract syntax tree branches to generate a set of structured query predicates bound to the data version number.

[0016] The performance monitoring and verification update module is used to monitor the performance metrics of the structured query predicate set in real time, adjust the predicate execution order based on the dynamic cost model, and perform incremental verification on the virtual logical edges generated by expert rules to dynamically update the validity period of the virtual logical edges.

[0017] The task decomposition and plan generation module is used to receive natural language retrieval requests, extract the data version number corresponding to the natural language retrieval requests, decompose the natural language retrieval requests into a set of meta-tasks and map them to the set of structured query predicates, and generate the optimal query execution plan for the current version.

[0018] The three-level cascaded retrieval engine module is used to perform three-level cascaded retrieval: the first level performs multimodal dynamic pruning based on the graph database according to the optimal query execution plan; the second level calls the preset large language model to perform semantic filtering on the results of the first level; and the third level calls the preset modality analysis model to perform feature inference and generate initial retrieval results.

[0019] The result verification and self-correction module is used to perform multi-dimensional correctness verification on the initial search results. If the verification passes, the final search result is output; if the verification fails, a correctness verification log is generated, and hierarchical self-correction is triggered to re-execute the cascaded search.

[0020] To achieve the above objectives, a third aspect of the present invention provides an electronic device, including a memory, a processor, and a computer program stored in the memory, wherein when the computer program is executed by the processor, it implements the above-described knowledge graph cascade retrieval method based on expert system collaboration.

[0021] The solution provided in this invention constructs a parallel architecture of a backend incremental update closed loop and a frontend real-time query closed loop. In actual processing of business such as high-frequency transaction verification or dynamic equipment troubleshooting, it utilizes multi-version concurrency control and incremental compilation of affected abstract syntax tree branches to ensure the version correspondence between the underlying flow data and the structured query predicates. When executing user query operations, this method preprocesses low-time-consuming and high-filtering-rate query predicates based on a dynamic cost model, and decomposes the overall retrieval into three progressive levels: underlying database pruning, large language model semantic filtering, and modal model feature inference. This progressively reduces the amount of candidate data, thereby reducing system computational consumption.

[0022] Furthermore, by introducing multi-dimensional correctness verification and autonomous error correction closed loop, the system can automatically re-initiate error correction retrieval based on verification logs when the initial retrieval fails to meet constraints due to abnormal data distribution. This improves the retrieval accuracy and business continuity of the system in complex and dynamic data environments. Attached Figure Description

[0023] Figure 1 This is a flowchart illustrating the knowledge graph cascade retrieval method based on expert system collaboration provided by the present invention;

[0024] Figure 2 This is a schematic diagram illustrating the implementation of the knowledge graph cascade retrieval system based on expert system collaboration provided by the present invention;

[0025] Figure 3 This is a schematic diagram of the structure of the electronic device provided by the present invention. Detailed Implementation

[0026] Embodiments of the present invention are described in detail below, examples of which are illustrated in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain the present invention, and should not be construed as limiting the present invention.

[0027] The following description, with reference to the accompanying drawings, describes an embodiment of the knowledge graph cascade retrieval system, method, and electronic device based on expert system collaboration.

[0028] Example 1:

[0029] This embodiment provides a knowledge graph cascade retrieval method based on expert system collaboration. This method is particularly suitable for business scenarios that require processing multimodal knowledge graph data with high frequency and dynamic changes, and maintaining strict consistency between expert system rules and underlying data versions, such as risk exposure verification of high-frequency trading networks and real-time dynamic root cause analysis of large industrial equipment failures.

[0030] The method in this embodiment achieves efficient and accurate retrieval of multimodal knowledge graphs by constructing and executing a closed loop of incremental updates in the background and a closed loop of real-time queries in the front end.

[0031] Specifically, as shown in the attached document Figure 1 As shown, the method includes the following steps:

[0032] Step S1: Multi-version concurrency control and atomic incremental event capture.

[0033] Specifically, the system continuously monitors and captures atomic-level incremental events occurring in the multimodal knowledge graph. An atomic-level incremental event, as described here, refers to the smallest indivisible unit of change in the knowledge graph, which itself constitutes a complete data change record. In a specific implementation scenario, such as during high-frequency trading network risk verification, adding a transaction, modifying a counterparty's credit rating attribute, or deleting an account node are all considered atomic-level incremental events.

[0034] Optionally, to ensure complete recording of event details, the data structure of each captured atomic incremental event shall include at least the following fields: an event identifier for globally unique identification of the event, a timestamp recording the precise time of the event occurrence, an operation type indicating the type of data change (such as add, modify, delete), an operation object type indicating the type of the change target (such as entity node, relation edge, attribute), a unique identifier of the operation object locating the specific change target, a pre-change value describing the data state before the change, and a post-change value describing the data state after the change.

[0035] Furthermore, the system performs multi-version concurrency control management on the captured event data. The core of this mechanism lies in generating a globally unique data version number for each data change and retaining a preset number of historical graph snapshots in the system based on this version number. The globally unique data version number is a strictly monotonically increasing temporal logical identifier; it not only identifies the order of data changes but also serves as the basis for version binding of all subsequent derived data (such as structured query predicate sets and virtual logical edges).

[0036] To implement multi-version concurrency control, the system logically maintains two parallel snapshot versions: the latest stable snapshot version and the latest temporary snapshot version. The front-end real-time query loop defaults to reading the latest stable snapshot version, ensuring that all user queries face a consistent and predictable static data view, thus avoiding inconsistent intermediate results due to changes in underlying data during the query process. Simultaneously, the back-end incremental update loop performs data write operations based on the latest temporary snapshot version. Any newly arriving atomic incremental event is first applied to the latest temporary snapshot version, forming a new version data space to be verified. Only after this new version passes all subsequent verification steps and is marked as stable does it transform into the new latest stable snapshot version. This read-write separation and version switching mechanism is the foundation for ensuring system retrieval performance and data consistency under high-frequency updates.

[0037] Step S2: Fine-grained rule dependency graph construction and incremental compilation.

[0038] Based on step S1, the system performs dependency analysis and incremental compilation of expert rules. First, the system constructs a fine-grained rule dependency graph for the pre-defined expert rules in the knowledge graph. The fine-grained rule dependency graph is a directed acyclic graph, where nodes represent sub-expressions or operators in the expert rule abstract syntax tree, and directed edges represent data dependencies between nodes.

[0039] For example, the process of constructing this dependency graph includes extracting dependencies for each node in the expert rule abstract syntax tree. These dependencies are fine-grained and specifically include: entity type dependencies (e.g., the rule condition specifies that the node type must be a transaction or a device), attribute dependencies (e.g., the rule condition specifies the transaction amount or device temperature attribute), relationship dependencies (e.g., the rule condition specifies the transfer or connection relationship between nodes), and modal feature dependencies (e.g., the rule condition involves feature values ​​extracted from a device vibration waveform image). Subsequently, the system applies a pre-defined hash algorithm to each extracted dependency to calculate a unique, fixed-length dependency fingerprint. Based on this, the system constructs an inverted index with the dependency fingerprint as the key and the set of rule branches containing that dependency as the value. This inverted index is the core data structure for quickly locating affected rules.

[0040] When the atomic incremental event generated in step S1 is submitted, the system parses the event, extracts the type and unique identifier of the operation object involved in the change, and generates a target dependency fingerprint set accordingly. Then, the system queries the inverted index and matches each fingerprint in the target dependency fingerprint set to quickly locate all expert rule abstract syntax tree branches affected by the incremental event.

[0041] Optionally, for the identified affected expert rule abstract syntax tree branches, the system performs incremental compilation. Unlike full compilation, incremental compilation only recompiles these affected branches, while unaffected abstract syntax tree branches are directly reused from the previous version's compilation cache. The system combines the newly generated recompiled branches with the reused old branches to generate a new predicate set bound to the current data version number. This structured query predicate set is essentially a set of structured query statements, such as Cypher or Gremlin statements, that can be directly executed by the graph database engine; it is a concrete expression of expert rule logic under a specific data version.

[0042] To ensure the correctness and stability of the new predicate set, this step introduces a verification mechanism based on traffic bypass testing. Specifically, the system bypasses and copies a preset proportion (e.g., 1% or 5%) of the retrieval query traffic in the front-end real-time query loop without impact, using it as test request traffic. This test request traffic is simultaneously input into both the retrieval process built on the old predicate set and the retrieval process built on the new predicate set. The system compares the results output by the two versions of the retrieval process. If, after a preset period or a certain number of test requests, the consistency ratio of the retrieval results output by the two versions is higher than a preset, high consistency threshold, such as 99.9%, then the new predicate set is deemed to have passed verification. The system officially designates it as the structured query predicate set bound to the current data version number and executes a version switch, enabling the new predicate set to begin serving all retrieval requests in the front-end real-time query loop.

[0043] Step S3: Incremental verification of dynamic cost model and virtual logical edge.

[0044] After generating the set of structured query predicates bound to the version in step S2, the system enters the dynamic optimization and verification phase. First, the system monitors the performance metrics of each predicate in the set of structured query predicates under real query load in real time. These performance metrics are statistically analyzed in real time using a sliding time window, including but not limited to: the total number of times the predicate is executed, the average execution time per execution, the percentage of data successfully filtered out by the predicate when filtering candidate datasets during execution (i.e., the data filtering rate), and the false positive rate of the predicate (e.g., incorrectly classifying relevant data as irrelevant).

[0045] Based on these real-time statistical performance metrics, the system employs a dynamic cost model to optimize the execution order of predicates. The core idea of ​​this dynamic cost model is to dynamically adjust the computation order of predicates with the goal of minimizing the overall expected execution cost of the query. In a specific implementation, the system uses a greedy algorithm to generate the execution sequence. The algorithm logic is as follows: the system considers predicate nodes with a data filtering rate greater than a preset high filtering threshold (e.g., 80%) and an execution time less than a preset low time threshold (e.g., 1 millisecond) as high-yield predicates and places them at the beginning of the initial execution sequence for priority execution. Conversely, the system considers predicate nodes with a data filtering rate lower than a preset low filtering threshold (e.g., 5%) as low-yield predicates and forcibly places them at the end of the execution sequence.

[0046] Optionally, for numerical attribute predicates (e.g., device temperature greater than T), this system also introduces an adaptive threshold optimization method based on kernel density estimation. Specifically, the system collects all values ​​of the numerical attributes involved in the query in real time and uses a kernel density estimation algorithm to fit the real-time probability distribution of these values. Based on the fitted probability density function, the system aims to maximize the data filtering rate of the predicate under the desired distribution. It dynamically calculates the optimal decision threshold by solving an extremum problem and incrementally updates it to the structured query predicate set. For example, if the device temperature attribute exhibits a bimodal distribution, the optimal threshold calculated by the system will automatically be located at the trough between the two peaks to achieve the best discrimination effect.

[0047] In parallel, the system also performs incremental verification of virtual logical edges. These virtual logical edges are logical relationships derived by the expert system from multi-step reasoning based on expert rules, and are not actually stored in the knowledge graph. For example, given the existing facts 'Entity B is a subsidiary of Entity A' and 'Entity B invested in Entity C', combined with preset equity penetration expert rules, the virtual logical edge 'Entity A and Entity C are related' can be derived. The system initializes a credibility score for each virtual logical edge in the graph database. When the atomic incremental event in step S1 occurs and affects the entity or relationship upon which a virtual logical edge depends, the system automatically triggers verification of the constraints implied by that virtual logical edge. If the verification passes, for example, if a new data change strengthens the correctness of the logical edge, its credibility score is increased by a preset amount; if the verification fails, for example, if a new data change violates the conclusion of the logical edge, its credibility score is decreased by a preset amount.

[0048] Based on the credibility score, the system classifies virtual logical edges into three states:

[0049] When the credibility score falls below a preset first-level threshold, the virtual logical edge is downgraded to a semi-credible state. During retrieval in this state, the system simultaneously uses the virtual logical edge and the original expert rule that generated it for parallel derivation, using the derivation result of the original expert rule as the basis for the final output, while using the result of the virtual logical edge as an auxiliary reference or masking it.

[0050] When the credibility score further decreases to below a preset second-level threshold (the first-level threshold is greater than the second-level threshold), the virtual logical edge is downgraded to an untrustworthy state. In this state, the system directly blocks the virtual logical edge during retrieval and no longer uses it for any derivation.

[0051] Step S4: Natural language retrieval request decomposition and execution plan generation.

[0052] When the system receives a natural language retrieval request from a user, the front-end real-time query closed loop begins. First, the system parses and extracts the data version number explicitly specified by the user or implicitly implied in the context from the request. If the user does not specify a version number, the system defaults to loading the latest stable snapshot version number. Subsequently, the system loads from the versioned storage a set of expert rules that strictly match the data version number, as well as the set of structured query predicates generated in step S2.

[0053] Furthermore, the system utilizes a pre-trained semantic parsing network to process the natural language retrieval request. This semantic parsing network is a deep neural network model based on the Transformer architecture, whose output is to decompose natural language into a set of meta-tasks consisting of multiple atomic operations. For example, for a natural language request to find all A-class customers who have transacted with Company B and have recently experienced a credit rating downgrade, the semantic parsing network might decompose it into multiple atomic operations such as finding all A-class customer entities, finding all entities that have transacted with Company B, finding all entities whose credit ratings have recently been downgraded, and calculating the intersection of these three entity sets. Simultaneously, the network also constructs a task dependency graph representing the order of execution of these atomic operations; for example, calculating the intersection operation depends on the results of the first three search operations.

[0054] Based on this, the system maps and transforms each meta-task node in the task dependency graph into one or a set of specific predicates in the structured query predicate set. Then, the system combines the performance-optimized predicate execution order output by the dynamic cost model described in step S3, arranges these predicates, and finally generates an optimal query execution plan that the graph computing engine can recognize and execute efficiently. This plan includes the predicate execution order, the data flow between operators, and the initial parallelism settings.

[0055] Step S5: Execute the three-level cascaded search.

[0056] Based on the optimal query execution plan generated in step S4, the system performs a three-level cascading retrieval, gradually reducing the size of candidate data.

[0057] The first level is multimodal dynamic pruning. This level is executed at the underlying level of the graph database. Based on the filtering conditions specified in the optimal query execution plan, the system directly scans and filters the entity attributes and edge relationships in the graph. This step removes all graph subgraphs that do not meet the expert rule constraints, retaining only candidate graph subgraphs that satisfy all hard constraints. Dynamic pruning leverages the graph database's indexing and native graph traversal capabilities to quickly reduce the search space with extremely low computational cost.

[0058] The second level is semantic filtering. The candidate subgraphs output from the first level are fed into a pre-defined large language model. This pre-defined large language model is a large-scale autoregressive language model pre-trained on massive amounts of text and code data. This step utilizes the model's semantic understanding capabilities to evaluate the overall semantic relevance of each node in the candidate subgraph to the original natural language retrieval request. The system sets a semantic matching threshold and filters out all nodes with semantic relevance below this threshold. For example, in the semantic context of investigating device anomalies, a node associated with the device's color will be assigned low relevance and removed, while a node associated with the device's vibration frequency will be retained. This step compensates for the first level's inability to understand complex intents due to its reliance on structured rules alone.

[0059] The third level is feature inference. The nodes output from the second level are often associated with multimodal feature data, such as on-site images of equipment malfunctions, sound spectra, or scanned copies of transaction documents. For each modality type, the system calls a pre-defined, specially trained modality analysis model. For example, it calls a convolutional neural network model to analyze images, a recurrent neural network model to analyze time-series signals, and an optical character recognition model to process documents. The system performs cross-modal feature fusion on the features extracted by these modality analysis models and executes logical inference based on the fused features, conforming to expert rules. Finally, it outputs the entity or relationship with the highest matching degree as the initial search result.

[0060] Step S6: Multi-dimensional correctness verification and hierarchical self-correction.

[0061] To ensure the reliability of the final output, the system performs multi-dimensional correctness verification on the initial search results generated in step S5. Specifically, this includes:

[0062] Rule Consistency Verification: This checks whether the entity attribute values ​​and topological relationships contained in the initial search results strictly satisfy the entity attribute constraints and topological relationship constraints defined in the current version of the expert rule set. This is a hard check to ensure that the search results conform to basic logical rules.

[0063] Multi-sample semantic consistency verification: This step aims to evaluate the semantic stability of the retrieval results. Based on the initial retrieval results, the system generates candidate answer sequences multiple times (e.g., 3-5 times) using the preset large language model. Each time, the model uses different random sampling parameters. Then, the system calculates the cosine similarity of the semantic vectors between these candidate answer sequences. If the expected similarity between any two sequences is lower than a preset similarity threshold, it indicates that the large language model is uncertain about the result, and the verification fails.

[0064] Version consistency verification: The system verifies that the version numbers of all graph entities and their associated virtual logical edges involved in the initial search results are completely consistent with the version numbers specified in the natural language search request. This prevents abnormal historical data from appearing in the search results due to version inconsistencies.

[0065] If all the above dimensions pass the verification, the system outputs the initial search result as the final search result. If any dimension fails the verification, the system generates a correctness verification log containing the reason for the failure, the data involved, and relevant context information, and triggers a hierarchical self-correction process to re-execute the cascading search.

[0066] This hierarchical autonomous error correction process executes three error correction levels sequentially:

[0067] Level 1: Query Rewriting. Based on the correctness verification log, the system locates the keywords or semantic units that caused the failure and uses an intent rewriting algorithm (e.g., a method based on synonym replacement, concept generalization, or hyponym expansion) to modify the feature parameters of the natural language retrieval request, generating one or more rewritten natural language retrieval requests. Then, it returns to step S5 and re-executes the three-level cascaded retrieval using the rewritten requests.

[0068] Level 2: Temporary Rule Generation. If the re-search still fails to validate after Level 1 error correction, the system triggers a dynamic rule generation mechanism. This mechanism mines co-occurrence patterns or frequent subgraphs based on the local topology of the current knowledge graph, dynamically generating missing temporary supplementary rules for specific scenarios. The system compiles these temporary supplementary rules into the current version of the structured query predicate set, forming an enhanced predicate set, and then returns to step S5 to re-execute the three-level cascaded search.

[0069] Level 3: User Interaction Guidance. If Level 2 error correction still fails verification, the system indicates that the current knowledge and rules are insufficient to resolve the query. At this point, the system generates interactive question text targeting specific verification points based on the correctness verification log (e.g., does 'Category A customer' in this query include dormant accounts that have been cancelled), and returns the question to the user. After obtaining the characteristic information from the user feedback, the system corrects the original natural language search request accordingly and initiates the search process again.

[0070] Through the closed loop of steps S1 to S6 described above, the knowledge graph cascade retrieval method based on expert system collaboration described in this embodiment has achieved significant progress compared to the offline batch rule updates and single-level query modes commonly used in existing technologies. Existing technologies, when faced with high-frequency data changes, often lead to a disconnect between the rule layer and the physical data layer because expert rules cannot match the underlying data version in a timely manner, resulting in delayed and erroneous search results. This solution, however, ensures strict binding and real-time synchronization between the structured query predicate set and the underlying data version through multi-version concurrent control and incremental compilation in the background incremental update closed loop, effectively improving the version consistency between the underlying data and the rules.

[0071] Meanwhile, existing technologies lack real-time awareness and dynamic scheduling of query predicate execution costs, often executing fixed path mappings for all rules, resulting in significant waste of computational resources when dealing with complex multimodal data. This solution constructs an efficient, progressively converging filtering architecture through the dynamic cost model in step S3 and the three-level cascaded retrieval in step S5. This eliminates most unnecessary computational overhead in the first stage, significantly reducing the overall system's computational load and response latency.

[0072] Finally, existing technologies lack the ability to verify and self-correct search results. When there are deviations in the query or rules are not covered, the system cannot cope, resulting in low search effectiveness. This solution introduces multi-dimensional correctness verification and a hierarchical self-correction closed loop, giving the system the ability to evaluate, diagnose, and repair its own output results. This significantly improves search accuracy and business continuity in complex, dynamic, and unstructured data environments. Therefore, this technical solution demonstrates significantly better robustness and reliability than existing technologies when handling demanding tasks such as high-frequency transaction verification or dynamic equipment troubleshooting.

[0073] Example 2:

[0074] In complex and dynamically changing business scenarios such as industrial manufacturing and financial risk control, the underlying multimodal graph data is not only updated frequently, but its inherent correlation logic and business characteristics also drift over time. If the system relies solely on manually pre-defined expert rules, it will inevitably face problems such as rule lag and decreased coverage after running for a period of time.

[0075] Therefore, this embodiment elaborates on the specific implementation steps of the method, which also includes a self-evolving closed loop for automatically discovering unknown rules. This closed loop enables the system to autonomously learn from massive dynamic data and generate new structured query predicates without human intervention, thereby maintaining the efficiency and accuracy of the knowledge graph cascade retrieval system.

[0076] Specifically, when hierarchical self-correction is triggered and a feedback signal indicating a deviation in the search results is received, the system extracts the semantic features of the current natural language search request and generates a knowledge-missing feature vector. In this process, the feedback signal indicating a deviation in the search results encompasses both explicit and implicit triggering sources. Explicit feedback signals originate from user interaction feedback in the third-level error correction layer, where the user explicitly states that the initial search results do not match their query intent. Implicit feedback signals originate from continuous failures in the multi-dimensional correctness verification module; for example, within a preset number of consecutive query cycles, queries targeting the same type of business feature fail to pass rule consistency verification. Once the system receives any of the above feedback signals, the self-evolving closed-loop monitoring daemon process will be immediately activated.

[0077] Subsequently, the system invokes the underlying semantic parsing network module to perform deep feature extraction on the current natural language retrieval request that caused the bias. The extraction process is not a simple keyword segmentation, but rather utilizes a multi-head self-attention mechanism to map the natural language into a high-dimensional, continuous semantic vector space. To accurately characterize what knowledge is missing in the current expert system's rule base, the system does not directly use the overall embedding of the natural language. Instead, it generates a directional knowledge-missing feature vector by calculating the semantic residual between the target query intent and the currently recalled but unmatched entities. The generation of this feature vector relies on matrix operations and nonlinear mapping; the specific formula algorithm used is as follows:

[0078] ;

[0079] in, This represents the extracted knowledge-missing feature vector, which contains potential logical feature directions that current expert rules fail to cover; This indicates the introduction of a nonlinear activation function, used to enhance the nonlinear expressiveness of the feature vector and limit numerical overflow; This represents a pre-defined query weight matrix used to map natural language retrieval requests to an aligned feature space, which is fixed during the model pre-training phase. This represents the initial semantic embedding vector output by the initial encoder for the current natural language retrieval request; This represents the total number of search entity nodes that were marked as biased in the initial search results due to verification failure or user rejection. The cumulative index number representing the retrieved entity node marked as a deviation, with a value of a positive integer; This represents the first value calculated using the attention model. The semantic attention weight of each retrieval entity node relative to the natural language retrieval request reflects the responsible contribution of that entity to the biased results. Indicates the first The graph embedding feature vector of each retrieved entity node in the underlying storage of the knowledge graph.

[0080] In practical applications, the formula above is used to calculate... It can accurately locate the uncovered areas of the system's knowledge base, guiding the subsequent mining module to specifically search for related data in massive logs, thus avoiding the waste of computing power caused by blindly scanning the entire database.

[0081] Optionally, a preset time-series pattern mining algorithm is used to retrieve atomic-level incremental event sequences that match the knowledge-missing feature vector within the background incremental update closed loop, and potential attribute relationships are identified through a preset causal inference model. Since changes in business data typically manifest as a series of events occurring sequentially, the system needs to conduct in-depth analysis of these dynamic change records.

[0082] Specifically, the system directly accesses the log bus of the background incremental update closed loop through memory mapping technology, based on the knowledge missing feature vector calculated in the preceding steps. The system utilizes the Locality Sensitive Hash (LSH) algorithm to perform an approximate nearest neighbor search on massive logs, filtering out target data slices that are highly correlated with missing knowledge in the semantic space. Subsequently, the system initiates pre-defined temporal pattern mining algorithms (such as optimized PrefixSpan or SPADE algorithms) to extract frequently occurring atomic incremental event sequences from these data slices. An atomic incremental event sequence refers to a series of indivisible data change operations that occur consecutively within a set time window, targeting the same entity group or a set of entities with a strongly connected graph topology. Simply mining frequently co-occurring event sequences in time is far from sufficient, because statistical temporal sequence or co-occurrence does not equate to logical causation. Directly converting strong correlations into expert rules can easily introduce pseudo-logic that leads to misjudgments.

[0083] Therefore, the system further inputs the mined high-frequency event sequences into a pre-defined causal inference model. This causal inference model employs a hybrid architecture based on structural causality (SCM) or Granger causality test. It not only verifies whether event B occurs with a high probability after event A occurs, but also verifies whether the probability of event B significantly decreases when event A is blocked by introducing counterfactual reasoning. After rigorous causal inference to eliminate confounding factors, the system ultimately extracts potential attribute relationships with directionality and logical necessity from the complex time series.

[0084] For example, the system invokes the pre-defined large language model to map the latent attribute relationships into candidate logical predicates conforming to the abstract syntax tree specification, generating candidate expert rules containing corresponding filtering conditions. After extracting the structured latent attribute relationships, the system faces the challenge of transforming them into code-level predicates that can be parsed and executed by the underlying graph computing engine. To this end, the system utilizes a distributed computing framework to invoke the pre-defined large language model service cluster.

[0085] During the invocation process, the system assembles the mined potential attribute relationships, related entity attribute metadata, and strict expert system abstract syntax tree (AST) specifications into a standardized context prompting engineering template, which is then input into the large language model. To ensure high rigor and determinism of the output, the sampling temperature parameter of the large language model is forcibly configured to an extremely low value. The large language model leverages its powerful code generation and logic transformation capabilities to map potential relationships expressed in natural language or in statistical formats word-by-word into candidate logical predicates that conform to the definition of abstract syntax tree nodes.

[0086] Subsequently, the system performs rigorous lexical and syntactic analysis on the output of the large language model, parses and assembles it into candidate expert rules containing corresponding filtering conditions. These candidate expert rules are logically compatible with the system's original expert rules and possess the theoretical capability to perform graph pruning.

[0087] It is also important to note that deploying rules without sufficient validation could lead to serious business misjudgments or exhaustion of system computing resources. Therefore, this embodiment requires introducing the candidate expert rules into the bypass test traffic to calculate the rule fitness score of the candidate expert rules in real time. The rule fitness score The computational model satisfies the following: it is positively correlated with the prediction filtering rate and prediction error correction accuracy of the candidate expert rules, and negatively correlated with the unit execution time of the candidate expert rules.

[0088] In practice, the system allocates a separate security sandbox area in memory to construct a bypass test traffic mechanism. The system replicates real user search requests from the real-time query loop at a fixed sampling rate and directs them to this sandbox environment. Independent computation is performed using a simulated structured query predicate set containing candidate expert rules. This entire process is strictly physically isolated from the main business link and has no visible impact on the end-user response. During sandbox operation, the system's monitoring probes frequently collect various operational metrics of the candidate expert rules. To scientifically and comprehensively evaluate the overall value of the candidate rules, the system employs a multi-dimensional aggregation calculation model to output a rule fitness score. The specific formula for this model is defined as follows:

[0089] ;

[0090] in, This represents the final score indicating the rule fitness of the currently evaluated candidate expert rule; The filter rate weighting coefficient, which is a fixed constant, is a pre-set parameter in the system used to measure the importance of data pruning. This represents the predicted filtering rate obtained from the actual execution statistics of the candidate expert rules in the bypass test traffic, i.e., the proportion of irrelevant underlying graph nodes that are successfully removed. This represents the system's preset error correction accuracy weighting coefficient, used to measure the correctness of rule logic. This indicates the prediction and error correction accuracy of the candidate expert rule in successfully outputting the correct matching result for those historical erroneous requests that triggered the self-evolutionary closed-loop feedback signal in the early stage. This represents a smoothing baseline constant used to prevent the logarithmic function of the denominator from producing meaningless (negative or 0) results. Its value is forcibly set to a value strictly greater than 1 during system initialization. This represents the average execution time per unit of time consumed by a candidate expert rule in a single execution within the graph computing engine sandbox, with physical dimensions accurate to the millisecond level. This represents a Boolean hard constraint verification factor. When a candidate expert rule is detected to have not caused fatal exceptions such as system memory overflow or deadlock loop during bypass execution, this factor is set to one; otherwise, it is forced to be set to zero, triggering a direct interception mechanism.

[0091] In practical applications, the brilliance of this computational model lies in its consideration of not only the positive impact of new rules on business correctness (positive correlation in the numerator), but also the strict limitation of inefficient rules with extremely high computational complexity (such as causing full Cartesian product traversal of the graph, negative correlation in the denominator) through a logarithmic penalty function, ensuring that system performance does not deteriorate drastically due to the introduction of new rules. It is clear that this model establishes a rational balance between logical accuracy and computational economy.

[0092] Specifically, when the rule fitness score When a candidate expert rule consistently scores higher than the average score of the online rule set within a preset time window, an incremental compilation mechanism is automatically triggered to convert the candidate expert rule into a formal expert rule and update it to the system. In this step, the system maintains a dynamically configurable time window (e.g., a complete business load fluctuation cycle of 24 hours or longer). A high score within just one time slice is insufficient to prove the universality of a rule. Within the preset time window, the rule must exhibit sustained stability, and its moving average score must be consistently and strictly higher than the average baseline score calculated from the current online rule set. Only when these stringent time and score thresholds are met will the system's state machine automatically transition, activating the incremental compilation mechanism. The system uses the incremental compiler to locate and lock the abstract syntax tree region corresponding to the current formal rule set. Without interrupting other foreground queries, it smoothly merges the branches of the candidate expert rule into the formal abstract syntax tree structure using a copy-on-write strategy, completing the rule's memory-state transformation. Subsequently, the system marks the candidate expert rule as a formal expert rule and distributes it to all distributed graph computing nodes via a version control protocol, marking the completion of the closed-loop self-evolution process.

[0093] Analysis of existing technologies reveals that traditional knowledge graph retrieval systems and conventional expert inference engines generally rely on domain experts spending significant time manually writing rules and releasing offline code. When faced with rapidly changing data distribution patterns in industrial IoT environments or financial fraud prevention scenarios, this static maintenance model often leads to severe rule gaps in the rule base, causing the system to suffer from persistent false positives or false negatives.

[0094] The knowledge graph cascade retrieval method based on expert system collaboration disclosed in this embodiment creatively constructs a complete self-evolving closed-loop mechanism, from feedback capture, time-series mining, causal inference to large-scale model logical mapping, and then to bypass quantitative evaluation and dynamic deployment. This significantly overcomes the rule iteration lag caused by manual intervention and ensures the dual superiority of newly generated expert rules in terms of logical correctness and computational cost. This data architecture scheme with highly autonomous iteration and adaptability greatly improves the long-term business continuity and intelligent reasoning effectiveness of the retrieval system in extremely complex and uncertain data environments.

[0095] Example 3:

[0096] In complex industrial troubleshooting or dynamic transaction analysis, traditional hard pruning often relies on precise Boolean logic. However, in real-world multimodal data environments, sensor noise, semantic ambiguity, or incomplete coverage of expert rules may lead to the premature filtering out of some potentially valuable entities. To address this, this embodiment introduces fuzzy set theory to fuzzify the deterministic logic in the retrieval process, thereby achieving a more flexible cascading retrieval filtering mechanism.

[0097] Specifically, the method described in this embodiment also includes fuzzy pruning based on membership degree. This process is not independent of the aforementioned steps, but is deeply embedded in the collaborative operation of the background incremental update closed loop and the front-end real-time query closed loop.

[0098] Specifically, during the incremental compilation process, the system needs to configure corresponding fuzzy membership functions for the affected expert rule branches, thereby transforming the structured query predicate set into a fuzzy logic predicate set with probabilistic output capabilities. In this step, the fuzzy membership function refers to a continuous function that maps input feature values ​​to the interval [0,1], used to characterize the degree to which a data item belongs to the semantic category defined by a specific expert rule. For example, in expert rules for temperature monitoring, a traditional hard predicate might be defined as a temperature higher than 80 degrees Celsius. After fuzzification, the system will configure an sigmoid or Gaussian membership function, ensuring that values ​​near 80 degrees Celsius receive a continuous membership score.

[0099] It's also important to note that when configuring fuzzy membership functions, the incremental compiler extracts threshold parameters from the abstract syntax tree branches and automatically adjusts the function's centroid and reduction factor based on the distribution statistics of historical data. Through this transformation, the structured query predicates, which originally output true / false, are given the ability to express uncertainty, forming a fuzzy logic predicate set. This set no longer directly returns filtering instructions during execution; instead, it outputs the probability or degree score of the entity satisfying a specific rule branch, providing foundational data support for subsequent multimodal weighted decision-making.

[0100] Specifically, during the first-level multimodal dynamic pruning, the system uses the set of fuzzy logic predicates to calculate the membership score of the entity to be retrieved relative to each expert rule branch. During the initial screening at the graph database level, for each candidate entity node, the system calls multiple fuzzy logic predicates of that version in parallel. Since the knowledge graph contains multimodal features, such as textual descriptions of entities, feature vectors of associated images, and numerical monitoring data, different fuzzy logic predicates will act on different modalities.

[0101] In this embodiment, the system uses the following formula to calculate the membership score of a single entity to be retrieved for a specific expert rule branch:

[0102] ;

[0103] In the formula, Indicates the entity to be retrieved is in the _th ... In the modality relative to the first Membership score of each expert rule branch; Represents an exponential function with the natural constant as its base; This indicates that the entity is in the... For one-dimensional scalar characteristic response values ​​under each modality, and for high-dimensional multimodal data, this value is mapped and output after dimensionality reduction or distance measurement by the corresponding modal analysis model to ensure the consistency of mathematical dimensions; Indicates the first The expert rule branch in the 1st The semantic center parameter in each modality, i.e., the ideal trigger threshold defined by the rule; Indicates the first The expert rule branch in the 1st The membership slope sensitivity factor for each modality is used to control the width of the fuzzy boundary. This factor is dynamically calculated by the incremental compilation stage based on the discreteness of the attribute. The membership score calculated by this formula can quantify the matching degree between entities and rules.

[0104] Specifically, the system needs to extract the data filtering rate and execution time of each modal predicate, calculate and generate the modal weight factor corresponding to each modality, and perform weighted aggregation of the membership score and the modal weight factor to generate the global confidence score of the entity to be retrieved. The modality weighting factor is a key parameter that measures the contribution and reliability of different modalities in the current retrieval scenario. Because the processing costs and filtering efficiencies of different modalities (such as images and text) vary greatly during pruning, the system cannot simply average the membership degrees of each modality; it must consider their performance. In this embodiment, the system uses the following formula to calculate the global confidence score of the entity to be retrieved. :

[0105] ;

[0106] In the formula, This represents the global confidence score of the entity to be retrieved, and its value ranges from [value range missing]. between; This indicates the total number of modalities involved in the current search request; The index number representing a specific mode; This represents the modal internal traversal auxiliary index used for weight normalization loop calculation. This independent index variable is set to avoid logical overlap with the sequence numbers of other entity levels. Indicates the relationship with the first The total number of expert rule branches related to each modality; Indicates the index number of the expert rule branch; Indicates the first The average data filtering rate of a modal predicate over a historical statistical period reflects the modality’s ability to exclude irrelevant interference terms. Indicates the first The average execution time of each modal predicate in the current system environment, in milliseconds; This represents a preset modal confidence constant, used to compensate for the native errors of different modal sensors or the extraction model itself; represents the natural constant, used here to ensure that the logarithmic term in the denominator is greater than zero and has smoothness.

[0107] This formula automatically increases the weight of efficient and time-saving modalities in the final decision by taking into account both the filtering rate and the execution time, thereby generating a global confidence score that represents the overall matching degree of the entity.

[0108] Specifically, the system needs to collect system concurrency load metrics and historical error correction frequency in real time, and dynamically calculate the adaptive pruning threshold for the current period using a preset logistic regression model. The so-called adaptive pruning threshold refers to the filtering boundary that the system dynamically adjusts based on its own operating status. When the system load is low and historical error corrections are frequent (indicating that the rules may be underfitting), the system should reduce the pruning intensity and allow more suspected entities to enter the subsequent fine-tuning screening stage; conversely, when the system load is close to the upper limit, in order to ensure the response speed of core business, the system will appropriately increase the threshold and perform stricter filtering.

[0109] It is also important to note that the logistic regression model uses the system's current CPU utilization, memory usage, requests per second (QPS), and the hierarchical self-correction trigger rate over the past hour as independent variables. Through a pre-trained weight matrix, the model outputs a dynamic threshold between 0 and 1. This mechanism ensures that the retrieval system can achieve a dynamic self-balance between computational resource allocation and retrieval recall, avoiding the failure of a fixed threshold under extreme load conditions.

[0110] Specifically, the system compares the global confidence scores. With the adaptive pruning threshold .like - If the difference is less than or equal to Δ, where Δ is a preset difference tolerance threshold, then the corresponding entity to be retrieved is marked as a suspected error retention state, and the autonomous error correction process is invoked first to re-verify the entity in the suspected error retention state; if - If the value is greater than Δ, then a pruning and filtering operation will be performed.

[0111] In this step, the "suspicious retention" state is the core feature phrase proposed in this embodiment, defined as an intermediate state between a perfect match and a perfect filter. When an entity's confidence level is lower than the current threshold, but the difference is within the range of Δ (difference tolerance threshold), the system considers the entity to be at risk of being incorrectly filtered out. The setting of Δ is usually determined based on the business's sensitivity to recall. For entities in the "suspicious retention" state, the system does not directly send them to the second or third level of retrieval (to save overhead), but instead pushes their feature logs directly to the self-correction module. In this module, the system attempts to perform a rapid secondary verification of the entity using a rewritten query intent or temporarily generated logical rules. Only suspicious entities that pass the re-verification are added back to the candidate set, while entities with confidence levels far below the threshold (i.e., a difference exceeding Δ) are decisively filtered out.

[0112] This pruning process based on fuzzy membership degree and adaptive threshold has significant technical advantages compared to traditional techniques.

[0113] For example, in existing knowledge graph retrieval schemes, pruning operations are typically binary. If the data from a sensor fails to meet the hard boundaries of an expert rule due to a slight deviation (e.g., a temperature requirement of >80°C, but actually 79.9°C), the entity and all its associated multimodal information are completely discarded, leading to missed search results. However, in this embodiment, through the transformation of fuzzy logic predicates, an entity with a membership score of 79.9 can still obtain a membership score close to 1. Combined with a comprehensive evaluation of other modalities (such as normal vibration characteristics), this entity is highly likely to be judged as a questionable retained state. Subsequently, through re-verification via an autonomous error correction process, the system can discover that this slight deviation is a normal sensor drift, thus correctly retrieving the target.

[0114] Meanwhile, by introducing a modality weighting factor, this scheme solves the problem of uneven resource allocation in multimodal data processing. When processing large-scale maps, if the analysis algorithm for a certain modality (such as deep learning feature extraction) is extremely time-consuming and contributes little to the discriminative power of the results, its weight will be automatically reduced, making the system more reliant on efficient and accurate attribute filtering and improving the overall retrieval response speed.

[0115] In summary, this embodiment organically combines fuzzy set theory with a dynamic cost model by introducing membership-based fuzzy pruning during the execution of a three-level cascaded retrieval process. By configuring the fuzzy membership function, a smooth transition from hard logic predicates to a set of fuzzy logic predicates is achieved; and the global confidence score is calculated through multimodal weight aggregation. The overall matching degree of entities was quantified; the adaptive pruning threshold was calculated using a logistic regression model. This approach enables dynamic adaptation of the retrieval strategy to different environments. Finally, by setting a "retain suspicious items" status, a self-correction process is integrated, effectively resolving the inherent conflict between accuracy and recall in traditional pruning methods. The overall solution not only improves the system's retrieval accuracy in demanding scenarios such as high-frequency transaction verification and complex equipment troubleshooting, but also ensures operational efficiency and business robustness in large-scale, multimodal data environments through a progressively converging filtering architecture.

[0116] Example 4:

[0117] like Figure 2 As shown, this embodiment aims to elaborate in detail, from the perspective of system architecture and hardware deployment, the specific implementation of a knowledge graph cascade retrieval system based on expert system collaboration proposed in this invention. Through modular hardware and software co-design, this system effectively addresses the technical challenge of balancing retrieval performance and logical consistency in large-scale, high-frequency, dynamically updated multimodal data environments.

[0118] Specifically, the knowledge graph cascade retrieval system based on expert system collaboration involved in this embodiment can be physically deployed in high-performance computing clusters, cloud server arrays, or industrial edge computing gateways with strong computing power. In practical application scenarios (such as real-time dynamic fault root cause analysis of large industrial equipment or high-frequency financial transaction risk control), the system achieves rapid reasoning and retrieval of complex logic through interaction with underlying sensor networks, distributed databases, and multimodal feature extraction hardware.

[0119] According to a system embodiment of the present invention, the knowledge graph cascade retrieval system based on expert system collaboration specifically includes the following core functional modules:

[0120] The version control and event capture module is primarily responsible for interfacing with external data sources (such as time-series databases, transaction log systems, or multimodal streaming media gateways) to capture atomic incremental events from the multimodal knowledge graph. At the hardware level, this module typically includes a high-speed data monitoring interface and message middleware (such as Kafka or RabbitMQ) to ensure that no subtle data changes are lost in a high-concurrency environment. After the atomic incremental event is captured, the module performs multi-version concurrency control management on the event data, generating a globally unique data version number through a logical clock or a globally unique identifier generation algorithm. This mechanism ensures that the data view used for front-end retrieval is logically strictly isolated from the intermediate data generated by back-end updates, thereby greatly avoiding phantom reads caused by read-write conflicts.

[0121] The dependency graph construction and incremental compilation module is connected to the expert knowledge base storage via a high-speed bus and is used to construct fine-grained rule dependency graphs. When the version control and event capture module outputs a new incremental event, this module quickly calculates the affected expert rule abstract syntax tree branches based on the atomic incremental event using the inverted index structure in memory. Subsequently, the incremental compiler inside the module performs incremental compilation on the affected expert rule abstract syntax tree branches. Compared with full compilation, this partial compilation technique significantly reduces CPU load and memory overhead. After compilation, the system generates a set of structured query predicates bound to the data version number and temporarily stores it in a high-speed cache for the search engine to call in real time.

[0122] The performance monitoring and verification update module is integrated into the system's performance metric feedback loop. It monitors the performance metrics of the structured query predicate set in real time. These metrics include, but are not limited to, hardware-level I / O latency and computation time, as well as software-level data filtering rate and false positive rate. Based on a built-in dynamic cost model, the module uses heuristic algorithms to dynamically adjust the predicate execution order, ensuring that high-efficiency, low-overhead predicates are prioritized for scheduling. Furthermore, this module is responsible for maintaining logical consistency by incrementally verifying virtual logical edges generated by expert rule derivation and dynamically updating the validity period of these virtual logical edges. If changes to the underlying physical data cause a logical edge to fail, the module will immediately issue a revocation command to ensure the accuracy of the knowledge graph topology.

[0123] The task decomposition and plan generation module, serving as the core of the user interaction frontend, receives natural language retrieval requests. It extracts the data version number corresponding to the natural language retrieval request through a semantic parsing server (potentially involving a dedicated natural language processing acceleration chip), thereby determining the retrieval time slice. Next, the module uses a preset intent recognition algorithm to decompose the natural language retrieval request into a set of meta-tasks and maps these atomic meta-tasks to the structured query predicate set. Combining cost evaluation data provided by the performance monitoring and verification update module, this module ultimately generates the optimal query execution plan for the current version. This plan, in the form of a DAG (Directed Acyclic Graph), directs the operation of the subsequent execution engine.

[0124] The three-level cascading search engine module is the core execution unit of the system. It is usually deployed on server nodes equipped with high-performance GPUs or dedicated AI accelerators to perform three-level cascading searches.

[0125] Level 1: Based on a graph database (such as Neo4j, JanusGraph, or a customized native graph database), multimodal dynamic pruning is performed according to the optimal query execution plan. This stage utilizes graph indexing hardware acceleration technology to quickly remove nodes that do not meet hard expert constraints in large-scale subgraphs, retaining candidate graph subgraphs.

[0126] Level 2: The pre-defined Large Language Model (LLM) is invoked to perform semantic filtering on the results of Level 1. This stage leverages the powerful semantic understanding capabilities of LLM on the Transformer accelerated architecture to evaluate the deep semantic matching degree between candidate subgraphs and the user's natural language description.

[0127] Level 3: Invoke pre-defined modal analysis models (such as ResNet, Transformer-based Audio, etc.) to perform feature inference. For unstructured features such as images, audio, or complex waveforms, inference is performed in real time at the hardware level using an NPU or FPGA, ultimately generating initial search results.

[0128] The result verification and self-correction module, located in the system's output quality assurance layer, performs multi-dimensional correctness verification of the initial search results. The verification process involves cross-modal consistency checks and rule conflict detection. If verification passes, the system outputs the final search results via a graphical interface or API. If verification fails, the module generates detailed correctness verification logs and triggers hierarchical self-correction to re-execute the cascading search. The correction mechanism includes query rewriting and temporary rule generation, which guides the system to perform closed-loop optimization based on bottleneck information in the logs until a search output meeting business accuracy requirements is obtained.

[0129] In summary, the knowledge graph cascade retrieval system based on expert system collaboration described in this embodiment constructs a complete closed loop from bottom-level atomic event perception to top-level complex semantic retrieval through the collaborative work of six functional modules. Compared to traditional retrieval systems, this system utilizes a combination of incremental compilation and cascaded filtering techniques to significantly alleviate the computational bottleneck caused by the dynamic expansion of the knowledge graph while ensuring the accuracy of multimodal data retrieval. Combined with the industrial monitoring or financial assessment needs mentioned in the background, this system can significantly improve the real-time performance of business processing and the continuity of business logic, demonstrating extremely high practical application value.

[0130] Example 5:

[0131] Corresponding to the above embodiments, the present invention also proposes an electronic device.

[0132] like Figure 3The diagram shows a structural schematic of an electronic device according to the present invention. The electronic device 100 includes a processor 101 and a memory 103. The processor 101 and the memory 103 are connected, for example, via a bus 102. Optionally, the electronic device 100 may further include a transceiver 104. It should be noted that in practical applications, the transceiver 104 is not limited to one unit, and the structure of this electronic device 100 does not constitute a limitation on the embodiments of the present invention.

[0133] Processor 101 may be a CPU, a general-purpose processor, a DSP, an ASIC, an FPGA, or other programmable logic device, transistor logic device, hardware component, or any combination thereof. It may implement or execute the various exemplary logic blocks, modules, and circuits described in connection with this disclosure. Processor 101 may also be a combination that implements computational functions, such as including one or more microprocessor combinations, a combination of a DSP and a microprocessor, etc.

[0134] Bus 102 may include a pathway for transmitting information between the aforementioned components. Bus 102 may be a PCI bus or an EISA bus, etc. Bus 102 may be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 3 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0135] The memory 103 stores a computer program corresponding to the knowledge graph cascade retrieval method based on expert system collaboration according to the above embodiments of the present invention. This computer program is executed under the control of the processor 101. The processor 101 executes the computer program stored in the memory 103 to implement the content shown in the aforementioned method embodiments.

[0136] Among them, electronic devices 100 include, but are not limited to: mobile terminals such as laptops and PADs (tablet computers) and fixed terminals such as desktop computers. Figure 3 The electronic device 100 shown is merely an example and should not be construed as limiting the functionality and scope of use of the embodiments of the present invention.

[0137] Although embodiments of the present invention have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting the present invention. Those skilled in the art can make changes, modifications, substitutions and variations to the above embodiments within the scope of the present invention.

Claims

1. An expert system cooperation-based knowledge graph cascade retrieval method, characterized in that, The method includes a parallel execution of a background incremental update closed loop and a front-end real-time query closed loop, specifically comprising: Capture atomic-level incremental events of multimodal knowledge graphs, perform multi-version concurrency control and management on event data, and generate globally unique data version numbers; Construct a fine-grained rule dependency graph, calculate the affected expert rule abstract syntax tree branches based on the atomic incremental events, and perform incremental compilation on the affected expert rule abstract syntax tree branches to generate a set of structured query predicates bound to the data version number; The performance metrics of the structured query predicate set are monitored in real time, the predicate execution order is adjusted based on the dynamic cost model, and incremental verification is performed on the virtual logical edges generated by expert rules to dynamically update the validity period of the virtual logical edges. Receive a natural language retrieval request, extract the data version number corresponding to the natural language retrieval request, decompose the natural language retrieval request into a set of meta-tasks and map them to the set of structured query predicates, and generate the optimal query execution plan for the current version; Perform a three-level cascaded retrieval: the first level performs multimodal dynamic pruning based on the graph database and the optimal query execution plan; the second level calls a preset large language model to perform semantic filtering on the results of the first level; and the third level calls a preset modality analysis model to perform feature inference and generate initial retrieval results. The initial search results are verified for correctness in multiple dimensions. If the verification passes, the final search results are output. If the verification fails, a correctness verification log is generated, and a hierarchical self-correction mechanism is triggered to re-execute the cascading search.

2. The method of claim 1, wherein, The atomic-level incremental events of the captured multimodal knowledge graph are managed with multi-version concurrency control, including: The atomic-level incremental event includes an event identifier, timestamp, operation type, operation object type, operation object unique identifier, value before change, and value after change; The multi-version concurrent control management of event data is specifically as follows: a preset number of historical map snapshots are retained in the system, the front-end real-time query closed loop reads the latest stable snapshot version by default, and the back-end incremental update closed loop writes data based on the latest temporary snapshot version.

3. The method of claim 1, wherein, The construction of the fine-grained rule dependency graph, which calculates the affected expert rule abstract syntax tree branches based on the atomic incremental events, includes: Dependencies are extracted for each node in the expert rule abstract syntax tree, including entity type dependencies, attribute dependencies, relation dependencies, and modal feature dependencies; For each extracted dependency, a unique dependency fingerprint is generated, and an inverted index is constructed with the dependency fingerprint as the key and the rule branch as the value. The atomic-level incremental events are parsed to extract the target dependency fingerprint set, and the affected expert rule abstract syntax tree branch is located by matching the inverted index.

4. The method of claim 1, wherein, The incremental compilation of the affected expert rule abstract syntax tree branch to generate a set of structured query predicates bound to the data version number includes: The affected expert rule abstract syntax tree branches are recompiled, and the unaffected abstract syntax tree branches are reused to generate a new version of the predicate set. A preset proportion of front-end retrieval query traffic is bypassed and copied as test request traffic, and the test request traffic is respectively input into the old version of the predicate set before the update and the new version of the predicate set; If the consistency ratio of the results output by the two versions is higher than the set consistency threshold, the new version of the predicate set is determined as the structured query predicate set and bound to the data version number for switching and going online.

5. The method of claim 1, wherein, The real-time monitoring of the performance metrics of the structured query predicate set, and the adjustment of the predicate execution order based on the dynamic cost model, includes: The performance metrics of each structured query predicate are statistically analyzed in real time through a sliding window. These performance metrics include the number of executions, execution time, data filtering rate, and data misjudgment rate. Based on the dynamic cost model and greedy algorithm, predicate nodes with data filtering rates greater than a set filtering threshold and execution times less than a set time threshold are adjusted to the front of the initial execution sequence, while predicate nodes with data filtering rates lower than the set filtering threshold are adjusted to the end of the execution sequence. For numerical attribute predicates, a kernel density estimation algorithm is used to fit the real-time distribution probability of attribute values. The optimal judgment threshold is calculated based on the goal of maximizing the data filtering rate and incrementally updated to the structured query predicate set.

6. The method of claim 1, wherein, The incremental verification of the virtual logical edges generated by expert rule derivation to dynamically update the validity period of the virtual logical edges includes: Initialize a credibility score for each virtual logical edge in the graph database; trigger the constraint verification of the affected virtual logical edges based on the atomic incremental event; if the verification passes, increase the corresponding credibility score; if the verification fails, deduct the corresponding credibility score. When the credibility score is lower than the first level threshold, the virtual logical edge is downgraded to a semi-credible state. During retrieval, the virtual logical edge is used in conjunction with the original expert rules for derivation, and the derivation result of the original expert rules is taken as the standard. When the credibility score is lower than the second grading threshold, the virtual logical edge is downgraded to an untrustworthy state and is blocked during retrieval. The first grading threshold is greater than the second grading threshold.

7. The method of claim 1, wherein, The process of receiving a natural language retrieval request, extracting the data version number corresponding to the natural language retrieval request, decomposing the natural language retrieval request into a set of meta-tasks and mapping them to the set of structured query predicates, and generating the optimal query execution plan for the current version includes: Parse the natural language retrieval request to obtain the specified data version number, and load the expert rule set and the structured query predicate set that match the data version number; The natural language retrieval request is decomposed into a set of meta-tasks consisting of multiple atomic operations using a pre-defined semantic parsing network, and a task dependency graph representing the execution order logic is constructed. The meta-task nodes in the task dependency graph are mapped and transformed into the corresponding structured query predicates. Combined with the predicate execution order output by the current dynamic cost model, an optimal query execution plan that can be recognized by the graph computing engine is generated.

8. The method of claim 1, wherein, The execution of the three-level cascading search includes: First-level multimodal dynamic pruning: At the bottom layer of the graph database, entity attributes and edge relationships are filtered according to the optimal query execution plan, and graph subgraphs that do not meet the expert rule constraints are pruned, while candidate graph subgraphs are retained; Second-level semantic filtering: Input the candidate graph subgraph into the preset large language model, use the preset large language model to evaluate the semantic relevance between the subgraph nodes and the natural language retrieval request, and filter out nodes whose semantic relevance is lower than the matching threshold; Third-level feature deduction: For the associated multimodal features of the nodes output in the second level, the corresponding preset modal analysis model is called to perform cross-modal feature fusion and logical deduction, and the final matching initial retrieval result is output.

9. The method of claim 1, wherein, The multi-dimensional correctness verification of the initial search results includes: Rule consistency verification: Check whether the initial search results satisfy the entity attribute constraints and topological relationship constraints defined in the expert rule set; Multi-sample semantic consistency verification: Based on the initial retrieval results, candidate answer sequences are generated multiple times using the preset large language model. The semantic vector cosine similarity between each candidate answer sequence is calculated. If the expected similarity value is lower than the set similarity threshold, the verification is deemed to have failed. Version consistency verification: Verify whether the data version numbers of all graph entities and their associated virtual logical edges involved in the initial search results are completely consistent with the data version numbers specified in the natural language search request.

10. An expert system cooperation-based knowledge graph cascade retrieval system, characterized in that, include: The version control and event capture module is used to capture atomic-level incremental events of the multimodal knowledge graph, perform multi-version concurrent control and management of event data, and generate globally unique data version numbers; The dependency graph construction and incremental compilation module is used to construct a fine-grained rule dependency graph, calculate the affected expert rule abstract syntax tree branches based on the atomic incremental events, and perform incremental compilation on the affected expert rule abstract syntax tree branches to generate a set of structured query predicates bound to the data version number. The performance monitoring and verification update module is used to monitor the performance metrics of the structured query predicate set in real time, adjust the predicate execution order based on the dynamic cost model, and perform incremental verification on the virtual logical edges generated by expert rules to dynamically update the validity period of the virtual logical edges. The task decomposition and plan generation module is used to receive natural language retrieval requests, extract the data version number corresponding to the natural language retrieval requests, decompose the natural language retrieval requests into a set of meta-tasks and map them to the set of structured query predicates, and generate the optimal query execution plan for the current version. The three-level cascaded retrieval engine module is used to perform three-level cascaded retrieval: the first level performs multimodal dynamic pruning based on the graph database according to the optimal query execution plan; the second level calls the preset large language model to perform semantic filtering on the results of the first level; and the third level calls the preset modality analysis model to perform feature inference and generate initial retrieval results. The result verification and autonomous error correction module is used for multi-dimension correctness verification on the initial search result, and outputs the final search result if the verification is passed. If the verification fails, the correctness verification log is generated, and the hierarchical autonomous error correction is triggered to re-execute the cascaded search.

Images