Multi-turn Response Selection using Dialogue Dependency Relations (2020)

Abstract: Multi-turn response selection is a task designed for developing dialogue agents. The performance on this task has a remarkable improvement with pre-trained language models. However, these models simply concatenate the turns in dialogue history as the input and largely ignore the dependencies between the turns. In this paper, we propose a dialogue extraction algorithm to transform a dialogue history into threads based on their dependency relations. Each thread can be regarded as a self-contained sub-dialogue. We also propose Thread-Encoder model to encode threads and candidates into compact representations by pre-trained Transformers and finally get the matching score through an attention layer. The experiments show that dependency relations are helpful for dialogue context understanding, and our model outperforms the state-of-the-art baselines on both DSTC7 and DSTC8*, with competitive results on UbuntuV2.

## introduction dialogue system is an important interface between machine and human. an intelligent dialogue agent is not only required to give the appropriate response based on the current utterance from the user, but also consider the dialogue history. dialogue context modeling has been a key point for developing such dialogue systems, including researches on state tracking @xcite , topic segmentation @xcite , multi-turn response selection @xcite , next utterance generation @xcite , etc. in this paper, we target on the multi-turn response selection task, which is first proposed by @xcite and is also a track in both dstc7 @xcite and dstc8 @xcite . given a dialogue history made up of more than one utterance, the selection task is to choose the most possible next utterance from a set of candidate responses. previous work on this task can be roughly divided into two categories: sequential models and hierarchical models. the former ones, including @xcite @xcite , concatenate the history utterances into a long sequence, try to capture the similarities between this sequence and the response and give a matching score. the latter ones, including @xcite @xcite , extract similarities between each history utterance and the response first. then, the matching information is aggregated from each pair (mostly in a chronological way) to get a final score. there is little difference between the performance of these two kinds of architectures until the emergence of large pre-trained language models. work such as @xcite has shown the extraordinary performance of the pre-trained language models on dialogues. these pre-trained models are easily transferred to the response selection task by concatenating all of the utterances as the input. all of the words in dialogue history can directly interact with each other via transformers like bi-encoder, even the words both in the dialogue history and the candidate response if time permits, such as cross-encoder @xcite . however, since such models can be regarded as the ultimate architecture of the sequential-based models, the dialogue dependency information between the utterances is largely ignored due to the concatenation operation @xcite . an example is shown in figure 1 . the dependency relations can definitely help us to understand the two tangled dialogue threads. besides, we always need to truncate the earlier dialogue history to limit the size of the model and make the computation efficient. however, it isn't always that the nearest utterances are more important. as we can see in figure 1 , several dialogue threads may be tangled especially in multi-party chat rooms, it's hard to tell which dialogue thread will be moving on. in this paper, we propose to incorporate dialogue dependency information into the response selection task. we train a dialogue dependency parser to find the most probable parent utterance for each utterance in a session. we name such relation between utterances as "reply-to". then, we empirically design an algorithm to extract dialogue threads, which is represented by a path of dependency relations according to the parsed trees. the extracted threads are sorted by the distance between the final utterance in each thread and the response in ascending order, following the intuition that the closer utterances are more relevant. after that, we propose the model named thread-encoder based on a pre-trained language model. each encoder in the model can distill the critical information from each dialogue thread or the candidate response. finally, another attention layer is used to calculate the matching score with thread representations and the candidate representation. the candidate with the highest matching score will be selected as the final response. we collect the training data for dialogue dependency parser from a dialogue disentanglement dataset @xcite in the technical domain. and we do response selection experiments among ubuntuv2, dstc7 and dstc8*. these datasets consist of dialogues in the same domain but under different settings, including two-party dialogues and multi-party dialogues. the results demonstrate our model's strong capability to repre-sent multi-turn dialogues on all of these datasets. our main contributions are as follows: ## approach the multi-turn response selection tasks represent each dialogue as a triple @xmath0, r, l , where @xmath1, t 2 , ..., t n } represents the history turns. r is a candidate response and l is the 0/1 label indicating whether r is the correct response or a negative candidate. to incorporate the dependency information between the history turns, we design a straight-forward algorithm to extract the dialogue history c into dialogues threads c 1 , c 2 , ..., c m based on the predicted dependencies, along with an elaborately designed model to find the function f (c 1 , c 2 , ..., c m , r), which measures the matching score of each (c, r) pair. both the extraction algorithm and the model will be explained as follows. ## experimental setup in this section, we introduce the datasets, baselines and implementation details of our model foot_1 . ## results and analysis here we show results on dialogue thread extraction and response selection of the three datasets, and give some discussions on our model design. ## related work related work contains dialogue dependency parsing and multi-turn response selection. ## conclusion as far as we know, we are the first work bringing the dependency information of dialogues into the multi-turn response selection task. we proposed the dialogue extraction algorithm and thread-encoder model, which becomes the stateof-the-art on several well-known ubuntu datasets. in the future, we will move on to develop a more general dialogue dependency parser and better in-corporate dependency information into dialogue context modeling tasks.