Fine-grained intention recognition method for large-model complex instruction

Abstract

The invention relates to the technical field of natural language processing and artificial intelligence, and discloses a large-model complex instruction-oriented fine-grained intention recognition method, which comprises the following steps of: constructing a candidate analysis forest of an input instruction, and executing entity alignment of each node and a domain knowledge graph; performing semantic compatibility verification on the candidate dependency trees by utilizing entity relationships in the atlas, and screening an optimal analytic tree in combination with syntactic probability and knowledge consistency scores; if the analytic tree meeting the threshold value does not exist, a semantic conflict edge is positioned, and candidate mounting points are searched by using a map neighborhood relation to reconstruct a dependency structure; and finally, generating standardized data containing a structured analytic path based on the optimal analytic tree, and performing fine adjustment on the large model. According to the method, logic constraint and dynamic repair are carried out on the syntactic structure by introducing the knowledge graph, analysis errors caused by multiple modification or structural ambiguity in a complex instruction are effectively solved, and the accuracy and robustness of intention recognition of a large model in the vertical field are improved.

Description

Technical Field

[0001] This invention relates to the fields of natural language processing and artificial intelligence, specifically to a fine-grained intent recognition method for complex instructions in large models. Background Technology

[0002] With the increasing application of large language models in vertical industries such as finance, aviation, and healthcare, the form of human-computer interaction commands is evolving from simple keyword queries to complex natural language commands that include multiple constraints, nested logic, and parallel relationships. When processing such complex commands, the accuracy of intent recognition directly determines the correctness of downstream task execution.

[0003] Existing large language model intent recognition technologies primarily rely on the probabilistic statistical patterns of massive text data for end-to-end generation and prediction. While this approach demonstrates strong fluency in general scenarios, it often struggles to accurately capture fine-grained semantic constraints when faced with complex and logically rigorous long and difficult sentences in vertical domains. Due to the lack of explicit modeling and verification mechanisms for the deep syntactic structure within instructions, the model is prone to content illusions or loss of key parameters when dealing with ambiguous prepositional phrases, unclear referents, or logical nesting, resulting in generated intent results that do not conform to actual business logic.

[0004] On the other hand, traditional semantic parsing methods typically employ deterministic dependency parsers to transform text into logical forms. However, most existing dependency parsing techniques output a single optimal syntactic tree based solely on linguistic features, neglecting the potential structural ambiguity in complex sentences. When the syntactic model malfunctions due to training corpus bias or domain differences, subsequent intent extraction will be based on the incorrect structure and cannot self-correct. More critically, existing syntactic analysis processes are disconnected from external knowledge bases such as domain knowledge graphs, failing to leverage domain-defined entity attributes and relational constraints to verify the business rationality of the syntactic structure. This often results in grammatically fluent parsing results that are logically conflicting in specific business scenarios, limiting the robustness and reliability of intent recognition systems in complex business environments. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides a fine-grained intent recognition method for complex instructions in large models, solving the problems of ambiguity and low accuracy in intent parsing caused by the lack of domain logic constraints and structural verification mechanisms when processing complex instructions in vertical domains.

[0006] To achieve the above objectives, the first aspect of the present invention is implemented through the following technical solution: a fine-grained intent recognition method for complex instructions in large models, comprising the following steps:

[0007] S1: Construct a candidate parsing forest for complex input instructions;

[0008] S2: Perform entity alignment between each node in the candidate parsing forest and the domain knowledge graph;

[0009] S3: Calculate semantic consistency based on feedback from the domain knowledge graph and select the optimal parse tree;

[0010] S4: Perform graph-based structural reconstruction when no parse tree meets the threshold;

[0011] S5: Generate standardized intent data based on the optimal parse tree and fine-tune the large model.

[0012] Furthermore, to effectively distinguish different syntactic structures in the candidate parsing forest, this invention proposes a semantic consistency calculation and filtering scheme based on knowledge graph feedback. The core of this scheme lies in using a domain knowledge graph as an external, objective logical benchmark to verify the legitimacy of dependency relations generated purely by the syntactic model.

