Instantiate a dialog process at a specific child node state

Abstract

The present disclosure relates to instantiating a conversation process at a specific subnode state. Methods, systems, and devices for instantiating a conversation process at a specific subnode state include a computer program encoded on a computer storage medium. In one aspect, the method includes: receiving a request for a specific subnode state of a specified conversation process; instantiating the conversation process at the root node state; providing input responses to the conversation process that cause the conversation process to traverse from the root node state to the specific subnode state, wherein each input response is provided in response to an input request; and providing data that causes a user device to present the conversation process at the specific subnode state.

Description

[0001] Description of the case

[0002] This application is a divisional application of Chinese invention patent application No. 201810101440.4, with a filing date of February 1, 2018. Technical Field

[0003] The present application relates to a method, system and storage medium for instantiating a dialog process at a specific subnode state. Background Art

[0004] A dialog process is a computer program, script, or any other set of instructions that simulates a conversation with a human user when executed by a computer device. Through these simulated conversations, the dialog process provides a wide range of automated assistance to the user. The dialog process is usually implemented by a state machine or a graphical process with multiple node states. Each state solicits one or more inputs from the user, and based on the input, traverses to another node state or takes a specific action.

[0005] The dialogue process, also known as "chatbot", is widely used as a part of a messaging platform, entertainment website, and for customer service. Generally, a dialogue process developer may wish to bring a user into a specific node state of the dialogue process. For example, suppose that a developer who has written a chatbot that helps users plan their travels has added a new function to the chatbot, which helps users compare hotel room reservations. The developer wants to expose this function to the user. However, in order to expose this function to the user, the user must traverse one or more chatbot states from the initial state to be exposed to the new function. Therefore, unless the user is instructed to manually enter the necessary response to reach the specific node state that will expose the new function (and then follow the instructions and manually enter the necessary response in fact) or unless the developer creates a new chatbot that emphasizes the new function (this increases the code base of the client and may have the risk of losing the user), the new function will not be exposed to most users. Summary of the invention

[0006] This specification describes techniques related to providing a user with a deep link into a specific subroutine of a conversation process, such as a chatbot (where a "deep link" is a link to a specific subroutine).

[0007] In general, an innovative aspect of the subject matter described in this specification can be embodied in a method including the following actions: receiving a request from a user device at a server computer to specify a specific child node state of a dialog process, wherein the dialog process defines a plurality of node states, the node states including a root node state and child node states, and wherein each child node state is derived from at least one of another child node state or the root node state; and each node state specifies an input request and an input response processing rule, the input response processing rule being used to process an input response received in response to the input request and select one of the child node states derived from the node state based on the input response. The server computer instantiates the dialog process at the root node state in response to the request to specify the specific child node state. Providing a plurality of input responses to the dialog process, wherein each input response is a response to an input request, and wherein a first input response among the provided input responses is provided for an input request of the root node state, and a last input response among the provided input responses is provided for an input request of a node state that is a parent node of the specific child node state, and causing the dialog process to select the specific child node state. The server computer then provides the user device with data that causes the user device to present the conversation process at a specific sub-node state. Other embodiments of this aspect include corresponding systems, devices, and computer programs encoded on a computer storage device configured to perform the actions of the method. For example, another innovative aspect of the subject matter described in this specification can be embodied in a computer storage medium (which can be a non-transitory computer storage medium, although this aspect is not limited to this), which stores instructions that can be executed by a data processing device having one or more server computers and when so executed causes the data processing device to perform operations, which operations include methods according to any aspect or implementation of the subject matter described in this specification.

[0008] Another innovative aspect of the subject matter described in the present specification can be embodied in a system including a server computer that receives a request from a user device specifying a particular sub-node state of a conversation process, wherein the conversation process defines multiple node states, the node states including a root node state and sub-node states, and wherein each sub-node state is derived from at least one of another sub-node state or the root node state; and each node state specifies an input request and an input response processing rule, the input response processing rule being used to process an input response received in response to the input request and to select one of the sub-node states derived from the node state based on the input response. The system includes a device for instantiating a dialog process at a child node state in response to a request for specifying a specific child node state and a device for providing (or causing the server computer to instruct another device such as a user device to provide) multiple input responses to the dialog process to the dialog process by a server computer, providing each input response as a response to the input request, wherein the first input response among the provided input responses is provided for the input request of the root node state, and the last input response among the provided input responses is provided for the input request of the node state that is the parent node of the specific child node state, and causing the dialog process to select the specific child node state. The server computer provides data to the user device that causes the user device to present the dialog process at the specific child node state. Another innovative aspect of the subject matter described in this specification can be embodied in a system, the system comprising: a data processing device; and a computer-readable medium (the computer-readable medium can be a non-transitory computer-readable medium, although this aspect is not limited thereto), the computer-readable medium storing instructions, the instructions can be executed by the data processing device and when so executed, cause the data processing device to perform operations, the operations including methods according to any aspect or implementation of the subject matter described in this specification.

