Low-Resource Knowledge-Grounded Dialogue Generation

Introduction

Open domain dialogue systems, due to the applications on social chatbots such as Microsoft XiaoIce (Shum et al., 2018) and virtual assistants such as Amazon Alexa (Ram et al., 2018), have drawn increasing attention from the research community of natural language processing and artificial intelligence. Thanks to the advances in neural sequence modeling (Vaswani et al., 2017; Sutskever et al., 2014) and machine learning techniques (Li et al., 2017; 2016), such systems now are able to reply with plausible responses regarding to conversation history, and thus allow an agent to have a natural conversation with humans. On the other hand, when people attempt to dive into a specific topic, they may clearly realize the gap between the conversation with a state-of-the-art system and the conversation with humans, as the system is only able to awkwardly catch up with the conversation, owing to the lack of knowledge of the subject.

We consider grounding open domain dialogue generation with knowledge which is assumed to be unstructured documents. While documents are abundant on the Web, it is difficult to obtain large scale dialogues that are naturally grounded on the documents for learning of a neural generation model. To overcome the challenge, some recent work (Zhou et al., 2018b; Dinan et al., 2019) resorts to crowd-sourcing and builds benchmarks with the source of Wikipedia. On the one hand, the datasets pave the way to the recent research on knowledge-grounded response generation/selection (Zhao et al., 2019; Lian et al., 2019; Li et al., 2019); on the other hand, we argue that there still a long way to go for application of the existing models in real scenarios, since (1) the models, especially those achieve state-of-the-art performance via sophisticated neural architectures, just overfit to the small training data (e.g., $\sim$ 18k dialogues). An evidence is that when they are applied to documents out of the domain of the training data, their performance drops dramatically, as will be seen in our experiments; and (2) it is difficult to collect enough training data for a new domain or a new language, as human effort is expensive.

As a step towards application of knowledge-grounded dialogue generation in real-world systems, we explore how to learn a model with as few knowledge-grounded dialogues as possible, yet the model achieves state-of-the-art performance and generalizes well on out-of-domain documents. The key idea is to make parameters that rely on knowledge-grounded dialogues small and independent by disentangling the response decoder, and thus we can learn the major part of the generation model from ungrounded dialogues and plain text that are much easier to acquire. Specifically, the encoder of the generation model consists of two independent components with one for encoding the context and the other for representing the knowledge. The decoder is decomposed into conditionally independent components including a language model, a context processor, and a knowledge processor, and the three components are coordinated by a decoding manager that dynamically determines which component is activated for response prediction. The language model predicts the next word of a response based on the prior sub-sequence, and the context processor ensures coherence of the dialogue by attending over the conversation history. Both components, along with the context encoder, are independent with the extra knowledge, and thus can be pre-trained using the ungrounded dialogues. The knowledge encoder has nothing to do with dialogues, and thus can be pre-trained with the plain text. The knowledge processor is responsible for grounding response generation on the document. This part, together with the decoding manager, depends on the knowledge-grounded dialogues, but the parameters are small in size, and estimation of these parameters just requires a few training examples depending on specific domains or tasks. By fixing the pre-trained parameters, we can adapt the model to a new domain with only a little cost.

We pre-train the language model, the context processor, and the context encoder with a clean version of Reddit data (Dziri et al., 2018), pre-train the knowledge encoder using a Wikipedia dump available on ParlAI, and compare our model with baselines that hold state-of-the-art performance on two benchmarks including the Wizard of Wikipedia (Wizard) (Dinan et al., 2019) and CMU Document Grounded Conversations (CMU$\_$DoG) (Zhou et al., 2018b). Evaluation results indicate that (1) to achieve the state-of-the-art performance, our model only needs $1/8$ training data ($\sim$ $2.3$k dialogues on Wizard and $\sim$ $0.4$k dialogues on CMU$\_$DoG); (2) on Wizard, the model significantly outperforms the baseline models on out-of-domain documents even though the baselines have leveraged all training data, while our model is only learned with $1/16$ training data; and (3) the model performs comparably well on in-domain and out-of-domain documents in a low-resource setting.

Contributions in this work are three-fold: (1) exploration of knowledge-grounded dialogue generation under a low-resource setting; (2) proposal of pre-training the knowledge-grounded dialogue generation model with a disentangled decoder using ungrounded dialogues and documents; and (3) empirical verification of the effectiveness of the model on two benchmarks.

Approach

We elaborate our approach to learning a response generation model with knowledge-grounded dialogues, ungrounded dialogues, and plain text.

