Knowledge graph construction and fusion method used in technical field of engines

Abstract

The invention discloses a knowledge graph construction and fusion method used in the technical field of engines, and aims to solve the problems of multi-source isomerism and semantic conflict of data in the field. According to the method, an automatic process is constructed: data is purified, verified and de-duplicated through an intelligent cleaning module; and then a large language model zero sample prompt mechanism is adopted, and entities and relationships are accurately extracted through structured prompt words containing engine field predefined ontologies. The core innovation of the invention lies in a set of vocabulary, semantic and structure three-layer knowledge fusion mechanism: the vocabulary layer uses special pattern matching to quickly process repeated entities; the semantic layer merges synonymous concepts by means of a large model; and the structural layer verifies and merges by analyzing a neighbor relation mode, and integrates a relation fusion system to eliminate a redundant relation and structural contradiction. According to the method, the engine field knowledge graph with a complete structure and clear semantics can be constructed, and the technical query and intelligent analysis capability is effectively improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of artificial intelligence, knowledge engineering and natural language processing, in particular to a knowledge graph construction and fusion method for the field of engine technology, which is suitable for application scenarios such as multi-source heterogeneous data integration, semantic knowledge extraction, graph fusion, and is particularly suitable for intelligent knowledge management and auxiliary decision-making systems in professional fields such as engine technology, automotive power systems, and energy equipment. BACKGROUND

[0002] As an important research direction in the field of artificial intelligence, knowledge graph has been widely applied in intelligent question answering, search recommendation, and intelligent decision-making tasks. Traditional knowledge graph construction methods mainly rely on relational databases, rule templates, and small-scale machine learning models. These methods perform well when dealing with structured or semi-structured data. However, in highly specialized fields such as engine technology, automotive power systems, and energy equipment, knowledge is widely distributed in massive multi-source heterogeneous documents. Traditional methods face the following challenges:

[0003] 1. Strong data heterogeneity: Engine-related professional knowledge is scattered in various carriers such as enterprise websites, standard documents, patent descriptions, and technical specifications. The structure, language style, and format of these data sources are different. Existing knowledge management systems cannot effectively handle this heterogeneity, leading to fragmented knowledge and serious lag in information updates.

[0004] 2. Serious semantic conflicts and redundancies: The same technical concept, entity, or relationship often has naming differences (such as synonyms, abbreviations), structural redundancies, or semantic deviations in different data sources. For example, an engine model may have different codes in different documents. Traditional methods based on string matching or fixed rules cannot accurately identify and complete high-quality entity and relationship fusion, resulting in poor consistency and accuracy of the graph.

[0005] 3. Weak context awareness: In professional technical documents, information describing complex relationships between entities often does not appear in a single sentence, but is distributed across multiple sentences or even paragraphs. Existing methods generally lack deep understanding and comprehensive judgment capabilities for long text context, and cannot effectively associate these scattered information, resulting in a large number of isolated nodes in the knowledge graph that cannot be effectively connected, seriously affecting the integrity and usability of the graph.

[0006] Therefore, there is an urgent need for a new intelligent knowledge graph construction method for the field of engine technology. This method should be able to automatically integrate multi-source heterogeneous data, deeply understand complex technical semantics, and have good scalability and graph reasoning capabilities, thereby providing a solid foundation for more efficient knowledge retrieval, competitive intelligence analysis, and decision support in the field. SUMMARY

[0007] To solve the problems of difficult unified extraction and serious semantic conflict of multi-source heterogeneous knowledge data mentioned in the background art, the application provides a knowledge graph construction and fusion method for the field of engine technology. The method is an automatic process including a data preprocessing and cleaning module, a knowledge extraction module based on the ontology of the engine field, a graph database construction module, and a three-level knowledge fusion module optimized for the engine field, aiming to build a professional knowledge graph system with high precision, high coverage and logical consistency.

[0008] The technical solution provided by the application has the following specific steps:

[0009] 1. Multi-source data acquisition and intelligent cleaning

[0010] This step is realized by a data preprocessing and cleaning module, aiming to process the original data (such as product manuals and technical specification documents) automatically crawled from global engine manufacturers and research institutions websites, and provide high-quality and formatted text data for subsequent knowledge extraction. The specific implementation of this module includes:

[0011] Content purification: First, remove Unicode replacement characters and other non-printing control characters in the text through encoding detection. Then, use a series of preset regular expressions to remove continuous special character combinations, suspected garbled patterns, and standardize white space characters such as line breaks and tabs to unify the format.