[0009] Optionally, these and other embodiments may include one or more of the following features respectively: In some implementations, the request for specifying a specific subnode state of a dialog process includes an index key value of a dialog process index, wherein the dialog process index specifies, for each index entry, a specific subnode state entry indexed by a corresponding index key value and an input response set that traverses the dialog process from a root node state to the specific subnode state. The multiple input responses provided to the dialog process may include: accessing the specific subnode state entry indexed by the index key value of the request, retrieving the input response set from the dialog process index, and then providing the input response set to the dialog process.

[0010] In some implementations, the request for specifying a specific subnode state of the dialog process includes multiple input responses that cause the dialog process to traverse from the root node state to the specific subnode state. The request may be specified by a uniform resource locator that includes a set of input responses as a query parameter.

[0011] In some implementations, the request is specified by a specific uniform resource identifier that references a resource, the resource including instructions that cause the dialog process to traverse from a root node state to a specific child node state, wherein the instructions may specify a plurality of input responses.

[0012] In some implementations, each input response of the plurality of input responses includes an input response for causing the dialog process to traverse to another node state.

[0013] In some implementations, the request to specify the state of a particular subnode of a dialog process is based in part on a user search history. The request to specify the state of a particular subnode of a dialog process may be based in part on a user browsing history.

[0014] The specific embodiment of the subject matter described in this specification can be implemented to realize one or more of the following advantages. A direct link (e.g., uniform resource identifier) ​​to a specific subnode state of a dialog process is provided to the user. The selection of the link instantiates the dialog process at the root node state. Further, the link causes the dialog process to be called in a manner including all necessary information for traversing from the root node state to the specific subnode state of the dialog process. By providing information to the dialog process so that the dialog process traverses to the specific subnode state, the system and method ensure that the function of exposing the specific subnode state to the user is not required to input any response to reach the specific subnode state. Eliminating the need for the user to input any response and providing the dialog process with an input request to the user reduces the network service required for the user to link to the specific subnode state and / or reduces the time spent by the user to link to the specific subnode state, thereby providing a more resource-efficient process. In addition, the need for custom code for the dialog process is avoided, so that the dialog process does not need to reprogram each desired exposure of the specific subnode state of the dialog process. This simplifies the developer code base and provides additional flexibility by a system that requires special coding for each dialog process.

[0015] The details of one or more embodiments of the subject matter described in this specification are set forth in the accompanying drawings and the description below. Other features, aspects, and advantages of the subject matter will become apparent from the description, drawings, and claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1A is a block diagram of an example environment of a user device that can invoke a conversation process at a particular subnode state.

[0017] Figure 1B is a diagram of the subset of child node states that are derived from the root node state during the dialog process.

[0018] Figure 2 is a flow diagram of an example process for instantiating a dialog process at a particular child node state.

[0019] Figure 3A -C is a block diagram of various example system process flows for instantiating a dialog process at a particular subnode state.

[0020] Like reference numbers and designations in the various drawings indicate like elements. DETAILED DESCRIPTION

[0021] Overview

[0022] The following describes a system and method for providing a user with a deep link to a specific sub-node state of a conversation process such as a chatbot or an artificial conversation entity. The selection of the link instantiates the conversation process at the root node state. The link causes the conversation process to be called in a manner including all necessary information for traversing the conversation process to the specific sub-node state of the conversation process. The information for traversing the conversation process to the specific sub-node state can be completed in several different ways. One method is to encode a uniform resource identifier with information, such as in the form of a query parameter, and when the conversation process is called, the conversation process consumes the information. Another method is to encode the uniform resource identifier with a token that indexes an index including the information, and when the call is made, the information is extracted from the index and provided to the conversation process. Another method is to link to a process such as a script, which is encoded to provide the information to the conversation process when the conversation process is called. A computer server receives a request for a conversation process at a specific sub-node state from a user device in response to a link selected by a user of the user device.

[0023] The dialog process has a plurality of node states including a root node state and a child node state. Each child node state of the dialog process is derived from at least one of another child node state or the root node state in the dialog process. Each node state includes an input request and an input response processing rule, wherein the input response processing rule determines how the node state will process the received input response, and selects a child node state derived from the root node in response to the input response.

[0024] According to various aspects of this specification, for each request to a dialog process at a particular child node state, the dialog process is instantiated at the root node state of the dialog process. A plurality of input responses are provided to the dialog process in response to the selection of a link. In some embodiments, the responses may be provided by a server computer, while in other embodiments, the responses may be provided by a user device.

[0025] Each input response is provided to the dialog process in response to an input request. For example, the first input response is provided for (in response to) an input request for the root node state of the dialog process, and the last input response is provided for (in response to) an input request for the node state of the parent node as the specific child node state that is linked to. Between the response provided for the root node state and the response provided for the node state of the parent node as the specific child node state, zero or more intermediate responses can be provided, depending on the depth of the specific child node state. When the last input response is received, the dialog process will select the specific child node state.

