Intelligent dialogue system for complex multi-intention scene
Through pseudo-code decomposition and asynchronous execution of the scheduling graph, the response lag problem of the Q&A system in complex multi-intention scenarios is solved, efficient multi-intention problem handling is achieved, and user experience and system capabilities are improved.
Patent Information
- Application Number
- CN202510364461.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-03-26
- Publication Date
- 2025-07-08
AI Technical Summary
Existing Q&A systems are difficult to efficiently handle complex multi-intention scenarios, resulting in lagging responses and poor user experience.
The pseudo-code prompt word template decomposes user problems, builds a scheduling chart and executes sub-problems asynchronously, and uses a large language model to perform single-step planning and result analysis to realize parallel processing of multi-intention problems.
It improves the response efficiency of the Q&A system to complex multi-intention problems, optimizes the user experience, expands the scope of capabilities of large language models, and adapts to diversified and multi-domain tools.
Smart Images
Figure CN120277186A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of intelligent conversations, and in particular to an intelligent conversation system for complex multi-intent scenarios. Background Art
[0002] With the development of artificial intelligence and natural language processing technologies, question-and-answer systems have become an important part of human-computer interaction. Traditional question-and-answer systems are usually designed for single-intent or simple questions. However, with the complexity of user requirements, more and more scenarios require the system to be able to handle complex inputs containing multi-intents and multi-level dependencies. Such inputs usually involve multiple sub-questions, context associations, and complex logical reasoning. Most of the existing technologies can only handle relatively simple user intents. When faced with such complex user inputs, a very complex planning and reasoning process is required, which leads to a lag in the response of the entire system and a poor user experience. However, the complex multi-intent problems of users can actually be decomposed into several relatively simple sub-questions, and there may be serial and parallel relationships between these sub-questions. If the parallel problems can be reasonably executed asynchronously, the response of the entire system can be optimized. Summary of the Invention
[0003] Object of the Invention: The technical problem to be solved by the present invention is to provide an intelligent conversation system for complex multi-intent scenarios in view of the deficiencies of the prior art.
[0004] To solve the above technical problem, the present invention discloses 1. An intelligent conversation system for complex multi-intent scenarios, including the following steps:
[0005] Step 1, input a user question;
[0006] Step 2, fill a pseudo-code prompt word template based on the question input by the user;
[0007] Step 3, use the prompt words in the prompt word template in Step 2 as the input of the large language model for prediction, and the prediction result is a single-step planning result;
[0008] Step 4, parse the single-step planning result in Step 3 and construct a scheduling graph;
[0009] Step 5, return the answer result of the user question by executing the scheduling graph.
[0010] In Step 2, the prompt word template includes:
[0011] Module 1, an instruction for task decomposition;
[0012] Module 2, predefined tools, including the definition, description, and parameter information of the predefined tools; (used to solve the sub-questions after task decomposition)
[0013] Module Three: Example of Pseudocode;
[0014] Module Four: Filled User Input Questions.
[0015] In Step 3, the single-step planning result is in the format of pseudocode. The result of pseudocode planning is to break down the complex intentions of the user, ensuring that each line of pseudocode is an independent sub-problem and can be directly solved by the predefined tools in Step 2.
[0016] The specific steps for constructing the scheduling graph in Step 4 are as follows:
[0017] Step 4-1: Through regular parsing processing, split the single-step planning result generated in Step 3 into multiple independent single-step plans;
[0018] Step 4-2: Perform regular parsing processing on each independent single-step plan in Step 4-1 to obtain a quadruple containing a result variable, a called function, a parameter name, and a parameter variable for the execution of subsequent tool functions;
[0019] Step 4-3: Construct a scheduling graph with the START node as the starting node and the RES node as the ending node, and use the quadruple corresponding to each independent single-step plan as an intermediate node;
[0020] Step 4-4: If the result variable of an intermediate node is equal to the parameter variable of another intermediate node, connect these two nodes, and complete the construction of the scheduling graph by connecting all nodes that meet the conditions.
[0021] The regular parsing processing described in Step 4-1 is as follows:
[0022] 4-1-1: Remove all leading and trailing spaces, redundant line breaks, and empty lines;
[0023] 4-1-2: Using the line break as the demarcation point, split the pseudocode corresponding to the single-step planning result into independent code lines, and remove the redundant spaces before and after each code line.
[0024] The specific steps for the regular parsing processing described in Step 4-2 are as follows:
[0025] 4-2-1: Use regular expressions to parse out a triple containing three elements: a result variable, a called function, and parameter information;
[0026] 4-2-2: Perform specific processing on the parameter information in the triple in Step 4-2-1 under different circumstances:
[0027] Case 1: If the parameter information is empty, set the parameter name and parameter variable of the triple to be empty;
[0028] Case 2: If the parameter information is not empty, use regular expressions to split the complete parameter information into multiple independent parameter information to ensure that each piece of parameter information has only one parameter name and one parameter variable. Then use regular expressions to further split each split parameter information into two parts: parameter name and parameter variable, obtaining a quadruple. In step 4-3, the specific operation of constructing the scheduling graph is as follows:
[0029] Step 4-3-1: Construct the starting node START node;
[0030] Step 4-3-2: Traverse the quadruples obtained in step 4-2 and add each quadruple to the graph structure in turn. The specific measures are as follows:
[0031] If the parameter name and parameter variable are empty, connect this node to the START node;
[0032] If the parameter name and parameter variable are not empty, traverse all parameter variables, and connect other nodes whose result variable is equal to the parameter variable of this node to this node respectively;
[0033] Step 4-3-3: Construct the RES node as the ending node, and by default, the tail node of RES is empty.
[0034] In step 5, the execution process of the scheduling graph is as follows:
[0035] Step 5-1: Initialize the process pool;
[0036] Step 5-2: Starting from the START node, add the current node whose previous node has completed execution to the process pool in turn. By default, the START node is considered an already executed node;
[0037] Step 5-3: Asynchronously execute all node tasks in the process pool. After each child node finishes execution, dynamically update the graph structure with the execution result and asynchronously return the result to the user;
[0038] Step 5-4: End all actions when reaching the RES node.
[0039] Through the construction of the scheduling graph, the present invention realizes the multi-threaded execution and solution of multi-intent problems, improving the efficiency of question answering.
[0040] The specific operations in step 5-3 are as follows:
[0041] For a node whose previous node is START, directly execute it and directly output the execution result to the user;
[0042] For nodes whose previous node is not START, an extraction node is additionally added before the current node to extract structured parameter information. Since the function execution result of the previous node may be unstructured text and cannot be directly used for the execution of the current function, an extraction node needs to be additionally added before the current node to extract structured parameter information, and the current node can only be executed after all the previous executions of the current node.
[0043] The specific operation of adding an extraction node is as follows:
[0044] Step 5-3-1: Fill the prompt template with the execution results of all executed nodes, and use this prompt template as the input to the large model to obtain the target parameters required for the function to call the current node;
[0045] Step 5-3-2: According to the target parameters obtained in Step 5-3-1, update the graph structure according to different situations:
[0046] Situation 1: If the target parameter is empty, set the return results of the current node and all subsequent child nodes to empty;
[0047] Situation 2: If the target parameter is a single parameter, insert the extraction node between the current node and its previous node, and use this single parameter as the parameter variable of the current node;
[0048] Situation 3: If the target parameter is multiple parameters, copy the current node and all subsequent child nodes except the RES node, and the number of copies is equal to the number of parameters. Each copied node subtree uses one of the multiple parameters as the parameter variable in turn, and the extraction nodes are inserted between each copied node subtree and its previous node respectively.
[0049] Beneficial effects:
[0050] 1. For the input problem of complex user intentions, through task decomposition and planning in the form of pseudocode, a question-answering framework for reasonable scheduling of user questions is constructed, breaking through the bottleneck of the capabilities of large language models, enabling the entire question-answering system to answer more complex questions;
[0051] 2. A general technical framework is constructed, which can adapt to diverse, multi-form, and multi-domain tools, greatly expanding the scope of capabilities of large language models;
[0052] 3. Through the scheduling graph, sub-questions with dependency relationships in multiple intentions are reasonably planned to achieve the solution of complex dependency problems. At the same time, based on the graph structure, all nodes without dependency relationships can be conveniently processed in parallel, greatly improving the overall response speed of the system and optimizing the user experience. Description of the Drawings
[0053] Figure 1 This is the flowchart of the present invention.
[0054] Figure 2 This is a schematic diagram of the initial construction scheduling graph.
[0055] Figure 3 This is a schematic diagram of the scheduling graph after inserting the extraction node.
[0056] Figure 4 This is a schematic diagram after updating the child nodes after the extraction node action is completed. Specific implementation mode
[0057] To solve the deficiencies of the prior art, this patent conducts planning and decomposition of the complex intentions of users based on pseudocode, ensuring that a single complex problem can be decomposed into multiple relatively simple sub-problems, effectively realizing the solution of complex multi-intention problems. At the same time, the natural topological order of pseudocode ensures that the logical relationships between each sub-problem can be easily modeled. Based on the planning results of pseudocode, a scheduling graph for solving sub-problems can be constructed, and asynchronous execution and dynamic update can be carried out based on the constructed scheduling graph, effectively reducing the response time of the entire link for solving problems.
[0058] The present invention discloses an intelligent dialogue system for complex multi-intention scenarios, including the following steps:
[0059] Step 1: Input the user's question;
[0060] "Please help me check the increase rate of all the stocks in my account since I opened the account"
[0061] Step 2: Fill the pseudocode prompt word template based on the user's input question. The prompt word examples are as follows:
[0062] Task decomposition instruction module: "You need to gradually decompose the user's input question into corresponding sub-problems, analyze the API logic that each sub-problem needs to call, and generate the pseudocode of the API that needs to be called to solve this problem. An input question may be decomposed into one or more sub-problems. You have the following callable APIs:
[0063] Predefined tool module:
[0064] Function name: Get_user_info
[0065] Function function: Query user account information
[0066] Function parameters: None
[0067] Function name: Get_all_stock
[0068] Functionality: Query all stocks of a user
[0069] Function parameters: None
[0070] Function name: Get_stock_price
[0071] Functionality: Query the price and increase rate of a stock according to time
[0072] Function parameters:
[0073] Parameter name: stock_id
[0074] Parameter description: Stock code
[0075] Parameter name: time
[0076] Parameter description: Query time
[0077] Pseudo-code example module:
[0078] Output: You need to generate the pseudo-code of all APIs to be called to solve this problem in the following format. Ensure that the content you generate is an executable Python code file. The intermediate results of each API call are saved as temp1, temp2... The final result res needs to use the Aggregation function to integrate the relevant results generated previously. Note that there may be parallel (no dependency relationship between the solutions of the front and back sub-problems) or serial (dependency relationship between the solutions of the front and back sub-problems) situations within the sub-problems. Note that when making serial calls, do not use a for loop to generate multiple calls, but merge multiple calls under the same logic. The following is an example call format for a type of basic problem, and you can generate more complex call codes based on these formats:
[0079] Single-step call example:
[0080] temp1 = Func(param1 = value1)
[0081] res = Aggregation(merged_result = [temp1])
[0082] Multi-step parallel call example:
[0083] temp1 = Func1(param1 = value1)
[0084] temp2 = Func2(param2 = value2)
[0085] res = Aggregation(merged_result = [temp1, temp2])
[0086] Example of multi-step serial call:
[0087] temp1 = Func1(param1 = value1)
[0088] temp2 = Func2(param2 = temp1)
[0089] res = Aggregation(merged_result = [temp2])
[0090] Fill in the user input question module:
[0091] User input question: Please help me check the increase in all the stocks in my account since I opened the account
[0092] Now start to execute!
[0093] ”
[0094] Step 3: Use the prompt in the prompt template in Step 2 as the input for the large language model (taking Qwen2-72B as an example) for prediction, and the prediction result is the single-step planning result;
[0095] “
[0096] temp1 = Get_user_info()
[0097] temp2 = Get_all_stock()
[0098] temp3 = Get_stock_price(time = temp1, stock_id = temp2)
[0099] res = Aggregation(merged_result = [temp3])
[0100] ”
[0101] Step 4: Analyze the single-step planning result in Step 3 and construct a scheduling graph, as Figure 2 shown, START is the start node, temp1, temp2, temp3 are intermediate nodes after parsing based on the example pseudo-code result in Step 3, and RES is the result node;
[0102] Step 5: Return the answer result of the user question by executing the scheduling graph.
[0103] The specific steps for constructing the scheduling graph described in Step 4 are:
[0104] Step 4-1: Parse and split the single-step planning results generated in Step 3 into multiple independent single-step plans by regular expression "\n".
[0105] "temp1 = Get_user_info()"
[0106] "temp2 = Get_all_stock()"
[0107] "temp3 = Get_stock_price(time = temp1, stock_id = temp2)"
[0108] "res = Aggregation(merged_result = [temp3])"
[0109] Step 4-2: Perform regular parsing on each independent single-step plan in Step 4-1 to obtain a quadruple containing the result variable, called function, parameter name, and parameter variable for the subsequent execution of the tool function.
[0110] [temp1, Get_user_info, [], []]
[0111] [temp2, Get_all_stock, [], []]
[0112] [temp3, Get_stock_price, [time, stock_id], [temp1, temp2]]
[0113] [res, Aggregation, [merged_result], [[temp3]]]
[0114] Step 4-3: Starting from the START node and ending with the RES node, construct a scheduling graph with the quadruple corresponding to each independent single-step plan as the intermediate node.
[0115] Step 4-4: If the result variable of an intermediate node is equal to the parameter variable of another intermediate node, connect these two nodes, and complete the construction of the scheduling graph by connecting all the nodes that meet the conditions.
[0116] The regular parsing process described in Step 4-1 is as follows:
[0117] 4-1-1: Remove all leading and trailing spaces, redundant line breaks, and empty lines.
[0118] 4-1-2: Split the pseudo-code corresponding to the single-step planning results into independent code lines with line breaks as the demarcation points, and remove the redundant spaces before and after each code line.
[0119] The specific steps of the regular parsing process described in Step 4-2 are as follows:
[0120] 4-2-1. Use the regular expression:
[0121] "^\s*([a-zA-Z_][a-zA-Z0-9_#]*)\s*=\s*([a-zA-Z_]+)\(([\s\S]*?)\)\s*#?([\s\S]*)?$'"
[0122] Parse out a triple containing three elements: the result variable, the called function, and the parameter information;
[0123] 4-2-2. Perform specific processing on the parameter information in the triple in Step 4-2-1 under different circumstances:
[0124] Case 1: If the parameter information is empty, set the parameter name and parameter variable of the triple to empty;
[0125] Case 2: If the parameter information is not empty, use the regular expression "[\s]*, " to split the complete parameter information into multiple independent parameter information, ensuring that each piece of parameter information has only one parameter name and one parameter variable. Then use the regular expression "'^\s*{param_name}\s*=\s*([\s\S]+)\s*$'" to further split the split parameter information into two parts: the parameter name and the parameter variable, obtaining a quadruple.
[0126] In Step 4-3, the specific operation of constructing the scheduling graph is as follows:
[0127] 4-3-1. Starting node: First, construct the starting node START node;
[0128] 4-3-2. Traverse the quadruple obtained in Step 4-2 and add each quadruple to the graph structure in turn. The specific measures are as follows:
[0129] If the parameter name and parameter variable are empty, connect this node to the START node;
[0130] If the parameter name and parameter variable are not empty, traverse all parameter variables, and connect the other nodes whose result variables are equal to the parameter variables of this node to this node respectively;
[0131] 4-3-3. Construct the RES node as the ending node, and by default, the tail node of RES is empty.
[0132] In Step 5, the execution process of the scheduling graph is as follows:
[0133] Step 5-1: Initialize the process pool;
[0134] Step 5-2: Starting from the START node, sequentially add the nodes that have been completed by the previous node to the process pool. The START node is defaulted to an executed node;
[0135] Step 5-3: Asynchronously execute all node tasks in the process pool. After each child node is executed, dynamically update the graph structure with the execution result and asynchronously return the result to the user;
[0136] Step 5-4: End all actions when reaching the RES node.
[0137] The specific operations in Step 5-3 are as follows:
[0138] For the node whose previous one is START, directly execute it and directly output the execution result to the user;
[0139] For the node whose previous one is not START, add an extraction node before the current node to extract structured parameter information. Then, the current node can only be executed after all the predecessors of the current node have been executed. (Since the function execution result of the predecessor node may be unstructured text and cannot be directly used for the execution of the current function, an extraction node needs to be added before the current node to extract structured parameter information.)
[0140] As Figure 3 shown, the Temp1 extract node and Temp2 extract node in the figure are the extraction nodes added additionally during the execution process.
[0141] The addition of an extraction node specifically means:
[0142] Step 5-3-1: Fill the prompt template with all the execution results of the executed nodes, and use this prompt template as the input to the large model (taking Qwen2-72B as an example) to obtain the target parameters required for calling the current node function;
[0143] Prompt example: "
[0144] The user needs to call Get_stock_price to query the price and increase rate of a stock according to the time. The definitions of Get_stock_price and its parameters are as follows:
[0145] Function name: Get_stock_price
[0146] Function function: Query the price and increase rate of a stock according to the time
[0147] Function parameters:
[0148] Parameter name: stock_id
[0149] Parameter description: Stock code
[0150] Parameter name: time
[0151] Parameter description: Query time
[0152] You need to extract the valid call parameters of Get_stock_price from the following **content to be extracted** and return the result in the format of {API_NAME}(param1=value1,param2=value2...). Note that the value in string format should be enclosed in double quotes. Optional parameters not present in the content to be extracted do not need to be declared. If there are multiple available call parameters, you need to generate multiple calls, with each call output on a separate line (at most 10 calls will be generated. If there are more than 10, the earliest 10 will be retained); if there are no valid call parameters, output null. Just give me the result directly without generating any extra textual reasoning process.
[0153] **Content to be extracted**:
[0154] The stock information held by the user is:
[0155] Stock 1: 000001
[0156] Stock 2: 000002
[0157] Stock 3: 000003
[0158] Now start!
[0159] ”
[0160] Step 5-3-2: According to the target parameters obtained in Step 5-3-1, perform the following actions to update the graph structure respectively:
[0161] 1. If the target parameter is empty, set the return results of the current node and all subsequent child nodes to empty;
[0162] 2. If the target parameter is a single parameter, insert the extracted node between the current node and its previous node, and use this parameter as the parameter variable of the current node;
[0163] 3. If the target parameter is multiple parameters, then for the current node and all subsequent child nodes except the RES node.
[0164] As Figure 4 shown, assume that after the temp2 node in the above example is executed, it is found that the user has three stocks held. Then, after extraction, the Temp3 node is copied three times to obtain three nodes: Temp3-1, Temp3-2, and Temp3-3.
[0165] The present invention provides an intelligent dialogue system for complex multi-intent scenarios. There are many methods and approaches to specifically implement this technical solution. The above description is only the preferred embodiment of the present invention. It should be noted that for those of ordinary skill in the art, without departing from the principle of the present invention, several improvements and refinements can be made, and these improvements and refinements should also be regarded as the protection scope of the present invention. Each component not clearly defined in this embodiment can be implemented by existing technologies.
Claims
1. An intelligent dialogue system for complex multi-intent scenarios, characterized in that, It includes the following steps: Step 1: Input the user's question; Step 2: Fill the pseudo-code prompt word template based on the question input by the user; Step 3: Use the prompt words in the prompt word template in Step 2 as the input of the large language model for prediction, and the prediction result is the single-step planning result; Step 4: Analyze the single-step planning result in Step 3 and construct a scheduling graph; Step 5: Return the answer result to the user's question by executing the scheduling graph.
2. The intelligent dialogue system for complex multi-intent scenarios according to claim 1, characterized in that, In Step 2, the prompt word template includes: Module 1: Instructions for task decomposition; Module 2: Predefined tools; Module 3: Examples of pseudo-code; Module 4: Filled user input question.
3. The intelligent dialogue system for complex multi-intent scenarios according to claim 1, wherein In Step 3, the single-step planning result is in the format of pseudo-code.
4. An intelligent dialogue system for complex multi-intent scenarios according to claim 1, characterized in that, The specific steps for constructing the scheduling graph in Step 4 are: Step 4-1: Through regular parsing processing, split the single-step planning result generated in Step 3 into multiple independent single-step plans; Step 4-2: Perform regular parsing processing on each independent single-step plan in Step 4-1 to obtain a quadruple containing result variables, called functions, parameter names, and parameter variables; Step 4-3: Construct a scheduling graph with the START node as the starting node and the RES node as the ending node, and use the quadruple corresponding to each independent single-step plan as an intermediate node; Step 4-4: If the result variable of a certain intermediate node is equal to the parameter variable of another intermediate node, then connect these two nodes, and complete the construction of the scheduling graph by connecting all nodes that meet the conditions.
5. An intelligent dialogue system for complex multi-intent scenarios according to claim 4, characterized in that, The regular parsing processing in Step 4-1 is: 4-1-1: Remove all leading and trailing spaces, redundant line breaks, and empty lines; 4-1-2: Use the line break as the demarcation point to split the pseudo-code corresponding to the single-step planning result into independent code lines, and remove the redundant spaces before and after each code line.
6. The intelligent dialogue system for complex multi-intent scenarios according to claim 5, characterized in that, The specific steps for the regular parsing processing in Step 4-2 are: Step 4-2-1: Use regular expressions to parse out a triple containing result variables, called functions, and parameter information; Step 4-2-2: Perform specific processing on the parameter information in the triple in Step 4-2-1 in different cases: Case 1: If the parameter information is empty, set the parameter name and parameter variable of the triple to be empty; Case 2: If the parameter information is not empty, use regular expressions to split the complete parameter information into multiple independent parameter information to ensure that each piece of parameter information has only one parameter name and one parameter variable, and then use regular expressions to further split the split parameter information into two parts: parameter name and parameter variable to obtain a quadruple.
7. An intelligent dialogue system for complex multi-intent scenarios according to claim 4, characterized in that, In Step 4-3, the specific scheduling graph construction operation is: Step 4-3-1: Construct the starting node START node; Step 4-3-2: Traverse the quadruples obtained in Step 4-2 and add each quadruple to the graph structure in turn. The specific measures are as follows: If the parameter name and parameter variable are empty, connect this node to the START node; If the parameter name and parameter variable are not empty, traverse all parameter variables and connect other nodes whose result variables are equal to the parameter variables of this node to this node respectively; Step 4-3-3: Construct the RES node as the end node, and by default, the tail node of RES is empty.
8. An intelligent dialogue system for complex multi-intent scenarios according to claim 1, characterized in that, In Step 5, the execution process of the scheduling graph is as follows: Step 5-1: Initialize the process pool; Step 5-2: Starting from the START node, sequentially add the nodes that have completed execution by the previous node to the process pool. The START node is by default considered an executed node; Step 5-3: Asynchronously execute all node tasks in the process pool. After each child node finishes execution, dynamically update the graph structure with the execution result and asynchronously return the result to the user; Step 5-4: End all actions when reaching the RES node.
9. An intelligent dialogue system for complex multi-intent scenarios according to claim 8, characterized in that, The specific operations in Step 5-3 are as follows: For the node whose previous node is START, directly execute it and directly output the execution result to the user; For the node whose previous node is not START, add an extraction node additionally before the current node.
10. An intelligent dialogue system for complex multi-intent scenarios according to claim 9, characterized in that, The specific addition of an extraction node is as follows: Step 5-3-1: Fill the prompt template with all the execution results of the executed node, and use this prompt template as the input to the large model to obtain the target parameters required for the call function that calls the current node; Step 5-3-2: According to the target parameters obtained in Step 5-3-1, update the graph structure according to different situations: Situation 1: If the target parameter is empty, set the return results of the current node and all subsequent child nodes to empty; Situation 2: If the target parameter is a single parameter, insert the extraction node between the current node and its previous node, and use this single parameter as the parameter variable of the current node; Situation 3: If the target parameter is multiple parameters, copy the current node and all subsequent child nodes except the RES node. The number of copies is equal to the number of parameters. Each copied node subtree sequentially uses one of the multiple parameters as the parameter variable, and insert the extraction nodes between each copied node subtree and its previous node respectively.