[0012] Content verification and filtering: Verify the effectiveness of the purified text by setting three core parameters: minimum content length, maximum content length, and minimum effective text ratio, to filter out invalid content that is too short, too long, or has too low effective character ratio.

[0013] Record deduplication: For each valid text record, generate a unique hash value of its content using an encryption hash algorithm such as MD5, and perform accurate deduplication based on the hash value to ensure that the text records input to the subsequent knowledge extraction module are unique.

[0014] 2. Knowledge extraction based on structured prompts

[0015] This step is realized by a knowledge extraction module driven by a large language model, which automatically extracts entities and relationships from the cleaned text. The core innovation of this module is to build a specific prompt for the engine technology field:

[0016] Constructing structured prompts based on engine domain ontology: The invention designs a complex zero-shot prompt word containing multiple parts. The prompt word embeds a pre-defined engine technology domain ontology, which includes at least the entity types of Engine (engine), EngineType (engine type), FuelType (fuel type), EmissionStandard (emission standard), Powertrain (powertrain), TechnicalSpec (technical specification), and Manufacturer (manufacturer); the relationship types of the ontology include at least DEVELOPS (develops), USES_FUEL (uses fuel), CERTIFIED_FOR (certified for), and COMPLIES_WITH (complies with).

[0017] Force formatting output: To ensure the reliability and machine readability of the extraction results, the prompt word explicitly requires the model to return the results strictly according to the specified JSON format. When calling the API of the large language model, by setting the technical parameter response_format:{"type":"json_object"}, the model output must be a syntactically correct JSON object, thereby greatly improving the stability and success rate of the automated processing process.

[0018] Concurrent processing and traceability: To improve the processing efficiency of massive data, the system uses a multi-threaded concurrent mechanism to process multiple text files in parallel. When building the model input, the absolute address of the original text file is transmitted as metadata, and recorded in the extracted knowledge, to facilitate subsequent data traceability and verification.

[0019] 3. Graph construction and import

[0020] This step uses a graph database construction module to import the structured knowledge data generated by the knowledge extraction module into the graph database Neo4j.

[0021] Unique identifier and traceability: When creating each entity node in the graph database, the system generates a globally unique ID (unique_id) for it, and retains its ID in the original extraction file (original_id) and the file path of the data source (file_source) as node properties, which provides key information for subsequent knowledge fusion and data traceability.

[0022] Attribute purification and storage: Before creating nodes and relationships, all attribute values are processed by an attribute purification function to safely convert complex data types such as dictionaries or lists into JSON string format for storage, ensuring data integrity and avoiding database import errors.

[0023] Graph creation: The system traverses all the extracted entity lists to create nodes and edges according to the source entity ID and target entity ID in the relationship list, thereby constructing an initial knowledge graph containing rich nodes and edges in the graph database.

[0024] 4. Three-level knowledge fusion optimized for the engine field

[0025] To solve the problems of entity redundancy and relationship conflicts in the initial graph due to the diversity of data sources, the invention designs and implements a three-level knowledge fusion mechanism containing a vocabulary layer, a semantic layer, and a structure layer, which is optimized for the unique characteristics of engine field knowledge:

[0026] Vocabulary layer fusion: This layer is implemented through an entity fusion module, aiming to quickly process entities with high similarity at the string level. The core is a comprehensive similarity calculation method that prioritizes the application of special pattern matching in the engine field: the system first detects and processes a set of special matching patterns with high confidence, which not only includes conventional parentheses abbreviations and company suffixes (such as 'inc', 'corp'), but more importantly, includes a set of specific normalization rules for processing engine models and component codes, which are used to match and merge complex entity names containing letters, numbers, hyphens, and series codes (for example, considering "X15-E5" and "X15 E5" as highly similar). If the special pattern is not applicable, the Levenshtein edit distance algorithm is used to calculate the similarity.

[0027] Semantic layer fusion: This layer is also implemented in the entity fusion module, focusing on processing synonymous entities that cannot be solved by the vocabulary layer and require deep semantic understanding. For the candidate entity pairs selected by the previous layer, the system queries their neighbor nodes and relationships in the graph, and constructs the neighbor node context information for each entity. Then, the attribute information (such as TechnicalSpec) of the two candidate entities is input into a large language model prompt designed for semantic verification, which requires strict conservative judgment. The prompt contains a key constraint condition for the engine field, which explicitly warns the large language model: "Common neighbor nodes (such as sharing the same ApplicationArea application domain or Manufacturer manufacturer) can only indicate that the entities are active in the same field, but cannot be used as direct evidence to judge that two Engine entities are duplicates", in order to effectively avoid misjudgment due to similar associated relationships.