[0026] In some embodiments, when a specific subnode state is reached, the dialog process is then presented at the user device. In other embodiments, the dialog process can be presented at the user device as each input response is provided to the dialog process so that the user can see the questions and responses that caused the dialog process to traverse to the specific subnode state.

[0027] These and additional features are described in more detail below.

[0028] Example operating environment

[0029] Figure 1A 1 is a block diagram of an example environment 100 in which a conversation process can be invoked at a particular subnode state of a user device. A computer network 102, such as a local area network (LAN), the Internet, or a combination thereof, connects a server computer 104 and a user device 108 including one or more conversation processes 106. The server computer 104 is connected to a server computer 104 at a particular node state of a user device. Figure 1A 102, but may include multiple different servers that communicate directly or through network 102.

[0030] The user device 108 is an electronic device capable of requesting and receiving a conversation process 106 over the network 102. Example user devices 108 include personal computers, mobile communication devices, and other devices that can send and receive data over the network 102. The user device 108 typically includes a user application such as a web browser to facilitate sending and receiving data, including the conversation process 106, over the network 102. The web browser can enable a user to display and interact with text, images, video, music, and other information on web pages typically located at websites on the World Wide Web or a local area network.

[0031] Instantiate the dialog process

[0032] The user device 108 may display a user environment 107 including a link 114 (or some other request instructions 114) to a specific sub-node state of a dialog process. For example, the user environment 107 may be a web page, a user interface in a local application, a text messaging environment, or any other environment that may provide instructions that, when selected, cause the user device 108 to send a request to a server. For example, a user on the user device 108 may request the server 104 to present the dialog process 106 at a specific sub-node state by selecting the request instruction 114. Each dialog process 106 has a plurality of node states {N1, N2, ...NN}, which include a root node state and a sub-node state. Each sub-node state of a dialog process 106 is derived from another sub-node state or a root node state. Each node state includes an input request (e.g., a question) and an input response processing rule for processing an input response (e.g., an answer). For a specific input response provided in response to an input request of a node state, the node state will select a sub-node state from the sub-node states derived from the node state.

[0033] exist Figure 1B The diagram shows the relationship between the node states in the dialogue process. Figure 1B is a schematic diagram of a subset of node states derived from the root node N0 in a dialog process. The root node N0 includes an input request {question 0} and rules for processing the input response. Figure 1B As shown, the rule resolves to two decisions - A01 traversing to child node N11 and A02 traversing to child node N12. For example, suppose the question is "Do you want to book a new hotel reservation, or review an existing reservation?" The A01 branch can be any response or input that resolves to "book", and the A02 branch can be any response and input that resolves to "view". For simplicity and to avoid drawing congestion, other node states indicated by ghost branches are omitted from the figure.

[0034] In order to traverse to child node state N33, the dialog process must receive inputs that resolve to A02 for question 0 at root node N0, resolve to A121 for question 12 at child node N12, and resolve to A231 for question 23 at child node N23. The systems and methods described below allow a dialog process to be instantiated at a root node state and automatically traverse from the root node state to a particular child node state.

[0035] As described above, three example methods are provided to instantiate a dialog process at a root node state and automatically traverse to a specific child node state. The first method is to encode a uniform resource identifier with information and refer to Figure 3A The second method is to encode the uniform resource identifier with a token that indexes the index of the information included, and refer to Figure 3B A third method is to link to a process such as a script that is coded to provide information to the dialog process when it is called, and refer to Figure 3C These examples are not exhaustive, and other suitable methods of instantiating a dialog process at a root node and automatically traversing from the root node state to a particular child node state may also be used.

[0036] Figure 2 1 is a flow chart of an example process 200 for instantiating a dialog process 106a at a particular child node state. The process 200 may be performed by a computer system such as the server computer 104.

[0037] The server 104 receives a request 114 (202) to provide a dialog process 106a at a specific sub-node state to a user device 108. The request can be generated by selecting a uniform resource identifier such as a uniform resource locator (URL). The content encoded in the link and the generated request can depend on the instantiation process used by the system to instantiate the dialog process at a root node state and automatically traverse from the root node state to the specific sub-node state. For example, the request 114 may include an input response as a query parameter. Alternatively, the request 114 may include a reference to an index key value of an index of the dialog process, wherein the index key value references an index entry and an input response set for a specific sub-node state. In another alternative, the request may refer to a resource, wherein the resource 112 (e.g., a web page) includes instructions and information related to the input response set. Refer to the following Figures 3A to 3C These different request types are described separately.

[0038] After receiving the request 114, the server 104 instantiates the dialog process at the root node state of the dialog process 106a (204). Although the dialog process 106a is instantiated in an environment on the server 104 separately from the user device 108, in some embodiments, for example, the dialog process 106a can be instantiated in an environment on the user device 108 instead.

