A dialogue management method and device, computer device and storage medium

Abstract

Embodiments of the present application provide a dialogue management method and device, computer equipment and a storage medium. The method comprises obtaining voice stream data sent by a user, and determining an initial user intent according to the voice stream data. After the initial user intent is determined, a target state machine flowchart can be obtained according to the initial user intent. Then, the target state machine flowchart is executed by a state machine to control a user say state node, a robot think state node and a robot say state node to determine a reply result of the initial user intent. Since the target state machine flowchart is controlled by the state machine and only includes three state nodes, the execution logic is simple, and the target state machine flowchart is completely decoupled from a flowchart constituted by complex nodes published by an operation side platform, thereby simplifying the operation and maintenance complexity.

Description

Technical Field

[0001] This application relates to the field of Internet technology, and in particular to a dialogue management method, apparatus, computer device, and storage medium. Background Technology

[0002] In recent years, with the continuous development and improvement of technologies such as speech recognition and spoken language understanding, voice interaction has been increasingly applied in human-computer dialogue. Among them, multi-turn dialogue is the core capability of human-computer dialogue. Robots can determine the initial user intent and fill the slots through multi-turn dialogue, thereby making accurate responses.

[0003] Currently, multi-turn dialogue management typically employs flowchart control. The robot needs to configure the execution logic for each node in the flowcharts published by the operations team, each corresponding to a different initial user intent. This allows the robot to perform the corresponding actions according to the configured execution logic after determining the target initial user intent, thus completing the human-computer dialogue. Specifically, the execution logic for each node includes the execution logic for slot-filling nodes. For example, after determining the target initial user intent, the robot first fills the slots according to the execution logic of the slot-filling node corresponding to the target initial user intent to obtain the complete user intent. Then, based on the complete user intent, it determines the response result corresponding to the complete user intent according to the execution logic of other nodes.

[0004] However, existing multi-turn dialogue management methods suffer from high complexity in execution logic. Summary of the Invention

[0005] This application provides a dialogue management method, apparatus, computer device, and storage medium, which can simplify the steps of the dialogue management method and reduce the execution complexity of multi-turn dialogue management.

[0006] In a first aspect, embodiments of this application provide a dialogue management method, including:

[0007] Acquire the voice stream data sent by the user, and determine the initial user intent based on the voice stream data;

[0008] Based on the initial user intent, obtain the target state machine flowchart, which consists of user-spoken state nodes, robot-thinking state nodes, and robot-spoken state nodes.

[0009] The flowchart of the state machine controlling the user's spoken state node, the robot's thinking state node, and the robot's spoken state node execution target state machine is used to determine the response result to the initial user intent.

[0010] In one feasible implementation, the generation of the target state machine flowchart includes:

[0011] Based on the initial user intent, obtain multiple initial dialogue logic flowcharts published by the operations platform. Each initial dialogue logic flowchart includes a first type of node and a non-first type of node. The first type of node is any one of the user speaking node, robot thinking node, and robot speaking node.

[0012] For each initial dialogue logic flowchart, filter out nodes that are not of the first type;

[0013] The compiler uses preset conversion rules to convert non-first-type nodes, generating corresponding state sub-processes, and converts first-type nodes into state nodes; a state node can be any one of the user-speaking state node, robot-thinking state node, or robot-speaking state node.

[0014] The compiler concatenates the state sub-processes and state nodes according to preset concatenation rules to generate the corresponding target state machine flowchart.

[0015] In one feasible implementation, non-first-class nodes include slot-filling nodes;

[0016] The compiler uses preset transformation rules to transform non-first-type nodes, obtaining the corresponding state sub-processes, including:

[0017] The compiler obtains the attributes of each slot in the slot node;

[0018] The compiler converts the slot nodes into execution logic flows corresponding to each slot attribute based on the attributes of each slot. The execution logic flows consist of user-speaking state nodes, robot thinking state nodes, and robot speaking state nodes.

[0019] The compiler combines the various execution logic flows according to a preset combination order to generate state sub-flows.

[0020] In one feasible implementation, the execution logic flow includes:

[0021] The robot uses its thinking state nodes to obtain the initial user intent and determines whether to perform the slot filling operation.

[0022] If so, the robot thinking state node sends a slot filling instruction to the robot speaking state node;

[0023] The robot says that the status node plays the slot filling attribute information according to the slot filling command;

[0024] The user says that the status node obtains user feedback information based on the slot attribute information;

[0025] The robot's thinking state node collects user feedback information and fills the target slot in the slot to be filled with the user feedback information;

[0026] The robot thinks a state node to determine whether all slots to be filled have been filled. If not, it jumps to the next execution logic flow until all slots to be filled are filled, generates a complete user intent, and sends the complete user intent to the robot's state node.

[0027] In one feasible implementation, the various execution logic flows are combined according to a preset combination order to generate state sub-flows, including:

[0028] Obtain the importance of each slot attribute, and determine the dialog priority of each slot attribute based on the importance of the slot attributes;

[0029] Based on the dialogue priority of each slot attribute, the execution logic flow is combined to generate a state sub-flow.

[0030] In one feasible implementation, a compilation device concatenates state sub-flows and state nodes according to preset concatenation rules to obtain the target state machine flowchart, including:

[0031] The compiler concatenates the state sub-flows and state nodes according to the concatenation order of the first type nodes and non-first type nodes in each initial dialogue logic flowchart to generate the target state machine flowchart.

[0032] In one feasible implementation, the target state machine flowchart is executed by controlling the user-speaking state node, the robot-thinking state node, and the robot-speaking state node to determine the response result to the initial user intent, including:

[0033] The initial user intent is obtained by controlling the state nodes through a state machine, and then the initial user intent is sent to the state sub-process.

[0034] The state machine controls the state sub-processes to generate a complete user intent based on the initial user intent and send it to the state node;

[0035] The state machine controls the state nodes to play the complete user intent and obtain the user's confirmation feedback information based on the complete user intent, and generates the response result.

[0036] In one feasible implementation, the dialogue management method also includes:

[0037] Determine whether at least one state sub-process is the same in at least two target state machine flowcharts;

[0038] If so, at least two target state machine flowcharts are merged to obtain a combined state machine flowchart as the new target state flowchart. In the combined state machine flowchart, at least two target state machine flowcharts share at least one state sub-flow.

[0039] Secondly, embodiments of this application provide a dialogue management device, including:

[0040] The voice stream data acquisition module is used to acquire the voice stream data sent by the user and determine the initial user intent based on the voice stream data;

[0041] The flowchart acquisition module is used to acquire the target state machine flowchart based on the initial user intent. The target state machine flowchart consists of user-spoken state nodes, robot thinking state nodes, and robot-spoken state nodes.

[0042] The response result determination module is used to determine the response result of the initial user intent based on the target state machine flowchart.

[0043] Thirdly, embodiments of this application provide a computer device, including a memory and a processor. The memory stores a computer program, and the processor executes the computer program to implement the steps of the method in any of the embodiments of the first aspect described above.

[0044] Fourthly, embodiments of this application provide a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the steps of the method in any of the embodiments of the first aspect described above.

[0045] The dialogue management method, apparatus, computer equipment, and storage medium provided in this application acquire voice stream data sent by the user and determine the initial user intent based on the voice stream data. After determining the initial user intent, a target state machine flowchart composed of user-speaking state nodes, robot-thinking state nodes, and robot-speaking state nodes can be obtained based on the initial user intent. Then, the target state machine flowchart is executed by controlling the user-speaking state nodes, robot-thinking state nodes, and robot-speaking state nodes to determine the response result of the initial user intent. Since the target state machine flowchart only includes three state nodes, the process can be triggered by the user-speaking state node, pass through a series of robot-thinking state nodes, and finally flow to a certain robot-speaking state node for response, which is completely implemented in the form of question and answer, and the execution logic is simple. In addition, compared with the prior art, the target state machine flowchart used in the dialogue management method of this application is completely decoupled from the flowchart composed of complex nodes published by the operation side platform. It is not necessary to implement logic separately for each different type of node in the prior art. Only one set of process logic based on the target state machine needs to be maintained, which simplifies the complexity of operation and maintenance. Attached Figure Description

[0046] Figure 1 This is a structural diagram of an existing technology flowchart;

[0047] Figure 2This is a schematic diagram of the application environment for a dialogue management method provided in an embodiment of this application;

[0048] Figure 3 This is a flowchart of a dialogue management method provided in an embodiment of this application;

[0049] Figure 4 This is a flowchart illustrating a method for generating a target state machine flowchart provided in an embodiment of this application;

[0050] Figure 5 This is one of the flowcharts in step 206 of a method for generating a target state machine flowchart provided in an embodiment of this application;

[0051] Figure 6 This is a flowchart of an execution logic flow provided in an embodiment of this application;

[0052] Figure 7 This is a flowchart illustrating another method for generating a target state machine flowchart provided in an embodiment of this application;

[0053] Figure 7a This is a flowchart of another dialogue management method provided in the embodiments of this application;

[0054] Figure 8 This is a flowchart of step 106 in a dialogue management method provided in an embodiment of this application;

[0055] Figure 9 This is a schematic diagram of one embodiment of a dialogue management method provided in this application.

[0056] Figure 10 This is a schematic diagram of the structure of a dialogue management device provided in an embodiment of this application;

[0057] Figure 11 This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. Detailed Implementation

[0058] To enable those skilled in the art to better understand the technical solutions in this application, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments in this application, all other embodiments obtained by those of ordinary skill in the art without creative effort should fall within the scope of protection of this application.

[0059] With the continuous advancement of technologies such as intelligent voice and natural language processing, voice dialogue systems have seen significant improvements in performance and user experience. Unlike traditional human-computer interfaces such as keyboards, mice, and touchscreens, voice dialogue systems more closely resemble real human interaction methods and require less technical expertise from users.

[0060] Voice interaction systems have a wide range of applications. Early on, they were primarily used in automated telephone customer service systems, such as for flight and hotel bookings. In scenarios where hands-free use is inconvenient, such as in vehicles, voice interaction is also the most suitable interaction method. In recent years, the advent of the mobile internet and the widespread adoption of mobile devices such as smartphones and tablets have led to a renewed surge in the use of voice interaction systems. These applications, relying on mobile device operating systems, help people perform tasks such as sending text messages, making phone calls, and customizing schedules. Currently, wearable devices, represented by smartwatches and smart glasses, have received widespread attention in the industry. The biggest difference between these wearable devices and mobile phones and tablets is that their screens are usually smaller, making touch operation inconvenient. This makes voice interaction a necessity on these devices.

[0061] Multi-turn dialogue is a core capability of human-computer voice interaction. Computer devices use multi-turn dialogue to understand the user's intent and slot filling, thus providing accurate responses. Currently, multi-turn dialogue management typically uses flowchart control. For example, the corresponding TaskFlow flowchart control logic can be pre-drawn based on the user intent flowchart released by the operations team and stored in the computer device. The TaskFlow flowchart generally includes multiple nodes such as API nodes, SLOTS nodes, SCRIPT nodes, NLG nodes, and JUDGE nodes.

[0062] The API interface node is used to retrieve business information via remote calls during the dialogue process. An API interface node can be created by configuring the Uniform Resource Locator (URL) of the remote service, the interface input parameters (key-value format), and the output parameters.

[0063] The SLOTS slot filling node is used to collect slot information (i.e., key information that needs to be collected from the user) during the execution of the dialogue flow. It performs multi-slot filling through NLU empowerment. During the execution of the dialogue flow, the SLOTS slot filling node continuously traverses all slots. When an unfilled slot is found, the corresponding clarification speech for that slot is output to TTS (Text To Speech). The user inputs information under the guidance of TTS speech, and after the NLU entity extracts the user's intent based on the user's input, the SLOTS slot filling node fills the unfilled slot.

[0064] SCRIPT node: Used to obtain dialogue state information through embedded scripts (such as scripts compiled in Groovy) during the execution of the dialogue process, and to control and modify the dialogue state information to realize the customization requirements of the dialogue process.

[0065] NLG Response Node: Used to generate response scripts by applying dynamically changing data in a templated manner during the dialogue process. The sentence template consists of several short sentences containing variables, which are dynamically updated by the data information and generated by relevant business rules, and finally assembled into a well-structured and complete script.

[0066] JUDGE decision nodes are used to control the direction of the dialogue flow based on configured conditional expressions during execution. JUDGE decision nodes support configuring multiple conditional expressions with priorities. The variables supported by the conditional expressions are provided by the current dialogue state information. When the node runs, it executes the conditional expressions according to their priorities. If the value of a conditional expression is true, it controls the direction of the dialogue flow to jump to that branch and continue executing the dialogue flow.