[0028] Structure layer fusion: This layer aims to solve the structural contradictions of the graph, mainly through neighbor node verification and relationship fusion. Neighbor node verification has been integrated as a core step in semantic layer fusion. On this basis, the invention optimizes the edge structure of the graph through an independent relationship fusion module. The module first identifies node pairs with multiple relationships (i.e., redundant edges) between two identical entities through graph database queries. Then, according to the pre-defined semantic relationship grouping in the engine field, the redundant relationships are classified, and the grouping includes at least "creation / development class" and "use / application class". Finally, the system selects a core relationship as the main relationship according to the pre-set relationship importance weight, and aggregates all attributes of all relationships in each group to the main relationship, and then deletes other redundant relationships, thereby realizing the simplification and optimization of the graph structure.

[0029] Preferably, the knowledge extraction module adopts a zero-shot inference mechanism based on a large language model, which can achieve high-precision identification of engine model, technical parameters and other professional entities and relationships in multi-source heterogeneous text without manual annotation and model training by designing structured prompt words containing engine technology field ontology and output format constraints.

[0030] Preferably, the structure layer fusion module constructs rich engine field context information by analyzing the neighbor relationship type (such as USES_FUEL) and neighbor node attribute (such as FuelType) of the entity to be fused (such as Engine), which is used for higher accuracy verification by the large language model, effectively solving the fusion problem of ambiguous entities (such as the same engine series of different generations) that traditional methods cannot handle.

[0031] Compared with the prior art, the beneficial effects of the present invention include:

[0032] Full-process automation and high efficiency: end-to-end automated construction from raw data cleaning to optimized knowledge graph is realized, and the overall processing efficiency is improved through concurrent processing, caching mechanism and other technical means.

[0033] High precision of domain knowledge extraction: by designing structured prompt words with engine technology field ontology and strict output format constraints for large language models, the recognition ability of complex entities and relationships in the fields of engines, powertrains, technical specifications, etc. is significantly improved, effectively reducing the phenomenon of isolated nodes and knowledge extraction omissions.

[0034] Robustness and accuracy of knowledge fusion: the three-level fusion mechanism of innovation effectively solves the problems of data redundancy and semantic conflict specific to the engine field by special pattern matching for engine models, domain constraint verification combined with neighbor context, and relationship fusion based on domain semantic grouping, greatly enhancing the structural integrity and semantic unity of the graph. BRIEF DESCRIPTION OF DRAWINGS

[0035] Figure 1 is the overall framework structure of the "engine technology field knowledge graph construction method" in the present application, which shows the complete process of data collection, knowledge extraction, and knowledge fusion.

[0036] Figure 2 is the structure diagram of the "multi-source data collection system" in the present application, which shows the steps of collecting data from global engine manufacturer websites and performing semantic preprocessing.

[0037] Figure 3 is the "knowledge extraction module" flowchart based on a large language model in the present application, which shows the whole process of realizing entity relationship extraction in the Zero-Shot prompt mode.

[0038] Figure 4 is the "knowledge fusion mechanism" diagram in the present application, which describes the fusion logic and conflict processing flow at the lexical, semantic, and structural levels. DETAILED DESCRIPTION

[0039] In order to facilitate the understanding of the technical solutions of the present application, the embodiments of the present application will be described in detail below with reference to the drawings. The present application can be realized in various forms and is not limited to the embodiments described herein. On the contrary, the purpose of providing these embodiments is to make the disclosure of the present application more thorough and comprehensive.

[0040] The present application proposes a knowledge graph construction and fusion method for the engine technology field, which significantly improves the construction quality and reasoning ability of professional knowledge graph by integrating a data preprocessing and cleaning module, a knowledge extraction module based on the ontology of the engine field, a graph database construction module, and a three-level knowledge fusion module optimized for the engine field. The complete process of the present application is shown in Figure 1 , which specifically includes the following steps:

[0041] First step: multi-source data collection and intelligent cleaning

[0042] This step aims to preprocess the raw data (such as product manuals, technical specification documents) automatically crawled from multi-source websites (such as MTU, AVL, etc. famous engine manufacturer websites) to provide high-quality, formatted text data for subsequent knowledge extraction. This step is realized through a data preprocessing and cleaning module, and its detailed process is shown in Figure 2shown.

[0043] Content purification: First, the module removes Unicode replacement characters and other non-printing control characters in the text through encoding detection. Then, a series of preset regular expressions are used to remove consecutive special character combinations, suspected garbled patterns, and normalize whitespace characters such as line breaks and tabs, and unify the format.