[0039] The server 104 provides a plurality of input responses to the dialog process, wherein each input response is provided in response to an input request (206). The provision of responses may be accomplished based on the type of request, and as described below. Figures 3A to 3CAn example thereof is described. By providing a specific input response set to the dialog process 106a, the dialog process 106a traverses from the root node state to a specific child node state. For example, the flight booking dialog process can provide a corresponding input response "Honolulu, Hawaii." for the input request "Where are you flying to today?" at the root node state. Before reaching the specific child node state, the dialog process 106a can then select a descendant child node state with a possible input response "Yes" etc. for the input request "Would you like to check-in?"

[0040] More specifically, refer to Figure 1B , can provide responses parsed to A02, A121, and A231 to traverse to child node state N33. For example, to Figure 1BThe dialog process traverses to the child node state N33. Once the server 104 has instantiated the dialog process under the root node state N0, for example, the server 104 enters a response that can effectively generate decision A02, so that the dialog process traverses to the child node state N12. The dialog process can prompt the server 104 for the response to be entered, or once the root node state has been instantiated, the server can automatically enter the response. Next, the response that effectively generates decision A121 under the child node state N12 is entered, so that the dialog process traverses to the child node state N23, followed by a response that effectively generates decision A231 under the child node state N23, so that the dialog process traverses to the specific child node state N33. Each response only needs to be the data required to resolve to the state. For example, if the question requires the digital input 1, 2, or 3 to resolve to the corresponding child node state 1, 2, or 3, the response that resolves to "1" can be the number "1" or the word "one", and so on. If the rule set includes semantic rules, the response only needs to be the data required to resolve to the state. For example, if the question soliciting input is "Tell us if you want to book a flight, manage a reservation, or cancel a flight", the inputs that resolve to "book a flight" may be words or phrases such as "book", "make a flight", or "buy ticket". Any of these words or phrases may be used as the input response to the node state. Thus, if the traversal needs to resolve the node state to "book a flight", the input response may simply be "book".

[0041] The input response to the traversal to the node state can be provided by the dialog process author, or can be discovered through machine learning techniques. In the former state, the dialog process author can be, for example, Figure 1A The specific node state of the dialog process provides a string separated response. To traverse to node N33, the string can be {A01}; {A121}; {A231}, where any {·} of the node is an alphanumeric value that causes the dialog process processing rule of the node to select the state required when traversing to a specific child node state. In the latter case, the virtual machine can be programmed to interpret the input request for each node state of the dialog process, provide input responses to the dialog process, and learn a dialog process "dialog graph" (similar to a website graph) that describes the hierarchy of the dialog process.

[0042] Once the conversation process 106a has traversed to the specific sub-node state, the server 104 provides the user device with data that enables the user device 108 to present the conversation process 106a at the specific sub-node state (208). The conversation process 106a can be presented to the user device 108 in the form of a new window in the application environment, and the conversation process 106a can be presented together with additional information related to the conversation process 106a.

[0043] Input response code in link

[0044] As reference Figure 1A -B and Figure 2 As described, various methods may be implemented to provide a user device with a conversation progress at a particular sub-node state. Figure 3A 300 is a block diagram of an example process 300 for instantiating a dialog process at a particular child node state 302. Figure 3A In the example, request 304 is generated from a URL that includes an input response set as a query parameter. When the dialog process is called, the dialog process consumes the information included in the query parameter.

[0045] For example, in Figure 3A , including the input response (e.g., {A1, A2, ... AN}) as a query parameter in the URL. A URL link to the location of the conversation process can be called in response to the request, for example, www.example / com / chatbot. Server 306 can receive request 304 generated from the selection of the URL and, in response, instantiate a conversation process 308.

[0046] The input response set provided for the request 304 is provided to the dialog process 308 as a query parameter. In response to the input request from the dialog process 308, each input response in the input response set is provided in turn. The dialog process 308 can be programmed to determine whether the input request is provided as a command parameter when calling, and process the input request accordingly. If the input request is not provided, the dialog process waits for input from the I / O device. For example, in response to the request generated by the URL 304 selection, the first input response "A1" is provided in response to the input request "Q1", the second response is provided in response to the input request "Q2", and so on, until the last input response "AN" is provided in response to the input request "QN". When the dialog process receives the input response "AN", the dialog process selects the descending node state as the specific child node state "M".

[0047] The user device 108 is then provided with data that enables the dialog process 302 at the specific sub-node state "M" to be displayed at the user device. In some embodiments, the input request and / or input response set 310 provided to the dialog process for traversing from the root node state of the dialog process 302 to the specific sub-node state is also provided to the user of the user device 108. This can display the complete dialog context from the root node state to the sub-node state to the user. For example, the text and / or graphic display 310 within or included with the dialog process 302 on the user device 108 can present a set of input requests (e.g., questions from the dialog process to the user) and corresponding input responses (e.g., answers provided by the server to the dialog process) corresponding to the node state traversing from the root node state to the specific sub-node state (e.g., "QM"). In other embodiments, only the input request for the sub-node state is provided to the user device.

