A knowledge graph construction method and device, electronic equipment and storage medium

Abstract

The application relates to the technical field of knowledge graphs, and discloses a knowledge graph construction method and device, electronic equipment and a storage medium. The method comprises the following steps: generating a search query statement for a current node to be expanded and searching by using the search query statement to obtain a context reference source document; based on the context reference source document, a candidate sub-node set related to the current node to be expanded is extracted; it is verified whether a candidate sub-node in the candidate sub-node set is a strict lower concept of the current node to be expanded, and according to the verification result, an effective candidate sub-node set is extracted from the candidate sub-node set; the effective candidate sub-nodes in the effective candidate sub-node set are subjected to semantic grouping, mutual exclusive semantic groups and corresponding disambiguation actions are obtained, the corresponding semantic groups are disambiguated according to the disambiguation actions, and a standard sub-node set is obtained; and a standard definition is generated for each standard sub-node in the standard sub-node set, so that the problems of hierarchical topology deviation and concept drift, disambiguation mechanism black-boxing and semantic overlap are solved.

Description

Technical Field

[0001] The embodiments of the present invention relate to the field of knowledge graph technology, and in particular to a knowledge graph construction method, apparatus, electronic device and storage medium. Background Technology

[0002] In the field of knowledge graph (KG) construction, extracting entities and relationships from unstructured text and building a structured knowledge base is a core technology for achieving intelligent retrieval, logical reasoning, and decision support. Traditional knowledge graph construction schemes mainly include the following technical paths: rule-based and template matching schemes, supervised deep learning-based named entity recognition and information extraction (IE) schemes, vector retrieval (RAG) and statistical clustering disambiguation schemes, and zero-shot direct extraction schemes based on large language models (LLM).

[0003] However, existing technologies have the following drawbacks: (1) Hierarchical topology disorder and concept drift: Existing large model extraction schemes lack strong formal constraints on "subordinate relationships". In recursive construction, large models are prone to misjudging "relevance" as "subordinate relationship", which leads to parallel concepts, upstream and downstream nodes or influencing factors being mixed into the same layer. The graph loses its strict tree or directed acyclic topology and cannot support downstream path reasoning and decision deduction.

[0004] (2) Black boxing of disambiguation mechanism and semantic overlap: Traditional vector similarity disambiguation mechanism and simple LLM pairing scheme cannot understand the dimensional intersection of candidate nodes in the same layer from a global perspective. This leads to a large number of semantically overlapping synonyms in nodes in the same layer, or the erroneous merging of important concepts with orthogonal dimensions. The disambiguation process lacks interpretable business logic support and is extremely sensitive to parameter tuning.

[0005] (3) Uncontrolled recursive divergence and node explosion: When recursively expanding in the open domain, due to the lack of effective quality assessment and dynamic pruning mechanism, the divergence of the large model is amplified exponentially with the depth of recursion, resulting in a large number of "illusion leaves" with no business value in the graph or excessive consumption of computing resources on worthless branches.

[0006] (4) Vulnerability and high latency in engineering implementation: Existing LLM graph construction mostly adopts single-node serial calls, lacks robust schema strong constraints and high concurrency control. When facing large-scale unstructured text, token consumption is high, call latency is large, and the entire construction process is easily interrupted due to abnormal output format of large models. Summary of the Invention

[0007] The purpose of this invention is to provide at least one method, apparatus, electronic device, and storage medium for constructing knowledge graphs, which can at least solve the technical problems of hierarchical topological deviation and concept drift, black-box disambiguation mechanism, and semantic overlap in existing methods.

[0008] To address the aforementioned technical problems, at least one embodiment of this application provides a knowledge graph construction method, including: Generate a search query statement for the current node to be expanded and use the search query statement to retrieve the context reference source document; Based on the context reference source document, extract the set of candidate child nodes related to the current node to be expanded; Verify whether a candidate node in the candidate child node set is a strictly subordinate concept of the current node to be expanded, and extract a set of valid candidate child nodes from the candidate child node set based on the verification result; Semantically group the valid candidate child nodes in the set of valid candidate child nodes to obtain mutually exclusive semantic groups and corresponding disambiguation actions. Disambiguate the corresponding semantic groups according to the disambiguation actions to obtain the standard child node set. Generate a standard definition for each standard child node in the set of standard child nodes.

[0009] At least one embodiment of this application also provides a knowledge graph construction apparatus, comprising: The dynamic query and network retrieval module is used to generate a retrieval query statement for the current node to be expanded and to use the retrieval query statement to perform a retrieval and obtain the context reference source document. The candidate node extraction module is used to extract a set of candidate child nodes related to the current node to be expanded based on the context reference source document; The hierarchical verification module is used to verify whether the candidate child nodes in the candidate child node set are strictly subordinate concepts of the current node to be expanded, and to extract the valid candidate child node set from the candidate child node set based on the verification result. The set partitioning and disambiguation module is used to semantically group the valid candidate child nodes in the set of valid candidate child nodes to obtain mutually exclusive semantic groups and corresponding disambiguation actions. Based on the disambiguation actions, the corresponding semantic groups are disambiguated to obtain the standard child node set. The definition generation module is used to generate a standard definition for each standard child node in the standard child node set.

[0010] At least one embodiment of this application also provides an electronic device, including: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the knowledge graph construction method described above.

[0011] At least one embodiment of this application also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the knowledge graph construction method described above.

[0012] In some optional embodiments, the knowledge graph construction method described above further includes: Initialize the root node, write the root node to the graph database, and initialize the queue of nodes to be expanded; When the queue of nodes to be expanded is not empty, the first element of the queue of nodes to be expanded is taken out and determined as the current node to be expanded; Generate a search query for the current node to be expanded and use the search query to perform a search to obtain the context reference source document, including: Based on the industry background, the current node to be expanded and its corresponding parent path, and the current recursion depth, a multi-dimensional retrieval query statement is adaptively generated using a large language model. The retrieval query statement is then used to perform online retrieval to obtain a set of M highly relevant unstructured text documents as context reference source documents.

[0013] In some optional embodiments, based on the context reference source document, a set of candidate child nodes related to the current node to be expanded is extracted, including: Using the context reference source document and the current node to be expanded as context input, a set of candidate child nodes related to the current node to be expanded is extracted using a large language model, and the formatted data of the candidate child node set is output under the constraints of JSON Schema.