Suppose that we have a dataset $\mathcal{D}_{S}=\{(U_{i}^{S},D_{i}^{S},r_{i}^{S})\}_{i=1}^{n}$, where $\forall i\in\{1,\ldots,n\}$, $D_{i}^{S}$ is a document that serves as the background of the dialogue $(U_{i}^{S},r_{i}^{S})$, $U_{i}^{S}=(u_{i,1}^{S},\ldots u_{i,n_{i}}^{S})$ is the context of the dialogue with $u_{i,j}^{S}$ the $j$-th utterance, and $r_{i}^{S}$ is the response regarding to $U_{i}^{S}$ and $D^{S}_{i}$. In addition to $\mathcal{D}_{S}$, we further assume that there are $\mathcal{D}_{P}=\{{D_{i}^{P}}\}_{i=1}^{N}$ and $\mathcal{D}_{C}=\{(U_{j}^{C},r_{j}^{C})\}_{j=1}^{M}$ with $D_{i}^{P}$ a document and $(U_{j}^{C},r_{j}^{C})$ a context-response pair, $\forall i\in\{1,\ldots N\}$ and $\forall j\in\{1,\ldots,M\}$. $N\gg n$ and $M\gg n$. The goal is to learn a generation model $P(r|U,D;\theta)$ ($\theta$ denotes the parameters of the model) with $\mathcal{D}=\{\mathcal{D}_{S}\cup\mathcal{D}_{P}\cup\mathcal{D}_{C}\}$. Thus, given a new document $D$ with the associated dialogue context $U$, one can generate a response $r$ following $P(r|U,D;\theta)$.

Our idea is inspired by the observation on the nature of open domain dialogues: despite the fact that a dialogue is based on a document $D$, words and utterances in the dialogue are not always related to $D$ (e.g., a reply just echoing the previous turn), even for the turns from the interlocutor who has access to $D$, as demonstrated by the examples in (Dinan et al., 2019; Zhou et al., 2018b). Therefore, we postulate that formation of a response could be decomposed into three uncorrelated actions: (1) selecting a word according to what has generated to make the sentence linguistically valid (corresponding to a language model); (2) selecting a word according to the context to make the dialogue coherent (corresponding to a context processor); and (3) selecting a word according to the extra knowledge to ground the dialogue (corresponding to a knowledge processor). The three actions can be independently learned, which becomes the key to aiding the small $\mathcal{D}_{S}$ with the large $\mathcal{D}_{P}$ and $\mathcal{D}_{C}$.

2 Generation Model

Figure 1 illustrates the architecture of the model. The model is made up of a context encoder, a knowledge encoder, a decoder, and a decoding manager. The major difference lies in the decoding phase which simulates the aforementioned actions by decomposing the decoder into a language model, a context processor, and a knowledge processor. The three components are independent conditioned on the hidden states of the decoder, and are coordinated by the manager.

Given a dialogue context $U=(u_{1},\ldots,u_{l})$, the context encoder concatenates $\{u_{i}\}_{i=1}^{l}$ as $(w^{u}_{1},\ldots,w^{u}_{i},\ldots,w^{u}_{l_{u}})$ with $w^{u}_{i}$ the $i$-th word in the sequence, and then exploits a recurrent neural network with gated recurrent units (GRUs) (Chung et al., 2014) to transform the word sequence into a sequence of hidden vectors given by

where $\bm{e}^{u}_{i}$ is the embedding of $w^{u}_{i}$ initialized with GloVe (Pennington et al., 2014). $\{\bm{h}^{u}_{i}\}_{i=1}^{l_{u}}$ serve as the input of the context processor in decoding.

In the meanwhile, given a document $D=(d_{1},\ldots,d_{i},\ldots,d_{m})$ with $d_{i}$ the $i$-th sentence, the knowledge encoder represents $d_{i}$ as a sequence of hidden vectors through a bidirectional GRU (Cho et al., 2014):

where $\bm{e}^{d}_{i,j}$ is the embedding of the $j$-th word in $d_{i}$ initialized using GloVe. $\{\bm{h}^{d}_{i,j}\}_{i=1,j=1}^{i=m,j=l_{d}}$ are fed to the knowledge processor to ground response prediction on $D$.

Different from Transformer Memory Network (Dinan et al., 2019), our model does not perform knowledge selection in the encoding phase (e.g., via attention over $\{\bm{h}^{d}_{i,j}\}_{i=1,j=1}^{i=m,j=l_{d}}$), but leaves it to the decoding phase. This could remove the dependency between context encoding and knowledge encoding, and facilitate us to estimate $\theta_{e}$ and $\theta_{k}$ with $\mathcal{D}_{P}$ and $\mathcal{D}_{C}$ respectively.