[0067] Computer devices can retrieve corresponding flowcharts from storage devices based on user intent, execute the logic of the corresponding nodes in the flowchart, and achieve human-computer interaction, such as... Figure 1 As shown. Figure 1 This is a schematic diagram of a flowchart illustrating user intent mapping in existing technology. The flowchart includes user-speaking nodes, slot-filling nodes, robot-speaking nodes, and robot-thinking nodes. For the slot-filling node, developers need to configure multiple execution logics, including slot prediction and named entity filling. The execution logic is quite complex. If another personalized node exists, developers must also configure corresponding execution logic based on that personalized node. Since each node in the flowchart is different, the execution logic for each node is relatively complex.

[0068] Based on this, this application provides a dialogue management method that can be applied to, for example... Figure 2In the application environment shown, computer device 102 communicates with server 104 of the operation-side platform and user 11 via a network. Computer device 102 can acquire the user's voice stream data and determine the initial user intent. Then, based on the initial user intent, it retrieves a target state machine flowchart stored in the computer device, consisting only of user-spoken state nodes, robot-thinking state nodes, and robot-spoken state nodes, to determine the response result to the initial user intent. The target state machine flowchart is obtained by converting the flowchart published by server 104 of the operation-side platform.

[0069] The computer device 102 may include, but is not limited to, mobile phones, tablets, laptops, ultra-mobile personal computers (UMPCs), handheld computers, touch-screen TVs, walkie-talkies, netbooks, point-of-sale (POS) machines, personal digital assistants (PDAs), wearable devices, virtual reality devices, wireless USB flash drives, Bluetooth speakers / headphones / glasses, in-vehicle pre-installed devices, dashcams, security equipment, and other mobile or fixed terminals.

[0070] Server 104 can be a cloud server, also known as a cloud computing server or cloud host. It is a hosting product in the cloud computing service system, which solves the shortcomings of traditional physical hosts and VPS (Virtual Private Server) services, such as high management difficulty and weak business scalability. The server can also be a server for a distributed system or a server integrated with blockchain. In other words, this server can be a server hosted on any website, such as Baidu Server, 360 Server, or Sogou Server.

[0071] This application provides a dialogue management method, apparatus, computer device, and storage medium. It acquires voice stream data from a user and determines the initial user intent based on the voice stream data. After determining the initial user intent, a target state machine flowchart consisting of user-spoken state nodes, robot-thinking state nodes, and robot-spoken state nodes can be obtained. Then, the response result for the initial user intent is determined based on the target state machine flowchart. Since the target state machine flowchart is controlled by the state machine's flow, and the state machine only includes three state nodes, the flow can be triggered by the user-spoken state node, passing through a series of robot-thinking state nodes, and finally flowing to a certain robot-spoken state node for response. This question-and-answer format is fully implemented, with simple execution logic and complete decoupling from the complex node-based flowchart published by the operation platform. This simplifies operation and maintenance complexity; only one set of state machine-based flow logic needs to be maintained, eliminating the need to implement logic separately for each different type of node in existing technologies.

[0072] The following describes in detail the dialogue management method, apparatus, computer equipment, and storage medium according to embodiments of this application, with reference to the accompanying drawings.

[0073] Figure 3 This is a flowchart illustrating a dialogue management method provided in an embodiment of this application. (Refer to...) Figure 3 As shown, this application provides a dialogue management method.

[0074] It should be noted that the embodiments of this application can be applied to electronic devices such as terminal devices, computer systems, and servers, and can operate together with a wide range of other general-purpose or special-purpose computing system environments or configurations. Well-known terminal devices, computing systems, environments, and / or configurations of electronic devices suitable for use with terminal devices, computer systems, servers, and other electronic devices include, but are not limited to: personal computer systems, server computer systems, thin clients, thick clients, handheld or laptop devices, microprocessor-based systems, set-top boxes, programmable consumer electronics products, network personal computers, minicomputer systems, mainframe computer systems, and distributed cloud computing technology environments that include any of the above systems.

[0075] Electronic devices such as terminal devices, computer systems, and servers can be described in the general context of computer system executable instructions (such as program modules) executed by a computer system. Typically, program modules can include routines, programs, object programs, components, logic, data structures, etc., which perform specific tasks or implement specific abstract data types. Computer systems / servers can be implemented in distributed cloud computing environments, where tasks are executed by remote processing devices linked through communication networks. In distributed cloud computing environments, program modules can reside on local or remote computing system storage media, including storage devices.

[0076] Specifically, this dialogue management method includes the following steps:

[0077] S102, acquire the voice stream data sent by the user, and determine the initial user intent based on the voice stream data.

[0078] Among them, voice stream data is a file collected from the user's voice through a recording device.

[0079] Specifically, when a user interacts with a computer device via voice, once the user issues a voice instruction, this instruction can be captured by a recording device and stored as voice stream data. The computer device can then perform intent recognition on the voice stream data to determine the initial user intent. For example, a user might issue a voice instruction to the computer device stating, "I want to check my phone bill." The computer device can then perform intent recognition on this voice instruction to obtain the initial user intent of checking the phone bill.

[0080] S104. Based on the initial user intent, obtain the target state machine flowchart, which consists of user-spoken state nodes, robot-thinking state nodes, and robot-spoken state nodes.

[0081] The target state machine flowchart is a flowchart controlled by a state machine. It only includes user state nodes, robot thinking state nodes, and robot speaking state nodes.

[0082] Specifically, based on the initial user intent, the target state machine flowchart corresponding to the initial user intent can be found in the database of the computer device.

[0083] It should be noted that the user-speaking node is used to acquire relevant voice stream data emitted by the user. The robot thinking node is used to perform operations such as conditional judgment, API interface calls, and information collection. The robot speaking node is used to configure device response information.

[0084] Figure 4 This is a flowchart illustrating a method for generating a target state machine flowchart according to an embodiment of this application. (Refer to...) Figure 4 As shown, in one feasible example, the generation of the target state machine flowchart includes:

[0085] S202. Based on the initial user intent, obtain multiple initial dialogue logic flowcharts published by the operations platform. Each initial dialogue logic flowchart includes a first-type node and non-first-type nodes. The first-type node is any one of the following: user speak node, robot think node, or robot speak node. Non-first-type nodes are any nodes other than the first-type nodes. For example, non-first-type nodes include any one of the following: slot filling node, script execution node, or transfer to human operator node. There are no restrictions on this.

