Dynamic updating method and system of knowledge graph based on reasoning enhancement

Abstract

The invention provides a dynamic updating method and system of a knowledge graph based on reasoning enhancement. The method belongs to the cross technical field of artificial intelligence, knowledge engineering and dynamic system modeling. The method comprises the following steps: performing multi-dimensional feature extraction on original knowledge data to generate a knowledge feature vector set; constructing an initial knowledge graph structure based on the knowledge feature vector set, and defining an initial association rule between knowledge nodes to form a basic knowledge graph model; building a multi-order causal inference engine according to the basic knowledge graph model, performing deep mining on potential causal relationships among knowledge nodes, and generating a knowledge causal relationship network; and performing confidence evaluation on each causal chain in the knowledge causal relationship network to obtain the knowledge causal relationship network subjected to quality verification. Based on a multi-order causal reasoning engine, the system can mine and verify potential causal relationships among knowledge nodes in real time, and continuous updating and self-optimization of the knowledge graph are ensured.

Description

Technical Field

[0001] This invention proposes a dynamic update method and system for knowledge graphs based on reasoning enhancement, belonging to the interdisciplinary technical field of artificial intelligence, knowledge engineering, and dynamic system modeling. Background Technology

[0002] In the practical application of knowledge graph technology, with the rapid iteration of domain knowledge and the diversified needs of application scenarios, traditional knowledge graph update methods have gradually revealed obvious limitations: On the one hand, most methods rely on manual annotation or fixed rules to supplement knowledge, making it difficult to efficiently mine potential causal relationships between nodes, resulting in insufficient coverage of implicit knowledge in the graph, and it is prone to subjective bias due to human intervention; on the other hand, existing update mechanisms lack dynamic adaptation capabilities, either making simple adjustments only to local nodes or associations, ignoring the coordination of the overall graph structure, or failing to distinguish update priorities based on application scenario needs, resulting in wasted resources or key knowledge gaps remaining unfilled for a long time.

[0003] Meanwhile, traditional methods often rely on single-dimensional judgments to verify knowledge, making it difficult to quantify the reliability of causal relationships and retaining low-confidence knowledge chains, thus affecting the quality of the knowledge graph. Furthermore, the lack of closed-loop linkage between updates and real-world application scenarios prevents timely correction of deviations based on application feedback, leading to a gradual decline in the graph's adaptability to business needs. This makes it difficult to support scenarios with high requirements for knowledge accuracy and timeliness, such as medical diagnosis and intelligent recommendation. Therefore, there is an urgent need for a knowledge graph update method that can achieve deep knowledge mining, dynamic adaptation to scenario requirements, and closed-loop optimization capabilities to solve the problems of low efficiency, poor adaptability, and difficulty in guaranteeing quality associated with traditional methods. Summary of the Invention

[0004] This invention provides a method and system for dynamically updating knowledge graphs based on reasoning enhancement, in order to solve the problems mentioned in the background section above: The present invention proposes a dynamic update method for knowledge graphs based on reasoning enhancement, the method comprising: Multi-dimensional feature extraction is performed on the original knowledge data to generate a knowledge feature vector set; an initial knowledge graph structure is constructed based on the knowledge feature vector set, and initial association rules between knowledge nodes are defined to form a basic knowledge graph model; A multi-level causal reasoning engine is built based on the basic knowledge graph model to deeply mine the potential causal relationships between knowledge nodes and generate a knowledge causal relationship network. The confidence level of each causal chain in the knowledge causal relationship network is evaluated, and causal chains with confidence levels below a preset threshold are removed to obtain a quality-verified knowledge causal relationship network. Based on a quality-verified knowledge causal relationship network, an adaptive evolution strategy is designed; the concept dimensionality upgrade operation generates higher-level knowledge concept nodes by semantically abstracting and generalizing knowledge nodes; the path reconstruction operation dynamically adjusts the association paths between knowledge nodes based on new knowledge discoveries, generating an updated knowledge graph structure. Based on the metacognitive controller, and using the updated knowledge graph structure as a foundation, combined with the requirements of the current application scenario, intelligent decision analysis is performed; a dynamic update decision scheme for the knowledge graph is generated; and based on the dynamic update decision scheme, the updated knowledge graph structure is locally or globally optimized to obtain an optimized knowledge graph. The optimized knowledge graph is then deployed in a real-world application environment to verify its effectiveness and collect application feedback data. Based on this feedback data, the multi-level causal reasoning engine is triggered again, initiating a new round of knowledge discovery and verification.

[0005] The dynamic update system for knowledge graphs based on reasoning enhancement proposed in this invention includes: One or more processors; Memory, used to store one or more programs. Wherein, when the one or more programs are executed by the one or more processors, the one or more processors are made to implement the method described in any one of the above.

[0006] Beneficial effects of this invention: Based on a multi-level causal reasoning engine, the system can mine and verify potential causal relationships between knowledge nodes in real time, ensuring the continuous updating and self-optimization of the knowledge graph.

[0007] Through the Bayesian verification mechanism, the system can evaluate the confidence of causal chains, thereby eliminating causal chains with low confidence, improving the quality of the knowledge graph, and ensuring its reliability and accuracy.

[0008] The combination of conceptual dimensionality enhancement and path reconstruction enables the system to automatically adjust its graph structure when new knowledge emerges, and enhances the hierarchy of knowledge through semantic abstraction and generalization, making the graph more flexible and adaptable to change.

[0009] The updated knowledge graph can provide intelligent decision support based on actual application needs, help identify potential knowledge gaps and prioritize them, thereby providing decision-makers with more accurate and timely information support.

[0010] Through the feedback mechanism, the system can continuously trigger new reasoning and updating processes based on application feedback, forming a closed-loop feedback system that enables the knowledge graph to continuously self-verify and optimize, always maintaining its optimal state. Attached Figure Description

[0011] Figure 1 This is a diagram illustrating the steps of the method described in this invention. Detailed Implementation

[0012] The preferred embodiments of the present invention will be described below with reference to the accompanying drawings. It should be understood that the preferred embodiments described herein are for illustration and explanation only and are not intended to limit the present invention.