[0014] In some optional embodiments, the standard definition includes the name of the parent node as a prefix, and the number of characters is limited to a preset range.

[0015] In some optional embodiments, the knowledge graph construction method described above further includes: Each standard sub-node and its standard definition in the standard sub-node set are evaluated quantitatively from multiple dimensions to obtain a comprehensive quality score. The decision to continue expansion is based on the comprehensive quality score.

[0016] In some optional embodiments, a multi-dimensional quantitative evaluation is performed on each standard sub-node and its standard definition in the standard sub-node set to obtain a comprehensive quality score. Based on the comprehensive quality score, a determination is made as to whether to continue expansion, including: If the overall quality score of all standard child nodes under the current expansion node is lower than the threshold, and the current recursion depth has not reached the target recursion depth, then the current branch will be pruned.

[0017] In some optional embodiments, a multi-dimensional quantitative evaluation is performed on each standard sub-node and its standard definition in the standard sub-node set to obtain a comprehensive quality score. The determination of whether to continue expansion is based on the comprehensive quality score further includes: Write the standard child nodes that reach the threshold of the comprehensive quality score into the graph database, and create an edge between the standard child node and its parent node. Attached Figure Description

[0018] One or more embodiments are illustrated by way of example with reference to the accompanying drawings, and these illustrative descriptions do not constitute a limitation on the embodiments.

[0019] Figure 1 This is a flowchart of a knowledge graph construction method provided in an embodiment of this application; Figure 2 This is a schematic diagram of a knowledge graph construction apparatus provided in an embodiment of this application; Figure 3 This is an overall system block diagram provided by an embodiment of this application. Detailed Implementation

[0020] To make the objectives, technical solutions, and advantages of the embodiments of this application clearer, the various embodiments of this application will be described in detail below with reference to the accompanying drawings. However, those skilled in the art will understand that many technical details have been provided in the various embodiments of this application to help readers better understand this application. However, the technical solutions claimed in this application can be implemented even without these technical details and various changes and modifications based on the following embodiments. The division of the various embodiments below is for the convenience of description and should not constitute any limitation on the specific implementation of this application. The various embodiments can be combined with and referenced by each other without contradiction.

[0021] To facilitate understanding of the embodiments of this application, relevant content regarding knowledge graph construction will be introduced first.

[0022] Traditional knowledge graph construction schemes mainly include the following technical paths: (1) Rule-based and template-based matching scheme: This scheme uses pre-defined regular expressions, dependency syntax trees, or pattern templates to perform matching and extraction in the text. This scheme has a high accuracy rate in specific vertical fields, but its generalization ability is extremely poor. When facing new industries or long-tail terms, a large number of rules need to be written manually, and the maintenance cost increases exponentially.

[0023] (2) Supervised deep learning-based named entity recognition and relation extraction (IE) scheme: knowledge extraction is performed by training an end-to-end sequence labeling model (such as BERT-BiLSTM-CRF or UIE) on a massive dataset with manual annotation. This scheme relies heavily on high-quality labeled data, and the schema is fixed after training, making it impossible to dynamically expand the hierarchy during the construction process, resulting in high costs for cross-domain migration.

[0024] (3) Disambiguation scheme based on vector retrieval (RAG) and statistical clustering: The text is sliced ​​and transformed into low-dimensional vectors using an embedding model. Cosine similarity is calculated and combined with traditional clustering algorithms (such as DBSCAN and K-Means) to identify synonymous entities and perform disambiguation. However, statistical indicators such as cosine similarity cannot understand complex business contexts, have difficulty distinguishing between "strongly related but not synonymous" concepts (such as "battery" and "range"), and are extremely sensitive to clustering thresholds, easily "falsely killing" professional long-tail keywords during the disambiguation process.

[0025] (4) Zero-shot direct output scheme based on Large Language Model (LLM): Directly use prompt words to guide the large model to extract entities and relations from the input text and output JSON or triples. Although this scheme lowers the cold start threshold, when expanding recursively in the open domain, due to the lack of strict hierarchical constraints and process control, the fundamental contradiction between the probability divergence generated by the large model and the convergence of the underlying structure of the graph begins to appear. This leads to serious structural irregularities and semantic entropy increase problems such as "hierarchical flattening" (mixing parallel concepts into hierarchical relations), "semantic overlap pollution" (semantic redundancy of nodes at the same level), and "recursion out of control" (generating a large number of illusory leaf nodes) when the graph is expanded vertically.

[0026] The disadvantages of existing technologies include: 1. Hierarchical topological irregularities and concept drift: Existing large model extraction schemes lack strong formal constraints on "hierarchical relationships". In recursive construction, large models are prone to misjudging "relevance" as "hierarchical relationships", resulting in parallel concepts, upstream and downstream nodes or influencing factors being mixed into the same layer. The graph loses its strict tree or directed acyclic topology and cannot support downstream path reasoning and decision deduction.

[0027] 2. Black-box nature of disambiguation mechanisms and semantic overlap: Traditional vector similarity disambiguation mechanisms and simple LLM pairing schemes cannot understand the dimensional intersection of candidate nodes at the same level from a global perspective. This leads to a large number of semantically overlapping synonyms among nodes at the same level, or the incorrect merging of important concepts with orthogonal dimensions. The disambiguation process lacks interpretable business logic support and is extremely sensitive to parameter tuning.

[0028] 3. Uncontrolled recursive divergence and node explosion: During open domain recursive expansion, due to the lack of effective quality assessment and dynamic pruning mechanisms, the divergence of large models increases exponentially with the depth of recursion, resulting in a large number of "illusionary leaves" with no business value in the graph or excessive consumption of computing resources on worthless branches.

[0029] 4. Vulnerability and high latency in engineering implementation: Existing LLM graph construction mostly adopts single-node serial calls, which lacks robust schema constraints and high concurrency control. When facing large-scale unstructured text, token consumption is high, call latency is large, and the entire construction process is easily interrupted due to abnormal output format of large models.

[0030] To address the aforementioned technical problems, this invention proposes a knowledge graph construction method, apparatus, electronic device, and storage medium. The implementation details of the knowledge graph construction method in this embodiment are described below. The following content is only for ease of understanding and is not essential for implementing this solution.

[0031] Example 1: The knowledge graph construction method of this embodiment can be applied to electronic devices with communication, computing, and data storage capabilities. Its specific process can be as follows: Figure 1 As shown, it includes: Step 101: Generate a search query statement for the current node to be expanded and use the search query statement to perform a search to obtain the contextual reference documents (or reference document set).