[0048] In some implementations, providing the input request and / or input response set 310 may include displaying a summary of the input request and / or input response set 310 on the user device 108. The summary may include presenting relevant information to a user of the user device 108 along with or as part of the conversation progress 302 at the particular sub-node state. For example, for the input requests "where would you like to fly to?", "do you need to book a hotel at your destination?", and "would you like to book a rental car at your destination?" and the corresponding input response sets "Hawaii," "Yes," and "Yes" provided, the summary of the information is: "You would like topurchase plane tickets to go to Hawaii and book a hotel room and a rental carwhile you are visiting?" Other methods of displaying information related to the input requests and / or input response sets (e.g., textually or graphically) may be used.

[0049] Input response from the indexed response collection

[0050] As mentioned above Figure 1A -B, request 114 may include a URL containing a reference to an index key value of the dialog process index 110, wherein the index key value references an index entry and an input response set for a particular child node state. Using the key value, the server retrieves the input response from the index and provides the response to the dialog process when called. Figure 3B 3 is a block diagram of an example process 320 for instantiating a conversation process 322 at a specific child node state by request 324, wherein request 324 includes a reference to an index key value of a conversation process index 326. In some implementations, server 104 includes conversation process index 326. Conversation process index 326 may include multiple index entries (e.g., NS1, NS2, etc.), each index entry representing a specific child node state indexed by a corresponding index key value (e.g., IK1, IK2, etc.), and a set of input responses (e.g., {A1, A2, ... AN1}, {A1, A2, ... AN2}, etc.) that traverse conversation process 322 from a root node state to a specific child node state. For example, an index entry represented by index key IK1 and corresponding to a specific child node state NS1 includes an input response set {A1, A2, ... AN1}.

[0051] In some implementations, request 324 may include a reference to a specific sub-node state of a specified dialog process, including an index key value stored on server 328 corresponding to dialog process index 326. For example, an index entry for a specific sub-node state "M" of a dialog process, such as node state M (NSM), may include an index key value "IKM" and an input response set 330 {A1, A2, ...ANN}, which causes the dialog process 332 to traverse from the root node state to the specific sub-node state "M". More specifically, each node in the dialog process may correspond to an index entry, and the value recorded may be a response from the root node to the specific sub-node indexed by the index entry. For example, for Figure 1A At the level of , the index entry of node N12 may include the value {A01}. Similarly, for the index entry of node N23, the values ​​may be {A01}, {A121}, etc.

[0052] The conversation process index 326 may be provided by the conversation process author, or may be generated by an automated process. For example, as described above, a virtual machine may be programmed to generate a "conversation graph." The conversation graph may then be used to generate an index.

[0053] The server 328 receives the request 324 and accesses the specific child node state index entry represented by the index key value from the dialog process index 326 by using the index key value. From the index entry NSM, the server can retrieve the input response set 330. For example, for the index key value "IKM", the input response set 330 {A1, A2, ... ANN} can be retrieved by the server 328.

[0054] The server 328 can then instantiate the dialog process 332 at the root node state and follow the same procedure as described in reference Figure 3A The input response set 330 that causes the dialog process 332 to traverse from the root node state to the specific child node state "M" is provided to the dialog process 332 in a similar manner as discussed. The data that enables the dialog process under the specific child node state "M" 322 to be displayed at the user device is then provided to the user device 108.

[0055] Input response from resource directive

[0056] In some embodiments, as described in Figure 1A As discussed in -B, request 114 may include a URL that contains a reference to resource 112, wherein the resource (eg, a web page) includes information and instructions, such as a script, that provide the information to the dialog process when executed after invoking the dialog process. Figure 3C 340 is a block diagram of an example process 340 for instantiating a conversation process 342 at a specific sub-node state by means of a request 344 referencing a resource 346 including instructions 348. Information 348 included in the resource may include a plurality of input responses that may be provided in response to the conversation process input request to traverse to another node state until the specific sub-node state is reached. Once the specific sub-node state is reached, as instructed by the script, the server provides data that causes the user device to present the conversation process 342 at the specific sub-node state.

[0057] In some embodiments, information 348 is a script for automatically executing tasks written for a runtime environment. A scripting language (e.g., Perl or Python) may be used to write the script. For example, information 348 may include an executable task, which includes: generating a new dialog process at a root node state, and providing an input response set (e.g., {A1, A2, ... ANN}) to the dialog process in response to an input request (e.g., {Q1, Q2, ... QN}) of the dialog process.

[0058] In some embodiments, a different URL is used for each node state of the dialog process, wherein the information 348 of each request 344 is customized with instructions to cause the dialog process to traverse to a specific sub-node state of the dialog process. For example, a request 344 for a specific sub-node state "M" can be generated from a URL reference to a resource containing information 348, wherein the information 348 is a script that causes the dialog process to traverse from the root node state to the specific sub-node state "M". Different requests 344 for a specific sub-node state "Q" can be generated from different URL references to different resources containing different information that causes the dialog process to traverse from the root node state to the specific sub-node state "Q".

[0059] Node status selection