[0013] Specifically, the step of calculating semantic consistency and selecting the optimal parse tree based on the feedback of the domain knowledge graph includes processing each dependency edge in the candidate dependency tree. Perform semantic compatibility verification. This is done using a domain knowledge graph. Searching for nodes at both ends of a dependency edge Corresponding entity To quantify the validity of the dependency relationship, we need to determine if there is a direct or indirect logical path between them. Then, we combine this with the syntactic prior probabilities output by the dependency parsing model. Consistency score with calculated knowledge By integrating scoring functions To select the optimal parse tree

[0014] ;

[0015] in, These are preset weight hyperparameters. This scheme combines data-driven syntactic analysis with knowledge-driven logical reasoning, effectively resolving structural ambiguities in complex instructions.

[0016] Furthermore, to address the parsing failure issue when all candidate syntactic structures conflict with domain knowledge, this invention proposes a dynamic structure reconstruction scheme based on graph relations. This scheme is triggered when the scores of all candidate trees fall below a preset safety threshold, proactively correcting erroneous syntactic structures.

[0017] Specifically, the structural reconstruction step first locates the dependency edge that causes semantic conflict and marks the subordinate node of the edge as a free node. Then, the system uses the topological structure of the domain knowledge graph to search for neighboring entities that are logically related to the entity corresponding to the free node in the graph, and finds new candidate mount points that conform to business logic in the original instruction sequence accordingly.

[0018] By disconnecting the original conflicting edges and establishing new dependency edges, the topology of the dependency tree is corrected. This scheme enables the system to self-correct syntactic analysis errors and improves its robustness to long and complex sentences or unconventional expressions.

[0019] A second aspect of the present invention provides a fine-grained intent recognition system for large-scale complex instructions, the system being configured to perform the steps of the aforementioned method.

[0020] Specifically, the system includes: a candidate parsing forest construction module, an entity alignment module, a consistency calculation and screening module, a structure reconstruction module, and a data generation and training module.

[0021] In summary, this application includes at least one of the following beneficial technical effects:

[0022] 1. This invention introduces a domain knowledge graph to perform semantic consistency verification on candidate parse forests, uses the logical relationships between entities in the graph to verify the legality of dependency syntax structures, and combines syntactic probability and knowledge consistency scores to select the optimal parse tree. This effectively resolves the ambiguity in complex instructions caused by vague or ambiguous modification relationships, and significantly improves the accuracy of fine-grained intent recognition in vertical domains.

[0023] 2. This invention designs a dynamic structural reconstruction mechanism based on graph relationships. When none of the candidate parsing structures meet the confidence threshold, it can automatically locate the dependency edges with semantic conflicts and actively search for mounting points that conform to business logic using the topological structure of the knowledge graph to correct the syntax tree. This enables the system to have structural self-healing ability when faced with syntax model failure or abnormal input, and enhances the robustness of the intent recognition system in processing long and difficult sentences.

[0024] 3. This invention supervises and fine-tunes large language models by constructing standardized intent data containing structured parsing paths, transforming the explicit logical constraints of knowledge graphs into parameter weights that the model can learn. This enables large models to directly output structured intents verified by domain logic during the inference phase, effectively reducing the risk of content illusion in traditional large models in specific business scenarios and improving the interpretability of the intent parsing process. Attached Figure Description

[0025] Figure 1 This is a flowchart of the method of the present invention;

[0026] Figure 2 This is a system architecture diagram of the present invention. Detailed Implementation

[0027] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0028] Example:

[0029] Please see the appendix Figure 1 This invention provides a fine-grained intent recognition method for complex instructions in large models, comprising the following steps:

[0030] S1. Construct a candidate parsing forest for complex input instructions;

[0031] S2. Align each node in the candidate parsing forest with the entities in the domain knowledge graph;

[0032] S3. Calculate semantic consistency based on feedback from domain knowledge graph and select the optimal parse tree;

[0033] S4. Perform graph-based structural reconstruction when there is no parse tree that meets the threshold;

[0034] S5. Generate standardized intent data based on the optimal parse tree and fine-tune the large model.