[0032] Specifically, in a single loop of recursively building a knowledge graph, the current node to be expanded serves as the "parent node" of the current branch. By searching and extracting, its "child nodes" are found, thereby achieving vertical hierarchical expansion downwards.

[0033] Step 102: Based on the context reference source document, extract the set of candidate child nodes related to the current node to be expanded.

[0034] Step 103: Verify whether the candidate child nodes in the candidate child node set are strict subordinate concepts of the current node to be expanded, and extract the valid candidate child node set from the candidate child node set based on the verification results.

[0035] Step 104: Semantically group the valid candidate child nodes in the set of valid candidate child nodes to obtain mutually exclusive semantic groups and corresponding disambiguation actions. Disambiguate the corresponding semantic groups according to the disambiguation actions to obtain the standard child node set.

[0036] In the specific implementation, disambiguation actions include merging, splitting, and discarding. In addition to outputting semantic groups and corresponding disambiguation actions, business reasons are also output. Business reasons refer to the natural language explanations given by the large language model after reasoning about the semantic similarities and differences, conceptual boundaries, inclusion relationships, or dimensional intersections between candidate child nodes based on industry knowledge and context.

[0037] In some examples, the correspondence between disambiguation actions and business reasons is strong. The specific mapping is as follows: The business rationale for merging is to clarify that the two concepts are synonyms in the current industry context, have a relationship between abbreviation and full name, or have a strong coupling between engineering implementation and theoretical model (e.g., "LLM" and "Large Language Model" are synonymous abbreviations).

[0038] The business rationale for splitting is to clarify that although two concepts are highly related, they belong to different technical dimensions, architectural branches, or orthogonal categories (for example, "CNN" and "RNN" are both neural networks, but one emphasizes spatial features and the other emphasizes temporal features, and the dimensions are orthogonal, so they must be split and retained).

[0039] The business reasons for dropping (discarding) are: clarifying that the concept exceeds the industry boundaries, is an illusion, or has extremely low business value (for example, extracting "the price of a robot dog" under the theme of "embodied intelligence" is attribute information with no reasoning value and should be discarded).

[0040] Step 105: Generate a standard definition for each standard child node in the standard child node set.

[0041] Specifically, the standard definition includes the name of the parent node as a prefix, and the number of characters is limited to a preset range.

[0042] The method in this embodiment generates a retrieval query statement for the current node to be expanded and uses the retrieval query statement to retrieve the context reference source document to extract a set of candidate child nodes related to the current node to be expanded. It verifies whether the candidate child nodes in the candidate child node set are strictly subordinate concepts of the current node to be expanded, and then extracts a set of valid candidate child nodes from the candidate child node set. The valid candidate child nodes in the set of valid candidate child nodes are semantically grouped to obtain mutually exclusive semantic groups and corresponding disambiguation actions. Disambiguation is performed on the corresponding semantic groups according to the disambiguation actions to obtain a standard child node set, and a standard definition is generated for each standard child node in the standard child node set. By performing rigorous formal verification of proper subsets and subordinate relationships for each generation of child nodes in the recursive process, the mixing of parallel concepts and upstream / downstream relationships is prevented, ensuring that the graph has a strict hierarchical topological structure. The semantic set partitioning and disambiguation mechanism of batch set partitioning realizes the construction of an open-domain recursive knowledge graph.

[0043] In some embodiments, the method further includes: initializing the root node, writing the root node into the graph database, and initializing the queue of nodes to be expanded; when the queue of nodes to be expanded is not empty, taking out the first element of the queue of nodes to be expanded and determining it as the current node to be expanded.

[0044] In the specific implementation, let the industry background field input by the user be I, and the analysis topic be the root node. The maximum recursion depth is D, and the current recursion depth is d. The root node... Write to the graph database and initialize the queue of nodes to be expanded. : .

[0045] In some embodiments, a search query is generated for the current node to be expanded and the search query is used to retrieve the context reference source document, including: Based on the industry background, the current node to be expanded and its corresponding parent path, and the current recursion depth, a multi-dimensional search query is adaptively generated using a large language model. This query is then used for online retrieval to obtain a set of M highly relevant unstructured text documents as contextual reference source documents. This is an unstructured document.

[0046] In the specific implementation, at the beginning of each loop, it first checks whether the queue to be expanded, Qqueue, is empty. If the queue of nodes to be expanded is empty... If the value is not empty, extract the first element (p, d) as the "parent node" to be expanded, and obtain its current recursion depth d. If the current recursion depth d > D, skip the node (first element). Otherwise, based on the industry background domain I, the name of the current node to be expanded p, and its parent path (i.e., from the root node)... A linked list of all ancestor nodes traversed to the current node p to be expanded (arranged in order) is used to generate a set of targeted retrieval queries using a large language model:

[0047] In one example, if the root node is "Artificial Intelligence", its child node is "Machine Learning", and the current node to be expanded is "Deep Learning", then the parent path of "Deep Learning" is ["Artificial Intelligence", "Machine Learning"].

[0048] When generating search queries, relying solely on the isolated current node to be expanded, such as "deep learning," can result in highly generalized documents. However, by using the "parent path" as a contextualized prompt, the large model can generate highly targeted queries (such as "latest advancements in artificial intelligence, machine learning, and deep learning"), effectively preventing search drift.

[0049] In some embodiments, based on the context reference source document, a set of candidate child nodes related to the current node to be expanded is extracted, including: Using the context reference source document and the current node to be expanded as context input, a large language model is used to extract a set of candidate child nodes related to the current node to be expanded, and the formatted data of the candidate child node set is output under the constraints of JSON Schema.