[0086] The initial dialogue logic flowchart is a set of flowcharts constructed by the operations platform based on different initial user intentions. The initial dialogue logic flowchart can include any one of the following first-type nodes: user speaking nodes, robot thinking nodes, and robot speaking nodes, as well as non-first-type nodes.

[0087] Specifically, developers can create and publish initial dialogue logic flowcharts corresponding to different user intentions. Computer devices can subscribe to the initial dialogue logic flowcharts published by the operations platform, thus obtaining the initial dialogue logic flowcharts.

[0088] S204, for each initial dialogue logic flowchart, filter out nodes that are not of the first type.

[0089] Specifically, after obtaining the initial dialogue logic flow, the dialogue logic flow diagrams are filtered to identify the non-first-class nodes in each dialogue logic flow diagram.

[0090] S206, the compiler uses a preset conversion rule to convert non-first-class nodes, generate corresponding state sub-processes, and convert first-class nodes into state nodes; the state node can be any one of the user-speaking state node, robot thinking state node, or robot speaking state node.

[0091] The preset conversion rules are for converting non-first-type nodes (including state nodes) and first-type nodes into state nodes. The state sub-flow is the execution logic flow constructed from state nodes. The compilation device can be a compilation and conversion program product internal to the robot.

[0092] Specifically, the compiler can use preset transformation rules to transform the selected non-first-type nodes, generating state sub-flows that can implement the execution logic corresponding to the non-first-type nodes. Then, the first-type nodes are transformed into state nodes corresponding to the state machine.

[0093] Optionally, a robot thinking node can be added after the user's statement node in the status node. The user judges whether the user's response can be recognized. If it cannot be recognized, the robot's statement status node is triggered to issue a rejection instruction.

[0094] In some examples, Figure 5 This is one of the flowcharts in step 206 of the method for generating the target state machine flowchart, such as... Figure 5 As shown, non-first-type nodes include slot-filling nodes; the compiler uses preset conversion rules to convert non-first-type nodes to obtain the corresponding state sub-processes, including:

[0095] S2062, obtain the attributes of each slot in the slot node through the compilation device.

[0096] Among them, the slot filling node is used to collect user intent slot information.

[0097] Specifically, the slot filling nodes in the initial dialogue logic flow published by the operations platform include various slot filling attributes (slot information) that need to be filled. By searching the slot information in the slot filling nodes, the user intent slot information can be obtained. For example, the semantic slot format in the slot filling node is as follows:

[0098]

[0099]

[0100] Based on the above semantic slot format, the slot information can be obtained as follows: movie name, cinema name, time, quantity, and seat location.

[0101] S2064, the compiler converts the slot nodes into execution logic flows corresponding to each slot attribute according to each slot attribute; the execution logic flow consists of user-speaking state nodes, robot thinking state nodes, and robot speaking state nodes.

[0102] Specifically, once the attributes of each slot are obtained, the corresponding slot attributes are converted into an execution logic flow that only includes the user speaking state node, the robot thinking state node, and the robot speaking state node, which simplifies the multiple types of nodes in the existing technology.

[0103] Figure 6 This is a flowchart illustrating an execution logic flow provided in an embodiment of this application. For example... Figure 6 As shown, as one feasible embodiment, the steps for executing the logic flow include:

[0104] S2064a, the robot thinks about the state node to obtain the initial user intent and determine whether to perform the slot filling operation.

[0105] Specifically, after the robot's thinking state node obtains the initial user intent, it determines whether to perform a slot filling operation. Optionally, a slot check can be performed after obtaining the initial user intent to determine whether the slot to be filled has been filled. If not, the slot filling operation is then performed.

[0106] If S2064b is true, then the robot thinking state node sends a slot filling instruction to the robot speaking state node.

[0107] Specifically, if a slot filling operation is to be performed, the robot thinking state node sends a slot filling instruction to the robot speaking state node, instructing the robot speaking state node to play the slot filling attribute information according to the slot filling instruction.

[0108] S2064c, the robot says the status node plays the slot filling attribute information according to the slot filling command.

[0109] Specifically, once the robot's status node receives a slot-filling instruction, it can play pre-set slot-filling attribute information. For example, if the initial user intent is to check their phone bill, after receiving the slot-filling instruction, the robot can play the slot-filling attribute information such as "What number are you looking for?", "What is the time range for the query?", and "What are the details of the queried phone bill?"

[0110] S2064d, the user says the status node obtains user feedback information based on the slot attribute information.

[0111] Specifically, when a user hears the slot-filling attribute information played by the robot's "Say" node, they respond based on that information. At this point, the "User Says Status" node obtains the user's feedback information. For example, the queried number is 177xxxxxxxx.

[0112] S2064e, the robot thinking state node collects user feedback information and fills the target slot in the slot to be filled with user feedback information.

[0113] Specifically, after the robot's thinking state node collects user feedback information, it fills the user feedback information into the target slot in the slot to be filled.

[0114] S2064f, the robot's thinking state node determines whether all slots to be filled have been filled. If not, it jumps to the next execution logic flow until all slots to be filled are filled and a complete user intent is generated.

[0115] Specifically, after the user feedback information is filled into the target slot, the robot thinking state node can perform slot verification to determine whether the slot to be filled is completely filled. If there are unfilled slots, it will re-determine whether to fill the slots and then proceed to fill the next target slot. That is, the robot speaking node plays the slot attribute information corresponding to the unfilled slot according to the slot filling instruction until all slots to be filled are filled, thereby generating a complete user intent.

[0116] In this embodiment, the initial user intent can be obtained through the robot thinking state node. It then determines whether a slot-filling operation should be performed. If slot filling is required, the robot thinking state node sends a slot-filling instruction to the robot speaking state node. The robot speaking state node then plays slot-filling attribute information according to the instruction, and the user speaking state node obtains user feedback information based on this attribute information. The robot thinking state node then collects this feedback and fills it into the target slots. It then determines whether all slots are filled; if not, it proceeds to the next execution logic flow until all slots are filled, ultimately generating a complete user intent.

[0117] Clearly, the execution logic flow only includes three state nodes: user speaking state node, robot thinking state node, and robot speaking state node. It simplifies the multi-type nodes in the initial dialogue logic flow diagram of existing technologies, resulting in a simple question-and-answer filling logic, rather than the complex execution flow of slot-filling nodes in existing technologies, which includes slot prediction, follow-up questions, and ambiguity clarification. This reduces the complexity of the execution logic.