[0013] One embodiment of the present invention, such as Figure 1 As shown, a dynamic update method for knowledge graphs based on reasoning enhancement is described, the method comprising: S1: Extract multi-dimensional features from the original knowledge data to generate a knowledge feature vector set; construct an initial knowledge graph structure based on the knowledge feature vector set, and define the initial association rules between knowledge nodes to form a basic knowledge graph model; S2: Build a multi-level causal reasoning engine based on the basic knowledge graph model. Deeply mine the potential causal relationships between knowledge nodes through the multi-level causal reasoning engine to generate a knowledge causal relationship network. Use the uncertainty-aware Bayesian verification mechanism to evaluate the confidence of each causal chain in the knowledge causal relationship network, and remove causal chains with confidence below the preset threshold to obtain a quality-verified knowledge causal relationship network. S3: Based on the quality-verified knowledge causal relationship network, an adaptive evolution strategy including concept upgrading and path reconstruction is designed; the concept upgrading operation generates higher-level knowledge concept nodes by semantically abstracting and generalizing knowledge nodes; the path reconstruction operation dynamically adjusts the association paths between knowledge nodes based on new knowledge discovery to generate an updated knowledge graph structure. S4: Based on the metacognitive controller, and using the updated knowledge graph structure as a foundation, combined with the current application scenario requirements, intelligent decision analysis is performed. The intelligent decision analysis process includes applicability assessment of the knowledge graph, identification of potential knowledge gaps, and priority ranking of updates, generating a dynamic update decision scheme for the knowledge graph. Based on the dynamic update decision scheme for the knowledge graph, the updated knowledge graph structure is locally or globally optimized and adjusted to obtain the optimized knowledge graph. S5: Deploy the optimized knowledge graph into a real-world application environment to verify its effectiveness and collect application feedback data; based on the application feedback data, trigger the multi-level causal reasoning engine again to start a new round of knowledge discovery and verification process.

[0014] The working principle and effects of the above technical solution are as follows: By extracting multi-dimensional features and defining initial association rules, redundancy and conflicts in the original knowledge data are reduced, making the basic knowledge graph model more accurate and reliable, and improving the construction quality of the knowledge graph; by using a multi-level causal reasoning engine and Bayesian verification mechanism, the accuracy of identifying potential causal relationships is improved, the interference of low-confidence invalid causal chains on the network is reduced, and the depth of knowledge causal relationship mining is enhanced; through adaptive strategies of concept dimensionality upgrading and path reconstruction, the efficiency of integrating newly discovered knowledge is enhanced, the problem of decreased graph applicability caused by knowledge lag is reduced, and the dynamic evolution capability of the knowledge graph is improved; relying on the intelligent decision analysis of the metacognitive controller, the accuracy of knowledge gap identification and the rationality of update priority ranking are improved, the waste of resources caused by blind optimization is reduced, and the adaptability of the knowledge graph to application scenarios is enhanced; through the closed-loop update mechanism triggered by application feedback, the response speed to actual application needs is enhanced, the update delay and error caused by manual intervention are reduced, and the continuous optimization efficiency of the knowledge graph is improved.

[0015] In one embodiment of the present invention, S1 includes: S11. Obtain multi-source heterogeneous raw knowledge data, which includes structured database data (e.g., relational database tables), semi-structured document data (e.g., XML / JSON format files), and unstructured text data (e.g., academic papers, industry reports) to form a multi-source raw knowledge dataset; perform data preprocessing on the multi-source raw knowledge dataset to obtain a preprocessed raw knowledge dataset; S12. Perform multi-dimensional feature extraction on the preprocessed knowledge dataset, construct a feature system from semantic dimension (e.g., entity type, attribute semantics), structural dimension (e.g., entity association frequency) and attribute dimension (e.g., numerical attribute range, text attribute keywords), quantize the features through a deep learning model (e.g., BERT embedding model) to generate a knowledge feature vector set; S13. Based on the knowledge feature vector set, construct the initial knowledge graph structure using a graph database architecture (e.g., Neo4j), map the entities corresponding to the knowledge feature vectors to graph nodes, and map feature associations to edges between nodes to generate the initial knowledge graph topology. S14. Combining domain expert experience and knowledge graph construction specifications, define initial association rules between knowledge nodes. These initial association rules include attribute constraint rules (e.g., age attributes must be positive integers), association type rules (e.g., belonging is an entity-category exclusive association), and logical reasoning rules (e.g., if A belongs to B and B belongs to C, then A belongs to C), forming an initial association rule base. Integrate the initial knowledge graph topology with the initial association rule base, and verify the consistency between the topology and rules using rule verification tools (e.g., the inference engine Rete), correct conflicting nodes and edges, and finally form a basic knowledge graph model.

[0016] The working principle and effects of the above technical solution are as follows: By acquiring multi-source data covering structured, semi-structured, and unstructured data, the problem of knowledge omission caused by a single data source is reduced, making the knowledge foundation for subsequent graph construction more comprehensive and improving the utilization rate of original knowledge data; by filtering redundant and erroneous data through preprocessing, the interference of invalid information on feature extraction is reduced, making the preprocessed knowledge data cleaner and more usable, and reducing the impact of data impurities on graph quality; by constructing a feature system from multiple dimensions of semantics, structure, and attributes, and combining deep learning models to quantify features, the distinguishability of entities and relationships is enhanced, reducing the problem of graph node ambiguity caused by single features, and improving the accuracy of knowledge features; by relying on the graph database architecture to map entities and relationships, the chaotic relationship between nodes and edges under traditional storage methods is reduced, making the initial topology clearer and easier to expand, and enhancing the structural rationality of the initial knowledge graph; by combining expert experience and standard definition of association rules, and by using tools to verify and correct conflicts, the errors in node attributes and contradictions in association logic caused by missing rules are reduced, making the basic knowledge graph model more reliable and reducing the risk of conflict in the graph structure.