[0044] Content verification and filtering: The purified text is verified for effectiveness by setting three core parameters: minimum content length, maximum content length, and minimum effective text ratio. Invalid content with a length shorter than the minimum or longer than the maximum, or with an effective character (defined as letters, numbers, Chinese and English, and common punctuation) ratio below the preset threshold of 0.7, is filtered out.

[0045] Record deduplication: For each valid text record, a unique hash value of its content is generated using the MD5 encryption algorithm, and based on this hash value, accurate deduplication is performed to ensure that the text records input to the subsequent knowledge extraction module are unique.

[0046] Step 2: Knowledge extraction based on structured prompts

[0047] This step uses a knowledge extraction module driven by a large language model to automatically extract specific entities and relationships in the engine field from the cleaned text. The process is as follows Figure 3 shown.

[0048] Constructing structured prompts based on engine domain ontology: The invention designs a complex zero-shot prompt word containing multiple parts. The prompt word embeds a predefined engine technology domain ontology, which includes at least the following entity types: Engine (engine), EngineType (engine type), FuelType (fuel type), EmissionStandard (emission standard), Powertrain (powertrain), TechnicalSpec (technical specification), and Manufacturer (manufacturer). The ontology includes at least the following relationship types: DEVELOPS (develops), USES_FUEL (uses fuel), CERTIFIED_FOR (certified for), and COMPLIES_WITH (complies with standards).

[0049] Force formatting output: To ensure the reliability and machine readability of the extraction results, the prompt clearly requires the model to return the results strictly according to the specified JSON format. When making API calls to large language models, by setting the technical parameter response_format: {"type":"json_object"}, the model output must be a syntactically correct JSON object, greatly improving the stability and success rate of the automated processing process.

[0050] Concurrent processing and traceability: To improve the processing efficiency of massive data, the system uses a multi-threaded concurrent mechanism to process multiple text files in parallel. When building model input, the absolute address of the original text file is transmitted as metadata, and recorded in the extracted knowledge, to facilitate subsequent data traceability and verification.

[0051] Step 3: Graph construction and import

[0052] This step uses a graph database construction module to import the structured knowledge data generated by the knowledge extraction module into a graph database Neo4j.

[0053] Unique identifier and traceability: When creating each entity node in the graph database, the system generates a globally unique ID (unique_id) for it, while retaining its original extraction file ID (original_id) and data source file path (file_source) as node properties, which provides key information for subsequent knowledge fusion and data traceability.

[0054] Attribute purification and storage: Before creating nodes and relationships, an attribute purification function is used to process all attribute values, safely converting complex data types such as dictionaries or lists into JSON string format for storage, ensuring data integrity and avoiding database import errors.

[0055] Graph creation: The system traverses all extracted entity lists to create nodes, and creates edges according to the source entity ID and target entity ID in the relationship list, thereby constructing an initial knowledge graph containing rich engine domain nodes and edges in the graph database.

[0056] Step 4: Three-level knowledge fusion optimized for the engine domain

[0057] To solve the problem of entity redundancy and relationship conflict caused by the diversity of data sources in the initial graph (for example, the same engine model is named "ISX15" or "ISX 15E5" in different documents), the present application designs and implements a three-level knowledge fusion mechanism including vocabulary layer, semantic layer and structure layer. The mechanism is optimized for the unique characteristics of engine domain knowledge, and its fusion logic is as shown in Figure 4

[0058] Vocabulary layer fusion: This layer is implemented through an entity fusion module, aiming to quickly process entities with high similarity at the string level. Its core is a comprehensive similarity calculation method that prioritizes the application of special pattern matching in the engine domain: the system first detects and processes a set of special matching patterns with high confidence, which not only includes conventional parentheses abbreviations and company suffixes (such as 'inc', 'corp'), but more importantly, includes a set of specific normalization rules for processing engine models and component codes, which are used to match and merge complex entity names containing letters, numbers, hyphens, and series codes (for example, "X15-E5" and "X15 E5" are considered highly similar). If the special pattern is not applicable, the Levenshtein edit distance algorithm is used to calculate the similarity.

[0059] Semantic layer fusion: This layer is also implemented in the entity fusion module, focusing on processing synonymous entities that cannot be solved by the vocabulary layer and require deep semantic understanding. For the candidate entity pairs selected by the previous layer, the system queries their neighbor nodes and relationships in the graph, and constructs the neighbor node context information for each entity. Then, the attribute information (such as TechnicalSpec) of the two candidate entities is input into a large language model prompt designed for semantic verification, which requires strict conservative judgment. The prompt word contains a key constraint condition for the engine domain, which explicitly warns the large language model: "Common neighbor nodes (such as sharing the same ApplicationArea application domain or Manufacturer manufacturer) can only indicate that the entities are active in the same field, but cannot be used as direct evidence to judge that the two Engine entities are duplicates", in order to effectively avoid false positives caused by similar associated relationships.