2.2 Disentangled Decoder

The decoder maintains a hidden sequence $\{\bm{s}_{t}\}_{t=1}^{l_{r}}$. Let $\bm{e}^{r}_{t-1}$ be the embedding of the word predicted at step $t-1$, then $\bm{s}_{t}$ is defined by

where $\bm{s}_{0}=\bm{h}^{u}_{l_{u}}$. Based on $\{\bm{s}_{t}\}_{t=1}^{l_{r}}$, the three components are defined as follows:

The language model predicts a word based on $\bm{s}_{t}$. For words that do not need the context and the document (e.g., function words), employing the language model may enhance decoding speed without loss of accuracy. Formally, the generation probability is defined by

The context processor predicts a word by attending over $\{\bm{h}^{u}_{i}\}_{i=1}^{l_{u}}$. The word could be either fetched from the vocabulary or copied from the context $U$. Let $\bm{c}^{u}_{t}$ be the context vector at step $t$, then $\bm{c}^{u}_{t}$ can be formulated as

where $\alpha_{t,i}=\mathtt{exp}(e_{t,i})/\sum_{i}\mathtt{exp}(e_{t,i})$ denotes the attention distribution and $e_{t,i}=g_{\theta_{s}}(\bm{s}_{t},\bm{h}^{u}_{i})=v^{\top}\text{tanh}(W_{h}\bm{h}^{u}_{i}+W_{s}\bm{s}_{t}+b)$. The generation probability is defined by

In Equation (6), the first term models the correspondence between a context and a response, and is formulated as $P_{\mathtt{vocab}}(w^{r}_{t}|U,w^{r}_{1:t-1})=\mathtt{MLP}_{\theta_{v}}([\bm{s}_{t};\bm{c}^{u}_{t}])$. The second term models the copy mechanism, and $p_{\mathtt{gen}}=\mathtt{MLP}_{\theta_{g}}([\bm{c}^{u}_{t};\bm{s}_{t};\bm{e}^{r}_{t-1}])\in$ a trade-off between the two terms.

The knowledge processor goes through the document $D$ by a hierarchical attention mechanism, and predicts a word in a similar way as Equation (6). Formally, let $\{\beta^{s}_{t,i}\}_{i=1}^{m}$ and $\{\beta^{w}_{t,i,j}\}_{i=1,j=1}^{i=m,j=l_{d}}$ be the sentence-level attention distribution and the word-level attention distributions respectively at step $t$, then $\forall i\in\{1,\ldots,m\}$ and $\forall j\in\{1,\ldots,l_{d}\}$, $\beta^{s}_{t,i}$ and $\beta^{w}_{t,i,j}$ are calculated by

where $\mathbf{Z}_{s}$ and $\mathbf{Z}_{w}$ are normalization factors, and $\hat{\bm{h}}^{d}_{i}$ represents the average pooling of $\{\bm{h}^{d}_{i,j}\}_{j=1}^{l_{d}}$. A knowledge vector $\bm{c}^{d}_{t}$ that is analogous to $\bm{c}^{u}_{t}$ is then defined by

Finally, the generation probability is formulated as

where $\beta_{t,i,j}=\beta^{s}_{t,i}\cdot\beta^{w}_{t,i,j}$, $w^{d}_{i,j}$ is the $j$-th word of $d_{i}$, $P_{\mathtt{vocab}}(w^{r}_{t}|D,w^{r}_{1:t-1})=\mathtt{MLP}_{\theta_{v^{\prime}}}([\bm{s}_{t};\bm{c}^{d}_{t}])$, and $p_{\mathtt{gen}}^{\prime}=\mathtt{MLP}_{\theta_{g^{\prime}}}([\bm{c}^{d}_{t};\bm{s}_{t};\bm{e}^{r}_{t-1}])$ acts as a trade-off between the common term and the copy term.

2.3 Decoding Manager

The three components are controlled by the decoding manager with one picked up at each step of response prediction. Then, the probability to predict word $w^{r}_{t}$ can be formulated as

In training, to handle the discrete and undifferentiable process, we employ the Gumbel trick (Jang et al., 2016) and define ${\pi}_{t}$ as

where $f_{\pi}(\cdot)=\mathtt{MLP}_{\theta_{\pi}}(\cdot)$, $\mathtt{gumbel\_softmax}(\cdot)$ denotes the Gumbel-Softmax function (Jang et al., 2016), and $\tau$ is the temperature (hyperparameter). ${\pi}_{t}$ approaches to a one-hot vector when $\tau\rightarrow 0$. We start from a high temperature and gradually reduce it. In test, we discretize ${\pi}_{t}$ as a one-hot vector according to the distribution in Equation (11).