[0060] When the dialog process owner wants to use the dialog process to expose specific features to the user, the dialog process owner can create a resource with a link that instantiates the dialog process to the root node state when selected and causes the dialog process to automatically traverse from the root node state to specific child node states.

[0061] In other embodiments, the request for a particular sub-node state of the conversation process is based in part on the user search history and / or browsing history of the user of the user device 108. For example, the server can use the current session data of the user device to determine the current user interests based on, for example, keywords and topics. For example, a travel agency website may determine that the user is interested in traveling to Hawaii and provide content items for instantiating the travel agency's chatbot. However, instead of requiring the user to enter multiple responses to enter a node state in the chatbot for Hawaii, for example, "We have travelspecials for Hawaii. Would you like to learn about them?", the chatbot will be instantiated at the root node state and will be able to automatically traverse to the particular sub-node state by using one (or more) of the above processes. For example, assume that Figure 1A Depicts the information in the chatbot's index, and the expected child node state is N33. The record can be of the following form:

[0062]

[0063] Considering that the user's interest is determined to be domestic travel to Hawaii, the user may have an interest vector indicating that domestic travel to Hawaii is the user's current interest. Therefore, node N33 may be selected to have a higher relevance score than all other nodes of the chatbot. The relevance score may be determined by any suitable scoring algorithm, such as by the cosine similarity of the terms in the question and response path fields and the current user interest term vector. Therefore, if the user selects the link, the link generated for the chatbot and used for the user device will enable the chatbot to consume the following response to the following question as input when instantiated:

[0064]

[0065] The conversation progress at the specific sub-node state is then presented at the user device without the user having to enter "Book," "Domestic," and "Hawaii."

[0066] Additional implementation details

[0067] In the case where the system discussed herein collects personal information about the user or can utilize personal information, the user can be provided with the following opportunity: control whether the application or feature collects user information (e.g., information about the user's social network, social actions or activities, occupation, user's preferences, or the user's current location) or control whether and / or how to receive content that may be more relevant to the user. In addition, before storing or using specific data, the specific data can be processed in one or more ways so that personally identifiable information can be removed. For example, the user's identity can be processed so that the user's personally identifiable information cannot be determined, or in the case where location information can be obtained, the user's geographical location can be generalized (such as, to the city, zip code, or state and county level) so that the user's specific location cannot be determined. Thus, the user can control the way in which the content server collects and / or uses information about the user.

[0068] The embodiments and operations of the subject matter described in this specification may be implemented using digital electronic circuit systems, or using computer software, firmware, or hardware, including the structures disclosed in this specification and their structural equivalents, or a combination of one or more of them. The embodiments of the subject matter described in this specification may be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on a computer storage medium, executed by a data processing device or controlling the operation of the data processing device.

[0069] A computer storage medium can be, or be included in, a computer-readable storage device, a computer-readable storage substrate, a random or serial access memory array or device, or a combination of one or more of them. In addition, although a computer storage medium is not a propagated signal, a computer storage medium can be a source or destination of computer program instructions encoded in an artificially generated propagated signal. A computer storage medium can also be, or be included in, one or more separate physical components or media (e.g., multiple CDs, disks, or other storage devices).

[0070] The operations described in this specification may be implemented as operations performed by a data processing apparatus on data stored on one or more computer-readable storage devices or received from other sources.

[0071] The term "data processing device" encompasses all kinds of devices, apparatuses, and machines for processing data, including, for example, a programmable processor, a computer, a system on a chip, or multiple or combinations of the foregoing. The device may include a dedicated logic circuit system, for example, an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit). In addition to hardware, the device may also include code that creates an execution environment for the computer program in question, for example, code that constitutes processor firmware, a protocol stack, a database management system, an operating system, a cross-platform runtime environment, a virtual machine, or a combination of one or more of them. The device and execution environment can implement a variety of different computing model infrastructures, such as network services, distributed computing, and grid computing infrastructures.

[0072] Computer programs (also referred to as programs, software, software applications, scripts, or codes) can be written in any form of programming language including compiled languages ​​or interpreted languages, declarative languages, or procedural languages, and can be deployed in any form including as stand-alone programs or modules, components, subroutines, objects, or other units suitable for computing environments. Computer programs can but do not necessarily correspond to files in a file system. Programs can be stored in a portion of a file that stores other programs or data (e.g., one or more scripts stored in a markup language document), or in a single file dedicated to the program in question, or in multiple collaborative files (e.g., files storing one or more modules, subroutines, or partial codes). Computer programs can be deployed to execute on one computer or on multiple computers located at one site or distributed in multiple sites and interconnected by a communication network.

[0073] The processes and logic flows described in this specification may be performed by one or more programmable processors executing one or more computer programs to perform actions by operating input data and generating output. The processes and logic flows may also be performed by a dedicated logic circuit system such as an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit), and the device may also be implemented as a dedicated logic circuit system.