[0017] In one embodiment of the present invention, S13 includes: Read the knowledge feature vector set, classify and parse the feature vectors in the vector set, extract the entity identifier (e.g., entity ID, entity name), entity attribute features (e.g., type, numerical attribute, text attribute), and feature association identifier (e.g., associated entity ID, association strength value) corresponding to each vector, and generate an entity feature parsing list. Based on the storage specifications of graph database architecture, entity node data structure templates are designed. These templates include basic fields (node ​​ID, entity name, entity type), attribute extension fields (custom fields matching entity attribute features), and association index fields (index identifiers used to associate with other nodes), forming a node structure template library. The entity identifiers and attribute features in the entity feature parsing list are mapped according to the field requirements of the node structure template library, transforming the feature vector corresponding to each entity into node data records conforming to the template specifications (e.g., mapping "Patient ID: P001, Type: Human, Age: 55" to node data), generating an entity node dataset. Based on the edge structure design rules of graph databases, association edge data structure templates are constructed. These templates include edge identifiers (edge ​​ID), starting node ID, ending node ID, association type (e.g., "belongs to" or "treatment"), and association strength (the association strength value matching the association identifier in the feature association identifier), forming an edge structure template library. Extract feature association identifiers from the entity feature parsing list, filter out valid entity associations (e.g., entity P001 - associated entity D001 - association strength 0.9), convert the associations into edge data records according to the field requirements of the edge structure template library, and generate an associated edge dataset; start the graph database initialization tool, import the entity node dataset into the graph database node storage module, and ensure that the node data is free of missing or errors through data verification algorithms (e.g., field integrity verification), complete the creation and storage of entity nodes, and generate a node storage index table; The associated edge dataset is imported into the edge storage module of the graph database. Based on the node IDs in the node storage index table, an association mapping between the starting node and the ending node is established. Invalid associated edges are eliminated through association validity verification (e.g., checking for non-existent node IDs), thus completing the creation and storage of associated edges and generating an edge storage index table. The graph database's topology generation function is then invoked. Based on the node storage index table and the edge storage index table, the network connection relationship between entity nodes and associated edges is automatically constructed to form an initial graph framework containing topological features, including node hierarchy, association paths, and network density, generating an initial draft of the knowledge graph topology structure. The initial draft of the knowledge graph topology is checked for topological integrity. Graph structure analysis algorithms (such as connectivity analysis) are used to identify isolated nodes (nodes without any associated edges) and broken associated paths (paths where the starting and ending nodes cannot be connected). The location and type of topological defects are recorded, and a topological defect report is generated. Based on the topological defect report, associated edges are added to isolated nodes (e.g., adding an "affiliated system" associated edge to an "isolated disease node" based on domain knowledge), and the mapping relationships of nodes or edges in broken associated paths are repaired (e.g., correcting incorrect node IDs). The topology is then verified again until there are no defects, and the initial knowledge graph topology is finally generated.

[0018] The working principle and effects of the above technical solution are as follows: By classifying and extracting entity identifiers, attributes, and association information, the subsequent mapping chaos caused by information mixing in feature vectors is reduced, allowing the core information of each entity to be accurately separated, thus improving the clarity of entity feature parsing; by designing standardized node and edge structure templates, the problem of inconsistent formats when mapping different entity data is reduced, making the data imported into the graph database more standardized and easier to store, and reducing the risk of chaotic format of node and edge data; through verification steps such as field integrity verification and invalid association edge removal, storage errors caused by missing fields and incorrect node IDs are reduced, making the storage of entity nodes and association edges more reliable and improving the accuracy of data import; relying on the graph database to automatically construct network connection relationships, combined with connectivity analysis to check isolated nodes and broken paths, reduces structural loopholes that are prone to occur during manual construction, making the initial draft topology more comprehensive and enhancing the integrity of the initial graph topology structure; through defect reports to guide the repair of isolated nodes and correction of mapping relationships, the impact of unprocessed defects on the subsequent use of the graph is reduced, and the final generated initial topology structure is more stable and usable, reducing the defect rate of the topology structure.

[0019] In one embodiment of the present invention, S2 includes: S21. Based on the node types, association rules, and domain characteristics of the basic knowledge graph model, determine the core components of the multi-level causal reasoning engine. The core components include a causal rule template library (e.g., trigger condition-result template), a multi-level reasoning algorithm module (e.g., first-order logical reasoning, higher-order probabilistic reasoning), and a reasoning result storage module, and build the basic framework of the engine. Import the node attributes and associations in the basic knowledge graph model into the multi-level causal reasoning engine. Traverse the potential association paths between nodes using the path mining algorithm built into the engine (e.g., depth-first search). Combine the domain causal logic (e.g., disease-symptom causal logic) to mine hidden causal relationships and generate an initial set of knowledge causal relationship candidates. S22. The initial knowledge causal relationship candidate set is structured and organized, and each causal relationship is mapped into a chain form of cause node-causal type-result node. The chains are classified and aggregated according to the strength of causal association to generate the initial knowledge causal relationship network. S23. Construct a Bayesian verification mechanism for uncertainty perception. Take each causal chain in the initial knowledge causal relationship network as the verification object, input historical data of the domain (such as disease-symptom association statistics) as the prior probability, calculate the confidence value of each causal chain through Bayes' formula, and generate a causal chain confidence evaluation table. S24. Based on the application scenario requirements of the knowledge graph (e.g., high confidence is required in medical scenarios), set a confidence threshold (e.g., 0.8), compare the values ​​in the causal chain confidence evaluation table with the threshold, eliminate invalid causal chains with confidence below the threshold, and retain valid causal chains with high confidence. S25. Perform consistency verification on the retained high-confidence causal chains, check for logical conflicts between chains (such as causal loop conflicts), correct the association type or node attributes of conflicting chains, and finally obtain a knowledge causal relationship network that has been verified by quality.

[0020] The working principle and effects of the above technical solution are as follows: Core components are determined by combining the node types and domain characteristics of the basic knowledge graph, reducing inference bias caused by the mismatch between the general engine and specific domains, making the engine framework more aligned with actual needs, and improving the adaptability of the causal inference engine; By traversing associated paths through path mining algorithms and combining them with domain causal logic, hidden relationships missed by manual mining are reduced, making the initial causal relationship candidate set more comprehensive and enhancing the ability to mine potential causal relationships; The candidate set is organized into standardized chains and aggregated according to strength, reducing the interference of disordered causal relationships on the network structure, making the initial network clearer and easier to analyze, and reducing the clutter of the causal relationship network; Confidence is calculated by relying on the Bayesian verification mechanism combined with historical domain data, reducing the retention of unfounded causal relationships, providing clear data support for subsequent screening, and improving the reliability of the causal chain; Low-confidence chains are eliminated through threshold screening, and logical conflicts are checked through consistency verification, reducing the impact of invalid and conflicting chains on network quality, resulting in a more accurate and usable verified network, and reducing the logical risk of the causal network.

[0021] In one embodiment of the present invention, step S22 includes: S221. Read the initial knowledge causal relationship candidate set, perform element analysis on each causal relationship in the candidate set, extract the cause entity identifier, causal association description, result entity identifier and association feature parameters (such as association frequency, time sequence parameters), and generate a list of causal relationship elements. S222. Construct a standardized causal chain structure template of cause node - causal type - result node, wherein the causal type field is associated with a preset causal type dictionary (e.g., cause, trigger, inhibit, etc.), and the data format and constraint rules of each field are determined to form a causal chain template specification; according to the causal chain template specification, each record in the causal relationship element list is structurally transformed, the cause entity identifier is mapped to the cause node ID, the causal association description is matched to the standard causal type, and the result entity identifier is mapped to the result node ID, generating a standardized causal chain set; S223. Extract the association feature parameters of each chain from the standardized causal chain set, convert the parameters into causal association strength values ​​in the range of 0-1 through feature quantization algorithm, and supplement them into the attribute fields of the corresponding causal chain to form a causal chain dataset with strength attributes. S224. Set a threshold for classifying the strength of causal association (e.g., strong association ≥ 0.7, medium association 0.3-0.7, weak association < 0.3), classify the causal chain dataset with strength attribute according to the threshold, group causal chains of the same strength level into the same set, and generate a strength classification causal chain group. S225. Perform an aggregation operation on each intensity classification causal chain group, merge duplicate or highly similar causal chains using a chain structure matching algorithm (e.g., node pair matching), retain the chain with the highest correlation strength as the representative, and at the same time count the number of chains and the range of covered nodes in each group to generate an aggregated causal chain group. S226. Based on the aggregated causal chain group, construct the topology of the initial knowledge causal relationship network, taking the cause nodes and result nodes as network nodes, the causal chain as the directed edge between nodes, and the correlation strength as the weight attribute of the edge. Assemble the network using a graph structure generation tool to finally generate the initial knowledge causal relationship network.