3 Learning Details

Let us denote $\{\theta_{ol},\theta_{oc},\theta_{od}\}$ as the parameters of word embedding in response prediction corresponding to the language model, the context processor, and the knowledge processor respectively. For simplicity, we let $\theta_{oc}=\theta_{od}=\theta_{o}$. Then $\{\theta_{e};\theta_{d};\theta_{s};\theta_{v};\theta_{g};\theta_{o}\}$ (including parameters of the context encoder, parameters of the hidden states of the decoder, and parameters of the context processor) are estimated with maximum likelihood estimation (MLE) on $\mathcal{D}_{C}=\{(U_{j}^{C},r_{j}^{C})\}_{j=1}^{M}$.

To estimate $\theta_{l}$ (i.e., parameters of the language model) and $\theta_{ol}$, we construct a corpus $\mathcal{D}_{LM}=\{u_{j}^{LM}\}_{j=1}^{M^{\prime}}$ with $u_{j}^{LM}$ a response or an utterance from a context in $\mathcal{D}_{C}$, and then learn the parameters with MLE on $\mathcal{D}_{LM}$ with $\theta_{d}$ fixed.

Inspired by Peters et al. (2018), we estimate $\theta_{k}$ (i.e., parameters of the knowledge encoder) using a bidirectional language model by minimizing the following loss function on $\mathcal{D}_{P}$:

The remaining parameters $\{\theta_{s^{\prime}};\theta_{v^{\prime}};\theta_{g^{\prime}};\theta_{\pi}\}$ (i.e., parameters of the knowledge processor and parameters of the decoding manager) are learned with MLE on $\mathcal{D}_{S}$ with all other parameters fixed. Note that parameters of word embedding in the encoders are supposed to be included in $\theta_{e}$ and $\theta_{k}$.

We focus on document-grounded dialogue generation in this work, but the approach proposed actually provides a recipe for a general solution to low-resource knowledge-grounded dialogue generation in which the knowledge could be a structured knowledge base, images, or videos. To do that, one only needs to modify the knowledge encoder and the knowledge processor to make them compatible with the specific type of knowledge, and pre-train the knowledge encoder, if possible, on single-modal knowledge data.

Experiments

We test the proposed model on Wizard of Wikipedia (Wizard) published in Dinan et al. (2019) and CMU Document Grounded Conversations (CMU$\_$DoG) published in Zhou et al. (2018b).

Both Wizard and CMU$\_$DoG consist of open domain dialogues grounded on wiki articles, and the dialogues are collected from crowd-workers on Amazon Mechanical Turk. In Wizard, the articles cover a wide range of topics (totally $1,365$) such as bowling, Gouda cheese, and Arnold Schwarzenegger, etc. Each conversation happens between a wizard who has access to knowledge about a specific topic and an apprentice who is just eager to learn from the wizard about the topic. On average, each wizard turn is associated with $60.8$ sentences retrieved from the wiki articles and each sentence contains $30.7$ words. The data is split as a training set, a validation set, and a test set by the data owner. The test set is split into two subsets: Test Seen and Test Unseen. Test Seen contains new dialogues with topics appearing in the training set, while topics in Test Unseen never appear in the training set and the validation set, and thus the data allow us to examine the generalization ability of models. The task is to generate a response for each wizard turn based on the dialogue history and the retrieved knowledge. As pre-processing, for each wizard turn in the training/validation/test sets, the latest $128$ words in the dialogue history are kept as a context. The pre-processing strictly follows the procedure in Dinan et al. (2019), and is conducted with the code published on ParlAIhttps://github.com/facebookresearch/ParlAI/blob/master/projects/wizard_of_wikipedia.

Different from Wizard, CMU$\_$DoG focuses on movie domain (although covering various genres). In addition to wizard & apprentice, the data also contain dialogues between two workers who know the document and try to discuss the content in depth. Each document consists of $4$ sections and these sections are shown to the workers one by one every $3$ turns (the first section lasts $6$ turns due to initial greetings). On average, each section contains $8.22$ sentences and $27.86$ words per sentence. The data has been divided into a training set, a validation set, and a test set by the data owner. The task is to generate a response for each turn from a worker who has access to the document based on the dialogue history and the associated section as knowledge. Similar to Wizard, the latest $128$ words in the dialogue history are kept as a context. More details of the datasets can be found in Appendix A.