[0050] In some examples, the context reference source document set Docs and the parent node p are used as context input, and a potential candidate child node set C is extracted through a large language model. This step forces the large model to output structured data in the following format using JSON Schema: json { "candidates": [ {"name": "Candidate child node name", "source_doc_idx": 0} ] } ``` Large language models natively output free-format text, which can easily lead to redundant interpretations and formatting errors. In some cases, a JSON schema can be passed to the API's `response_format` method, forcing the large model to output only one structured JSON array (i.e., a structured set of candidate child nodes) containing "candidate child node names" and "source document index," facilitating direct parsing by the program and automated processing by subsequent modules.

[0051] To prevent concept drift, each candidate child node in the candidate set C... A rigorous hierarchical relationship validation is performed to verify whether each candidate child node in the candidate child node set is a strictly subordinate concept of the node to be expanded. Based on the validation results, a valid set of candidate child nodes is extracted from the candidate child node set to achieve strict hierarchy validation. The large language model determines the hierarchy based on specific hierarchical validation prompts. Determine whether it is a strict subordinate concept (subclass, component, or concrete instance) of the current node p to be expanded, and output the boolean value is_strict_sub and the confidence level. :

[0052] in, The preset hierarchical confidence threshold (taken in this embodiment) Only when At that time, candidate child nodes They are retained to form a valid candidate child node set. Other child nodes that do not satisfy strict hierarchical relationships (such as parallel concepts, causal relationships, influencing factors, etc.) are directly filtered out. It is an indicator function whose output value is 1 (meaning it passes the check and is retained) or 0 (meaning it fails and is filtered). It indicates whether the candidate child node ci satisfies the condition of being a strict subordinate concept of the parent node p. It is the confidence score output by the large language model ( ), This indicates an indicator function that, when its boolean value is True and the condition within the parentheses (the confidence level of the large language model is greater than or equal to a threshold) is met. When it was established, =1, otherwise 0.

[0053] In practical implementation, the prompt words for hierarchical verification can explicitly define what a "strict subordinate relation" (i.e., proper subset, subclass, member or component) is for the large language model, and provide counterexamples (such as causality, parallelism, influencing factors, upstream and downstream), requiring the large language model to perform logical reasoning.

[0054] Here is an example of a specific prompt word: ```text [Role Positioning] You are a rigorous ontology expert.

[0055] [Task] Determine whether a candidate concept (Child) is a strict subordinate concept of its parent concept (Parent).

[0056] [Judgment Criteria] - Must meet the following conditions: Child is a type of Parent (Is-A, e.g., [Convolutional Neural Network] is a type of [Neural Network]) or Child is a core component of Parent (Part-Of, e.g., [LiDAR] is part of [Embodied Smart Hardware]).

[0057] - Must reject: parallel concepts (e.g., [deep learning] and [reinforcement learning]), causal / influence relationships (e.g., [computing power improvement] leads to [deep learning development]), and upstream and downstream business processes (e.g., [data annotation] is a prerequisite for [model training]).

[0058]

enter

[0059] In some embodiments, semantic disambiguation based on large model set partitioning (LLM Set Partitioning) is used to obtain a standard child node set, specifically including: dividing the effective candidate child node set... The entire input is taken into a large language model, which is then guided to semantically group the valid candidate child nodes in the set of valid candidate child nodes according to the degree of semantic overlap, and outputs the equivalence class partition:

[0060] in, These are mutually exclusive semantic groups. The large language model considers each semantic group... Perform reasoning and output the corresponding disambiguation decision action. ):

[0061] If nodes within a semantic group are synonyms, retain the representative node with the most accurate semantics and the highest business value. The remaining nodes are merged; if nodes within a semantic group have overlapping dimensions rather than being completely synonymous, they are split into orthogonal independent nodes; if none of the nodes in a group fit the industry context or have extremely low business value, they are discarded entirely. Orthogonality here means that two concepts do not overlap, are independent, and exist in parallel dimensions in the semantic space. When the large language model finds that a group of candidate child nodes are highly similar in wording or frequently co-occur in the same document, but represent different technical paths or orthogonal dimensions, they must be split into two independent nodes. For example: candidate child nodes ["hardware acceleration", "software optimization"]. They both belong to the sub-means of "performance improvement" and are extremely closely related, but one is a hardware dimension and the other a software dimension (semantically orthogonal). The large language model determines to perform a split action, creating two independent child nodes in the graph and generating their respective definitions to prevent conceptual confusion.

[0062] In graph databases, the names of merged nodes (non-representative nodes) are not directly erased, but stored as **"aliases" or **"synonyms properties** of the representative node**. For example, consider a semantic group ["LLM", "Large Language Model", "Large Language Model"]. The Large Language Model selects "Large Language Model" as the representative node and writes it into the graph. The other two nodes are merged into this node, i.e., the attribute `synonyms: ["LLM", "Large Language Model"]` is added to the "Large Language Model" node. This way, when searching downstream, entering "LLM" will still accurately locate this node, preserving the integrity of the knowledge.

[0063] In its implementation, the large language model addresses each semantic group. The reasoning process and the output of the corresponding disambiguation decision are determined dynamically by the large language model during runtime. The specific operational mechanism is as follows: 1. Input phase: Input the effective candidate child nodes (e.g., 10 nodes) into the large language model at once.

[0064] 2. Dynamic partitioning and decision-making: In the same round of reasoning, the large language model not only needs to find out which child nodes should be grouped together (i.e., divide semantic groups), but also needs to dynamically decide what action to take on this group of child nodes (merge / split / drop) based on the actual semantic relationship of this group of child nodes in the current industry context.

[0065] 3. The large language model makes decisions based on the specific circumstances of each group. For example, the large language model might group ["neural network", "deep learning"] into group 1 and dynamically decide to perform a merge; or group ["CNN", "RNN"] into group 2 and dynamically decide to perform a split. This integrated "partitioning + decision-making" design fully utilizes the large language model's global contextual understanding capabilities.

[0066] In some cases, disambiguation yields a clean set of layer nodes:

[0067] Where K represents the total number of mutually exclusive semantic groups obtained after the large model partitions the set of valid candidate child nodes Cvalid.