[0074] Processors suitable for executing computer programs include any one or more processors of, for example, general-purpose microprocessors, special-purpose microprocessors, and any type of digital computer. Generally speaking, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are: a processor for acting according to instructions and one or more memory devices for storing instructions and data. Generally speaking, a computer will also include one or more mass storage devices such as a disk, a magneto-optical disk, or an optical disk for storing data, or a computer may be operatively coupled to receive data from the mass storage device or to transfer data to the mass storage device or to perform both. However, a computer need not have such a device. In addition, a computer may be embedded in another device, for example, a mobile phone, a personal digital assistant (PDA), a mobile audio or video player, a game console, a global positioning system (GPS) receiver, or a portable storage device (for example, a universal serial bus (USB) flash drive), to name a few. Devices suitable for storing computer program instructions and data include all forms of nonvolatile memory, media, and storage devices, including, for example, semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices; magnetic disks, such as internal hard disks or removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory may be supplemented by, or incorporated in, special purpose logic circuitry.

[0075] To provide interaction with a user, embodiments of the subject matter described in this specification may be implemented on a computer having: a display device for displaying information to the user, such as a CRT (cathode ray tube) or LCD (liquid crystal display) monitor; and a keyboard and pointing device, such as a mouse or trackball, through which the user can provide input to the computer. Other types of devices may also be used to provide interaction with the user; for example, the feedback provided to the user may be any form of sensory feedback, such as visual feedback, auditory feedback, or tactile feedback; and input from the user may be received in any form including acoustic input, voice input, or tactile input. In addition, the computer may interact with the user by sending documents to and receiving documents from a device used by the user, such as by sending a web page to a web browser on a user device of the user in response to a request received from the web browser.

[0076] Embodiments of the subject matter described in this specification may be implemented in a computing system that includes a backend component (e.g., as a data server), or a computing system that includes a middleware component (e.g., an application server), or a computing system that includes a frontend component (e.g., a user computer with a graphical user interface or a web browser through which a user can interact with an implementation of the subject matter described in the present invention), or a computing system that includes any combination of one or more such backend components, middleware components, or frontend components. The components of the system may be interconnected by any form or medium of digital data communication, such as a communications network. Examples of communications networks include: local area networks ("LANs") and wide area networks ("WANs"), internets (e.g., the Internet), and point-to-point networks (e.g., adhoc point-to-point networks).

[0077] A computing system may include a user and a server. The user and the server are generally remote from each other and usually interact through a communication network. The relationship between the user and the server is generated by computer programs running on respective computers and having a user-server relationship with each other. In some embodiments, the server transmits data (e.g., an HTML page) to a user device (e.g., to display data to a user interacting with the user device and to receive user input from the user). Data generated at the user device (e.g., a result of user interaction) may be received from the user device at the server.

[0078] Although this specification includes many specific implementation details, these details should not be regarded as limitations on the scope of any feature or content that may be required, but as descriptions of features for specific embodiments. Certain features described in the context of a separate embodiment in this specification can also be implemented in a single embodiment in combination. On the contrary, the various features described in the context of a single embodiment can also be implemented in multiple embodiments individually or according to any suitable sub-combination. In addition, although the above may describe features as working with certain combinations and initially even the features are required in the same manner, one or more features from the required combination can be deleted from the combination in some cases, and the required combination can point to a sub-combination or a change in the sub-combination.

[0079] Equally, although operation is shown in a specific order in the accompanying drawings, it should not be understood that it is necessary to perform such operation in the specific order shown or in a sequential order, or it is necessary to perform all illustrated operations to achieve the desired result. In some cases, multitasking and parallel processing can be advantageous. In addition, the separation of the various system components in the above-described embodiments should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can be integrated together in a single software product or encapsulated in multiple software products usually.

[0080] Thus, specific embodiments of the present subject matter have been described. Other embodiments are within the scope of the following claims. In some cases, the actions recited in the claims can be performed in a different order and still achieve the desired results. In addition, the processes depicted in the accompanying drawings do not necessarily require the specific order shown or the sequential order to achieve the desired results. In some embodiments, multitasking and parallel processing can be advantageous.

Claims

1. A method implemented by one or more processors, the method comprising: Automatically generate a dialogue diagram for the dialogue process, wherein the dialogue diagram describes the hierarchy of the dialogue process, and Wherein, the dialog process defines multiple node states, The node status includes the root node status and the child node status, and wherein each child node state is derived from at least one of another child node state or the root node state; After automatically generating the conversation diagram: receiving, at the server computer, from a user device of a user, a request specifying a particular sub-node state of the sub-node states of the conversation process; In response to receiving the request to specify a state of a particular child node of the dialog process: Instantiating the dialog process in the root node state by the server computer; Automatically traversing from the root node state to the specific child node state based on the dialog graph, wherein automatically traversing from the root node state to the specific child node state based on the dialog graph comprises: Prior to traversing to the particular subnode state, traversing to an intermediate subnode state among the subnode states without requiring any user input from the user of the user device to reach the intermediate subnode state, wherein the particular subnode state is derived from the intermediate subnode state; and traversing from the intermediate sub-node state to the specific sub-node state without requiring any user input from the user of the user device to reach the specific sub-node state; and The server computer provides data to the user device, the data causing the user device to present the dialog process at the specific sub-node state for presentation to the user.