[0035] Please see the appendix Figure 2 This invention provides a fine-grained intent recognition system for complex instructions in large models, comprising: a candidate parsing forest construction module, an entity alignment module, a consistency calculation and filtering module, a structure reconstruction module, and a data generation and training module.

[0036] In S1, which constructs a candidate parsing forest for complex input instructions, the system does not output only a single optimal syntactic analysis result. Instead, it generates a set containing multiple potential dependency syntactic structure trees by preserving ambiguous paths during the parsing process. This process specifically includes the following sub-steps:

[0037] Instruction serialization and basic feature extraction.

[0038] The system receives complex natural language commands as input and defines them as word sequences. ,in Represents the nth lexical unit in the instruction. The sequence length is specified. The system performs word segmentation and part-of-speech tagging on the sequence, defining each lexical unit as a word. Assign corresponding part-of-speech tags The specific implementation algorithms for word segmentation and part-of-speech tagging, such as sequence tagging algorithms based on Hidden Markov Models or Conditional Random Fields, are well-known technologies to those skilled in the art and will not be elaborated upon here.

[0039] Dependency structure prediction based on probabilistic models.

[0040] The system uses a pre-built probabilistic dependency parser to process instruction sequences with part-of-speech tags. Unlike deterministic dependency parsing, which directly constructs a single dependency tree, this parser calculates the conditional probability of any possible dependency tree structure TT given the input sequence. .

[0041] A dependency tree is defined as a directed graph. , where is a set of nodes, node 0 is the virtual root node, and nodes 11 to 12 are virtual nodes. Corresponding vocabulary sequence ; For a set of directed dependent edges, the edges Words It is a word The governing word, yes The dependent words, and each edge is associated with a dependency label.

[0042] The model evaluates the probability score of the entire tree by summing the scores of all dependent edges in the tree. For each edge... The model calculates its score. The whole tree Score Represented as:

[0043] ;

[0044] The corresponding conditional probabilities are normalized using the Softmax function.

[0045] Candidate forest generation based on beam search strategy.

[0046] To capture structural ambiguities in complex instructions caused by different placements of prepositional phrases or unclear modification scopes, the system employs a bundle search strategy or a Top-K decoding algorithm for structural filtering. The system sets the bundle width parameter. During the decoding process, the highest-scoring complete dependency tree structure is retained to form a candidate parse forest. .

[0047] The candidate parsing forest must meet the following selection criteria for construction:

[0048] ;

[0049] in, Represents the space of all possible legal dependency trees. Let the i-th candidate dependency tree be . This represents the rank after sorting the probability values ​​from largest to smallest.

[0050] In this process, the system not only retains the optimal solution with the highest probability, but also retains the second-best solutions whose probability values ​​differ from the optimal solution within a preset range. Both of these potential semantic structures are stored in the candidate parsing forest, providing a structural foundation for subsequent knowledge graph-based semantic disambiguation.

[0051] In step S2, which aligns each node in the candidate parsing forest with entities in the domain knowledge graph, the system maps unstructured lexical items in natural language instructions to structured knowledge base entities, thereby transforming textual symbols into semantic objects. This process specifically includes the following sub-steps:

[0052] Data structure definition for domain knowledge graph.

[0053] The system has pre-configured or integrated domain knowledge graphs built for specific vertical fields. The graph is formally defined as a set of triples. , where represents the set of all entities in the graph. A set representing the relationships between entities. A triple representing a specific fact. Each entity It includes the standard name, a list of synonyms, and the concept type attribute to which it belongs.

[0054] This involves analyzing the traversal of forest nodes and the retrieval of candidate entities.

[0055] The system uses a candidate parse forest. Each candidate dependency tree in Perform node traversal. For each word node in the tree... The system uses the textual form of the word and its part-of-speech tag as query conditions in the entity set of the domain knowledge graph. Search within.