[0068] The output format of the disambiguation process is strictly constrained, as shown in the following example: json { "groups": [ { "group_id": 1, "nodes": ["deep learning", "neural network"], "reason": "In the current context, the engineering implementation and the theoretical model highly overlap; merging them is recommended." "action": "merge" } ] } ``` The layer node set refers to the set of all qualified child nodes (standard child nodes) in the current layer (current recursion depth d) that have been determined and are ready to be written into the graph database after disambiguation, deduplication, and cleaning. For example, if there are 10 candidate child nodes in the candidate child node set, the large language model divides these 10 candidate child nodes into four semantic groups (i.e., k=4). After performing disambiguation decisions on each of these four semantic groups, the merged or split nodes are recombined to form the final layer node set. That is, the standard child node set.

[0069] In some embodiments, for For each standard child node c in the set, a standard definition is generated using a large language model. To eliminate concept drift, the generated prompts are subject to parent node anchoring rules, meaning the generated definition must include the name of the parent node p as a prefix, and the word count is limited to a preset range (e.g., 30-50 characters). This ensures the business executability of the definition, thereby generating a standard definition for each standard child node in the set.

[0070] In some embodiments, the knowledge graph construction method described above further includes: performing multi-dimensional quantitative evaluation on each standard sub-node and its standard definition in the standard sub-node set to obtain a comprehensive quality score, and determining whether to continue expansion based on the comprehensive quality score.

[0071] Specifically, a multi-dimensional quantitative evaluation is performed on each standard sub-node and its standard definition in the standard sub-node set to obtain a comprehensive quality score. The decision to continue expansion is based on the comprehensive quality score, including: If the overall quality score of all standard child nodes under the current expansion node is lower than the threshold, and the current recursion depth has not reached the target recursion depth, then the current branch will be pruned.

[0072] In the specific implementation, the generated standard child node c and its standard definition are subjected to multi-dimensional quantitative evaluation to achieve quality assessment and dynamic pruning. The large language model scores the data from three dimensions: industry relevance, definition clarity, and extensibility, and calculates the comprehensive quality score Q(c)∈[0,1]:

[0073] The early stopping condition for determining whether the current branch should continue to expand is:

[0074] in, The preset quality threshold (taken in this embodiment) If the quality scores of all child nodes under the current node p to be expanded are lower than 10, then ... If the current branch has no further development value, it is immediately pruned, and its child nodes are no longer added to the queue for development.

[0075] In some cases, industry relevance (S) rel ∈[0,1]): The evaluation criterion is whether the sub-concept belongs to the core technology, business, or application scope of the input industry background domain I; its quantification rules are: 1.0—core industry technology / core entity; 0.5—general technology, but with important applications in this industry; 0.1—general terms completely unrelated to this industry. Definition clarity (C larity S cla ∈[0,1]): Evaluation criteria: Whether the generated definition eliminates ambiguity, achieves parent node anchoring, and contains ambiguous words (such as "etc.", "other"); Quantification rules: 1.0—Accurate definition, clear boundaries, no ambiguous words, successfully anchors parent node; 0.6—Definition is basically accurate, but has slight self-reference (explaining the concept with the concept itself); 0.2—Definition is ambiguous, contains a large number of "etc.", or does not anchor parent node. Extensibility (S ext ∈[0,1]): Evaluation criteria: Whether the node belongs to the "leaf node" (cannot be further subdivided), or whether it has the potential to further recursively grow subtrees (i.e., whether it is a higher-level concept classification); Quantification rules: 1.0—belongs to a meso-level concept, containing rich lower-level technical paths, with extremely high expansion potential; 0.5—belongs to a micro-level specific technology, still with a small amount of subdivision space; 0.1—is already the smallest atomic operation or specific parameter, and cannot be further subdivided (e.g., "30 milliseconds"). Comprehensive score calculation: After the large language model outputs scores in three dimensions, a weighted average or direct evaluation is used to calculate the comprehensive quality score: Q(c) = w1 S rel +w2 S cla + w3 S ext For example, take the average weight w1=w2=w3=1 / 3. If Q(c) is less than θq (e.g. 0.6), then the node will not be expanded.

[0076] In some embodiments, the knowledge graph construction method described above further includes: Write the standard child nodes with the comprehensive quality score reaching the threshold into the graph database, and create an edge between the standard child node and its parent node.

[0077] In some examples, after performing multi-dimensional quantitative evaluation on each standard child node in the standard child node set and its standard definition to obtain a comprehensive quality score, the standard child nodes that pass the quality evaluation are written into the Neo4j graph database, and a strict_sub_of (proper subset relationship) edge between the child node and the parent node is created. At the same time, loop detection is performed, and if no loop is detected, (c, d+1) is pushed into the to-be-expanded queue , and the loop continues until the to-be-expanded queue is empty.

[0078] After passing the hierarchy verification, disambiguation, definition generation, quality evaluation and loop detection, only the "standard child node" c that is finally determined to be qualified, and whose current recursion depth d<D (not reaching the maximum recursion depth), will be combined with the next generation depth to form a tuple (c, d+1), which is pushed to the tail of the to-be-expanded queue to wait for subsequent loops to expand it. (c, d+1) is a binary tuple, as an element in the to-be-expanded queue QqueueQqueue, where c represents the newly generated standard child node that has passed all verifications (it will be expanded as a "parent node" in the next round of loop), and d+1 represents the hierarchical depth of the child node in the knowledge graph (that is, the recursion depth d of the parent node plus 1).

[0079] The method of this embodiment performs set partitioning based on a large language model, and realizes open-domain recursive knowledge graph construction. By introducing a large language model hierarchy verification gate, formal verification of proper subset and hyponymy relationship is strictly performed on each generation of child nodes in the recursive process, so as to prevent the mixing of parallel concepts and upstream-downstream relationships, and ensure that the graph has a strict hierarchical topology. The semantic disambiguation mechanism based on large language model batch set partitioning abandons the traditional vector similarity calculation, uses the semantic reasoning ability of the large language model to perform batch grouping decision-making on the same-layer candidate set, and outputs auditable merge, split or discard actions, so as to realize semantic orthogonality of nodes in the same layer. A dual-condition early-stop pruning mechanism based on quality scoring and effective child node counting is established, and multi-dimensional value evaluation of nodes is carried out through the large language model to realize value-driven depth expansion and automatically terminate invalid branches. A deterministic structured engine based on asynchronous parallelism, JSON Schema strong constraints and dynamic cache is constructed, which reduces engineering latency and Token cost while ensuring 100% parsable output format, and improves the robustness and engineering availability of the system.

[0080] The aforementioned open domains are mainly reflected in the following three core designs, which are key differences from the traditional "closed domain / restricted schema" graph construction: 1. Boundless input source: It does not rely on a pre-set local static corpus, but obtains the latest unstructured text from the Internet (such as search engines and open APIs) in real time through dynamic query and network retrieval, and can handle text from any emerging, cross-cutting or undefined industry.

[0081] 2. Dynamic emergence of Schema: Instead of using pre-coded entity types (such as pre-setting to only extract "person names / place names / organizations"), the large language model autonomously discovers and extracts any new concepts that conform to "strict hierarchical relations" based on the context during the recursive process.

[0082] 3. Zero-sample cold start capability: Without the need for pre-trained models for specific domains or the provision of manually annotated industry dictionaries, it can autonomously radiate outwards and recursively grow a complete knowledge tree simply by inputting the industry background domain (such as "low-altitude economy" or "embodied intelligence") and the root node.

[0083] The aforementioned "auditable" means that every structured decision made by the large model must be verifiable, traceable, and able to output a deterministic logical chain. The specific implementation is as follows: 1. Structured log output (strong JSON Schema constraints): When the large language model performs disambiguation, the output JSON message must include not only the action, but also the "reason" and "confidence" fields.

[0084] 2. Decision Link Backtracking: Write the original input context, the reason output by the large language model, the execution timestamp, the model version used, and the prompt word template of each disambiguation decision (e.g., grouping "deep learning" and "neural network" together and performing a merge) as metadata to the graph database or local audit log along with the node.

[0085] 3. Human-in-the-loop interface: Because all decision reasons are stored in structured text format, the system provides a visual audit dashboard. Security officers or industry experts can search for "all decisions that have executed drop or merge actions and have a confidence level below 0.8" with one click and directly view the reasons given by the large model. One-click rejection or correction is supported, thereby achieving production-level security auditing.

[0086] Example 2: Another embodiment of this application relates to a knowledge graph construction apparatus. The implementation details of this knowledge graph construction apparatus are described below. The following content is for ease of understanding and is not essential for implementing this solution. The schematic diagram of the knowledge graph construction apparatus in this embodiment can be seen as follows: Figure 2 As shown, it includes a dynamic query and network retrieval module 210, a candidate node extraction module 220, a hierarchical verification module 230, a set partitioning and disambiguation module 240, and a definition generation module 250.

[0087] The dynamic query and network retrieval module 210 is used to generate retrieval query statements for the current node to be expanded and to use the retrieval query statements to perform retrieval and obtain context reference source documents.

[0088] The candidate node extraction module 220 is used to extract a set of candidate child nodes related to the current node to be expanded based on the context reference source document.

[0089] The hierarchical verification module 230 is used to verify whether the candidate child nodes in the candidate child node set are strict subordinate concepts of the current node to be expanded, and to extract the valid candidate child node set from the candidate child node set based on the verification results.

[0090] The set partitioning and disambiguation module 240 is used to semantically group the valid candidate child nodes in the set of valid candidate child nodes to obtain mutually exclusive semantic groups and corresponding disambiguation actions. Based on the disambiguation actions, the corresponding semantic groups are disambiguated to obtain the standard child node set.

[0091] Definition generation module 250 is used to generate standard definitions for each standard child node in the standard child node set.

[0092] In some embodiments, the knowledge graph construction apparatus further includes: a recursive controller (LLM Orchestrator): serving as the core scheduling hub, responsible for managing the recursion depth, maintaining the queue of nodes to be expanded (supporting depth-first search (DFS) or breadth-first search (BFS) strategies), and coordinating the calling order and data flow of each functional module.

[0093] In some embodiments, the device further includes: The quality assessment and pruning module is used to perform multi-dimensional quantitative evaluation of each standard child node and its standard definition in the standard child node set to obtain a comprehensive quality score. Based on the comprehensive quality score, it determines whether to continue expansion. If the comprehensive quality score of all standard child nodes under the current expansion node is lower than the threshold and the current recursion depth has not reached the target recursion depth, then the current branch is pruned.

[0094] The graph storage and persistence module is used to write standard child nodes that have reached the threshold of comprehensive quality score into the graph database and create edges between standard child nodes and their parent nodes.

[0095] It is worth mentioning that all modules involved in this embodiment are logical modules. In practical applications, a logical unit can be a physical unit, a part of a physical unit, or a combination of multiple physical units. Furthermore, to highlight the innovative aspects of this application, this embodiment does not introduce units that are not closely related to solving the technical problems proposed in this application; however, this does not mean that other units are absent in this embodiment.

[0096] In some embodiments, the knowledge graph construction apparatus can implement the knowledge graph construction method in any of the above embodiments.

[0097] The specific implementation methods of the above modules can be found in Example 1, and will not be repeated here.

[0098] Example 3: Based on the above embodiments, this embodiment provides an application example of a knowledge graph construction system and method, and the overall system structure diagram is as follows. Figure 3 As shown, it mainly includes the following core software modules: Recursive Controller: As the core scheduling hub of the system, it is responsible for managing the recursion depth, maintaining the queue of nodes to be expanded (supporting depth-first DFS or breadth-first BFS strategies), and coordinating the calling order and data flow of various functional modules.

[0099] Dynamic Query and Online Retrieval Module: This module adaptively generates multi-dimensional retrieval queries based on the current node to be expanded, the industry background field and its corresponding parent path, and the current recursion depth. It also calls online retrieval interfaces (such as Tavily / SerpAPI) to obtain the latest authoritative unstructured text as context reference source documents.

[0100] Candidate node extraction module: Utilizes a large language model to read the retrieved context reference source document and extracts a list of candidate child nodes related to the current parent node under strong JSON Schema constraints.

[0101] Hierarchical verification module: Before each level of expansion, a confidence gate is introduced. The large language model is used to determine whether each candidate child node is a strict subordinate concept (subclass / component / concrete instance) of the parent node, and to filter out out-of-bounds nodes.

[0102] Set partitioning and disambiguation module: Receives the candidate child node set that has passed the hierarchical verification, performs batch set partitioning using a large language model, and outputs mutually exclusive semantic groups and corresponding disambiguation actions (merge / split / discard) and business reasons.

[0103] Definition generation module: Employing a parent node anchoring and industry context injection strategy, it generates high-precision definitions with business executability for the disambiguated standard child nodes.

[0104] Quality assessment and pruning module: Nodes are scored from three dimensions: industry relevance, definition clarity, and scalability. Low-quality branches are automatically pruned using a two-condition early stop rule.

[0105] The graph storage and persistence module is used to persist verified nodes and their "strictly subordinate" relationships to a graph database (such as Neo4j) and perform graph topology loop detection.

[0106] The core method flow and algorithm implementation are as follows: Let the industry background field input by the user be I, the analysis topic be the root node p0, the maximum recursion depth be D, and the current depth be d. The specific steps are as follows: Step 1: Root node initialization and queue construction.

[0107] The system will root node Write to the graph database and initialize the queue of nodes to be expanded:

[0108] Step 2: Dynamic query generation and contextual retrieval.

[0109] When queue If the value is not empty, the recursive controller retrieves the first element of the queue. If the current recursion depth If the condition is met, then skip that node. Otherwise, the dynamic query and network retrieval module generates a set of targeted retrieval query statements based on the industry background domain I, the name of the current node p, and its parent path, using a large language model:

[0110] The system uses the generated query to perform an online retrieval, obtaining a set of the top M highly relevant unstructured documents:

[0111] Step 3: Extract candidate child nodes.

[0112] The candidate node extraction module takes the document set Docs and the parent node p as context input, and extracts the potential candidate child node set C through a large language model. This step forces the large model to output structured data in the following format using JSON Schema: json { "candidates": [ {"name": "Candidate node name", "source_doc_idx": 0} ] } ``` Step 4: Strict Hierarchy Validation.