[0022] The working principle and effects of the above technical solution are as follows: By parsing the candidate set to extract cause, result identifiers, and related parameters, the subsequent processing chaos caused by mixed elements is reduced, allowing the core information of each causal relationship to be clearly separated, thus improving the clarity of causal relationship elements; by constructing a standardized structural template and matching it with standardized causal types, the integration difficulty caused by inconsistencies in the expression of different causal relationships is reduced, making the causal chain set more regular and easier to analyze, and reducing the problem of inconsistent causal chain formats; by using a quantization algorithm to convert parameters into 0-1 range values, the strength judgment bias caused by different units and magnitudes of the original parameters is reduced, making the chain stronger. The differences in strength are more intuitive, enhancing the comparability of causal relationship strength; grouping and classifying by strength threshold reduces the interference of mixed strong and weak chains on network analysis, making subsequent aggregation operations more targeted and improving the rationality of causal chain classification; merging duplicate or similar chains through structural matching and retaining high-strength representative chains reduces the occupation of redundant data in network storage and usage, making the causal chain group more concise and reducing the redundancy of causal chains; constructing a weighted topology based on the chain group reduces the disordered association of network nodes and edges, resulting in a clearer and easier-to-verify network, enhancing the structure of the initial causal relationship network.

[0023] In one embodiment of the present invention, S225 includes: Read the causal chain group data of each strength category, and extract the complete information of the causal chain contained in each group (node ​​ID, causal type, association strength, etc.) in turn according to the strength level (strong association, medium association, weak association) to generate a list of chain groups to be aggregated; For a single chain group in the list of chain groups to be aggregated, structural features are extracted for each causal chain. The cause node ID, result node ID, and causal type combination are extracted as core matching features to generate a chain structure feature vector set. A chain structure matching algorithm is used to compare the chain structure feature vector set. A matching threshold is set (e.g., if the node pair is completely consistent with the causal type, it is a repeating chain; if the similarity is ≥0.9, it is a highly similar chain). Repeating or highly similar causal chain clusters are identified, and similar chain groups are generated. Traverse each similar chain group, extract the correlation strength value of all causal chains in the group, determine the chain with the highest strength as the representative chain of the group through the maximum value screening algorithm, remove the other chains, and generate a candidate set of representative chains; Perform data statistics on the processed individual chain groups, calculate the total number of chains in the original chain group, the number of chains merged, and the total number of cause nodes and result nodes covered by the remaining representative chains, and generate chain group aggregation statistics; The candidate set of representative chains is associated with and stored with the aggregated statistics of the chain groups. All processed chain group data are integrated according to the strength level to form a structured set containing representative chains and aggregated statistics, and finally the aggregated causal chain group is generated.

[0024] The working principle and effects of the above technical solution are as follows: The chain groups to be processed are split into strong, medium, and weak correlation levels, reducing aggregation bias caused by mixed processing of chains of different strengths, making the processing of each chain group more focused, and improving the targeting of chain group aggregation; Node IDs and causal type combinations are extracted as core features, reducing misjudgments caused by single feature matching, making the identification of duplicate or similar chains more accurate, and enhancing the accuracy of causal chain matching; Similar chain clusters are filtered by matching thresholds, and high-strength representative chains are retained, reducing the data storage occupation of duplicate chains, making the final chain group more streamlined and efficient, and reducing the redundancy rate of causal chains; The number of original chain groups, the number of merged chains, and the node coverage are statistically analyzed, reducing the problem of not being able to trace back the processing details after aggregation, allowing subsequent analysis to clearly identify the data source, and improving the traceability of the aggregation process; Representative chains and aggregation statistics are stored together and integrated according to strength, reducing the inconvenience caused by data dispersion, and the final generated chain group is easier for subsequent network construction, enhancing the structure of the chain group data.

[0025] In one embodiment of the present invention, S3 includes: S31. Perform structural feature analysis on the quality-verified knowledge causal relationship network, calculate relevant indicators using graph structure analysis tools (e.g., NetworkX), including node density, average path length, and association strength distribution, identify hierarchical missing nodes (e.g., no high-level classification nodes) and redundant association paths in the network, and generate a network structure feature report; based on the network structure feature report, design an adaptive evolution strategy framework that includes concept dimensionality upgrade and path reconstruction, clarify the triggering conditions for concept dimensionality upgrade (e.g., the number of nodes exceeds a threshold) and the execution rules for path reconstruction (e.g., the proportion of redundant paths exceeds a threshold), and determine the core parameters of the evolution strategy; S32. For the basic nodes in the knowledge causal relationship network, a semantic abstraction algorithm (such as Word2Vec semantic clustering) is used to classify the node attributes, extract the common semantic features of nodes of the same type (for example, the common feature of pneumonia and influenza is respiratory disease), and generate a semantic abstraction result set; based on the semantic abstraction result set, a concept dimensionality upgrade operation is performed to map the common semantic features to higher-level knowledge concept nodes (such as respiratory disease nodes), establish the subordinate relationship between basic nodes and high-level concept nodes, and generate a high-level knowledge concept node set; S33. Combining newly discovered knowledge from the multi-level causal reasoning engine (e.g., the causal relationship between new symptoms and diseases), the path analysis algorithm identifies redundant paths (e.g., repeated association paths) and missing paths (e.g., the missing path between disease and treatment plan) in the existing knowledge causal relationship network, and generates a path optimization requirement table. S34. Based on the path optimization requirement table, perform path reconstruction operation, delete redundant related paths to simplify the network structure, add related paths corresponding to newly discovered knowledge to improve the network, adjust the related weights in the paths (e.g., strengthen the weights of high-confidence paths), and generate the reconstructed set of related paths. S35. Integrate the high-level knowledge concept node set and the reconstructed associated path set into the initial knowledge causal relationship network, update the node attribute table and the association relationship table, and ensure the network connectivity and logic through the topology structure verification tool, and finally generate the updated knowledge graph structure.