2. The method according to claim 1, wherein: Automatically generating the dialog graph includes using a virtual machine to interpret input requests for each of the node states and provide input responses to the dialog process.

3. The method according to claim 1, wherein: Each node state specifies an input request output by the dialog process and an input response processing rule for processing an input response received in response to the input request.

4. The method according to claim 3, wherein: The input response processing rule determines how the node state will process a received input response and, based on the input response, selects one of the child node states derived from the node state in response to the input response.

5. The method according to claim 1, further comprising: generating an index based on the conversation graph; Wherein, automatically traversing from the root node state to the child node state based on the dialog graph includes using the index in automatically traversing from the root node state to the child node state.

6. The method according to claim 1, wherein: The request to specify a particular sub-node state of the conversation process is based in part on a user search history.

7. The method according to claim 1, wherein: The request to specify a particular child node state of the conversation process is based in part on a user's browsing history.

8. The method according to claim 1, wherein: Traversing from the intermediate child node state to the specific child node state includes: A specific input response selected based on the specific child node state specified in the request is provided to the dialog process.

9. A system comprising: Data processing equipment; and A non-transitory computer-readable medium storing instructions that are executable by the data processing apparatus and thereby, when so executed, cause the data processing apparatus to perform operations comprising: Automatically generate a dialogue diagram for the dialogue process, wherein the dialogue diagram describes the hierarchy of the dialogue process, and Wherein, the dialog process defines multiple node states, The node status includes the root node status and the child node status, and wherein each child node state is derived from at least one of another child node state or the root node state; After automatically generating the conversation diagram: receiving, from a user device of a user, a request for specifying a specific sub-node state among the sub-node states of the dialog process; In response to receiving the request to specify a state of a particular child node of the dialog process: Instantiating the dialog process in the root node state by the server computer; Automatically traversing from the root node state to the specific child node state based on the dialog graph, wherein automatically traversing from the root node state to the specific child node state based on the dialog graph comprises: Prior to traversing to the particular subnode state, traversing to an intermediate subnode state among the subnode states without requiring any user input from the user of the user device to reach the intermediate subnode state, wherein the particular subnode state is derived from the intermediate subnode state; and traversing from the intermediate sub-node state to the specific sub-node state without requiring any user input from the user of the user device to reach the specific sub-node state; and Data is provided to the user device, the data causing the user device to present the dialog progress at the specific sub-node state for presentation to the user.

10. The system according to claim 9, wherein: Automatically generating the dialog graph includes using a virtual machine to interpret input requests for each of the node states and provide input responses to the dialog process.

11. The system according to claim 9, wherein: Each node state specifies an input request output by the dialog process and an input response processing rule for processing an input response received in response to the input request.

12. The system according to claim 11, wherein: The input response processing rule determines how the node state will process a received input response and, based on the input response, selects one of the child node states derived from the node state in response to the input response.

13. The system of claim 9, the operations further comprising: generating an index based on the conversation graph; Wherein, automatically traversing from the root node state to the child node state based on the dialog graph includes using the index in automatically traversing from the root node state to the child node state.

14. The system according to claim 9, wherein: The request to specify a particular sub-node state of the conversation process is based in part on a user search history.

15. The system according to claim 9, wherein: The request to specify a particular child node state of the conversation process is based in part on a user's browsing history.

16. The system of claim 9, wherein: Traversing from the intermediate child node state to the specific child node state includes: A specific input response selected based on the specific child node state specified in the request is provided to the dialog process.

17. A non-transitory computer readable medium storing instructions that are executable by a data processing apparatus and that, when so executed, cause the data processing apparatus to perform operations comprising: Automatically generate a dialogue diagram for the dialogue process, wherein the dialogue diagram describes the hierarchy of the dialogue process, and Wherein, the dialog process defines multiple node states, The node status includes the root node status and the child node status, and wherein each child node state is derived from at least one of another child node state or the root node state; After automatically generating the conversation diagram: receiving, at the server computer, from a user device of a user, a request specifying a particular sub-node state of the sub-node states of the conversation process; In response to receiving the request to specify a state of a particular child node of the dialog process: Instantiating the dialog process in the root node state by the server computer; Automatically traversing from the root node state to the specific child node state based on the dialog graph, wherein automatically traversing from the root node state to the specific child node state based on the dialog graph comprises: Prior to traversing to the particular subnode state, traversing to an intermediate subnode state among the subnode states without requiring any user input from the user of the user device to reach the intermediate subnode state, wherein the particular subnode state is derived from the intermediate subnode state; and traversing from the intermediate sub-node state to the specific sub-node state without requiring any user input from the user of the user device to reach the specific sub-node state; and The server computer provides data to the user device, the data causing the user device to present the dialog process at the specific sub-node state for presentation to the user.

Images