We choose Reddit Conversation Corpushttps://github.com/nouhadziri/THRED cleaned by Dziri et al. (2018) as $\mathcal{D}_{C}$. The data contain $15,120,136$ context-response pairs for training and $830,777$ context-response pairs for validation. On average, each context consists of $3.5$ utterances. We use the Wikipedia dump published on ParlAIhttps://github.com/facebookresearch/ParlAI/tree/master/parlai/tasks/wikipedia as $\mathcal{D}_{P}$. The training set and the validation set contain $5,233,799$ articles and $52,867$ articles respectively with the first paragraph kept for learning. Articles that appear in Wizard and CMU$\_$DoG are removed beforehand. For both Wizard and CMU$\_$DoG, the vocabulary is made up of top $60,000$ most frequent words appearing in $\mathcal{D}_{S}\cup\mathcal{D}_{P}\cup\mathcal{D}_{C}$ with other words regarded as $\langle\mathtt{unk}\rangle$.

Following the common practice in evaluating open domain dialogue generation, we choose perplexity (PPL) of the ground-truth response, BLEU (Papineni et al., 2002), and BOW Embedding (Liu et al., 2016) as metrics. Besides, we also follow Dinan et al. (2019) and employ unigram F1 as a metric. BLEU and Embedding-based metrics are computed with an NLG evaluation open source available at https://github.com/Maluuba/nlg-eval, and unigram F1 is calculated with the code published at https://github.com/facebookresearch/ParlAI/blob/master/parlai/core/metrics.py. Besides quantitative evaluation, we also recruit human annotators to do qualitative analysis on response quality, which is presented in Appendix C.

2 Baselines

The following models are selected as baselines:

Transformer Memory Network (TMN). The model proposed by Dinan et al. (2019) along with the release of the Wizard data. It is built upon a transformer architecture with an external memory hosting the knowledge. We implement the model using the code shared at https://github.com/facebookresearch/ParlAI/blob/master/projects/wizard_of_wikipedia.

Incremental Transformer with Deliberation Decoder (ITDD). A transformer-based model published very recently on ACL’19 (Li et al., 2019). The encoder incrementally represents multi-turn dialogues and knowledge, and the decoder conducts response decoding in two passes similar to the deliberation network in machine translation. We implement the model using the code shared at https://github.com/lizekang/ITDD.

Note that to make the comparison fair, we employ the end-to-end version of TMN without the knowledge regularization in learning. After all, one can include ground-truth signals on knowledge selection in both our model and TMN, and improve the two in the same way, although such signals are not available in most scenarios (e.g., in CMU$\_$DoG).

3 Evaluation Results

To simulate a low-resource scenario, we start from using the full training data as $\mathcal{D}_{S}$, and gradually reduce the number of training examples by halving the training set. Note that baseline models are learned with the full training sets. Table 1 and Table 2 report evaluation results on Test Seen and Test Unseen of Wizard respectively, and Table 3 reports evaluation results on CMU$\_$DoG. Through pre-training $95$% parameters with the ungrounded dialogues and the plain text and fixing the parameters afterwards, our model holds the state-of-the-art performance in terms of most metrics on all test sets even when the training sets have been cut to $1/8$, and has stable performance on Test Unseen with respect to different training sizes. Particularly, the model achieves more significant improvement over the baselines on Test Unseen, and when the training set shrinks, the performance gap on Test Seen and Test Unseen becomes marginal. The results show a good generalization ability of the proposed model on out-of-domain knowledge. ITDD achieves low PPL on both Test Seen and CMU$\_$DoG, which may stem from overfitting by the two-pass decoder. As an evidence, the model is just comparable with TMN on most metrics except PPL on Test Seen and CMU$\_$DoG, and is worse than our model on Test Unseen even in terms of PPL.

4 Discussions

In addition to the performance of the model under low-resource settings, we are also curious about Q1: what if we fine-tune the pre-trained parameters, rather than fixing them, with the training data of the knowledge-grounded dialogues, given that pre-training $\rightarrow$ fine-tuning has become the fashion in NLP research and engineering? Q2: can we somehow leverage the ungrounded dialogues and the plain text in learning of TMN, and in this case, will there be any change in the comparison with our model? and Q3: what is the impact of pre-training to different components of the proposed model?