[0056] The retrieval process employs a strategy combining exact matching and fuzzy matching. For exact matching, the system directly queries the entity's standard name or the thesaurus for matches. Completely identical entities. For fuzzy matching, the system uses an edit distance algorithm or a character-level N-gram-based similarity algorithm to calculate... Similarity to the surface form of entities in the graph. The specific algorithm for similarity calculation is well-known in the field and will not be elaborated here. The system selects entities with similarity scores higher than a preset threshold as the candidate entity set for the word node.

[0057] Entity disambiguation and final mapping based on semantic vectors.

[0058] When a word node When dealing with multiple candidate entities, the system performs entity disambiguation. The system obtains vocabulary through a pre-trained word vector model. Vector representation in the current instruction context Simultaneously, the vector representations of each candidate entity in the graph embedding space are obtained. The system calculates the cosine similarity between the two:

[0059] ;

[0060] The system selects similarity The highest-ranking entity is used as the final mapping result to establish the mapping function. If vocabulary If the highest similarity is still lower than the preset minimum matching threshold, or if the word belongs to the stop word list, then its mapping result is marked as null. This indicates that the term has no corresponding entity object in the current domain graph.

[0061] Through the above steps, each word node in the candidate parsing forest is given a clear graph entity identifier, thereby expanding the tree structure that originally only had syntactic dependency relations into a semantic graph structure with entity attribute associations.

[0062] In S3, which uses domain knowledge graphs to compute semantic consistency and select the optimal parse tree, an external knowledge base is introduced to logically verify the syntactic structures in the candidate parse forest. By quantifying the rationality of each candidate dependency tree at the business logic level, ambiguous structures are accurately resolved. This process specifically includes the following sub-steps:

[0063] Dependency edge semantic compatibility check.

[0064] The system processes each dependency edge in the candidate dependency tree. Perform semantic logic verification. Here, nodes are subordinate terms, and nodes are governing terms. The system establishes a mapping function based on the preceding steps. Retrieve the corresponding entity in the knowledge graph. and .

[0065] The system defines a semantic compatibility function to quantify the reasonableness of the dependency relationship. When When both are valid entities, the system in the domain knowledge graph Search for a path connecting the two. If a direct relationship exists... Make triplet or It exists in the graph, or has a length not exceeding the preset number of jumps. If the indirect path is a valid path, then the dependency edge is determined to be semantically compatible, and the function value is... Set to a positive value. If no connection path exists in the graph, it indicates an incorrect modification relationship has been established, which is judged as a semantic conflict, and the function value is set to... Set a larger negative penalty value .when or When at least one null value exists in the dependency edge, the dependency edge does not directly carry core business logic conflicts, and the system assigns it a smoothing score. To maintain the integrity of the tree structure, a score is given.

[0066] Calculation of knowledge consistency score for candidate trees.

[0067] The system calculates the entire candidate tree based on the compatibility results of each dependency edge. Knowledge Graph Consistency Score This score reflects the degree to which the syntactic structure fits the domain knowledge. To eliminate scoring bias caused by differences in the number of nodes among different candidate trees, the system employs an averaging method:

[0068] ;

[0069] in, For trees The set of all dependent edges in the set. This represents the total number of edges in the set.

[0070] Integrating scoring and optimal structure selection.

[0071] The system combines the syntactic prior probabilities output by the probabilistic dependency parser. Consistency score with the above knowledge Construct a fusion scoring function This scoring aims to identify parsing results that have a high probability of syntactic structure and conform to the domain's business logic.

[0072] The system calculates the fusion score for each tree in the candidate parse forest. First, perform hard constraint filtering; if the score of a certain tree contains... Extremely low negative values ​​resulting from this are directly removed from the forest. Then, among the remaining candidate trees, the system selects the tree with the highest fusion score as the optimal parse tree. This tree structure is considered the optimal structure for expressing the intent of complex instructions while taking into account both linguistic principles and business logic constraints.

[0073] In S4, which performs graph-based structural reconstruction, if all candidate trees in the candidate parse forest fail the consistency check or have too low a score, the system executes proactive structural repair logic. This process does not rely on the syntactic model's re-prediction but directly utilizes the knowledge graph's topology to guide edge reconnection of dependency trees, specifically including the following sub-steps:

[0074] Reconstruction trigger judgment and conflict location.