[0118] In addition, during subsequent operation and maintenance, only one set of state machine-based flow logic needs to be maintained, without the need to implement maintenance logic separately for different types of nodes.

[0119] S2066, the compiler combines each execution logic flow according to a preset combination order to generate state sub-flows.

[0120] The preset combination order can be a combination order obtained by sorting according to the priority of the slot filling attributes, or it can be a combination order obtained by sorting according to the default combination order of arbitrary combinations. There is no restriction here.

[0121] Specifically, after generating the corresponding execution logic flow based on each slot attribute, the execution logic flows are combined and spliced ​​together according to a preset combination order to obtain the state sub-flow.

[0122] In some examples, the various execution logic flows are combined according to a preset combination order to generate state sub-flows, including:

[0123] S2066a: Obtain the importance of each slot attribute through the compilation device, and determine the dialog priority of each slot attribute based on the importance of the slot attributes.

[0124] S2066b uses a compiler to combine execution logic flows based on the dialog priority of each slot attribute to generate state sub-flows.

[0125] Specifically, the semantic slot design for each slot-filling attribute in a slot-filling node is generally based on the importance of the attributes. Therefore, the order of the semantic slot design can be used as the importance of each attribute. Alternatively, there may be an indicator for the importance of slot-filling attributes during the design process. The importance of each attribute can then be obtained from the initial dialogue logic flowchart. Based on the importance of each attribute, its dialogue priority can be determined.

[0126] Once the dialogue priority is determined, the execution logic can be combined according to the dialogue priority to generate state sub-processes.

[0127] In this embodiment, by obtaining the importance of each slot attribute, the dialog priority of each slot attribute is determined based on the importance of the slot attribute, and the execution logic flow is combined according to the dialog priority of each slot attribute to generate a state sub-flow. This can generate more logical dialog logic and make the structure of the generated state sub-flow more reasonable.

[0128] S208, the compiler connects the state sub-processes and state nodes according to the preset splicing rules to generate the corresponding target state machine flowchart.

[0129] Specifically, the compilation device concatenates the state sub-flows and state nodes according to the concatenation order of the first type of nodes and non-first type nodes in each initial dialogue logic flowchart to generate the target state machine flowchart.

[0130] In other examples, since the target state machine flowcharts for different user intentions may contain the same state sub-flows, these identical state sub-flows can be further merged after generating the target state machine flowchart to generate a new target state machine flowchart. Figure 7 This is a flowchart illustrating another method for generating a target state machine flowchart provided in this application embodiment, as shown below. Figure 7 As shown, the dialogue management method also includes:

[0131] S108, determine whether at least one state sub-process in at least two target state machine flowcharts is the same.

[0132] S110, if so, then merge at least two target state machine flowcharts to obtain a combined state machine flowchart as a new target state flowchart, wherein in the combined state machine flowchart, at least two target state machine flowcharts share at least one state sub-flow.

[0133] Specifically, the state sub-processes in at least two generated target state machine flowcharts are compared. If there is overlap in the state sub-processes, the two target state machine processes are merged, that is, the two target state machine processes share the same state sub-process to execute the same execution logic process.

[0134] For example, consider two target state machine flowcharts: one for booking a hotel and the other for booking a flight. The hotel booking flowchart includes a user-speaking state node that obtains the initial user intent (hotel booking). This intent is sent to the robot thinking state node in the sub-flow to determine if slot filling is required. If so, a slot filling instruction is sent to the robot speaking state node to query the first slot attribute, "What is the user's name?" The user-speaking state node obtains the user's feedback information based on the slot attribute, "Zhang San". The robot thinking state node fills the target slot with the user feedback information and performs slot verification. If the slot is not filled, the process proceeds to the next execution logic flow to fill the slot, continuing until the robot thinking state node obtains the complete user intent and plays it. For example, the booking information might be: user's name is Zhang San, ID number 610xxxxxxxxx, mobile number 150xxxxxx. The user-speaking state node obtains the user's feedback information based on the complete user intent and, after obtaining the user's confirmation information through the user-speaking state node, proceeds to the next sub-flow to confirm the specific hotel booking information.

[0135] In the next state sub-process, the robot thinking state node determines whether to fill the slot. If so, it sends the slot-filling instruction to the robot speaking state node to query the first slot-filling attribute, "What is the check-in date?" The user speaking state node obtains the user's feedback information based on the slot-filling attribute, "May 20th." The robot thinking state node fills the target slot with the user feedback information. The robot thinking state node performs slot verification to determine if the slot to be filled is complete. If not, it enters the next execution logic process to fill the slot until the robot thinking state node obtains the complete user intent and plays the specific hotel booking information: check-in time is May 20th, location is City A, and the target hotel is XX Hotel. The user speaking state node obtains the user's feedback information based on the complete user intent response. The robot thinking state node calls the API interface to subscribe, plays the subscription result, and the robot responds.

[0136] Additionally, the target state machine flowchart for booking airline tickets includes a user-speaking state node that obtains the initial user intent (booking an airline ticket). This intent is sent to the robot thinking state node in the state sub-flow to determine whether slot filling is required. If so, the slot filling instruction is sent to the robot speaking state node to query the first slot filling attribute, "What is the user's name?" The user-speaking state node obtains the user's feedback information based on the slot filling attribute, "Zhang San". The robot thinking state node fills the target slot with the user feedback information and performs slot verification to determine if the slot is fully filled. If not, it proceeds to the next execution logic flow to fill the slot until the robot thinking state node obtains the complete user intent and plays it. For example, the ticket booking information is: user's name is Zhang San, ID number 610xxxxxxxxx, mobile phone number 150xxxxxx. The user-speaking state node obtains the user's feedback information based on the complete user intent and, after obtaining the user's confirmation information through the user-speaking state node, proceeds to the next state sub-flow to determine the specific information for booking the airline ticket.