Answer to Q1: Figure 2 and Figure 2 compare our models with fine-tuned parameters and fixed parameters on Test Seen and Test Unseen respectively. Basically, when there are enough training data (e.g., $>1/2$), fine-tuning can further improve the model on both in-domain and out-of-domain knowledge. On the other hand, when the training size is small, which is the assumption of the paper, fine-tuning may cause overfitting and lead to performance drop on the test sets. Test Unseen is more vulnerable than Test Seen, and the smaller the training size is, the bigger the gap is between the model with fixed parameters and the model with fine-tuned parameters. Therefore, in a low-resource setting (e.g., less than $5$k training dialogues), it is better to fix the pre-trained parameters and only estimate the remaining $5$% parameters with the training data.

Answer to Q2: Normally, it is not trivial to learn an entangled architecture like TMN with ungrounded dialogues and plain text. However, to make the comparison even more fair, we first pre-train a transformer-based encoder-decoder with the Reddit data. The encoder is fixed and used for TMN, and the parameters of the decoder is used to initialize the parameters of the decoder of TMN. Then, we pre-train the document representation in TMN with the Wikipedia dump. Finally, the knowledge attention in encoding and the decoder are learned (fine-tuned) with the training data of knowledge-grounded dialogues, as knowledge and dialogue contexts are entangled in the two modules. Figure 3 compares the pre-trained TMN with our model. Even though we have tried our best to make TMN use $\mathcal{D}_{C}$ and $\mathcal{D}_{P}$, it is still much worse than our model. The results indicate the importance of disentangling to leveraging ungrounded dialogues and plain text for low-resource knowledeg-grounded dialogue generation.

Answer to Q3: Figure 2 and Figure 2 show the results of ablation study in terms of pre-training. -lm means that $\theta_{l}$ and $\theta_{ol}$ are estimated using $\mathcal{D}_{S}$ together with $\{\theta_{s^{\prime}};\theta_{v^{\prime}};\theta_{g^{\prime}};\theta_{\pi}\}$. Similarly, -context and -knowledge mean that pre-training is removed from $\{\theta_{e};\theta_{d};\theta_{s};\theta_{v};\theta_{g};\theta_{o}\}$ and $\theta_{k}$ respectively. We can conclude that (1) pre-training is crucial to low-resource knowledge-grounded dialogue generation, since removing any component from pre-training causes performance drop when training data is small; and (2) in terms of impact to performance, lm$>$context$>$knowledge on Test Seen, while knowledge$>$lm$>$context on Test Unseen.

Related Work

Research on end-to-end open domain dialogue generation is encouraged by the success of neural sequence-to-sequence models on machine translation (Sutskever et al., 2014). On top of the basic architecture (Shang et al., 2015; Vinyals & Le, 2015), various extensions have been made to tackle the safe response problem (Li et al., 2015; Xing et al., 2017; Zhao et al., 2017; Song et al., 2018; Tao et al., 2018; Qiu et al., 2019); to model dialogue history for multi-turn conversation (Serban et al., 2016; 2017); and to learn with advanced machine learning techniques (Li et al., 2016; 2017). Very recently, grounding response generation on a specific type of knowledge, such as triples from a knowledge base (Zhou et al., 2018a), documents (Ghazvininejad et al., 2018; Zhao et al., 2019), personas (Zhang et al., 2018), and images (Mostafazadeh et al., 2017), has emerged as a new fashion in the research of open domain dialogue systems. This work aligns with the trend by considering document-grounded dialogue generation. Our model is built upon state-of-the-art neural generation techniques such as attention (Bahdanau et al., 2015; Yang et al., 2016) and copying (See et al., 2017; Raghu et al., 2019; Yavuz et al., 2019), but is unique in that components are pre-trained from various sources, thanks to the disentangled design. Thus, rather than testing new architectures on the benchmarks, our main contribution lies in investigation of knowledge-grounded dialogue generation under a low-resource setting with pre-training techniques, which roots in the requirement from practice.

The idea of “disentangling response decoding” is inspired by the similar research in representation learning that aims to seek a representation axis aligning with the generative factors of data (Bengio et al., 2013). State-of-the-art models are built within the framework of variational auto-encoding (Kingma & Welling, 2013) either under an unsupervised assumption (Higgins et al., 2017; Kim & Mnih, 2018; Chen et al., 2016; 2018) or aided by a few labels (Narayanaswamy et al., 2017; Locatello et al., 2019). In this work, we borrow the concept of “disentangling”, but apply it to the structure of the decoder of a response generation model. The result is a few independent components that allow asynchronous parameter estimation. The work is also encouraged by the recent breakthrough on pre-training for NLP tasks (Peters et al., 2018; Devlin et al., 2018; Yang et al., 2019; Liu et al., 2019; Song et al., 2019). We take advantage of disentanglement, and employ pre-training techniques to tackle the low-resource challenge in the task of knowledge-grounded dialogue generation.