[0075] The system detects the optimal parse tree generated by S3. Fusion score If the score is lower than the preset safety threshold... If the candidate forest is cleared during pruning, a structural reconstruction mechanism is triggered. The system backtracks the candidate tree with the highest score and locates the one that caused the semantic compatibility function. Obtain negative penalty value Conflict Dependency The subordinate node connected by this edge A node is marked as a free node because its current mounting location is not valid in the business logic.

[0076] Search for potential mount points based on graph neighborhood.

[0077] For free nodes The system obtains the corresponding map entity. The system utilizes domain knowledge graphs. Query entities The set of all one-hop or multi-hop neighbor nodes At the same time, the system is in the lexical sequence of the current instruction. In the process, all word nodes that have been successfully mapped to any entity in the set are identified, forming a potential parent node set. .

[0078] and ;

[0079] The nodes in this set are candidate mounting points that have a logical connection with the free nodes at the knowledge graph level.

[0080] Structural modification under dependency distance constraints.

[0081] The system starts from the set of potential parent nodes. Nodes that meet the linear distance constraint are selected as new parent nodes. The selection criteria are based on nodes. and The absolute value of the position index difference in the original instruction sequence Minimum, and this distance is less than the preset dependency window size. The system disconnects the original conflicting edge. and establish new dependency edges. This generates the corrected dependency tree structure. .

[0082] Secondary verification of the reconstructed structure.

[0083] The system will correct the tree structure Re-enter the data into the consistency calculation module and recalculate its knowledge consistency score. If the corrected score is higher than the threshold... Then If the result is confirmed as the final optimal parse tree, and is still below the threshold, the instruction is marked as an unparseable abnormal sample and output to the manual review queue for graph completion or rule intervention.

[0084] Through the above reconstruction process, the system can correct the modification relation errors caused by syntactic model deviations, and use the prior logic of the knowledge graph to enforce constraints on the syntactic structure, ensuring the logical consistency of the output intent.

[0085] In S5, which generates standardized intent data based on the optimal parse tree and fine-tunes the large model, the system transforms the optimal parse tree, validated and reconstructed by the knowledge graph, into instruction fine-tuning samples for training the large language model, and then performs model parameter updates. This process specifically includes the following sub-steps:

[0086] The system defines a transformation rule function for mapping tree structures to intent slots. Dependency tree structure Mapped to a structured JSON object The transformation process follows this logic: First, identify the root node or predicate verb node of the tree and map it to the core intent field Intent. Second, traverse the direct child nodes of the root node and its subtrees.

[0087] To enhance the interpretability of large model outputs, the system generates a structured parsing path text that describes the parsing process, in addition to the final JSON object, when generating training data. The text is generated by depth-first traversal of the optimal parse tree. For each node mapped to an intent or slot, its corresponding dependency label and text content are recorded.

[0088] Supervised fine-tuning training of large models involves constructing a training dataset containing a large number of training samples. Each training sample consists of raw natural language instructions. As input, the structured parsed path text... The sequence concatenated with the final JSON object is used as the target output. A causal language modeling objective function is employed to fine-tune the parameters of the pre-trained large language model. The model parameters are set as follows: For each sample, the model needs to predict the target output sequence based on the input. The optimization objective is to minimize the negative log-likelihood loss function. :

[0089] ;

[0090] in, Represents the target sequence The first Token in the array, This represents the generated preceding token sequence. Through this fine-tuning process, the model parameters are updated to enable it to generate a structured intent representation that conforms to the logic of the domain knowledge graph when receiving similarly complex instructions.

Claims

1. A fine-grained intent recognition method for complex instructions in large models, characterized in that, Includes the following steps: S1: Construct a candidate parsing forest for complex input instructions; S2: Perform entity alignment between each node in the candidate parsing forest and the domain knowledge graph; S3: Calculate semantic consistency based on feedback from the domain knowledge graph and select the optimal parse tree; S4: Perform graph-based structural reconstruction when no parse tree meets the threshold; S5: Generate standardized intent data based on the optimal parse tree and fine-tune the large model.

