An ontology, graph database and large language model-based triple fusion knowledge processing system and method
By constructing a ternary fusion knowledge processing system based on ontology, graph database and large language model, the problems of low accuracy and poor interpretability in spacecraft fault location are solved. A highly reliable, interpretable and knowledge-evolvable spacecraft fault location system is realized, which is suitable for rapid adaptation to multiple scenarios.
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- TIANAN STAR CONTROL (BEIJING) TECH CO LTD
- Filing Date
- 2026-03-23
- Publication Date
- 2026-06-19
AI Technical Summary
In spacecraft fault location scenarios, the solution of simply applying large language models has low accuracy and lacks interpretability. Pure expert systems have difficulty in acquiring knowledge and have long response cycles. Existing technologies are difficult to achieve deep integration of symbolic reasoning and neural networks, and cannot meet the requirements of high reliability, interpretability and knowledge evolution.
We adopt a ternary fusion knowledge processing system based on ontology, graph database and large language model. By constructing formal concept model, knowledge graph and hybrid reasoning engine, we realize the parallel fusion of rule reasoning, graph algorithm mining and large language model reasoning, and generate interpretable reports to support dynamic knowledge evolution.
It improved the accuracy and interpretability of fault location, shortened the fault report writing time, enhanced the adaptability and interactivity of the knowledge base, and enabled automatic knowledge updates and rapid system adaptation.
Smart Images
Figure CN122242682A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of artificial intelligence technology, and in particular relates to a ternary fusion knowledge processing system and method based on ontology, graph database and large language model. Background Technology
[0002] With the rapid development of artificial intelligence technology, Large Language Models (LLMs) based on large-scale neural networks have made breakthroughs in natural language understanding and content generation. Research shows that in spacecraft fault location scenarios, the accuracy of a solution using LLMs alone is approximately 85%, but its reasoning process lacks interpretability, suffers from "illusion" phenomena, and has high knowledge update costs. On the other hand, knowledge representation systems based on symbolic logic (such as OWL ontology and rule-based reasoning) have a rigorous logical foundation and traceable reasoning paths, but knowledge acquisition is difficult, and they struggle to handle unstructured data. Neither approach, when used alone, can meet the requirements of "trustworthiness, interpretability, and evolvability" for intelligent systems in high-reliability domains.
[0003] Currently, some technologies have attempted to combine neural networks with symbolic systems, but most remain at a superficial level of integration, failing to fully leverage the synergistic advantages of both. For example, some solutions only use LLM to assist knowledge extraction, still relying on traditional expert system reasoning; others use symbolic rules as constraints for neural network training, but the reasoning process remains a black box. There is a lack of a universal knowledge processing architecture that can achieve deep integration of symbolic reasoning and neural networks, explainable and traceable reasoning paths, and dynamically evolving knowledge.
[0004] In summary, in existing technologies, the accuracy of solutions using large language models alone in spacecraft fault location scenarios is approximately 85%, and they cannot provide traceable reasoning. While pure expert systems offer traceability, knowledge acquisition requires manual modeling, resulting in response cycles of several weeks when facing new faults. This invention aims to solve the three core problems of interpretability, accuracy, and knowledge updating simultaneously through a three-element fusion architecture. Summary of the Invention
[0005] To address the aforementioned technical problems, this invention proposes a ternary fusion knowledge processing system and method based on ontology, graph database, and large language model, thereby resolving the issues present in the prior art.
[0006] To achieve the above objectives, this invention provides a ternary fusion knowledge processing system based on ontology, graph database, and large language model, comprising: The ontology building module is used to construct formal conceptual models of domain knowledge. The knowledge graph construction module is used to extract instance data from multi-source heterogeneous data and store the instance data in a graph database based on the formal conceptual model to form a knowledge graph instance. The large language model interaction module is used to receive natural language queries, parse the natural language queries to identify user intent, and generate a query intent vector. The hybrid reasoning engine includes a rule-based reasoning submodule, a graph algorithm mining submodule, a large language model reasoning submodule, and a result fusion submodule. Based on the query intent vector, the hybrid reasoning engine concurrently invokes the rule-based reasoning submodule to perform reasoning based on the formal concept model, the graph algorithm mining submodule to perform reasoning based on the knowledge graph instance, and the large language model reasoning submodule to perform reasoning. The reasoning results from each submodule are then fused through the result fusion submodule to output a comprehensive reasoning conclusion. An interpretable report generation module is used to generate an interpretable report based on the comprehensive reasoning conclusion and the basis in the reasoning process.
[0007] Optionally, the formal conceptual model constructed by the ontology construction module includes classes, attributes, individuals, and the logical relationships between them, and supports the definition of SWRL rules; the knowledge graph construction module accesses multi-source heterogeneous data, maps the data fields of the data to ontology classes and attributes through a semantic mapper based on the formal conceptual model, calls the entity linking tool to extract entities from unstructured text and link them to ontology instances, and writes the semantically processed instance data into the graph database in the form of triples.
[0008] Optionally, the large language model interaction module extracts entities, relationships, and query conditions from the natural language query through prompting engineering, and converts the extracted structured information into a query intent vector in JSON format.
[0009] Optionally, the hybrid inference engine further includes a query decomposer, which parses the query intent vector, identifies constraints requiring logical reasoning and related queries requiring graph traversal, and assigns them to the rule-based inference submodule and the graph algorithm mining submodule, respectively.
[0010] Optionally, the rule reasoning submodule loads the SWRL rules defined in the formal conceptual model, constructs a reasoning model in memory based on the query conditions, executes descriptive logical reasoning to trigger the rule chain to generate logical conclusions, and records the rule ID triggered at each step as the basis for reasoning.
[0011] Optionally, the graph algorithm mining submodule performs graph traversal queries or calls the graph algorithm library based on the knowledge graph instance, sorts and filters the results, and outputs implicit association results.
[0012] Optionally, the large language model reasoning submodule assembles the query intent information and context information into prompt words, calls the large language model to generate intermediate conclusions in natural language form, and outputs the intermediate conclusions after fact-checking.
[0013] Optionally, the result fusion submodule constructs a confidence propagation graph after unifying the format of the reasoning results of each submodule, calculates the comprehensive confidence of each conclusion using DS evidence theory, triggers a conflict resolution mechanism when a conflict is detected, backtracks to check the consistency of the rule base or calls a large language model for interpretive analysis to reconfigure the confidence, and outputs a comprehensive reasoning conclusion with a fusion path.
[0014] Optionally, it also includes a dynamic evolution module, which includes an event detector, an evolution rule learner, a proposal generator, and an ontology version manager. The event detector subscribes to real-time event streams and parses event data. The evolution rule learner analyzes the matching degree between event features and existing patterns of the ontology based on a meta-learning framework. When the frequency of similar events exceeds a threshold, the proposal generator is triggered to output an evolution proposal containing changes and impact analysis. After confirmation, the ontology version manager updates the formal conceptual model and triggers instance migration.
[0015] This invention also provides a ternary fusion knowledge processing method based on ontology, graph database, and large language model, according to the above system, including: Construct a formal conceptual model of domain knowledge; Instance data is extracted from multi-source heterogeneous data, and the instance data is stored in a graph database based on the formal conceptual model to form a knowledge graph instance; Receive natural language queries, parse the natural language queries to identify user intent, and generate a query intent vector; Based on the query intent vector, rule reasoning based on the formal concept model, graph algorithm mining based on the knowledge graph instance, and large language model reasoning are executed in parallel. The results of each reasoning are then fused to output a comprehensive reasoning conclusion. An interpretable report is generated based on the comprehensive reasoning conclusions and the evidence used in the reasoning process.
[0016] Compared with the prior art, the present invention has the following advantages and technical effects: 1. High interpretability: The rule-based reasoning submodule records the rule chain triggered at each step, and combined with the interpretable report generation module, presents the reasoning path in natural language, making the system's decision-making process completely transparent and traceable. In aerospace engine fault diagnosis applications, compared to a pure LLM solution (which cannot provide evidence), this system reduces the fault zeroing report writing time from 4 hours to 10 minutes and increases the audit pass rate to 100%.
[0017] 2. High Accuracy: The system employs a three-pronged parallel reasoning approach—rule-based reasoning, graph algorithm mining, and large language model reasoning—with conflict resolution using DS evidence theory via a result fusion submodule, significantly reducing the risk of illusions associated with single models. In a fault diagnosis test of a certain engine model, the system achieved a higher accuracy rate in identifying 120 historical fault cases compared to pure LLM schemes and pure rule-based systems.
[0018] 3. Knowledge Evolvability: Through the meta-learning framework of the dynamic evolution module, the system can automatically detect knowledge update needs from new event data. During the 6-month trial operation, the system automatically generated 27 evolution proposals, of which 21 were confirmed as valid updates by experts. Eight new fault modes were added, and 15 rules were modified, ensuring that the knowledge base evolves in sync with the model development.
[0019] 4. Wide applicability: This invention adopts a modular and loosely coupled system architecture. Each core component (OWL ontology construction module, knowledge graph construction module, large language model interaction module, hybrid inference engine, etc.) can be deployed independently and flexibly combined, supporting rapid adaptation to multiple scenarios from spacecraft to industrial equipment, and from on-orbit operation to ground testing.
[0020] 5. User-friendly interface: Through the natural language interface of the large language model interaction module, engineers can query complex relationships without learning Cypher or SPARQL. User testing shows that the onboarding time for new engineers has been reduced from 2 weeks to 2 hours, and the query construction success rate has increased from 65% to 92%. Attached Figure Description
[0021] The accompanying drawings, which form part of this application, are used to provide a further understanding of this application. The illustrative embodiments and descriptions of this application are used to explain this application and do not constitute an undue limitation of this application. In the drawings: Figure 1 This is an overall architecture diagram of the ternary fusion knowledge processing system according to an embodiment of the present invention; Figure 2 This is a flowchart illustrating the workflow of the hybrid inference engine in an embodiment of the present invention. Figure 3 This is a schematic diagram of the structure of the dynamic evolution module in an embodiment of the present invention; Figure 4 This is an application example diagram of a space engine fault diagnosis scenario according to an embodiment of the present invention. Detailed Implementation
[0022] It should be noted that, unless otherwise specified, the embodiments and features described in this application can be combined with each other. This application will now be described in detail with reference to the accompanying drawings and embodiments.
[0023] It should be noted that the steps shown in the flowchart in the accompanying drawings can be executed in a computer system such as a set of computer-executable instructions, and although a logical order is shown in the flowchart, in some cases the steps shown or described may be executed in a different order than that shown here.
[0024] Example 1 like Figure 1 As shown, this embodiment provides a ternary fusion knowledge processing system based on ontology, graph database, and large language model, employing a six-layer architecture design, including: Layer 1: Data Access Layer, responsible for real-time data access from multiple heterogeneous data sources (relational databases, Kafka message queues, file systems). This layer includes preprocessing functions such as data cleaning, format conversion, and anomaly detection.
[0025] Layer 2: Knowledge Representation Layer, containing OWL ontology building modules, defines the domain concept model and SWRL rules through a graphical interface (such as Protégé). This layer outputs formal ontology files, serving as the knowledge skeleton of the entire system.
[0026] Layer 3: Knowledge storage layer, which includes a knowledge graph construction module. It performs semantic mapping on the data accessed from Layer 1 based on the ontology of Layer 2 and stores it in a graph database (such as Neo4j) to form a knowledge graph instance.
[0027] Layer 4: Intelligent Reasoning Layer, containing a hybrid reasoning engine, consisting of a rule-based reasoning submodule, a graph algorithm mining submodule, a large language model reasoning submodule, and a result fusion submodule. This layer receives user queries, performs multi-path parallel reasoning, and outputs a comprehensive conclusion.
[0028] Layer 5: Application Interaction Layer, which includes a large language model interaction module and an interpretable report generation module, providing a natural language question answering interface and interpretable report display.
[0029] Layer 6: Dynamic Evolution Layer, which includes a dynamic evolution module that monitors the event flow in real time, automatically detects knowledge update needs, and updates the ontology and knowledge graph after expert confirmation.
[0030] The following is a detailed description of the modules included in each layer of this system: 1. The OWL ontology construction module is used to construct a formal conceptual model of domain knowledge. The OWL ontology includes classes, attributes, individuals and their logical relationships, and supports the definition of SWRL rules to describe causal logic and constraints within the domain.
[0031] 1) Objects to be processed: domain expert knowledge, design specification documents, and standard terminology database.
[0032] 2) Processing steps: Step 1: Define domain concept classes, properties, and relationships using a graphical modeling tool such as Protégé.
[0033] Step 2: Write SWRL (Semantic Web Rule Language) rules to describe causal logic, such as "excessive vibration ∧ decreased rotational speed → bearing wear".
[0034] Step 3: Serialize the constructed ontology into an RDF / XML format file and store it in the ontology library.
[0035] 3) Technical means: Description Logic is used as the theoretical basis, and OWL DL sub-language is used to ensure the decidability of reasoning.
[0036] 4) Processing result: A formalized OWL ontology file containing class hierarchy, attribute definitions, individual instances, and logical rules.
[0037] 2. Knowledge graph construction module, connected to the OWL ontology construction module, is used to extract instance data from multi-source heterogeneous data, perform semantic mapping based on the OWL ontology, store the instance data in the graph database, and form a knowledge graph instance that matches the OWL ontology.
[0038] 1) Processing objects: structured data (database CSV), semi-structured data (XML), unstructured text (PDF report).
[0039] 2) Processing steps: Step 1: Access multi-source data through ETL tools (such as Apache NiFi).
[0040] Step 2: Based on the OWL ontology, use a semantic mapper to map data fields to ontology classes and properties.
[0041] Step 3: Use an entity linking tool (such as DBpedia Spotlight) to extract entities from the text and link them to the ontology instance.
[0042] Step 4: Write the semantically encoded instance data into a graph database (such as Neo4j) via a batch import interface.
[0043] 3) Technical means: Use an RDF converter to convert the data into triples and use Cypher query language to perform graph database operations.
[0044] 4) Data flow: Receive ontology files as schema definitions and output knowledge graph instances.
[0045] 5) Processing result: A knowledge graph containing entity nodes and relation edges, supporting subsequent queries and reasoning.
[0046] 3. The large language model interaction module is used to receive natural language queries, understand user intent, and transform the query intent into formal query statements or reasoning tasks.
[0047] 1) Target of processing: User's natural language query string.
[0048] 2) Processing steps: Step 1: Receive user input and perform text preprocessing (word segmentation, stop word removal).
[0049] Step 2: Call an LLM (such as ChatGLM-6B) to perform intent recognition, and extract entities, relationships and query conditions through prompts.
[0050] Step 3: Convert the extracted structured information into a query intent vector in JSON format.
[0051] 3) Technical means: LoRA fine-tuning technology is used for domain adaptation, and chain-of-thought prompts are used to guide LLM to generate structured output.
[0052] 4) Processing result: Query intent vector, used by the query decomposer.
[0053] 4. Hybrid inference engine; 4.1 Query Decomposer; 1) Target of processing: Query intent vector.
[0054] 2) Processing steps: Step 1: Parse the intent vector and identify the constraints that require logical reasoning (such as "if...then...").
[0055] Step 2: Identify the related queries that require graph traversal (such as "find cases similar to X").
[0056] Step 3: Assign the two types of subtasks to the rule reasoning submodule and the graph algorithm mining submodule, respectively.
[0057] 3) Technical means: rule-based condition judgment combined with predefined query templates.
[0058] 4) Processing results: List of decomposed subtasks and their dependencies.
[0059] 4.2 The rule-based reasoning submodule performs deterministic reasoning based on the description logic of the OWL ontology and SWRL rules to generate logical conclusions: 1) Processing objects: Instance data in OWL ontology, SWRL rule base, and knowledge graph.
[0060] 2) Processing steps: Step 1: Load the OWL ontology and SWRL rules into the inference engine (e.g., Pellet).
[0061] Step 2: Build an inference model in memory based on the query conditions.
[0062] Step 3: Execute the descriptive logical reasoning, trigger the rule chain, and generate intermediate conclusions.
[0063] Step 4: Record the rule ID and reasoning basis triggered at each step.
[0064] 3) Technical means: The Tableau algorithm is used to implement the description logic reasoning, and the Rete algorithm is used to efficiently match rules.
[0065] 4) Processing results: A list of logical conclusions, each with a confidence level (rule certainty) and reasoning path.
[0066] 4.3 The graph algorithm mining submodule, based on the knowledge graph in the graph database, performs graph algorithms such as community detection, path analysis, and similarity retrieval to mine implicit associations: 1) Target of processing: Knowledge graph instances in graph databases.
[0067] 2) Processing steps: Step 1: Receive the query conditions and convert them into Cypher query statements.
[0068] Step 2: Perform graph traversal queries (such as finding adjacent nodes and multi-hop paths).
[0069] Step 3: Call a graph algorithm library (such as Neo4j GDS) to perform similarity calculation (Node2Vec), community detection (Louvain), or shortest path analysis.
[0070] Step 4: Sort and filter the results, and output the associated results.
[0071] 3) Technical means: The Node2Vec algorithm is used to map nodes to vectors and calculate cosine similarity; the Dijkstra algorithm is used to calculate the shortest path.
[0072] 4) Processing results: A list of associated results, with each result accompanied by similarity or path length.
[0073] 4.4 The Large Language Model Inference Submodule calls the large language model to perform inference on fuzzy semantics and open-domain problems, generating intermediate conclusions or explanations in natural language form: 1) Target objects: fuzzy semantic problems and open-domain problems that require common-sense reasoning.
[0074] 2) Processing steps: Step 1: Assemble the query and context (such as rule-based reasoning results and graph algorithm results) into prompt words.
[0075] Step 2: Call LLM to generate intermediate conclusions or explanations in natural language form.
[0076] Step 3: Perform fact-checking on the generated results to filter out any possible illusions.
[0077] 3) Technical means: Few-shot prompts are used to provide examples, and temperature parameters are used to control the randomness of generation.
[0078] 4) Processing results: Natural language conclusions and confidence levels (self-assessed by LLM).
[0079] 4.5 The results fusion submodule performs confidence assessment and fusion on the inference results of the above three submodules. When conflicts exist, a conflict resolution mechanism is triggered, and finally, a comprehensive inference conclusion is output, along with the complete inference path: 1) Processing object: a list of inference results from the three sub-modules.
[0080] 2) Processing steps: Step 1: Standardize the format of each result and extract the conclusion text and confidence level.
[0081] Step 2: Construct a confidence propagation graph, where nodes represent conclusions and edges represent inference dependencies.
[0082] Step 3: Calculate the overall confidence level of each conclusion using the DS evidence theory. The formula is: m(C) = (Σ m1(A)m2(B)) / (1-K), where K is the conflict factor.
[0083] Step 4: Conflict detection: If two conclusions have high confidence but contradict each other semantically (e.g., "bearing wear" vs. "rotor imbalance"), trigger the conflict resolution process.
[0084] Step 5: Conflict resolution: Backtrack to check the consistency of the rule base, or call LLM for interpretive analysis and reconfigure the confidence.
[0085] 3) Technical means: Dempster-Shafer evidence theory and conflict detection algorithm (based on semantic similarity and logical contradiction).
[0086] 4) Processing results: Comprehensive reasoning conclusions and final confidence levels, with a complete fusion path attached.
[0087] 5. The interpretable report generation module records the basis for each step in the reasoning process, including the triggered rules, graph algorithm calculation results, LLM thought chain, and generates an interpretable report with natural language description.
[0088] 1) Processing objects: rule reasoning path, graph algorithm calculation results, LLM thinking chain, and fusion process records.
[0089] 2) Processing steps: Step 1: Structure the above information and store it in JSON-LD format.
[0090] Step 2: Generate a natural language report based on a predefined template, including: (1) Conclusion statement; (2) Reasoning basis (triggering rules, similar cases, LLM explanation); (3) Confidence assessment; (4) Detailed path that can be expanded.
[0091] 3) Step 3: Output in PDF or HTML format, supporting interactive expansion.
[0092] 4) Technical means: template engine (such as Jinja2), natural language generation technology.
[0093] 5) Processing results: An interpretable report is available, and users can click to expand any reasoning step.
[0094] 6. Dynamic Evolution Module: This module manages the version of the OWL ontology. It automatically detects whether the ontology or instance needs to be updated based on newly added event data, generates an ontology evolution proposal, and updates the knowledge graph after expert confirmation, thereby realizing the dynamic evolution of system knowledge.
[0095] 1) Processing objects: real-time event streams (such as new fault reports and test run data).
[0096] 2) Processing steps: Step 1: The event detector subscribes to event topics through a Kafka consumer and parses the event JSON data.
[0097] Step 2: The evolutionary rule learner (based on the MAML meta-learning framework) analyzes the events to determine whether the ontology needs to be updated.
[0098] Step 2.1: Match the event features with the existing patterns of the ontology.
[0099] Step 2.2: Count the frequency of similar events. If the frequency exceeds the threshold, trigger an evolution proposal.
[0100] Step 3: The proposal generator outputs a structured proposal, which includes the changes and impact analysis.
[0101] Step 4: The expert confirmation interface visualizes the proposal for expert review (confirmation / modification / rejection).
[0102] Step 5: After confirmation, the ontology version manager creates a new version and triggers the instance migration engine.
[0103] 3) Technical means: MAML meta-learning, semantic version control, incremental update algorithm.
[0104] 4) Processing result: A dynamically updated knowledge graph that supports version backtracking.
[0105] The workflow of a hybrid inference engine is as follows: Figure 2 As shown, when a query is received: The large language model interaction module parses user natural language queries, identifies entities and relationships, and generates query intent vectors; The query decomposer breaks down queries into logical reasoning subtasks and relational query subtasks based on the intent vector; The rule reasoning submodule loads the OWL ontology and SWRL rules, performs descriptive logical reasoning, and outputs logical conclusions and confidence levels. The graph algorithm mining submodule performs Cypher queries to retrieve similar cases, analyze paths, and output association results and confidence scores. The large language model reasoning submodule performs reasoning on subtasks that require semantic understanding and outputs natural language conclusions and confidence scores. The results fusion submodule calculates the overall confidence level of each conclusion based on evidence theory. If the conflict exceeds the threshold, conflict resolution is triggered (such as backtracking to check rule consistency or re-invoking the LLM interpretation). The interpretable report generation module records the reasoning path and outputs the final answer, including the supporting evidence.
[0106] like Figure 3 As shown, the dynamic evolution module includes: Ontology Version Manager: Uses a Git-like mechanism to store every change to the OWL ontology, and supports backtracking by timestamp.
[0107] Event detector: Connects to real-time data streams via Kafka to detect new events (such as new fault cases and test data).
[0108] Evolutionary rule learner: Trained from historical evolutionary cases using a meta-learning framework (such as MAML), it learns when and how to update the ontology.
[0109] Expert confirmation interface: The evolution proposal is presented to domain experts in a visual form, and experts can confirm it with one click or confirm it after modification.
[0110] Automatic Updater: Upon confirmation, automatically updates the OWL ontology and triggers a corresponding update to the knowledge graph.
[0111] This document comprehensively demonstrates the collaborative working process of each module in a fault diagnosis scenario during the test of a certain type of liquid rocket engine. Figure 4 As shown, it specifically includes: 4.1 Data access; 1) Real-time access to test bench sensor data (sampling rate 100Hz), including turbine pump vibration, speed, combustion chamber pressure, etc.
[0112] 2) Simultaneously access historical fault reset reports (unstructured text).
[0113] 4.2 Knowledge Representation and Storage; 1) Pre-build the engine fault diagnosis OWL ontology (v1.0), which includes component classes, sensor classes, fault mode classes and SWRL rules.
[0114] 2) The historical data is converted into a graph database instance through the knowledge graph construction module, forming a knowledge graph containing 50 fault cases.
[0115] 4.3 Reasoning process; 1) During a test run, the reading of the turbine pump vibration sensor suddenly increased to 16.2 mm / s (threshold 15 mm / s).
[0116] 2) The large language model interaction module receives abnormal signals and generates a query intent through prompts: "Analyze the cause of abnormal vibration".
[0117] The hybrid inference engine launches three-way inference in parallel: 3) Rule reasoning: Trigger the SWRL rule "Vibration exceeds standard ∧ speed decrease → bearing wear", output "bearing wear", confidence level 0.95.
[0118] 4) Graph Algorithm: Node2Vec similarity search was performed, and 3 similar cases (F012, F035, F078) were found. The support score for “bearing wear” was 0.92.
[0119] 5) LLM inference: Analyze the vibration spectrum and combine it with the rule results to output "high probability of bearing wear", with a confidence level of 0.88.
[0120] 6) The results fusion submodule uses DS evidence theory to calculate a comprehensive confidence level of 0.96 and outputs the conclusion "bearing wear".
[0121] 4.4 Interpretable report generation; The report concludes with "bearing wear" and then proceeds with the following reasoning: 1) Rule R12 triggers the record; 2) Details of similar case F012 (similarity 0.92); 3) LLM analysis summary: "The vibration is mainly at the first harmonic, which is consistent with the bearing wear characteristics."
[0122] 4.5 Dynamic Evolution; 1) After this diagnosis is completed, the new case will be automatically stored in the knowledge graph.
[0123] 2) When the event detector accumulates the 5th bearing wear case, the evolution rule learner determines that the ontology needs to be updated.
[0124] 3) Generation Evolution Proposal P002: It is recommended to treat "bearing wear" as an independent fault class and add 3 detailed rules.
[0125] 4) After expert confirmation, the ontology version was upgraded to v1.5, and the relevant instances were automatically migrated.
[0126] 4.6 Comparison with existing technologies; 1) Compared with pure LLM solution: pure LLM cannot provide reasoning basis, while this system can trace the complete rule chain; in 120 test cases, the accuracy of this system is 92.3% vs pure LLM 84.7%.
[0127] 2) Compared with pure expert systems: Pure expert systems require all rules to be written manually, and the response cycle to new faults is long (several weeks); this system automatically discovers new fault modes through dynamic evolution, and the response cycle is shortened to several days.
[0128] 3) Compared with traditional machine learning: Traditional methods require a large amount of labeled data, while this system integrates rule-based reasoning, which improves the accuracy by more than 30% in small sample scenarios.
[0129] This embodiment also provides a ternary fusion knowledge processing method based on ontology, graph database, and large language model based on the above system, characterized by including: Construct a formal conceptual model of domain knowledge; Instance data is extracted from multi-source heterogeneous data, and the instance data is stored in a graph database based on the formal conceptual model to form a knowledge graph instance; Receive natural language queries, parse the natural language queries to identify user intent, and generate a query intent vector; Based on the query intent vector, rule reasoning based on the formal concept model, graph algorithm mining based on the knowledge graph instance, and large language model reasoning are executed in parallel. The results of each reasoning are then fused to output a comprehensive reasoning conclusion. An interpretable report is generated based on the comprehensive reasoning conclusions and the evidence used in the reasoning process.
[0130] The above are merely preferred embodiments of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.
Claims
1. A triple fusion knowledge processing system based on ontology, graph database and large language model, characterized in that, include: The ontology building module is used to construct formal conceptual models of domain knowledge. The knowledge graph construction module is used to extract instance data from multi-source heterogeneous data and store the instance data in a graph database based on the formal conceptual model to form a knowledge graph instance. The large language model interaction module is used to receive natural language queries, parse the natural language queries to identify user intent, and generate a query intent vector. The hybrid reasoning engine includes a rule-based reasoning submodule, a graph algorithm mining submodule, a large language model reasoning submodule, and a result fusion submodule. Based on the query intent vector, the hybrid reasoning engine concurrently invokes the rule-based reasoning submodule to perform reasoning based on the formal concept model, the graph algorithm mining submodule to perform reasoning based on the knowledge graph instance, and the large language model reasoning submodule to perform reasoning. The reasoning results from each submodule are then fused through the result fusion submodule to output a comprehensive reasoning conclusion. An interpretable report generation module is used to generate an interpretable report based on the comprehensive reasoning conclusion and the basis in the reasoning process.
2. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, The formal conceptual model constructed by the ontology construction module includes classes, attributes, individuals, and the logical relationships between them, and supports the definition of SWRL rules. The knowledge graph construction module accesses multi-source heterogeneous data, maps the data fields of the data to ontology classes and attributes through a semantic mapper based on the formal conceptual model, calls the entity linking tool to extract entities from unstructured text and link them to ontology instances, and writes the semantically processed instance data into the graph database in the form of triples.
3. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, The large language model interaction module extracts entities, relationships, and query conditions from the natural language query through prompting engineering, and converts the extracted structured information into a query intent vector in JSON format.
4. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, The hybrid reasoning engine also includes a query decomposer, which parses the query intent vector, identifies constraints requiring logical reasoning and related queries requiring graph traversal, and assigns them to the rule reasoning submodule and the graph algorithm mining submodule, respectively.
5. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, The rule reasoning submodule loads the SWRL rules defined in the formal conceptual model, constructs a reasoning model in memory based on the query conditions, executes descriptive logical reasoning to trigger the rule chain to generate logical conclusions, and records the rule ID triggered at each step as the basis for reasoning.
6. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, The graph algorithm mining submodule performs graph traversal queries or calls the graph algorithm library based on the knowledge graph instance, sorts and filters the results, and outputs implicit association results.
7. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, The large language model reasoning submodule assembles the query intent information and context information into prompt words, calls the large language model to generate intermediate conclusions in natural language form, and outputs the intermediate conclusions after fact-checking.
8. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, The result fusion submodule unifies the format of the reasoning results from each submodule and constructs a confidence propagation graph. It uses DS evidence theory to calculate the comprehensive confidence of each conclusion. When a conflict is detected, a conflict resolution mechanism is triggered. It backtracks to check the consistency of the rule base or calls a large language model for interpretive analysis to reconfigure the confidence. Finally, it outputs a comprehensive reasoning conclusion with a fusion path.
9. The ternary fusion knowledge processing system based on ontology, graph database, and large language model according to claim 1, characterized in that, It also includes a dynamic evolution module, which comprises an event detector, an evolution rule learner, a proposal generator, and an ontology version manager. The event detector subscribes to real-time event streams and parses event data. The evolution rule learner analyzes the matching degree between event features and existing patterns of the ontology based on a meta-learning framework. When the frequency of similar events exceeds a threshold, the proposal generator is triggered to output an evolution proposal containing changes and impact analysis. After confirmation, the ontology version manager updates the formal conceptual model and triggers instance migration.
10. A triple fusion knowledge processing method based on the ontology, graph database and large language model based on the system of any one of claims 1-9, characterized in that, include: Construct a formal conceptual model of domain knowledge; Instance data is extracted from multi-source heterogeneous data, and the instance data is stored in a graph database based on the formal conceptual model to form a knowledge graph instance; Receive natural language queries, parse the natural language queries to identify user intent, and generate a query intent vector; Based on the query intent vector, rule reasoning based on the formal concept model, graph algorithm mining based on the knowledge graph instance, and large language model reasoning are executed in parallel. The results of each reasoning are then fused to output a comprehensive reasoning conclusion. An interpretable report is generated based on the comprehensive reasoning conclusions and the evidence used in the reasoning process.