[0026] The working principle and effects of the above technical solution are as follows: By calculating indicators such as node density and path length, missing and redundant paths in the hierarchy are identified, reducing structural problems missed by manual analysis, making subsequent evolution strategy design more targeted, and improving the accuracy of knowledge network structure analysis; an adaptive framework including concept dimensionality upgrading and path reconstruction is designed, clarifying triggering conditions and execution rules, reducing the blindness of the evolution process, making the strategy more in line with the actual needs of the network, and enhancing the evolutionary adaptability of the knowledge graph; by extracting common features through semantic abstraction to generate high-level concept nodes and establishing subordinate relationships, the difficulty of understanding caused by the disordered accumulation of basic nodes is reduced, making the graph hierarchy clearer and reducing the problem of hierarchical confusion of knowledge nodes; by combining newly discovered knowledge to identify and supplement missing paths, delete redundant paths, and adjust association weights, the interference of incomplete or redundant paths on network use is reduced, making the paths more practical and improving the completeness and simplicity of knowledge paths; after integrating new nodes and paths, topological verification is used to ensure connectivity and logic, reducing node isolation and logical conflicts that occur during the integration process, and the finally generated updated graph is more reliable, reducing the structural risk of the updated graph.

[0027] In one embodiment of the present invention, S35 includes: Read the original node attribute table and association table of the initial knowledge causal relationship network, extract the node ID encoding rules, attribute field format and association type definition of the existing network, and generate the original network structure specification document; The high-level knowledge concept node set is format adapted, and a unique ID is assigned to the new node according to the encoding rules in the original network structure specification document. Attribute fields are added, including the level identifier and the domain to which the attribute fields belong, and the adapted high-level node dataset is generated. The adapted high-level node dataset is imported into the original node attribute table. New node information is supplemented by field matching algorithms (such as attribute name mapping). At the same time, the uniqueness of the IDs of the new nodes and existing nodes is verified, and duplicate ID nodes are removed to generate an updated node attribute table. The reconstructed set of associated paths is validated to confirm that the association type of each path (e.g., subordinate, cause) conforms to the association relationship type definition of the original network. Mismatched types are standardized and transformed to generate an adapted set of associated paths. The adapted associated path dataset is integrated into the original association table, new path records are added, redundant path records are deleted, and the path association weight field is updated. Data integrity verification is performed to ensure that the start / end node ID of each path exists in the updated node attribute table, and the updated association table is generated. Call a topology verification tool (such as NetworkX's connectivity analysis function), take the updated node attribute table and relationship table as input, check whether there are logical problems in the network, such as isolated nodes and circular relationships, and generate a topology verification report; Based on the topology verification report, correct the problematic nodes and paths (e.g., add subordinate association paths to isolated nodes, delete circular association paths), perform topology verification again until there are no anomalies, and finally integrate the updated node and association data to generate the updated knowledge graph structure.

[0028] The working principle and effects of the above technical solution are as follows: By extracting the encoding rules and field formats of the original network to generate a standard document, and adapting the high-level node IDs and attributes according to the standard, the integration failure of new nodes due to inconsistent formats is reduced, and the compatibility of new nodes with the original network is improved; when importing new nodes, the uniqueness of the ID is verified and duplicate nodes are removed, which reduces the chaos of graph data caused by ID duplication, makes the updated node attribute table more accurate, and reduces the risk of node ID conflict; the association type of the reconstructed path is verified and mismatched types are standardized and converted, which reduces the damage of illegal paths to network logic, makes the adapted path more in line with the original network rules, and enhances the compliance of the association path; when integrating new paths and deleting redundant paths, the existence of node IDs is verified, which reduces the retention of invalid paths (such as paths pointing to non-existent nodes), makes the updated relationship table more reliable, and improves the integrity of the association relationship table; through topology verification, isolated nodes are identified, circular associations are identified and repaired in a targeted manner, which reduces hidden structural problems that are difficult to detect manually, and the finally generated updated graph is more stable and usable, reducing the structural defect rate of the updated graph.

[0029] In one embodiment of the present invention, step S4 includes: S41. Collect the application scenario requirement parameters of the current knowledge graph. The scenario requirement parameters include business accuracy requirements (e.g., 99.9% data accuracy is required for financial scenarios), real-time response speed (e.g., a recommendation system needs to respond within 100ms), and knowledge coverage (e.g., the education scenario needs to cover all K12 subjects), forming a scenario requirement parameter table; start the metacognitive controller, import the updated knowledge graph structure and scenario requirement parameter table into the controller, and the controller establishes the correspondence between graph structure features (e.g., number of nodes, response time) and scenario requirements through parameter matching algorithms (e.g., cosine similarity matching), generating a parameter matching report; S42. Design a knowledge graph applicability evaluation index system, which includes functional matching degree (the degree of fit between the graph capabilities and scenario requirements), performance compliance rate (the proportion of indicators such as response speed and accuracy that meet the standards), and resource utilization rate (the proportion of storage and computing resources used). Set the weight coefficient for each indicator (e.g., functional matching degree weight 0.4). Based on the index system, quantitatively evaluate the updated knowledge graph, calculate the scores of each indicator through the evaluation model built into the controller, and obtain the overall applicability score by weighted summation, generating a knowledge graph applicability evaluation report. S43. Construct a knowledge gap identification algorithm. Based on the scenario requirement parameter table, compare the differences between the node coverage, relationship type and requirements in the knowledge graph, mark the uncovered knowledge domains (e.g., the lack of blockchain knowledge nodes in the financial scenario) and the relationships to be supplemented, and generate a knowledge gap list. S44. Establish an update priority ranking model, using the impact of knowledge gaps (e.g., the probability of business failure caused by the gap), urgency (e.g., business launch time), and implementation difficulty (e.g., data acquisition difficulty) as input variables. Calculate the priority score of each update task using the Analytic Hierarchy Process (AHP) to generate an update priority ranking table. S45. Integrate the knowledge graph applicability assessment report, knowledge gap list, and update priority ranking table to formulate a dynamic update decision scheme for the knowledge graph, which includes optimization goals (e.g., improving the applicability score to 0.9), optimization scope (e.g., adding blockchain nodes), optimization steps, and time limits; based on the optimization scope in the dynamic update decision scheme, determine the optimization type (local optimization such as single node attribute update, global optimization such as overall hierarchy adjustment), determine the execution object and scope of impact of the optimization operation, and generate an optimization execution plan; S46. According to the optimization execution plan, perform targeted optimization operations on the updated knowledge graph structure. Local optimization is achieved by editing node attributes and adjusting relationships, while global optimization is achieved by hierarchical reconstruction and node re-clustering. Record optimization process data in real time. Perform functional and performance testing on the optimized knowledge graph to verify whether the optimized graph meets the scenario requirements parameters, correct problems found in the test (such as relationship conflicts caused by optimization), and finally obtain the optimized knowledge graph.

[0030] The working principle and effects of the above technical solution are as follows: By collecting requirement parameters such as business accuracy and response speed and establishing matching relationships, the problem of the disconnect between knowledge graph functions and scenario requirements is reduced, making the adaptation analysis more aligned with actual business and improving the matching accuracy between knowledge graphs and application scenarios; by designing multi-dimensional evaluation indicators and setting weight coefficients, quantitative scoring replaces subjective judgment, reducing the bias of evaluation results, making the applicability analysis more credible, and enhancing the objectivity of knowledge graph evaluation; by using algorithms to compare the coverage of the knowledge graph with scenario requirements, the uncovered areas and relationships to be supplemented are accurately marked, reducing the omissions of manual review and making the gap list more comprehensive. It is more comprehensive, reducing the omission rate of knowledge gaps; by prioritizing according to the degree of impact and urgency, it reduces the waste of resources caused by blind updates, allowing limited resources to be invested in key gaps and improving the execution efficiency of update tasks; by distinguishing between local and global optimization types according to decision-making schemes, it clarifies the execution objects and scope, reduces the arbitrariness of the optimization process, makes adjustments more focused on the goal, and enhances the pertinence of optimization operations; by verifying and correcting issues such as correlation conflicts through functional performance testing, it reduces new risks brought about by optimization, and the final graph is more in line with the actual needs of the scenario, reducing the residual problems of the optimized graph.

[0031] In one embodiment of the present invention, S44 includes: Read the knowledge gap list, extract the update task corresponding to each knowledge gap (such as supplementing blockchain knowledge nodes, adding digital currency-transaction relationship), clarify the task identifier, gap description and related scenario requirements, and generate an update task list; The design updates the quantitative standards for task evaluation dimensions, setting scoring rules of 1-5 points for impact (e.g., ≥80% probability of business failure is high impact, 40%-80% is medium impact, <40% is low impact), urgency (e.g., completion before business launch is high urgency, completion within 1 month is medium urgency, completion after 1 month is low urgency), and implementation difficulty (e.g., easy-to-obtain data and development cycle <1 week is low difficulty, data needs to be customized and cycle 1-4 weeks is medium difficulty, data is scarce and cycle >4 weeks is high difficulty), and generating a quantitative scoring table; Each update task is independently scored based on its impact, urgency, and implementation difficulty according to a quantitative scoring table. The average score for each dimension is calculated as the final score for that dimension, generating a task dimension score table. An update priority judgment matrix is ​​constructed based on the analytic hierarchy process (AHP), with impact, urgency, and implementation difficulty as the criteria layers. The weights of each criterion are determined through comparison using an expert database system (e.g., impact weight 0.5, urgency weight 0.3, implementation difficulty weight 0.2), generating a criterion weight vector. Substitute the task dimension score table and criterion weight vector into the priority calculation model, and calculate the priority score of each updated task using the weighted summation formula (priority score = impact score × 0.5 + urgency score × 0.3 + implementation difficulty score × 0.2), generating a task priority score list; Update tasks are sorted from highest to lowest priority score. Tasks with the same score are sorted a second time according to their urgency. The dimensional score and weight of each task are also labeled to form a structured update priority sorting table.

[0032] The working principle and effects of the above technical solution are as follows: It clearly extracts task identifiers, descriptions, and related requirements from the knowledge gap list, reducing subsequent processing confusion caused by ambiguous task information and ensuring precise positioning of each update task, thus improving the clarity of task organization; it designs a quantitative scoring standard of 1-5 points, clearly classifying dimensions such as impact and urgency, reducing the arbitrariness of scoring based on experience, making the evaluation results more objective, and reducing subjective bias in the evaluation dimensions; it determines the weight of each dimension through comparison using an expert database system, avoiding weight imbalance under a single perspective, making priority calculation more aligned with actual business needs, and enhancing the rationality of the criterion weights; it uses a weighted summation formula combined with dimension scores and weight vector calculations, reducing priority misjudgments caused by simple sorting, ensuring scores truly reflect task importance, and improving the accuracy of priority scoring; it sorts by score from highest to lowest and, in the case of a tie, sorts again by urgency, while simultaneously annotating the basis for scores and weights, reducing disputes over sorting results, and the final generated sorting table is easier to execute, reducing the chaos of task sorting.

[0033] In one embodiment of the present invention, step S5 includes: S51. Build a practical application verification environment for the knowledge graph. The practical application verification environment includes simulated application scenarios (e.g., simulated medical diagnosis scenarios) and real business scenarios (e.g., accessing a real recommendation system). Configure the hardware resources (e.g., server computing power) and software dependencies (e.g., API interfaces, data transmission protocols) of the environment to ensure that the environment is consistent with the actual application. Deploy the optimized knowledge graph to the verification environment through the interface, establish a data interaction channel between the graph and the application system, configure data read permissions and update permissions, and ensure that the application system can call the graph data normally. S52. Run typical application tasks (such as disease diagnosis reasoning tasks in medical scenarios and product recommendation tasks in e-commerce scenarios) in the verification environment, perform operations according to the preset task flow (such as inputting symptoms → calling the atlas → outputting diagnosis results), and record key data during the task execution process; start the feedback data collection module to collect application task performance data (such as task response time and data call success rate) and user feedback data (such as doctors' satisfaction with diagnosis results and users' ratings of recommendation results) in real time, classify and store the data according to timestamps, and generate an application feedback dataset; S53. Preprocess the application feedback dataset to generate a standardized application feedback dataset; set feedback data trigger thresholds according to the knowledge graph update requirements, the trigger thresholds include performance thresholds (e.g., response time threshold of 500ms) and satisfaction thresholds (e.g., user satisfaction threshold of 0.7), determine the rules for triggering updates if the thresholds are not met, and generate a trigger condition configuration table. S54. Compare the standardized application feedback dataset with the trigger condition configuration table, verify whether each indicator meets the threshold requirements, count the number and severity of non-compliant indicators, and generate a feedback threshold comparison report. If the feedback threshold comparison report shows that the number of non-compliant indicators exceeds the preset ratio (e.g., 30%) or there are seriously non-compliant indicators (e.g., response time exceeds the threshold by 2 times), it is determined that the update trigger condition is met, and the standardized application feedback dataset is sent as input data to the trigger interface of the multi-level causal inference engine. After receiving the trigger signal and input data, the S55 multi-level causal reasoning engine restarts the knowledge node potential causal relationship mining process. It adjusts the mining strategy based on the problem points in the feedback data (such as poor recommendation results corresponding to insufficient causal relationship between products and users), generates a new round of knowledge causal relationship candidate set, and starts a new round of knowledge discovery and verification process.

[0034] The working principle and effects of the above technical solution are as follows: Simultaneously building simulated and real business scenarios and matching actual hardware and software configurations reduces the effect deviation caused by the disconnect between the verification environment and actual application, making the graph test results more reliable and improving the authenticity of the verification environment; collecting both performance data such as task response time and subjective feedback such as user satisfaction reduces the one-sidedness of evaluation caused by a single data dimension, making the feedback dataset more reflective of the actual performance of the graph and enhancing the comprehensiveness of the feedback data; setting performance and satisfaction thresholds and clarifying triggering rules reduces the arbitrariness of judging whether to update based on experience, providing clear data basis for triggering decisions and reducing the blindness of update triggering; comparing feedback data with thresholds and statistically analyzing the number and severity of non-compliant indicators reduces the omission of problems caused by vague judgments, making the reasons for triggering updates clearer and improving the accuracy of problem localization; the engine adjusts the mining strategy based on the problem points in the feedback (such as poor recommendations corresponding to insufficient causal relationships), reducing the inefficiency caused by aimless mining and enhancing the targeting of the new round of knowledge discovery.

[0035] One embodiment of the present invention provides a dynamic update system for knowledge graphs based on reasoning enhancement, comprising: One or more processors; Memory, used to store one or more programs. Wherein, when the one or more programs are executed by the one or more processors, the one or more processors are made to implement the method described in any one of the above.

[0036] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A dynamic update method for knowledge graphs based on reasoning enhancement, characterized in that, The method includes: S1: Extract multi-dimensional features from the original knowledge data to generate a knowledge feature vector set; construct an initial knowledge graph structure based on the knowledge feature vector set, and define the initial association rules between knowledge nodes to form a basic knowledge graph model; S2: Build a multi-level causal reasoning engine based on the basic knowledge graph model, deeply mine the potential causal relationships between knowledge nodes, and generate a knowledge causal relationship network; evaluate the confidence of each causal chain in the knowledge causal relationship network, remove causal chains with confidence below the preset threshold, and obtain a quality-verified knowledge causal relationship network. S3: Based on the quality-verified knowledge causal relationship network, an adaptive evolution strategy is designed; the concept dimensionality upgrade operation generates higher-level knowledge concept nodes by semantically abstracting and generalizing knowledge nodes; the path reconstruction operation dynamically adjusts the association paths between knowledge nodes based on new knowledge discoveries to generate an updated knowledge graph structure. S4: Based on the metacognitive controller, and using the updated knowledge graph structure as a foundation, combined with the current application scenario requirements, intelligent decision analysis is performed; a dynamic update decision scheme for the knowledge graph is generated; and based on the dynamic update decision scheme for the knowledge graph, the updated knowledge graph structure is locally or globally optimized and adjusted to obtain an optimized knowledge graph. S5: Deploy the optimized knowledge graph into a real-world application environment to verify its effectiveness and collect application feedback data; based on the application feedback data, trigger the multi-level causal reasoning engine again to start a new round of knowledge discovery and verification process.

2. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 1, characterized in that, S1 includes: S11. Obtain multi-source heterogeneous raw knowledge data to form a multi-source raw knowledge dataset; perform data preprocessing on the multi-source raw knowledge dataset to obtain a preprocessed raw knowledge dataset. S12. Extract multi-dimensional features from the preprocessed knowledge dataset, construct a feature system, quantify the features through a deep learning model, and generate a knowledge feature vector set. S13. Based on the knowledge feature vector set, construct an initial knowledge graph structure, map the entities corresponding to the knowledge feature vectors to graph nodes, and map feature associations to edges between nodes to generate the initial knowledge graph topology. S14. Define the initial association rules between knowledge nodes to form an initial association rule base; integrate the initial knowledge graph topology with the initial association rule base to finally form a basic knowledge graph model.

3. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 2, characterized in that, S13 includes: Read the knowledge feature vector set, classify and parse the feature vectors in the vector set, extract the entity identifier, entity attribute features and feature association identifiers corresponding to each vector, and generate an entity feature parsing list. Based on the storage specifications of graph database architecture, entity node data structure templates are designed to form a node structure template library; entity identifiers and attribute features are mapped according to the field requirements of the node structure template library to generate entity node datasets; based on the edge structure design rules of graph database, associated edge data structure templates are constructed to form an edge structure template library. Extract feature association identifiers from the entity feature parsing list, filter out valid inter-entity associations, and convert the associations into edge data records according to the field requirements of the edge structure template library to generate an associated edge dataset; start the graph database initialization tool, import the entity node dataset into the node storage module of the graph database, and generate a node storage index table; Import the associated edge dataset into the edge storage module of the graph database. Based on the node ID in the node storage index table, establish the association mapping between the start node and the end node and generate the edge storage index table. Call the topology generation function of the graph database. Based on the node storage index table and the edge storage index table, automatically construct the network connection relationship between entity nodes and associated edges to form an initial graph framework and generate an initial draft of the knowledge graph topology structure. The initial draft of the knowledge graph topology is checked for topological integrity, and a topological defect report is generated. Based on the topological defect report, isolated nodes are supplemented with associated edges, and the mapping relationships of nodes or edges in broken associated paths are repaired. The topology is then checked again until there are no defects, and the initial knowledge graph topology is finally generated.

4. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 1, characterized in that, The S2 includes: S21. Build the basic framework of the engine; import the node attributes and relationships in the basic knowledge graph model into the multi-level causal reasoning engine, traverse the potential relationship paths between nodes through the path mining algorithm built into the engine, and mine the hidden causal relationships by combining the domain causal logic to generate an initial knowledge causal relationship candidate set. S22. The initial knowledge causal relationship candidate set is structured and organized, each causal relationship is mapped into a chain, and the chains are classified and aggregated according to the strength of causal association to generate the initial knowledge causal relationship network. S23. Construct a Bayesian verification mechanism for uncertainty perception, taking each causal chain in the initial knowledge causal relationship network as the verification object, inputting historical data of the domain as prior probability, calculating the confidence value of each causal chain through Bayes' formula, and generating a causal chain confidence evaluation table. S24. Set a confidence threshold according to the application scenario requirements of the knowledge graph, compare the values ​​in the causal chain confidence evaluation table with the threshold, remove invalid causal chains with confidence below the threshold, and retain valid causal chains with high confidence. S25. Perform consistency verification on the retained high-confidence causal chains to finally obtain a quality-verified knowledge causal relationship network.

5. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 4, characterized in that, S22 includes: S221. Read the initial knowledge causal relationship candidate set, perform element analysis on each causal relationship in the candidate set, extract the cause entity identifier, causal association description, result entity identifier and association feature parameters, and generate a list of causal relationship elements. S222. Construct a standardized causal chain structure template to form a causal chain template specification; based on the causal chain template specification, perform a structured transformation on each record in the causal relationship element list to generate a standardized causal chain set; S223. Extract the association feature parameters of each chain from the standardized causal chain set to form a causal chain dataset with strength attributes; S224. Set a threshold for classifying the strength of causal associations. Classify the causal chain dataset with strength attributes according to the threshold. Group causal chains of the same strength level into the same set to generate a strength-classified causal chain group. S225. Perform an aggregation operation on each intensity-classified causal chain group to generate an aggregated causal chain group. S226. Based on the aggregated causal chain group, construct the topology of the initial knowledge causal relationship network, taking the cause nodes and result nodes as network nodes, the causal chain as the directed edge between nodes, and the correlation strength as the weight attribute of the edge. Assemble the network using a graph structure generation tool to finally generate the initial knowledge causal relationship network.

6. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 5, characterized in that, S225 includes: Read the causal chain group data of each intensity category, extract the complete information of the causal chain contained in each group in order of intensity level, and generate a list of chain groups to be aggregated; For a single chain group in the list of chain groups to be aggregated, structural features are extracted for each causal chain. The cause node ID, result node ID, and causal type combination are extracted as core matching features to generate a chain structure feature vector set. A chain structure matching algorithm is used to compare the chain structure feature vector set, a matching threshold is set, and causal chain clusters that are repetitive or highly similar are identified to generate similar chain groups. Traverse each similar chain group, extract the correlation strength value of all causal chains in the group, determine the chain with the highest strength as the representative chain of the group through the maximum value screening algorithm, remove the other chains, and generate a candidate set of representative chains; Perform data statistics on the processed individual chain groups, calculate the total number of chains in the original chain group, the number of chains merged, and the total number of cause nodes and result nodes covered by the remaining representative chains, and generate chain group aggregate statistics; The candidate set of representative chains is associated with and stored with the aggregated statistics of the chain groups. All processed chain group data are integrated according to the strength level to form a structured set containing representative chains and aggregated statistics, and finally the aggregated causal chain group is generated.

7. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 1, characterized in that, The S3 includes: S31. Perform structural feature analysis on the quality-verified knowledge causal relationship network and generate a network structure feature report; S32. For the basic nodes in the knowledge causal relationship network, a semantic abstraction algorithm is used to classify the node attributes, extract the common semantic features of nodes of the same type, and generate a semantic abstraction result set; based on the semantic abstraction result set, a concept dimensionality upgrade operation is performed to map the common semantic features to higher-level knowledge concept nodes, establish the subordinate relationship between basic nodes and high-level concept nodes, and generate a high-level knowledge concept node set. S33. Combining the newly discovered knowledge from the multi-level causal reasoning engine, the path analysis algorithm is used to identify redundant and missing paths in the existing knowledge causal relationship network and generate a path optimization requirement table. S34. Based on the path optimization requirement table, perform path reconstruction operation, delete redundant related paths to simplify the network structure, add related paths corresponding to newly discovered knowledge to improve the network, adjust the related weights in the paths, and generate the reconstructed related path set. S35. Integrate the high-level knowledge concept node set and the reconstructed associated path set into the initial knowledge causal relationship network, update the node attribute table and the association relationship table, and ensure the network connectivity and logic through the topology structure verification tool, and finally generate the updated knowledge graph structure.

8. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 1, characterized in that, The S4 includes: S41. Collect the application scenario requirement parameters of the current knowledge graph and form a scenario requirement parameter table; start the metacognitive controller, import the updated knowledge graph structure and scenario requirement parameter table into the controller, and the controller establishes the correspondence between the graph structure features and scenario requirements through the parameter matching algorithm and generates a parameter matching report. S42. Design a knowledge graph applicability evaluation index system and set the weight coefficients of each index; perform quantitative evaluation on the updated knowledge graph based on the index system, calculate the scores of each index through the evaluation model built into the controller, and obtain the overall applicability score by weighted summation, and generate a graph applicability evaluation report. S43. Construct a knowledge gap identification algorithm. Based on the scenario requirement parameter table, compare the differences between the node coverage, relationship type and requirements in the knowledge graph, mark the uncovered knowledge domains and the relationships to be supplemented, and generate a knowledge gap list. S44. Establish an update priority ranking model, using the impact, urgency, and difficulty of implementation of the knowledge gap as input variables, calculate the priority score of each update task through the analytic hierarchy process, and generate an update priority ranking table. S45. Integrate the knowledge graph applicability assessment report, knowledge gap list, and update priority ranking table to formulate a dynamic update decision plan for the knowledge graph; based on the optimization scope in the dynamic update decision plan, determine the optimization type, identify the execution object and scope of impact of the optimization operation, and generate an optimization execution plan; S46. According to the optimization execution plan, perform targeted optimization operations on the updated knowledge graph structure, conduct functional and performance tests on the optimized knowledge graph, verify whether the optimized graph meets the scenario requirements parameters, correct the problems found in the test, and finally obtain the optimized knowledge graph.

9. The dynamic update method for knowledge graphs based on reasoning enhancement according to claim 1, characterized in that, The S5 includes: S51. Build a practical application verification environment for the knowledge graph, deploy the optimized knowledge graph to the verification environment through the interface, establish a data interaction channel between the graph and the application system, and configure data read permissions and update permissions. S52. Run typical application tasks in the verification environment, perform operations according to the preset task flow, and record key data during task execution; start the feedback data collection module to collect application task performance data and user feedback data in real time, classify and store the data according to timestamps, and generate an application feedback dataset. S53. Preprocess the application feedback dataset to generate a standardized application feedback dataset; set the feedback data trigger threshold according to the knowledge graph update requirements, determine the rules for triggering updates if the threshold is not met, and generate a trigger condition configuration table. S54. Compare the standardized application feedback dataset with the trigger condition configuration table and generate a feedback threshold comparison report. After receiving the trigger signal and input data, the S55 multi-level causal reasoning engine restarts the process of mining potential causal relationships of knowledge nodes. It adjusts the mining strategy based on the problem points in the feedback data, generates a new set of candidate knowledge causal relationships, and starts a new round of knowledge discovery and verification process.

10. A dynamic update system for knowledge graphs based on reasoning enhancement, including: One or more processors; Memory, used to store one or more programs. Wherein, when the one or more programs are executed by the one or more processors, the one or more processors implement the method of any one of claims 1 to 9.

Images