Conclusions

We study knowledge-grounded dialogue generation under a low-resource setting. To overcome the challenge from insufficient training data, we propose decomposing the response decoder into independent components in which most parameters do not rely on the training data any more and can be estimated from large scale ungrounded dialogues and unstructured documents. Evaluation results on two benchmarks indicate that our model achieves the state-of-the-art performance with only $1/8$ training data, and exhibits a good generalization ability on out-of-domain knowledge.

We would like to thank the reviewers for their constructive comments. This work was supported by the National Key Research and Development Program of China (No. 2017YFC0804001), the National Science Foundation of China (NSFC No. 61876196 and NSFC No. 61672058). Rui Yan was sponsored as the young fellow of Beijing Academy of Artificial Intelligence (BAAI). Rui Yan is the corresponding author.

References

Appendix A Details of datasets

Table 4 reports the statistics of the Wizard data and the CMU$\_$DOG data.

Appendix B More Implementation Details

In both Wizard and CMU$\_$DOG, we set the size of word embedding as $300$, the hidden size of the context encoder, the knowledge encoder, and the decoder as $1024$. The context encoder and the decoder have $3$ layers respectively. The $g_{\theta_{s}}$ and $g_{\theta_{s^{\prime}}}$ are similarity functions which contain two single-layer feed-forward networks (FFNs) of size $512$ with tanh non-linearity. The $\mathtt{MLP}_{\theta_{l}}$, $\mathtt{MLP}_{\theta_{v}}$ and $\mathtt{MLP}_{\theta_{v}}$ are two-layer FFNs of size $1024$ and $300$ respectively. The $\mathtt{MLP}_{\theta_{g}}$, $\mathtt{MLP}_{\theta_{g^{\prime}}}$ and $\mathtt{MLP}_{\theta_{\pi}}$ are single-layer FFNs. All models are learned with Adam (Kingma & Ba, 2015) optimizer with $\beta_{1}=0.9$, $\beta_{2}=0.999$, and an initial learning rate $=5e-4$. We increase the learning rate linearly for the first $5000$ training steps and decrease it thereafter proportionally to the inverse square root of the step number. We set the initial temperature, the minimum temperature, and the anneal rate of $\mathtt{gumbel\_softmax}$ as $1.0$, $0.6$, and $4e-5$ respectively. In training, we choose $64$ as the size of mini-batches, and add dropout to $g_{\theta_{s^{\prime}}}$ and $\mathtt{MLP}_{\theta_{v^{\prime}}}$, but do not see much difference. Early stopping on validation is adopted as a regularization strategy. We employ beam search in response decoding with a beam size $5$. We add weak supervision to guide the training of the decoding manager where the words that belong to modal verbs“can”, “would”, “could”, “will”, “should”, “may” are forced to be classified as language model.

Appendix C Human Evaluation

The goal of human study is to get more insights on quality of responses generated by different models from human annotators. To this end, we randomly sample $300$ examples from Test Seen and Test Unseen respectively, and recruit $3$ well educated native speakers as the annotators. Comparison is conducted among TMN, ITDD, our model (with $1/4$ training data), and our model (with $1/8$ training data). On each test set, for each of the $300$ examples, an annotator is provided with a context, the ground-truth knowledge, and responses provided by the models under evaluation (the top one response in beam search). Responses are pooled and randomly shuffled to hide their sources. Then, each annotator judges the responses from three aspects including fluency, context coherence, and knowledge relevance, and assigns a score from $\{0,1,2\}$ to each of the response on each aspect, in which means bad, $1$ means fair, and $2$ means good. Each response receives $3$ scores on each aspect, and agreement among the annotators are calculated with Fleiss’ kappa (Fleiss, 1971). Table 5 shows the average scores on the three aspects. Overall, the proposed model achieves the state-of-the-art performance in terms of all the three aspects on both Test Seen and Test Unseen when only $1/8$ training examples are left. All kappa values exceed or are close to $0.6$, indicating substantial agreement among the annotators. The results are consistent with those reported in Table 1 and Table 2. Our model estimates the decoder with abundant extra resources, and ITDD exploits a two-pass decoder. Therefore, both of the two models can provide grammatical and fluent responses, no matter the background knowledge is within the domain of training or out of the domain of training. On the other hand, with the $15$M Reddit data in learning of the context processor, our model can make the dialogues more coherent than the baselines, although there is a little drop on Test Unseen compared to Test Seen. Since the model only obtains limited guidance from training in terms of the connection between the knowledge and the dialogues, how to make the responses relevant to the knowledge is still challenging, although our model has done a better job than the baselines.