[0113] To prevent concept drift, the hierarchical verification module verifies each candidate node in the candidate child node set C. Strict verification of hierarchical relationships was conducted.

[0114] Large language models validate prompt words at specific levels to determine... Determine whether p is a strict subclass (subclass, component, or concrete instance) and output the boolean value is_strict_sub and the confidence level. :

[0115]

[0116] in, The preset hierarchical confidence threshold (taken in this embodiment) Only when At that time, candidate child nodes They are retained to form a valid candidate child node set. Nodes that do not meet the strict hierarchical relationship requirement (such as parallel concepts, causal relationships, influencing factors, etc.) are directly filtered out.

[0117] Step 5: Semantic disambiguation based on large model set partitioning (LLM Set Partitioning).

[0118] The set partitioning and disambiguation module receives the set of valid candidate child nodes. To avoid semantic comprehension biases caused by traditional pairwise vector similarity calculations, a batch set partitioning strategy is adopted. The entire input is taken into a large language model, which is then guided to group candidate child nodes based on semantic overlap, and outputs an equivalence class partition.

[0119] in, These are mutually exclusive semantic groups. The large language model considers each semantic group... Perform reasoning and output the corresponding disambiguation decision action. ):

[0120] If nodes within a group are synonyms, retain the representative node with the most accurate semantics and highest business value. The rest are merged; if the nodes in the group have overlapping dimensions but are not completely synonymous, they are split into orthogonal independent nodes; if none of the nodes in the group fit the industry context or have extremely low business value, they are discarded as a whole. After disambiguation, a clean set of layer nodes is obtained:

[0121] The output format of the disambiguation process is strictly constrained, as shown in the following example: json { "groups": [ { "group_id": 1, "nodes": ["deep learning", "neural network"], "reason": "In the current context, the engineering implementation and the theoretical model highly overlap; merging them is recommended." "action": "merge" } ] } ``` Step 6: Context-aware definition generation.

[0122] for For each pure standard child node c in the definition generation module, the standard definition is generated using the large language model. To eliminate concept drift, the generated prompts are subject to parent node anchoring rules, meaning that the generated definition must include the name of the parent node p as a qualifying prefix, and the number of characters is limited to a preset range (e.g., 30-50 characters) to ensure the business executability of the definition.

[0123] Step 7: Quality assessment and dynamic pruning.

[0124] The quality assessment and pruning module performs a multi-dimensional quantitative evaluation of the generated node c and its definition. The large language model scores the node based on three dimensions: industry relevance, definition clarity, and extensibility, calculating a comprehensive quality score. :

[0125] The system's early stopping condition for determining whether a branch should continue to expand is:

[0126] in, The preset quality threshold (taken in this embodiment) If the quality scores of all child nodes under the current node p are lower than 10, then ... If the branch is deemed to have no further value for expansion, it is immediately pruned, and its child nodes are no longer added to the queue for expansion.

[0127] Step 8: Graph writing and recursive enqueueing.

[0128] For child nodes that pass the quality assessment, the graph storage and persistence module writes them to the Neo4j graph database and creates a strict_sub_of edge between the child and parent nodes. Simultaneously, the system performs loop detection; if no loop is detected, (c, d+1) is pushed into a queue. Continue the loop until the queue is empty.

[0129] This embodiment abandons the traditional statistical approximation disambiguation method based on vector cosine similarity. Instead, it adopts a batch set partitioning disambiguation mechanism based on large-scale model semantic reasoning. The entire set of candidate child nodes at the same level is input into the large language model, and the deep semantic reasoning capability of the large model is used for batch set partitioning. The large language model not only outputs equivalence class groups but also explicitly outputs the disambiguation action (merging, splitting, or discarding) and specific business rationale for each group, achieving interpretability and high robustness of the disambiguation process.

[0130] In each step of the recursive expansion, this embodiment also introduces a hierarchical verification gate based on the confidence threshold θh. Through formal verification of the large model, it verifies whether there are strict proper subset, subclass, or component relationships between child nodes and parent nodes, thereby blocking the incorporation of parallel concepts and upstream and downstream concepts from the source and solving the common problems of "hierarchical flattening" and "concept drift" in open domain graph construction.

[0131] This embodiment introduces a dual-condition early stopping rule that combines multi-dimensional quality scoring of the large model (industry relevance, definition clarity, and scalability) with the count of effective child nodes. This achieves a value-driven dual-condition early stopping pruning mechanism. During the recursive process, the system can dynamically evaluate the business value of branches and automatically prune branches with low quality or no room for expansion, preventing node explosion and unnecessary consumption of computing resources.

[0132] When generating node definitions, the parent node anchoring rule is enforced, which requires that the definition must include the parent node name as a limiting prefix. Boundary constraints are also applied in conjunction with the context documents retrieved from the network, thus realizing a context-aware definition generation mechanism with parent node anchoring. This mechanism ensures that the generated definitions have extremely high business executability and eliminates ambiguity of homonyms in the graph.

[0133] In the test, a cold start graph was constructed for emerging cross-industry sectors lacking standard ontology libraries, such as the low-altitude economy and embodied intelligence, and the following results were achieved: New industry access time: shortened from the original "weekly manual parameter tuning and modeling" to "Prompt configuration and startup within 2 hours", achieving rapid cold start with zero annotation and zero pre-training.

[0134] Hierarchical topology accuracy: Based on expert sampling evaluation, the hierarchical accuracy (strict lower-level relationship preservation rate) of the map reaches over 88%.

[0135] Semantic disambiguation effect: Compared with the traditional "vector retrieval + DBSCAN clustering" baseline scheme, the semantic overlap rate of nodes in the same layer is reduced by more than 50%, the false merging rate is reduced by 40%, and the graph structure is clearer and more orthogonal.

[0136] Engineering robustness: By introducing asynchronous parallel calls (asyncio) and Redis caching mechanism, the single-layer build latency is controlled within 5 seconds, the token consumption cost is reduced by more than 60%, and there are no interruptions due to format parsing failures in 100 consecutive hours of automated recursive build tests.

[0137] Example 4: Another embodiment of this application relates to an electronic device, including: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the knowledge graph construction methods described in the above embodiments.

[0138] In this embodiment, the memory and processor are connected via a bus, which can include any number of interconnected buses and bridges, connecting various circuits of one or more processors and the memory together. The bus can also connect various other circuits, such as peripheral devices, voltage regulators, and power management circuits, which are well known in the art and therefore will not be further described in this embodiment. A bus interface provides an interface between the bus and the transceiver. The transceiver can be a single element or multiple elements, such as multiple receivers and transmitters, providing a unit for communicating with various other devices over a transmission medium. Data processed by the processor is transmitted over the wireless medium via an antenna, which further receives data and transmits it to the processor.

[0139] The processor manages the bus and general processing, and also provides various functions, including timing, peripheral interfaces, voltage regulation, power management, and other control functions. Memory is used to store data used by the processor during operation.

[0140] Example 5: Another embodiment of this application relates to a computer-readable storage medium storing a computer program. When executed by a processor, the computer program implements the above-described knowledge graph construction method embodiment.

[0141] That is, those skilled in the art will understand that all or part of the steps in the methods of the above embodiments can be implemented by a program instructing related hardware. This program is stored in a storage medium and includes several instructions to cause a device (which may be a microcontroller, chip, etc.) or processor to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0142] Those skilled in the art will understand that the above embodiments are specific embodiments for implementing this application, and in practical applications, various changes can be made to them in form and detail without departing from the spirit and scope of this application.

Claims

1. A method for constructing a knowledge graph, characterized in that, include: Generate a search query statement for the current node to be expanded and use the search query statement to retrieve the context reference source document; Based on the context reference source document, extract the set of candidate child nodes related to the current node to be expanded; Verify whether the candidate child nodes in the candidate child node set are strictly subordinate concepts of the current node to be expanded, and extract the set of valid candidate child nodes from the candidate child node set based on the verification results; Semantically group the valid candidate child nodes in the set of valid candidate child nodes to obtain mutually exclusive semantic groups and corresponding disambiguation actions. Disambiguate the corresponding semantic groups according to the disambiguation actions to obtain the standard child node set. Generate a standard definition for each standard child node in the set of standard child nodes.

2. The knowledge graph construction method according to claim 1, characterized in that, Also includes: Initialize the root node, write the root node to the graph database, and initialize the queue of nodes to be expanded; When the queue of nodes to be expanded is not empty, the first element of the queue of nodes to be expanded is taken out and determined as the current node to be expanded; Generate a search query for the current node to be expanded and use the search query to perform a search to obtain the context reference source document, including: Based on the industry background, the current node to be expanded and its corresponding parent path, and the current recursion depth, a multi-dimensional retrieval query statement is adaptively generated using a large language model. The retrieval query statement is then used to perform online retrieval to obtain a set of M highly relevant unstructured text documents as context reference source documents.

3. The knowledge graph construction method according to claim 1, characterized in that, Based on the aforementioned context reference source document, a set of candidate child nodes related to the current node to be expanded is extracted, including: Using the context reference source document and the current node to be expanded as context input, a set of candidate child nodes related to the current node to be expanded is extracted using a large language model, and the formatted data of the candidate child node set is output under the constraints of JSON Schema.

4. The knowledge graph construction method according to claim 1, characterized in that, The standard definition includes the name of the parent node as a prefix, and the number of characters is limited to a preset range.

5. The knowledge graph construction method according to claim 1, characterized in that, Also includes: Each standard sub-node and its standard definition in the standard sub-node set are evaluated quantitatively from multiple dimensions to obtain a comprehensive quality score. The decision to continue expansion is based on the comprehensive quality score.

6. The knowledge graph construction method according to claim 5, characterized in that, A multi-dimensional quantitative evaluation is performed on each standard sub-node and its standard definition in the standard sub-node set to obtain a comprehensive quality score. Based on the comprehensive quality score, it is determined whether to continue expansion, including: If the overall quality score of all standard child nodes under the current expansion node is lower than the threshold, and the current recursion depth has not reached the target recursion depth, then the current branch will be pruned.

7. The knowledge graph construction method according to claim 6, characterized in that, A multi-dimensional quantitative evaluation is performed on each standard sub-node and its standard definition in the standard sub-node set to obtain a comprehensive quality score. Based on the comprehensive quality score, a decision is made on whether to continue expansion. This also includes: Write the standard child nodes that reach the threshold of the comprehensive quality score into the graph database, and create an edge between the standard child node and its parent node.

8. A knowledge graph construction device, characterized in that, include: The dynamic query and network retrieval module is used to generate a retrieval query statement for the current node to be expanded and to use the retrieval query statement to perform a retrieval and obtain the context reference source document. The candidate node extraction module is used to extract a set of candidate child nodes related to the current node to be expanded based on the context reference source document. The hierarchical verification module is used to verify whether the candidate child nodes in the candidate child node set are strictly subordinate concepts of the current node to be expanded, and to extract the valid candidate child node set from the candidate child node set based on the verification result. The set partitioning and disambiguation module is used to semantically group the valid candidate child nodes in the set of valid candidate child nodes, obtain mutually exclusive semantic groups and corresponding disambiguation actions, and disambiguate the corresponding semantic groups according to the disambiguation actions to obtain the standard child node set. The definition generation module is used to generate a standard definition for each standard child node in the standard child node set.

9. An electronic device, characterized in that, include: At least one processor; as well as, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the knowledge graph construction method as described in any one of claims 1 to 7.

10. A computer-readable storage medium storing a computer program, characterized in that, When the computer program is executed by a processor, it implements the knowledge graph construction method according to any one of claims 1 to 7.

Images