[0137] In the next state sub-process, the User Says state node obtains the initial user intent (booking a flight) and sends it to the Robot Thinking state node in the same sub-process. The Robot Thinking state node determines whether to fill the slot. If so, it sends a slot-filling instruction to the Robot Says state node to query the first slot-filling attribute: "What are the origin and destination?" The User Says state node obtains the user feedback information based on the slot-filling attributes: "Xi'an-Beijing". The Robot Thinking state node fills the target slot with the user feedback information. It then performs slot verification to determine if the slot is fully filled. If not, it proceeds to the next execution logic flow to fill the slot, continuing until the Robot Thinking state node obtains the complete user intent and plays it. For example, the specific flight information is Xi'an to Beijing, with a date of May 20th. The User Says state node obtains the user feedback information based on the complete user intent. After the Robot Thinking state node subscribes to the API interface, it plays the subscription result, which is the response result.

[0138] The two target state machine flowcharts above clearly contain the same state sub-processes for confirming ticket booking information. Therefore, the state sub-processes for confirming ticket booking information can be merged and reused, resulting in the following: Figure 7a The flowchart of the new target state machine is shown.

[0139] Optionally, it can be determined whether the execution logic flows in each state sub-flow of at least two target state machine flowcharts are the same. If they are the same, the same execution logic flows can be reused, that is, at least two target state machine flowcharts are merged to obtain a combined state machine flowchart as a new target state flowchart. In the combined state machine flowchart, at least two target state machine flowcharts share at least one execution logic flow.

[0140] Therefore, this embodiment of the application determines whether at least two target state machine flowcharts contain at least one identical state sub-process. If so, the at least two target state machine flowcharts are merged to obtain a combined state machine flowchart as a new target state flowchart. Identical state sub-processes can be reused, meaning state machine flowcharts with different intentions can be merged. Target state machine flowcharts can be combined, offering greater flexibility.

[0141] In this embodiment, multiple initial dialogue logic flowcharts, including first-type nodes and non-first-type nodes, published by the operation platform are obtained. For each initial dialogue logic flowchart, non-first-type nodes are filtered out, and a preset transformation rule is used to transform the non-first-type nodes to generate corresponding state sub-flows. First-type nodes are then transformed into state nodes. Finally, the state sub-flows and state nodes are concatenated according to a preset concatenation rule to generate the corresponding target state machine flowchart. Since the initial dialogue logic flowcharts include various types of nodes, the execution logic implemented by different node types is also different.

[0142] Therefore, the execution logic of the initial dialogue logic flowchart used in the prior art is more complex. This application's embodiment converts the initial dialogue logic flowchart into a target state machine flowchart controlled by a state machine. Since the target state machine flowchart only includes user-speaking state nodes, robot-thinking state nodes, and robot-speaking state nodes, the execution logic flow has fewer nodes compared to the multiple types of nodes in the initial dialogue logic flowchart of the prior art, thus simplifying the execution logic.

[0143] In addition, by decoupling from the operation platform, only one set of state machine-based flow logic needs to be maintained during subsequent operation and maintenance, without the need to implement separate logic for each type of node.

[0144] S106, Based on the target state machine flowchart, determine the response result to the initial user intent.

[0145] Specifically, once the target state machine flowchart is determined, the corresponding execution logic can be executed according to the target state machine flowchart to obtain the response result of the initial user intent.

[0146] Figure 8This is a flowchart of step 106 in a dialogue management method provided in an embodiment of this application. Figure 8 As shown, in some examples, the user speaks state node, the robot thinks state node, and the robot speaks state node execute the target state machine flowchart to determine the response result to the initial user intent, including:

[0147] S1062, obtain the initial user intent through the state machine control state node, and send the initial user intent to the state sub-process.

[0148] S1064 uses a state machine to control the state sub-process, which generates a complete user intent based on the initial user intent and sends it to the state node.

[0149] S1066: The state machine controls the state node to play the complete user intent and obtain the user's confirmation feedback information based on the complete user intent, and generates the response result.

[0150] Specifically, the initial user intent is obtained by controlling the state node through a state machine and sent to the state sub-process. The state sub-process can then execute various execution logic processes according to the initial user intent, generate a complete user intent and send it to the state node. The state node plays the complete user intent and obtains the user's confirmation feedback information based on the complete user intent, and generates a response result.

[0151] For example, Figure 9 This is a schematic diagram of one embodiment of a dialogue management method provided in this application. Figure 9 As shown, taking the initial user intent of checking phone bill as an example, the user says the status node obtains the initial user intent (check phone bill) and sends it to the robot thinking status node to determine whether to fill the slot. If so, it sends the slot filling instruction to the robot saying status node to query the first slot filling attribute, "What is the number being queried?" The user says the status node obtains the user feedback information "177xxxxxxxx" based on the slot filling attribute. The robot thinking status node fills the target slot with the user feedback information and performs slot verification to determine whether the slot to be filled is complete. If not, it enters the next execution logic flow to fill the slot until the robot thinking status node obtains the complete user intent and plays it, for example, querying whether the number is 177xxxxxxxx, June, and phone bill details. The user says the status node obtains the user feedback information based on the complete user intent. After the robot thinking status node calls the API interface to perform a details query, it plays the query result, which is the reply result.

[0152] In this embodiment, the initial user intent is determined by acquiring the user's voice stream data. After determining the initial user intent, a target state machine flowchart consisting of user-speaking state nodes, robot-thinking state nodes, and robot-speaking state nodes can be obtained. Then, the target state machine flowchart is executed by controlling the user-speaking state nodes, robot-thinking state nodes, and robot-speaking state nodes to determine the response result to the initial user intent. Since the target state machine flowchart is controlled by the state machine's flow, and the state machine only includes three state nodes, the process can be triggered by the user-speaking state node, passing through a series of robot-thinking state nodes, and finally flowing to a certain robot-speaking state node for response. This is fully implemented in a question-and-answer format, with simple execution logic and complete decoupling from the complex node-based flowchart published by the operation platform. This simplifies operation and maintenance complexity, requiring only one set of state machine-based process logic to be maintained, without needing to implement logic separately for each different type of node in existing technologies.

[0153] It should be understood that, although Figures 3-9 The steps in the flowchart are shown sequentially as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order in which these steps are executed, and they can be performed in other orders. Figures 3-10 At least some of the steps in the process may include multiple steps or multiple stages. These steps or stages are not necessarily completed at the same time, but may be executed at different times. The execution order of these steps or stages is not necessarily sequential, but may be executed in turn or alternately with other steps or at least some of the steps or stages in other steps.

[0154] Based on the same inventive concept, this application also provides a dialogue management device for implementing the dialogue management method described above. The solution provided by this device is similar to the solution described in the above method; therefore, the specific limitations in one or more dialogue management device embodiments provided below can be found in the limitations of the dialogue management method described above, and will not be repeated here.