Table 6 shows an example from Test Unseen, from which we can see that the response from our model (with $1/8$ training data) not only smoothly catches the context, but also expands the topic with proper pieces of knowledge (highlighted in red). On the other hand, responses from the baselines just reply to the context but lose the connection with the knowledge, as we have analyzed with the results in Table 5. Moreover, we also visualize the sources of words in the response with colors. Basically, words that have weak or no correlation with the context and the knowledge are generated by the language model, words that connect with the context but have nothing to do with the knowledge are generated by the context processor, and words that are copied from the knowledge are generated by the knowledge processor.

Appendix D Comparison with MASS

We compare our model with MASS (Song et al., 2019), a pre-training technique that achieves state-of-the-art performance on several language generation tasks such as machine translation, text summarization, and conversational response generation. MASS firstly pre-trains an encoder-decoder architecture with large-scale monolingual data from WMT News Crawl datasets by reconstructing a fragment of a sentence from the remaining, and then fine-tunes the architecture on downstream language generation tasks. We use the code and the model published at https://github.com/microsoft/MASS. The original model is for sequence-to-sequence generation. To adapt it to the knowledge-grounded dialogue generation task, we concatenate the knowledge sentences and conversational history as a long context as the input of the encoder.

Figure 4 shows the evaluation results. Note that we do not include PPL as a metric like in Figure 3, since MASS performs generation with sub-words, and thus is not comparable with our model on PPL. On both Test Seen and Test Unseen, our model consistently outperforms MASS over all training sizes. The reason might be that “mask then predict”, which is basically the pre-training strategy exploited by MASS, is not an effective way to leverage the text data for knowledge-grounded dialogue generation, since the task needs more complicated operations such as deep copying. Another reason might be that MASS is designed for the sequence-to-sequence generation task and isn’t compatible with the knowledge-grounded response generation task which has extra knowledge input.

Appendix E Ablation over Components

We conduct ablation study over the language model, the context processor, and the knowledge processor by completely dropping any of them from the decoding manager (in both training and test). Figure 5 and Figure 5 report the results on Test Seen and Test Unseen respectively. First of all, all the three components are useful, since removing any of them in general will cause performance drop. Second, in terms of importance, knowledge processor$>$context processor$>$language model. The explanation is that (1) part of the function of the language model may be covered by the context processor and the knowledge processor after it is removed“Part of” is because the language model is pre-trained with monolingual Reddit data, which is different from the context processor and the knowledge processor., since both the context processor and the knowledge processor also contain language models, although in the full model, the language model generates $17$% words in the responses of Test Seen and Test Unseen; (2) the context processor is important (generating $27$% words), but not always, since a large proportion of responses in the Wizard data highly depend on the knowledge (e.g., the examples shown in (Dinan et al., 2019)); (3) the knowledge processor (generating $56$% words) is the most important component due to the nature of the Wizard data. The results also remind us that perhaps we can try pre-training the language model with larger and more heterogeneous data such as Common Crawl in the future.

Appendix F Comparison with non-pretraining

Figure 6 and Figure 6 compare two versions of our model on Test Seen and Test Unseen respectively. One version is the model pre-trained using ungrounded dialogues and documents, and the other version is the one trained with knowledge-grounded dialogues (i.e., no pre-training is performed). Besides, we also include the results of TMN to get more insights. We can see that when there are enough training data (e.g., full data), our model without pre-training outperforms both TMN and the pre-trained version on Test Seen. This is because the attention and copying operations can well capture the correlation among the knowledge, the contexts, and the responses in the training data, while in the pre-trained version, only a small proportion of the model can benefit from the training data, and a large proportion may suffer from the gap between the knowledge-grounded dialogues collected from crowd-sourcing and the ungrounded dialogues and documents collected from the Web. However, when the training size shrinks, which is basically the problem we study in the paper, the performance of our model without pre-training drops dramatically, and becomes even worse than that of TMN on Test Seen when the training size is no more than $1/8$. This is because when training data is not enough, our model is more prone to overfit the small training set than TMN, and thus results in bad generalization ability. In the low-resource setting, pre-training, especially with the disentangled decoder if we consider the results in Figure 3, is an effective approach to obtaining good generalization ability on test data. The conclusions are further verified by the comparison on Test Unseen, where non-pre-training is worse than pre-training over all training sizes, and non-pre-training quickly drops below TMN when the training data is halved. On Test Unseen, with $1/8$ training data, the pre-trained model achieves the performance of the model learned from the full training data without pre-training.