G raph D ialog: Integrating Graph Knowledge into End-to-End Task-Oriented Dialogue Systems (2020)

Abstract: End-to-end task-oriented dialogue systems aim to generate system responses directly from plain text inputs. There are two challenges for such systems: one is how to effectively incorporate external knowledge bases (KBs) into the learning framework; the other is how to accurately capture the semantics of dialogue history. In this paper, we address these two challenges by exploiting the graph structural information in the knowledge base and in the dependency parsing tree of the dialogue. To effectively leverage the structural information in dialogue history, we propose a new recurrent cell architecture which allows representation learning on graphs. To exploit the relations between entities in KBs, the model combines multi-hop reasoning ability based on the graph structure. Experimental results show that the proposed model achieves consistent improvement over state-of-the-art models on two different task-oriented dialogue datasets.

## introduction task-oriented dialogue systems aim to help user accomplish specific tasks via natural language interfaces such as restaurant reservation, hotel booking and weather forecast. there are many commercial applications of this kind (e.g. amazon alexa, google home, and apple siri) which make our life more convenient. figure 1 illustrates such an example where a customer is asking for the information about restaurants. by querying the knowledge base (kb), the agent aims to provide the correct restaurant entities from the kb to satisfy the customer in a natural language form. hence, the ability to understand the dialogue history, and to retrieve relevant information from the kb is essential in task-oriented dialogue systems. one approach for designing task-oriented dialogue systems is the pipeline approach (williams figure 1 : an example dialogue in the restaurant booking domain. the top part is knowledge base (kb) information that represented by a graph and the bottom part is the conversation between a customer and the agent. our aim is to predict the agent responses given kb information and the customer utterances. @xcite @xcite , but it suffers from the difficulty in credit assignment and adaption to new domains. another popular approach is the end-to-end models @xcite @xcite @xcite , which directly map the dialogue history to the output responses. this approach has attracted more attention in the research community recently as it alleviates the drawbacks of the pipeline approach. however, end-to-end dialogue models usually suffer from ineffective use of knowledge bases due to the lack of appropriate framework to handle kb data. to mitigate this issue, recent end-to-end dialogue studies @xcite employ memory networks @xcite to support the learning over kb, and have achieved promising results via integrating memory with copy mechanisms @xcite . by using memory, they assume that the underlying structure of kb is linear since memory can be viewed as a list structure. as a result, the relationships between entities are not captured. however, since kb is naturally a graph structure (nodes are entities and edges are relations between entities). by overlooking such relationships, the model fails to capture substantial information embedded in the kb including the semantics of the entities which may significantly impact the accuracy of results. moreover, structural knowledge such as dependency relationships has recently been investigated on some tasks (e.g., relation extraction) @xcite and shown to be effective in the model's generalizability. however, such dependency relationships (essentially also graph structure) have not been explored in dialogue systems, again missing great potential for improvements. with the above insight, we propose a novel graph-based end-to-end task-oriented dialogue model (graphdialog) aimed to exploit the graph knowledge both in dialogue history and kbs. unlike traditional rnns such as lstm @xcite and gru @xcite , we design a novel recurrent unit (section 3.1.2) that allows multiple hidden states as inputs at each timestep such that the dialogue history can be encoded with graph structural information. the recurrent unit employs a masked attention mechanism to enable variable input hidden states at each timestep. moreover, we incorporate a graph structure (section 3.2) to handle the external kb information and perform multi-hop reasoning on the graph to retrieve kb entities. overall, the contributions of this paper are summarized as follows: ## related work task-oriented dialogue system has been a longstanding studied topic @xcite @xcite and can be integrated into many practical applications such as virtual assistant @xcite . traditionally, task-oriented dialogue systems are built in the pipeline approach, which consists of four essential components: natural language understanding @xcite , dialogue state tracking @xcite @xcite , policy learning @xcite @xcite and natural language generation @xcite @xcite . another recent approach is the end-to-end models @xcite , which directly map the user utterances to responses without heavy annotations. @xcite apply endto-end memory networks @xcite for task-oriented dialogues and shown that end-toend models are promising on the tasks. to produce more flexible responses, several generative models are proposed @xcite . they formulate the response generation problem as a translation task and apply sequence-to-sequence (seq2seq) models to generate responses. seq2seq models have shown to be effective in language modeling but they struggle to incorporate external kb into responses. to mitigate this issue, @xcite has enhanced the seq2seq model by adding copy mechanism. @xcite combines the idea of pointer with memory networks and obtained improved performance. @xcite incorporates global pointer mechanism and achieved improved performance. our study differs from those works in that we exploit the powerful graph information both contained in the dialogue history and in the kbs to effectively incorporate kbs into dialogue systems. ## proposed model our proposed model consists of three components: an encoder (section 3.1), a decoder (section 3.3) and a knowledge graph with multi-hop reasoning ability (section 3.2). formally, let @xmath0,...,x n } be a sequence of tokens, where each token x @xmath1. we first obtain a dialogue graph g (section 3.1.1), which is the dependency parsing graph of the sentences in the dialogue history x, as the input of the encoder. the encoder then learns a fixed-length vector as the encoding of the dialogue history based on g, which is then fed to the decoder for hidden state initialization. the knowledge graph adopts another graph @xmath2,e} to store and retrieve the external knowledge data (section 3.2.1), where v denotes the entities and e denotes the edges. the decoder generates the system response @xmath3,...,y m } token-by-token either by copying entities from graph g via querying the knowledge graph or by generating tokens from vocabularies. figure 2 illustrates the overall architecture of the proposed model. in the following sections, we describe each component in detail. ## conclusion in this work, we present a novel graph-based endto-end model for task-oriented dialogue systems. the model leverages the graph structural information in dialogue history via the proposed recurrent cell architecture to capture the semantics of dialogue history. the model further exploits the relationships between entities in the kb to achieve better reasoning ability by combining the multi-hop reasoning ability with graph. we empirically show that our model outperforms the state-of-the-art models on two real-world taskoriented dialogue datasets. our model may also be applied to end-to-end open-domain chatbots since the goal is to generate responses given inputs and external knowledge, which is what our model can do. we will explore this direction in future work.