2. The method according to claim 1, characterized in that, The construction of the candidate parsing forest for complex input instructions includes: Probabilistic dependency analysis is performed on the complex instructions to calculate the conditional probabilities of different dependency tree structures; A beam search strategy or a Top-K decoding algorithm is used to retain multiple dependency parsing trees whose conditional probability is higher than a preset threshold, in order to form the candidate parsing forest.

3. The method according to claim 1, characterized in that, The process of aligning each node in the candidate parsing forest with the entities in the domain knowledge graph includes: Map the vocabulary nodes in the candidate parsing forest to the corresponding entities in the domain knowledge graph; When a word node corresponds to multiple candidate entities, entity disambiguation is performed based on the similarity between the semantic vector representation of the word node in the instruction context and the vector representation of each candidate entity in the graph embedding space to determine the final mapping result.

4. The method according to claim 1, characterized in that, The step of calculating semantic consistency and selecting the optimal parse tree based on the feedback of the domain knowledge graph includes: Semantic compatibility verification is performed on each dependency edge of the candidate dependency tree in the candidate parsing forest. The verification is performed by searching in the domain knowledge graph to see if there is a logical path between the entities corresponding to the nodes at both ends of the dependency edge. Based on the semantic compatibility verification results, the knowledge consistency score of each candidate dependency tree is calculated; The fusion score is calculated by combining the syntactic probability of dependency analysis with the knowledge consistency score. The optimal parse tree is selected based on the fusion score.

5. The method according to claim 4, characterized in that, The specific method for semantic compatibility verification is as follows: If the entities corresponding to the two ends of the dependency edge have a direct or indirect connection path in the domain knowledge graph, then the dependency edge is determined to have semantic compatibility. If no connection path exists, it is determined to be a semantic conflict, and a negative penalty value is assigned to the dependent edge.

6. The method according to claim 1, characterized in that, The method of performing graph-based structural reconstruction when no threshold-compliant parse tree exists includes: When the scores of all candidate trees in the candidate parsing forest are lower than a preset safety threshold, the structure reconstruction mechanism is triggered; Locate the conflicting dependency edges that cause semantic conflicts, and mark the dependent nodes of the edges as free nodes; Search the domain knowledge graph for neighboring nodes that have a logical relationship with the entity corresponding to the free node to determine candidate mounting points; Disconnect the conflicting dependency edges and establish new dependency edges from the free node to the candidate mount point to generate the modified dependency tree structure.

7. The method according to claim 1, characterized in that, The generation of standardized intent data based on the optimal parse tree includes: Identify the root node or predicate verb node of the optimal parse tree and map it to the core intent; Based on the dependency relationship labels, map the child nodes of the root node to intent parameter slots; The child nodes of the intent parameter slot node are extracted as constraints for that slot and converted into a structured JSON object.

8. The method according to claim 7, characterized in that, After generating the standardized intent data, the process also includes: By traversing the optimal parse tree, a structured parse path text describing the parse process is generated; The original complex instructions are used as input, and the structured parsed path text and the structured JSON object are concatenated as the target output to construct training samples.

9. The method according to claim 8, characterized in that, The fine-tuning of the large model includes: The parameters of a pre-trained large language model are fine-tuned using a causal language modeling objective function. The optimization objective of the fine-tuning is to minimize the negative log-likelihood loss function for predicting the standardized intent data or the target output part in the training samples based on the complex instructions.

10. A fine-grained intent recognition system for large-scale complex instructions, comprising a fine-grained intent recognition method for large-scale complex instructions according to any one of claims 1-9, characterized in that, include: The candidate parse forest building module is used to build a candidate parse forest for complex input instructions; The entity alignment module is used to perform entity alignment between each node in the candidate parsing forest and the domain knowledge graph; The consistency calculation and filtering module is used to calculate semantic consistency based on the feedback of the domain knowledge graph and filter the optimal parse tree; The structure reconstruction module is used to perform graph-based structure reconstruction when there is no parse tree that meets the threshold. The data generation and training module is used to generate standardized intent data based on the optimal parse tree and to fine-tune the large model.

Images