[0155] Figure 10 This is a schematic diagram of the network traffic anomaly detection device provided in an embodiment of this application. (Refer to...) Figure 10 As shown, the dialogue management device includes:

[0156] The voice stream data acquisition module 10 is used to acquire the voice stream data sent by the user and determine the initial user intent based on the voice stream data.

[0157] The flowchart acquisition module 11 is used to acquire the target state machine flowchart based on the initial user intent. The target state machine flowchart consists of user-spoken state nodes, robot thinking state nodes, and robot-spoken state nodes.

[0158] The response result determination module 12 is used to determine the response result of the initial user intent by controlling the user speaking state node, the robot thinking state node and the robot speaking state node to execute the target state machine flowchart through the state machine.

[0159] Specifically, the specific limitations in the dialogue management device embodiment can be found in the limitations of the dialogue management method above, and will not be repeated here.

[0160] In one feasible implementation, the dialogue management device of this application embodiment further includes: a target state machine flowchart generation module, comprising:

[0161] The initial flowchart acquisition unit is used to acquire multiple initial dialogue logic flowcharts published by the operation side platform based on the initial user intent. Each initial dialogue logic flowchart includes a first type of node and a non-first type of node. The first type of node is any one of the user speaking node, robot thinking node, and robot speaking node.

[0162] The filtering unit is used to filter out non-first-type nodes for each initial dialogue logic flowchart;

[0163] The conversion unit is used to convert non-first-type nodes using preset conversion rules through the compilation device, generate corresponding state sub-processes, and convert first-type nodes into state nodes; the state node can be any one of the user-speaking state node, robot thinking state node, and robot speaking state node;

[0164] The splicing unit is used to splice state sub-flows and state nodes according to preset splicing rules through the compilation device to generate the corresponding target state machine flowchart.

[0165] In one feasible implementation, non-first-type nodes include slot-filling nodes; the splicing unit is specifically used to obtain each slot-filling attribute in the slot-filling node through the compilation device; the compilation device converts the slot-filling node into the execution logic flow corresponding to each slot-filling attribute according to each slot-filling attribute; the execution logic flow is composed of user-speaking state nodes, robot thinking state nodes, and robot speaking state nodes; the execution logic flows are combined according to a preset combination order to generate state sub-flows.

[0166] In one feasible implementation, the splicing unit is specifically used to obtain the importance of each slot attribute through the compilation device, determine the dialogue priority of each slot attribute based on the importance of the slot attribute, and combine each execution logic flow according to the dialogue priority of each slot attribute to generate a state sub-flow.

[0167] In one feasible implementation, the response result determination module includes:

[0168] The sending unit is used to obtain the initial user intent through the state machine control state node and send the initial user intent to the state sub-process;

[0169] The complete user intent generation unit is used to generate a complete user intent based on the initial user intent through the state machine control state sub-process and send it to the state node;

[0170] The response result generation unit is used to control the state nodes through a state machine to play the complete user intent and obtain the user's confirmation feedback information based on the complete user intent, and generate the response result.

[0171] In one feasible implementation, the complete user intent generation unit is specifically used to execute the logical flow. The robot thinking state node obtains the initial user intent and determines whether to perform a slot filling operation. If so, the robot thinking state node sends a slot filling instruction to the robot speaking state node. The robot speaking state node plays the slot filling attribute information according to the slot filling instruction. The user speaking state node obtains user feedback information based on the slot filling attribute information. The robot thinking state node collects user feedback information and fills the target slot in the slot to be filled. The robot thinking state node determines whether all slots to be filled have been filled. If not, it jumps to the next execution logical flow until all slots to be filled are filled, generating a complete user intent.

[0172] In one feasible implementation, the dialogue management method also includes:

[0173] The judgment module is used to determine whether at least one state sub-process in at least two target state machine flowcharts is the same;

[0174] The merging module is used to merge at least two target state machine flowcharts if the condition is met, to obtain a combined state machine flowchart as a new target state flowchart, wherein at least two target state machine flowcharts share at least one state sub-flow in the combined state machine flowchart.

[0175] Specifically, the specific limitations in the dialogue management device embodiment can be found in the limitations of the dialogue management method above, and will not be repeated here.

[0176] Figure 11This is a schematic diagram of the structure of a computer device provided in an embodiment of this application. (Refer to...) Figure 11 As shown, based on the same inventive concept, this application also provides a computer device for implementing the dialogue management method described above. This computer device can be a terminal, and its internal structure diagram can be as shown... Figure 11 As shown, the computer device includes a processor, memory, communication interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, carrier networks, NFC (Near Field Communication), or other technologies. When the computer program is executed by the processor, it implements a dialogue management method. The display screen can be an LCD screen or an e-ink screen. The input devices can be a touch layer covering the display screen, buttons, a trackball, or a touchpad located on the computer device's casing, or an external keyboard, touchpad, or mouse.

[0177] Those skilled in the art will understand that Figure 11 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0178] In one feasible implementation, a computer device is provided, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the steps of the dialogue management method in any of the above embodiments.

[0179] Based on the same inventive concept, embodiments of this application also provide a computer-readable storage medium for implementing the dialogue management method involved above, wherein a computer program is stored thereon, and when the computer program is executed by a processor, it implements the steps of the dialogue management method in any of the above embodiments.

[0180] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the methods described above. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, or optical storage, etc. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc.

[0181] It is readily understood that, based on the several embodiments provided in this application, those skilled in the art can combine, split, or reorganize the embodiments of this application to obtain other embodiments, none of which exceed the protection scope of this application.

[0182] The above detailed embodiments further illustrate the purpose, technical solution, and beneficial effects of the embodiments of this application. It should be understood that the above are merely specific embodiments of the embodiments of this application and are not intended to limit the protection scope of the embodiments of this application. Any modifications, equivalent substitutions, improvements, etc., made on the basis of the technical solutions of the embodiments of this application should be included within the protection scope of the embodiments of this application.

Claims

