A Compact Architecture for Dialogue Management Based on Scripts and Meta-Outputs

Manny Rayner, Beth Ann Hockey, Frankie JamesNAACL 2000

TL;DR

This paper proposes a novel dialogue management architecture for spoken language interfaces to semi-autonomous systems. Instead of outputting logical forms, it generates executable scripts and uses "meta-outputs" to capture the nuances and potential failures of the interpretation process, leading to more robust and flexible human-robot interaction.

What Problem Does This Paper Address?

The paper tackles the challenge of building effective spoken dialogue interfaces for controlling semi-autonomous systems, like robots. Traditional approaches convert spoken language into logical forms that are then interpreted. However, this process is often brittle. Users can be unclear, systems can misinterpret, and the rigid nature of logical forms struggles to capture the dynamic, imperative nature of commands. The authors argue that this standard approach needs modification to better handle the inherent fallibility of interpretation and the command-oriented nature of human-robot interaction.

Methods

The core of the proposed architecture lies in two key ideas:

  • Scripts as Output: Instead of logical forms, the system's output is an executable script in a language similar to shell scripting (e.g., CSHELL). This is motivated by the observation that complex commands in real-world computing are often expressed in imperative scripting languages, which naturally handle temporal sequencing and error streams.
  • Meta-Outputs: Each step in the interpretation process (from speech to script) produces not only an output but also a "meta-output." These meta-outputs provide crucial information about how the transformation occurred, including potential errors, ambiguities, or user misconceptions. This meta-information is then used by the dialogue manager to make more informed decisions.

The interpretation process is described as a series of non-deterministic translation steps. These steps include:

  1. Linguistic to Discourse Level: Regularizing surface form differences (e.g., "measure the pressure" vs. "what is the pressure?").
  2. Discourse Level to Resolved: Handling ellipsis and anaphora (e.g., resolving "lower deck" to "measure temperature at lower deck").
  3. Resolved to Executable Script: Converting the representation into a script, including scoping quantified variables and optimizing the plan (e.g., reordering actions for efficiency).
  4. Plan Evaluation: Simulating the execution of the script to identify potential issues (like presupposition failures) and estimate costs.

Datasets

Not discussed in the paper. The paper focuses on the architecture and its implementation with a simulated Personal Satellite Assistant (PSA).

Key Insights and Ideas

  • Imperative Nature of Commands: Commands to robots are fundamentally imperative (telling the system what to do) rather than declarative (stating facts). Scripting languages, with their emphasis on sequence and action, are a more natural fit for representing these commands than logical forms.
  • Fallibility is the Norm: Interpretation is not a perfect process. Users are often unclear, and systems make mistakes. The architecture embraces this by explicitly modeling and handling interpretation failures through meta-outputs.
  • Meta-Information is Key: The "meta-output" concept is central. It allows the system to communicate why it produced a certain output or what went wrong, enabling richer dialogue management. For example, a "presupposition failure" meta-output can trigger a clarification question to the user.
  • Unified Framework: The architecture provides a unified way to handle diverse dialogue behaviors, such as resolving pronouns, correcting user misconceptions, and optimizing plans, all within the script/meta-output framework.
  • Plan Evaluation for Optimization: Simulating script execution before actual execution allows for plan optimization (e.g., finding the most efficient route) and the detection of potential problems, which can then be communicated to the user.

Key Results

The paper presents a prototype implementation and illustrates its capabilities through several examples of user-system interaction. These examples demonstrate how the architecture handles:

  • Plan Optimization: Reordering commands for efficiency (e.g., moving to locations in an optimal sequence).
  • Ellipsis Resolution: Understanding commands that rely on previous context (e.g., "Do the same for the pilot's seat").
  • Misconception Handling: Identifying and informing the user about incorrect assumptions (e.g., "There are in fact three doors," when the user said "Close both doors").
  • Ambiguity Resolution: Asking clarifying questions when a reference is underspecified (e.g., "Which door do you mean?").
  • Presupposition Failure Handling: Informing the user when a command cannot be executed as intended (e.g., "The crew hatch is already closed").

Limitations and Future Work

  • Cost Estimation: The paper notes that "cost" during plan evaluation is currently a simple estimate of execution time. More sophisticated cost models could be developed.
  • Real-World Deployment: The current implementation is a simulation of a robot. Future work would involve deploying this architecture on a real semi-autonomous system.
  • Complexity of Meta-Outputs: While the framework unifies meta-outputs, managing and prioritizing them for dialogue generation can still be complex.
  • Scripting Language Subset: The system uses a subset of a scripting language. The expressiveness and capabilities of this subset could be expanded.
  • User Modeling: While the system can detect user misconceptions, deeper user modeling could lead to more proactive and personalized interactions.

Summary updated

BibTeX
@inproceedings{rayner2000compact,
  author = {Manny Rayner and Beth Ann Hockey and Frankie James},
  title = {{A Compact Architecture for Dialogue Management Based on Scripts and Meta-Outputs}},
  booktitle = {Conference of the North American Chapter of the Association for Computational Linguistics},
  year = {2000},
}
Figure