Dialog manager

A dialog manager (DM) is a component of a dialog system (DS), responsible for the state and flow of the conversation.

Uses your system voice; voice and rate in settings.

Snapshot

≈ 8 min read

Names in other languages

No names in other languages are held for this entry yet.

Article bodies are English and are not machine-translated. A name in another language is not a translation of the article.

A dialog manager (DM) is a component of a dialog system (DS), responsible for the state and flow of the conversation. Usually: * The input to the DM is the human utterance, usually converted to some system-specific semantic representation by the Natural language understanding (NLU) component.

For example, in a flight-planning dialog system, the input may look like "ORDER(from=TA,to=JER,date=2012-01-01)". * The DM usually maintains some state variables, such as the dialog history, the latest unanswered question, etc., depending on the system. * The output of the DM is a list of instructions to other parts of the dialog system, usually in a semantic representation, for example "TELL(flight-num=123,flight-time=12:34)". This semantic representation is usually converted to human language by the Natural language generation (NLG) component.

There are many different DMs that fulfill very different roles. There can even be several DM components in a single DS. The only thing common to all DMs is that they are stateful, in contrast to other parts of the DS (such as the NLU and NLG components), which are just stateless functions.

The DM roles can roughly be divided into these groups: # Input-control, which enable context-dependent processing of the human utterances. # Output-control, which enable state-dependent generation of text.…

A dialog manager (DM) is a component of a dialog system (DS), responsible for the state and flow of the conversation. Usually: The input to the DM is the human utterance, usually converted to some system-specific semantic representation by the Natural language understanding (NLU) component.

For example, in a flight-planning dialog system, the input may look like "ORDER(from=TA,to=JER,date=2012-01-01)". The DM usually maintains some state variables, such as the dialog history, the latest unanswered question, etc., depending on the system.

The output of the DM is a list of instructions to other parts of the dialog system, usually in a semantic representation, for example "TELL(flight-num=123,flight-time=12:34)". This semantic representation is usually converted to human language by the Natural language generation (NLG) component. There are many different DMs that fulfill very different roles.

There can even be several DM components in a single DS. The only thing common to all DMs is that they are stateful, in contrast to other parts of the DS (such as the NLU and NLG components), which are just stateless functions. The DM roles can roughly be divided into these groups: Input-control, which enable context-dependent processing of the human utterances.

Output-control, which enable state-dependent generation of text. Strategic flow-control, which decide what action the dialog agent should take at each point of the dialog.

Tactic flow-control, which make some tactical conversational decisions (error handling, initiative control, etc.). A similar feature exists in ChatScript (a framework for authoring chatter-bots): Each time the DS uses a certain rule, the DM marks this rule as "used", so that it won't be used again. A recent DS for technical assistance uses advanced machine-learned rules to select the best terms for describing items.

For example, if the DM notices that it's speaking with an adult, it will use terms such as "the left hand"; if it notices that it's speaking with a child, it will use less technical terms such as "the hand where you wear the clock". This function is on the border between DM and NLG.

AIML, Facade and ChatScript (optimized for chat-bots), (Java-based, optimized for device-control dialogs), and TuTalk (optimized for tutorial dialogs). Additionally, the dialog structure can be described as a state-chart, using a standard language such as SCXML. This is done in (a framework for tactical questioning characters).

It is quite tedious for authors to write a full dialog structure. There are many improvements that allow authors to describe a dialog in a higher abstraction level, while putting more burden on the DM.

TRAVEL = {ORIGIN-PLACE, ORIGIN-TIME, DESTINATION-PLACE, DESTINATION-TIME} The DM keeps track of which slots are already filled and which slots are still empty, and navigates the conversation in order to collect the missing information. For example, the DM may ask the human about the origin place first, but if the human adds the destination place, the DM will keep the information and not ask about it again.

Such DSs were developed in MIT, for example, Wheels (for searching used car ads), Jupiter (for retrieving weather forecasts), and more. Simple DMs handle slot-filling binarily: either a slot is "filled", or it is "empty".

More advanced DMs also keep track of the degree of grounding - how sure are we, that we really understood what the user said: whether it was "Just recently introduced", "Introduced again", "acknowledged", "repeated", etc. We can also allow the author to specify, for each piece of information, the degree to which we NEED it to be understood, e.g. sensitive information need higher degree. The DM uses this information to control the course of dialog, e.g., if the human said something about a sensitive subject, and we are not sure we understood, then the DM will issue a confirmation question.

See . integrateAnswer: preconditions: ("If the human gave a relevant answer to a question currently under discussion...") in(SHARED.LM, answer (usr, A)) fst(SHARED.QUD, Q) relevant_answer(Q, A) effects: ("... then remove it from the Question Under Discussion, and add it to the shared ground") pop(SHARED.QUD) reduce(Q, A, P) add(SHARED.COM, P) The DM decides, according to the input and the state, which rules are applicable, and applies them to get the new state. This may help authors re-use general rules for dialog management rules, based on dialog theories.

DSs developed with TrindiKit include: GoDiS, MIDAS, EDIS and SRI Autorate. The information state approach was developed later in projects such as Siridus and the Dipper toolkit. Another example of an information state based dialog manager is FLoReS.

It uses a propositional information state to encode the current state and selects the next action using a Markov decision process. This dialog manager is implemented in the jmNL software.

Inform(Speaker,Hearer,Predicate): Precondition: Knows(Speaker,Predicate) AND Wants(Speaker,Inform(Speaker,Hearer,Predicate)) Effect: Knows(Hearer,Predicate) Body: Believes(Hearer,Wants(Speaker,Knows(Hearer,Predicate))) The conversation can be navigated using a general planner, such as SOAR (Strengths, Opportunities, Aspirations & Results). The planner maintains the current state, and tries to construct a plan to achieve the goal, using the given operations.

A similar approach is taken in SASO-ST (a DS for multi-agent negotiation training). Using SOAR allows the incorporation of complex emotional and social models, for example: the agent can decide, based on the human actions, whether he wants to cooperate with him, avoid him, or even attack him. A similar approach is taken in TRIPS (a DS for multi-agent collaborative problem solving).

They split the dialog management into several modules: Reference manager - Given a word (e.g. "the woman"), decide what object in the world it refers to (e.g. "WOM1234"). Task manager - Identify the problem-solving acts that the user tries to achieve (create new objective, extend an existing objective, etc.). Interpretation manager - in addition to calling the first two, also identify discourse obligations, for example: "respond to the latest question".

Behavioral agent - decides how to accomplish the goal that the user wants. The agent employs several task-specific agents that do the actual planning. A different kind of planning is theorem proving.

A dialog can be described as an attempt to prove a theorem. The system interacts with user to supply "missing axioms" to help complete the proof (this is called "backward chaining"). This approach was implemented by: Grammatical Framework.

IPSIM (Interruptible Prolog SIMulator), in the Circuit Fixit system. The dialog manager can be connected with an expert system, to give the ability to respond with specific expertise.

Text derived from https://en.wikipedia.org/w/index.php?oldid=1373202111 under CC BY-SA 4.0; modifications have been made.

Sources cited in this revision

3 named source(s) extracted from the cited revision. A source with no author is shown by its publication; nothing is invented.