[0060] ​Structure layer fusion: This layer aims to solve the structural contradictions of the graph, mainly through two aspects of neighbor node verification and relationship fusion. Neighbor node verification has been integrated as a core link in semantic layer fusion. On this basis, the invention optimizes the edge structure of the graph through an independent relationship fusion module. The module first identifies node pairs that have multiple relationships (i.e., redundant edges) between two identical entities through graph database queries. Then, according to the predefined semantic relationship groups (semantic_relation_groups) in the engine field, the redundant relationships are classified, which at least include the "creation / development class" (such as DEVELOPS, FOUNDED, LAUNCHED_IN) and the "use / application class" (such as USES_FUEL, USES_TECH). Finally, the system selects a most core relationship as the main relationship according to the preset relationship importance weight (relation_importance) from each group, retains it, and aggregates all attributes of all relationships in the group to the main relationship, and then deletes other redundant relationships, thereby realizing the simplification and optimization of the graph structure.

[0061] The present invention is implemented in the following environment:

[0062] Hardware: Intel i5-12400F, RTX 4070Super, DDR4 32GB.

[0063] Software: Windows 11, Python 3.10, Spring Boot 3, Neo4j 5.26.0, Ollama+deepseek-r1:14b-qwen-distill-q4_K_M model local deployment.

Claims

1. A method for knowledge graph construction and fusion in the field of engine technology, characterized in that, The method includes the following steps performed in sequence: Data collection and cleaning are performed on raw data obtained from multiple sources, including engine technical specifications, manufacturer product manuals, and scientific research literature. Based on a predefined ontology in the field of engine technology, knowledge is extracted from the cleaned data to generate structured knowledge data; The structured knowledge data is imported into a graph database to construct an initial knowledge graph; The initial knowledge graph is subjected to multi-level knowledge fusion. The fusion adopts matching and verification rules optimized for the engine domain to eliminate entity redundancy and relation redundancy.

2. The knowledge graph construction and fusion method for engine technology according to claim 1, characterized in that, The data acquisition and cleaning process includes: The text content in the engine technical specifications was purified by removing Unicode control characters and using regular expressions for noise reduction; The text is validated and filtered based on a preset content length threshold and the proportion of effective text. The MD5 hash algorithm is used to deduplicate records in order to generate formatted text data.

3. The knowledge graph construction and fusion method for engine technology according to claim 1, characterized in that, The knowledge extraction specifically refers to: A zero-sample prompting mechanism based on a large language model is adopted, which extracts prompts through a structured prompt word containing a predefined ontology of the engine technology field; By setting the response format to a JSON object in the request through concurrent API calls, entities and relationships can be automatically extracted from the formatted text data.

4. The knowledge graph construction and fusion method for engine technology according to claim 1, characterized in that, The multi-level knowledge fusion includes sequential lexical fusion, semantic fusion, and structural fusion.

5. The knowledge graph construction and fusion method for engine technology according to claim 4, characterized in that, The vocabulary-level fusion includes: A set of special pattern matching rules optimized for the engine field is applied. The set of rules includes regular bracket abbreviation matching and company prefix and suffix matching, as well as a specific normalization rule for handling engine model names. This rule is used to match complex entity names containing letters, numbers, hyphens and serial numbers. If the special mode is not applicable, the regular similarity is calculated using edit distance and sequence matching algorithms.

6. The knowledge graph construction and fusion method for engine technology according to claim 4, characterized in that, The semantic layer fusion includes: For candidate entity pairs selected at the lexical layer, construct a context that includes entity name, tags, and technical specification attributes; The context is provided to the large language model, and a decision is made by a prompt word specifically for semantic verification. This prompt word contains a constraint that explicitly indicates that common neighbor nodes can only indicate that entities are active in the same domain, and cannot be used as direct evidence to determine that entities are duplicates.

7. The knowledge graph construction and fusion method for engine technology according to claim 4, characterized in that, The structural layer fusion includes: By analyzing the context information of the neighboring nodes of the entity to be fused, the candidate entities for semantic layer fusion are verified; An integrated relationship fusion process is provided, which identifies node pairs with multiple relationship edges between two identical entities and merges the multiple relationships based on predefined engine domain semantic relationship grouping and relationship importance weights.

Images