1. A dialogue management method, characterized in that, include: Acquire the voice stream data sent by the user, and determine the initial user intent based on the voice stream data; Based on the initial user intent, a target state machine flowchart is obtained, wherein the target state machine flowchart consists of user-spoken state nodes, robot-thinking state nodes, and robot-spoken state nodes. The generation method of the target state machine flowchart includes: Based on the initial user intent, multiple initial dialogue logic flowcharts published by the operation platform are obtained. Each initial dialogue logic flowchart includes a first type of node and a non-first type of node. The first type of node is any one of the user speaking node, robot thinking node, and robot speaking node. The user speaking node is used to obtain relevant voice stream data sent by the user. The robot thinking node is used to perform condition judgment, application programming interface (API) interface call, or information collection. The robot speaking node is used to configure device response information. The non-first type of node includes slot filling nodes. For each of the initial dialogue logic flowcharts, the non-first type nodes are filtered out; The compiler uses a preset conversion rule to convert the non-first-type nodes, generating corresponding state sub-flows, and converts the first-type nodes into state nodes. The state node is any one of the user-speaking state node, robot-thinking state node, or robot-speaking state node. The state sub-flow is an execution logic flow composed of state nodes. The conversion of the non-first-type nodes into corresponding state sub-flows using the preset conversion rule includes: The compiler obtains the attributes of each slot in the slot node; The compilation device converts the slot-filling nodes into execution logic flows corresponding to each slot-filling attribute according to the slot-filling attributes; the execution logic flows consist of the user-speaking state node, the robot thinking state node, and the robot speaking state node; The compilation device combines the execution logic flows according to a preset combination order to generate the state sub-flow; wherein, the execution logic flow includes: The robot's thinking state node obtains the initial user intent and determines whether to perform the slot filling operation. If so, the robot thinking state node sends a slot filling command to the robot speaking state node; The robot says that the status node plays the slot filling attribute information according to the slot filling instruction; The user status node obtains user feedback information based on the slot attribute information; The robot's thinking state node collects the user feedback information and fills the user feedback information into the target slot in the slot to be filled; The robot's thinking state node determines whether all the slots to be filled have been filled. If not, it jumps to the next execution logic flow until all the slots to be filled are filled, generates a complete user intent, and sends the complete user intent to the robot's thinking state node. The compilation device concatenates the state sub-processes and the state nodes according to preset concatenation rules to generate the corresponding target state machine flowchart. The user speaks state node, the robot thinks state node, and the robot speaks state node execute the target state machine flowchart through a state machine to determine the response result of the initial user intent.

2. The method according to claim 1, characterized in that, The step of combining the execution logic flows according to a preset combination order to generate the state sub-flow includes: Obtain the importance of each of the slot filling attributes, and determine the dialog priority of each of the slot filling attributes based on the importance of the slot filling attributes; Based on the dialog priority of each slot attribute, the execution logic flow is combined to generate the state sub-flow.

3. The method according to claim 1 or 2, characterized in that, The step of concatenating the state sub-processes and the state nodes according to preset concatenation rules to obtain the target state machine flowchart includes: Based on the splicing order of the first type of nodes and the non-first type of nodes in each of the initial dialogue logic flowcharts, the state sub-flows and the state nodes are spliced ​​together to generate the target state machine flowchart.

4. The method according to claim 3, characterized in that, The process of controlling the user-speaking state node, the robot-thinking state node, and the robot-speaking state node to execute the target state machine flowchart and determine the response result to the initial user intent includes: The state machine controls the state node to obtain the initial user intent and sends the initial user intent to the state sub-process; The state machine controls the state sub-process to generate a complete user intent based on the initial user intent and send it to the state node; The state machine controls the state node to play the complete user intent and obtains confirmation feedback information from the user's response based on the complete user intent, thereby generating the response result.

5. The method according to claim 1, characterized in that, The dialogue management method also includes: Determine whether at least one of the state sub-processes in at least two of the target state machine flowcharts are the same; If so, at least two target state machine flowcharts are merged to obtain a combined state machine flowchart as a new target state flowchart, wherein in the combined state machine flowchart, the at least two target state machine flowcharts share the at least one state sub-flow.

6. A dialogue management device, characterized in that, include: The voice stream data acquisition module is used to acquire voice stream data sent by the user and determine the initial user intent based on the voice stream data. The flowchart acquisition module is used to acquire a target state machine flowchart based on the initial user intent. The target state machine flowchart consists of user-spoken state nodes, robot-thinking state nodes, and robot-spoken state nodes. The generation method of the target state machine flowchart includes: Based on the initial user intent, multiple initial dialogue logic flowcharts published by the operation platform are obtained. Each initial dialogue logic flowchart includes a first type of node and a non-first type of node. The first type of node is any one of the user speaking node, robot thinking node, and robot speaking node. The user speaking node is used to obtain relevant voice stream data sent by the user. The robot thinking node is used to perform condition judgment, application programming interface (API) interface call, or information collection. The robot speaking node is used to configure device response information. The non-first type of node includes slot filling nodes. For each of the initial dialogue logic flowcharts, the non-first type nodes are filtered out; The compiler uses a preset conversion rule to convert the non-first-type nodes, generating corresponding state sub-flows, and converts the first-type nodes into state nodes. The state node is any one of the user-speaking state node, robot-thinking state node, or robot-speaking state node. The state sub-flow is an execution logic flow composed of state nodes. The conversion of the non-first-type nodes into corresponding state sub-flows using the preset conversion rule includes: The compiler obtains the attributes of each slot in the slot node; The compilation device converts the slot-filling nodes into execution logic flows corresponding to each slot-filling attribute according to the slot-filling attributes; the execution logic flows consist of the user-speaking state node, the robot thinking state node, and the robot speaking state node; The compilation device combines the execution logic flows according to a preset combination order to generate the state sub-flow; wherein, the execution logic flow includes: The robot's thinking state node obtains the initial user intent and determines whether to perform the slot filling operation. If so, the robot thinking state node sends a slot filling command to the robot speaking state node; The robot says that the status node plays the slot filling attribute information according to the slot filling instruction; The user status node obtains user feedback information based on the slot attribute information; The robot's thinking state node collects the user feedback information and fills the user feedback information into the target slot in the slot to be filled; The robot's thinking state node determines whether all the slots to be filled have been filled. If not, it jumps to the next execution logic flow until all the slots to be filled are filled, generates a complete user intent, and sends the complete user intent to the robot's thinking state node. The compilation device concatenates the state sub-processes and the state nodes according to preset concatenation rules to generate the corresponding target state machine flowchart. The response result determination module is used to control the user speaking state node, the robot thinking state node, and the robot speaking state node to execute the target state machine flowchart through a state machine, and to determine the response result of the initial user intent.

7. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 5.

8. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 5.

Images