Year: 2018

Abstract:
We propose an adversarial learning approach to the generation of multi-turn dialogue responses. Our proposed framework, hredGAN, is based on conditional generative adversarial networks (GANs). The GAN’s generator is a modified hierarchical recurrent encoder-decoder network (HRED) and the discriminator is a word-level bidirectional RNN that shares context and word embedding with the generator. During inference, noise samples conditioned on the dialogue history are used to perturb the generator’s latent space to generate several possible responses. The final response is the one ranked best by the discriminator. The hredGAN shows major advantages over existing methods: (1) it generalizes better than networks trained using only the log-likelihood criterion, and (2) it generates longer, more informative and more diverse responses with high utterance and topic relevance even with limited training data. This superiority is demonstrated on the Movie triples and Ubuntu dialogue datasets with both the automatic and human evaluations.

heading: 1 INTRODUCTION
text: Recent advances in deep neural network architectures have enabled tremendous success on a number of difficult machine learning problems. While these results are impressive, producing a deployable neural network–based conversation model that can engage in open domain discussion still remains elusive. A dialogue system needs to be able to generate meaningful and diverse responses that are simultaneously coherent with the input utterance and the overall dialogue topic. Unfortunately, earlier conversation models trained with naturalistic dialogue data suffered greatly from limited contextual information (Sutskever et al., 2014; Vinyals & Le, 2015), and lack diversity (Li et al., 2016a). These problems often leads to generic and safe utterance in response to varieties of input utterance.
Serban et al. (2016) and Xing et al. (2017) proposed the Hierarchical Recurrent Encoder-Decoder (HRED) network to capture long temporal dependencies in multi-turn conversations to address the limited contextual information but the diversity problem remained. On the other hand, some HRED variants such as variational (Serban et al., 2017b) and multi-resolution (Serban et al., 2017a) HREDs attempt to alleviate the diversity problem by injecting noise at the utterance level and by extracting additional context to condition the generator on. While these approaches achieve certain measures of success over the basic HRED, generated responses are still mostly generic since they do not control the generator’s output as the output conditional distribution is not calibrated. Li et al. (2016a), on the other hand, consider diversity promoting training objective but their model is for single turn conversations, cannot not be trained end-to-end and therefore achieves little.
The generative adversarial network (GAN) (Goodfellow et al., 2014) seems to be an appropriate solution to the diversity problem. GAN matches data from two different distributions by introducing an adversarial game between a generator and a discriminator. We explore hredGAN: conditional GANs for multi-turn dialogue models with HRED generator and discriminator. hredGAN combines both generative and retrieval-based multi-turn dialogue systems to improve their individual performances. This is achieved by sharing the context and word embedding between the generator and the discriminator allowing for joint end-to-end training using back-propagation. To the best of our knowledge, no existing work has applied conditional GANs to multi-turn dialogue models and especially with HRED generators and discriminators. We demonstrate the effectiveness of hredGAN
over the VHRED for dialogue modeling with evaluations on the Movie triples and Ubuntu technical support datasets.

heading: 2 ADVERSARIAL FRAMEWORK FOR MULTI-TURN DIALOGUE
text: Consider a dialogue consisting of a sequence of N utterances, X = ( X1, X2, · · · , XN ) , where
each utterance Xi = ( X1i , X 2 i , · · · , X Mi i ) contains a variable-length sequence of Mi word tokens such that Xij ∈ V for vocabulary V . At any time step i, the dialogue history is given by Xi = ( X1, X2, · · · , Xi ) . The dialogue response generation task can be defined as follows: Given a
dialogue history Xi, generate a response Yi = ( Y 1i , Y 2 i , · · · , Y Ti i ) , where Ti is the number of generated tokens. We also want the distribution of the generated response P (Yi) to be indistinguishable from that of the ground truth P (Xi+1) and Ti =Mi+1. Conditional GAN learns a mapping from an observed dialogue history, Xi, and a sequence of random noise vectors, Zi to a sequence of output tokens, Yi, G : {Xi, Zi} → Yi. The generator G is trained to produce output sequences that cannot be distinguished from the ground truth sequence by an adversarially trained discriminator D that is trained to do well at detecting generator’s fakes. The distribution of the generator output sequence can be factored by the product rule:
P (Yi|Xi) = P (Y 1i ) Ti∏ j=2 P ( Y ji |Y 1 i , · · · , Y j−1 i ,Xi ) (1)
P ( Y ji |Y 1 i , · · · , Y j−1 i ,Xi ) = PθG ( Y 1:j−1i ,Xi ) (2)
where Y i:j−1i = (Y 1 i , · · · , Y j−1 i ) and θG are the parameters of the generator model. PθG ( Y i:j−1i ,Xi ) is an autoregressive generative model where the probability of the current token depends on the past generated sequence. Training the generator G with the log-likelihood criterion is unstable in practice, and therefore the past generated sequence is substituted with the ground truth, a method known as teacher forcing (Williams & Zipser, 1989), i.e.,
P ( Y ji |Y 1 i , · · · , Y j−1 i ,Xi ) ≈ PθG ( X1:j−1i+1 ,Xi ) (3)
Using equation 3 in relation to GAN, we define our fake sample as the teacher forcing output with some input noise Zi Y ji ∼ PθG ( X1:j−1i+1 ,Xi, Zi ) (4)
and the corresponding real sample as ground truth Xji+1.
With the GAN objective, we can match the noise distribution, P (Zi) to the distribution of the ground truth response, P (Xi+1|Xi). Varying the noise input then allows us to generate diverse responses to the same dialogue history. Furthermore, the discriminator, since it is calibrated, is used during inference to rank the generated responses, providing a means of controlling the generator output.

heading: 2.1 OBJECTIVES
text: The objective of a conditional GAN can be expressed as
LcGAN (G,D) = EXi,Xi+1 [log D(Xi+1,Xi)] + EXi,Zi [1 − logD(G(Xi, Zi),Xi)] (5) where G tries to minimize this objective against an adversarial D that tries to maximize it:
G∗, D∗ = argmin G max D LcGAN (G,D). (6)
Previous approaches have shown that it is beneficial to mix the GAN objective with a more traditional loss such as cross-entropy loss (Lamb et al., 2016; Li et al., 2017). The discriminator’s job remains unchanged, but the generator is tasked not only to fool the discriminator but also to be near the ground truth Xi+1 in the cross-entropy sense:
LMLE(G) = EXi,Xi+1,Zi [−log PθG ( Xi+1,Xi, Zi ) ]. (7)
Our final objective is,
G∗, D∗ = argmin G max D
( λGLcGAN (G,D) + λMLMLE(G) ) . (8)
i+1 . Right: RNN-based
discriminator that discriminates bidirectionally at the word level.
It is worth mentioning that, without Zi, the net could still learn a mapping from Xi to Yi, but would produce deterministic outputs and fail to match any distribution other than a delta function (Isola et al., 2017). This is one key area where our work is different from Lamb et al.’s and Li et al.’s. The schematic of the proposed hredGAN is depicted at the right hand side of Figure 1.

heading: 2.2 GENERATOR
text: We adopted an HRED dialogue generator similar to (Serban et al., 2016; 2017a;b; Xing et al., 2017). The HRED contains three recurrent structures, i.e. the encoder (eRNN), context (cRNN), and decoder (dRNN) RNN. The conditional probability modeled by the HRED per output word token is given by
PθG ( Y ji |X 1:j−1 i+1 ,Xi ) = dRNN ( E(Xj−1i+1 ), h j−1 i ,hi ) (9)
where E(.) is the embedding lookup, hi = cRNN(eRNN(E(Xi),hi−1), eRNN(.) maps a sequence of input symbols into fixed-length vector, and h and h are the hidden states of the decoder and context RNN, respectively.
In the multi-resolution HRED, (Serban et al., 2017a), high-level tokens are extracted and processed by another RNN to improve performance. We circumvent the need for this extra processing by allowing the decoder to attend to different parts of the input utterance during response generation (Bahdanau et al., 2015; Luong et al., 2015). We introduce a local attention into equation 9 and encode the attention memory differently from the context through an attention encoder RNN (aRNN), yielding:
PθG ( Y ji |X 1:j−1 i+1 ,Xi ) = dRNN ( E(Xj−1i+1 ), h j−1 i , A j i ,hi ) (10)
where Aji = ∑Mi m=1
exp(αm)∑Mi m=1 exp(αm) h ′m i , h ′m i = aRNN(E(X m i ), h ′m−1 i ), h ′ is the hidden state of
the attention RNN and αk is either a logit projection of (h j−1 i , h ′m i ) in the case of Bahdanau et al. (2015) or (hj−1i ) T · h′mi in the case of Luong et al. (2015). The modified HRED architecture is shown in Figure 2.
Noise Injection: We inject Gaussian noise at the input of the decoder RNN. Noise samples could be injected at the utterance or word level. With noise injection, the conditional probability of the decoder output becomes
PθG ( Y ji |X 1:j−1 i+1 , Z j i ,Xi ) = dRNN ( E(Xj−1i+1 ), h j−1 i , A j i , Z j i ,hi ) (11)
where Zji ∼ Ni(0, I), for utterance-level noise and Z j i ∼ N j i (0, I), for word-level noise.

heading: 2.3 DISCRIMINATOR
text: The discriminator shares context and word embedding with the generator and can discriminate at the word level (Lamb et al., 2016). The word-level discrimination is achieved through a bidirectional RNN and is able to capture both syntactic and conceptual differences between the generator output
and the ground truth. The aggregate classification of an input sequence, χ can be factored over word-level discrimination and expressed as
D(Xi, χ) = D(hi, χ) = [ J∏ j=1 DRNN (hi, E(χ j)) ] 1 J
(12)
where DRNN (.) is the word discriminator RNN, hi is an encoded vector of the dialogue history Xi obtained from the generator’s cRNN(.) output, and χj is the jth word or token of the input sequence χ. χ = Yi and J = Ti for the case of generator’s decoder output, χ = Xi+1 and J = Mi+1 for the case of ground truth. The discriminator architecture is depicted on the left hand side of Figure 1.

heading: 2.4 ADVERSARIAL GENERATION OF MULTI-TURN DIALOGUE RESPONSE
text: In this section, we describe the generation process during inference. The generation objective can be mathematically described as
Y ∗i = argmax l
{ P (Yi,l|Xi) +D∗(Xi, Yi,l)] }L l=1
(13)
where Yi,l = G∗(Xi, Zi,l), Zi,l is the lth noise samples at dialogue step i, and L is the number of response samples. Equation 13 shows that our inference objective is the same as the training objective (8), combining both the MLE and adversarial criteria. This is in contrast to existing work where the discriminator is usually discarded during inference.
The inference described by equation 13 is intractable due to the enormous search space of Yi,l. Therefore, we turn to an approximate solution where we use greedy decoding (MLE) on the first part of the objective function to generate L lists of responses based on noise samples {Zi,l}Ll=1. In order to facilitate the exploration of the generator’s latent space, we sample a modified noise distribution, Zji,l ∼ Ni,l(0, αI), or Z j i,l ∼ N j i,l(0, αI) where α > 1.0, is the exploration factor that increases
the noise variance. We then rank the L lists using the discriminator score, { D∗(Xi, Yi,l)] }L l=1
. The response with the highest discriminator ranking is the optimum response for the dialogue context.

heading: 3 TRAINING OF HREDGAN
text: We trained both the generator and the discriminator simultaneously as highlighted in Algorithm 1 with λG = λM = 1. GAN training is prone to instability due to competition between the generator and the discriminator. Therefore, parameter updates are conditioned on the discriminator performance (Lamb et al., 2016).
The generator consists of four RNNs with different parameters, that is, aRNN, eRNN, cRNN , and dRNN . aRNN and eRNN are both bidirectional, while cRNN and dRNN are unidirec-
Algorithm 1 Adversarial Learning of hredGAN Require: A generatorG with parameters θG. Require: A discriminatorD with parameters θD .
for number of training iterations do Initialize cRNN to zero state, h0 Sample a mini-batch of conversations, X = {Xi}Ni=1, Xi = (X1, X2, · · · , Xi) with N utterances. Each utterance mini batch i containsMi word tokens. for i = 1 toN − 1 do
Update the context state. hi = cRNN(eRNN(E(Xi)),hi−1) Compute the generator output using equation 11.
PθG ( Yi|, Zi,Xi ) = { PθG ( Y ji |X 1:j−1 i+1 , Z j i ,Xi )}Mi+1 j=1 Sample a corresponding mini batch of utterance Yi. Yi ∼ PθG ( Yi|, Zi,Xi
) end for Compute the discriminator accuracyDacc overN − 1 utterances {Yi}N−1i=1 and {Xi+1} N−1 i=1 ifDacc < accDth then Update θD with gradient of the discriminator loss.∑ i [∇θD logD(hi, Xi+1) +∇θD log ( 1−D(hi, Yi) ) ] end if ifDacc < accGth then
Update θG with the generator’s MLE loss only.∑ i [∇θG logPθG ( Yi|, Zi,Xi ) ]
else Update θG with both adversarial and MLE losses.∑ i [λG∇θG logD(hi, Yi) + λM∇θG logPθG ( Yi|, Zi,Xi ) ]
end if end for
tional. Each RNN has 3 layers, and the hidden state size is 512. The dRNN and aRNN are connected using an additive attention mechanism (Bahdanau et al., 2015).
The discriminator shares aRNN, eRNN , and cRNN with the generator. DRNN , is a stacked bidirectional RNN with 3 layers and a hidden state size of 512. The cRNN states are used to initialize the states of DRNN . The output of both the forward and the backward cells for each word are concatenated and passed to a fully-connected layer with binary output. The output is the probability that the word is from the ground truth given the past and future words of the sequence.
Others: All RNNs used are gated recurrent unit (GRU) cells (Cho et al., 2014). The word embedding size is 512 and shared between the generator and the discriminator. The initial learning rate is 0.5 with decay rate factor of 0.99, applied when the adversarial loss has increased over two iterations. We use a batch size of 64 and clip gradients around 5.0. As in Lamb et al. (2016), we find accDth = 0.99 and accGth = 0.75 to be good enough. All parameters are initialized with Xavier uniform random initialization (Glorot & Bengio, 2010). The vocabulary size V is 50, 000. Due to the large vocabulary size, we use sampled softmax loss (Jean et al., 2015) for MLE loss to expedite the training process. However, we use full softmax for evaluation. The model is trained end-to-end using the stochastic gradient descent algorithm.

heading: 4 EXPERIMENTS AND RESULTS
text: We consider the task of generating dialogue responses conditioned on the dialogue history and the current input utterance. We compare the proposed hredGAN model against some alternatives on publicly available datasets.

heading: 4.1 DATASETS
text: Movie Triples Corpus, (MTC) dataset (Serban et al., 2016). This dataset was derived from the Movie-DiC dataset by Banchs (2012). Although this dataset spans a wide range of topics with few spelling mistakes, its small size of only about 240,000 dialogue triples makes it difficult to train a dialogue model, as pointed out by Serban et al. (2016). We thought that this scenario would really benefit from the proposed adversarial generation.
Ubuntu Dialogue Corpus, (UDC) dataset (Serban et al., 2017b). This dataset was extracted from the Ubuntu Relay Chat Channel. Although the topics in the dataset are not as diverse as in the MTC,
the dataset is very large, containing about 1.85 million conversations with an average of 5 utterances per conversation.
We split both MTC and UDC into training, validation, and test sets, using 90%, 5%, and 5% proportions, respectively. We performed minimal preprocessing of the datasets by replacing all words except the top 50,000 most frequent words by an UNK symbol.

heading: 4.2 EVALUATION METRICS
text: Accurate evaluation of dialogue models is still an open challenge. In this paper, we employ both automatic and human evaluations.

heading: 4.2.1 AUTOMATIC EVALUATION
text: We employed some of the automatic evaluation metrics that are used in probabilistic language and dialogue models, and statistical machine translation. Although these metrics may not correlate well with human judgment of dialogue responses (Liu et al., 2016), they provide a good baseline for comparing dialogue model performance.
Perplexity - For a model with parameter θ, we define perplexity as:
exp [ − 1 NW K∑ k=1 log Pθ(Y1, Y2, . . . , YNk−1) ] (14)
where K is the number of conversations in the dataset, Nk is the number of utterances in conversation k, and NW is the total number of word tokens in the entire dataset. The lower the perplexity, the better. The perplexity measures the likelihood of generating the ground truth given the model parameters. While a generative model can generate a diversity of responses, it should still assign a high probability to the ground truth utterance.
BLEU - The BLEU score, (Papineni et al., 2002) provides a measure of overlap between the generated response (candidate) and the ground truth (reference) using a modified n-gram precision. According to Liu et. al. (Liu et al., 2016), BLEU-2 score is fairly correlated with human judgment for non-technical dialogue (such as MTC).
ROUGE - The ROUGE score, (Lin, 2014) is similar to BLEU but it is recall oriented instead. It is used for automatic evaluation of text summarization and machine translation. To compliment the BLEU score, we use ROUGE-N with N = 2 for our evaluation.
Distinct n-gram - This is the fraction of unique n-grams in the generated responses. It provides a measure of diversity. Models with higher number of distinct n-grams tend to produce more diverse responses (Li et al., 2016a). For our evaluation, we use 1- and 2- grams.
Normalized Average Sequence Length (NASL) - This measures the average number of words in model generated responses normalized by the average number of words in the groundtruth.

heading: 4.2.2 HUMAN EVALUATION
text: For human evaluation, we follow a similar setup as Li et al. (2016a), employing crowd-sourced judges to evaluate a random selection of 200 samples. We present both the multi-turn context and the generated responses from the models to 3 judges and asked them to rank the general response quality in terms of relevance and informativeness. For N models, the model with the lowest quality is assigned a score 0 and the highest is assigned a score N-1. Ties are not allowed. The scores are normalized between 0 and 1 and averaged over the total number of samples and judges.

heading: 4.3 BASELINE
text: We compare the performance of our model to (V)HRED (Serban et al., 2016; 2017b), since they are the closest to our approach in implementation and are the current state of the art in open-domain dialogue models. HRED is very similar to our proposed generator, but without the input utterance attention and noise samples. VHRED introduces a latent variable to the HRED between the cRNN and the dRNN and was trained using the variational lower bound on the log-likelihood.
The VHRED can generate multiple responses per context like hredGAN, but has no specific criteria for selecting the best response.
The HRED and VHRED models are both trained using the Theano-based implementation obtained from https://github.com/julianser/hed-dlg-truncated. The training and validation sets used for UDC and MTC dataset were obtained directly from the authors1 of (V)HRED. For model comparison, we use a test set that is disjoint from the training and validation sets.

heading: 4.4 RESULTS
text: We have two variants of hredGAN based on the noise injection approach, i.e., hredGAN with utterance-level (hredGAN u) and word-level (hredGAN w) noise injections.
We compare the performance of these two variants with HRED and VHRED models.
Perplexity: The average perplexity per word performance of all the four models on MTC and UDC datasets (validation/test) are reported in the first column on Table 1. The table indicates that both variants of the hredGAN model perform better than the HRED and VHRED models in terms of the perplexity measure. However, using the adversarial loss criterion (Eq. equation 8), the hredGAN u model performs better on MTC and worse on UDC. Note that, for this experiment, we run all models in teacher forcing mode.
Generation Hyperparameter: For adversarial generation, we perform a linear search forα between 1 and 20 at an increment of 1 using Eq. equation 13, with sample size L = 64, on validation sets with models run in autoregression. The optimum values of α for hredGAN u and hredGAN w for UDC are 7.0 and 9.0 respectively. The values for MTC are not convex, probably due to small size of the dataset, so we use the same α values as UDC. We however note that for both datasets, any integer value between 3 and 10 (inclusive) works well in practice.
Quantitative Generator Performance: We run autoregressive inference for all the models (using optimum α values for hredGAN models and selecting the best of L = 64 responses using a discriminator) with dialogue contexts from a unique test set. Also, we compute the average BLEU-2, ROUGE-2(f1), Distinct(1/2) and normalized average sequence length (NASL) scores for each model and summarize the results in the middle of Table 1. Distinct(1/2) largely agrees with the perplexity score. Most scores, similar to the perplexity, indicate that hredGAN models perform better than (V)HRED on both datasets. However, on the UDC and MTC, ROUGE and BLUE, respectively scores VHRED slightly better than hredGAN u but still worse than hredGAN w.
A good dialogue model should find the right balance between precision (BLEU) and diversity. We strongly believe that our adversarial approach is better suited to solving this problem. As hredGAN generators explore diversity, the discriminator ranking gives hredGAN an edge over (V)HRED because it helps detect responses that are out of context and the natural language structure (Table 2). Also, the ROGUE(f1) performance indicates that hredGAN w strikes a better balance between pre-
1UDC was obtained from http://www.iulianserban.com/Files/ UbuntuDialogueCorpus.zip, and the link to MTC was obtained privately.
cision (BLEU) and diversity than the rest of the models. This is also obvious from the quality of generated responses.
Qualitative Generator Performance: The results of the human evaluation is reported in the last column of Table 1. The human evaluation agrees largely with the automatic evaluation. The hredGAN w performs best on both datasets although the gap is more on the MTC than on the UTC. This implies that the improvement of HRED with adversarial generation is better than with variational generation (VHRED). In addition, looking at the actual samples from the generator outputs in Table 6 shows that hredGAN especially hredGAN w performs better than (V)HRED. While other models produce short and generic utterances, hredGAN w mostly yields informative responses. For example, in the first dialogue in Table 6, when the speaker is sarcastic about ”the man upstairs”, hredGAN w responds with the most coherent utterance with respect to the dialogue history. We see similar behavior across other samples. We also note that although hredGAN u’s responses are the longest on Ubuntu (in line with the NASL score), the responses are less informative compared to hredGAN w resulting into a lower human evaluation score. We reckon this might be due to a mismatch between utterance-level noise and word-level discrimination or lack of capacity to capture the data distribution using single noise distribution. We hope to investigate this further in the future.
Discriminator Performance: Although only hredGAN uses a discriminator, the observed discriminator behavior is interesting. We observe that the discriminator score is generally reasonable with longer, more informative and more persona-related responses receiving higher scores as shown in Table 2. It worth to note that this behavior, although similar to the behavior of a human judge is learned without supervision. Moreover, the discriminator seems to have learned to assign average score to more frequent or generic responses such as “I don’t know”, “I’m not sure” and so on, and
high score to rearer answers. That’s why we sample a modified noise distribution during inference so that the generator can produce rearer utterances that will be scored high by the discriminator.

heading: 5 CONCLUSION AND FUTURE WORK
text: In this paper, we have introduced an adversarial learning approach that addresses response diversity and control of generator outputs, using an HRED-derived generator and discriminator. The proposed system outperforms existing state-of-the-art (V)HRED models for generating responses in multiturn dialogue with respect to automatic and human evaluations. The superiority of the adversarial generation (hredGAN) over the variational generation (VHRED) is in line with other generative models employing these approaches. Our analysis also concludes that the word-level noise injection seems to perform better in general.
While this is a good starting point, we recognize the need to explore further improvements to the proposed adversarial framework: In the future, we hope to: explore which noise level works with which discrimination level; consider a multi-resolution discriminator with combined word- and utterancelevel discriminations; and explore further tuning of the generator and discriminator models.

heading: 6 RELATED WORK
text: Our work is related to end-to-end neural network–based open domain dialogue models. Most neural dialogue models use transduction frameworks adapted from neural machine translations (Sutskever et al., 2014; Bahdanau et al., 2015). These Seq2Seq networks are trained end-to-end with MLE criteria using large corpora of human-to-human conversation data. Others use GAN’s discriminator as a reward function in a reinforcement learning framework (Yu et al., 2017) and in conjunction with MLE (Li et al., 2017; Che et al., 2017). Zhang et al. (2017) explored the idea of GAN with a feature matching criterion. Xu et al. (2017) and Zhang et al. (2018) employed GAN with an approximate embedding layer as well as with adversarial information maximization respectively to improve Seq2Seq’s diversity performance.
Still, Seq2Seq models are limited in their ability to capture long temporal dependencies in multiturn conversation. Although, Li et al. (2016b) attempted to optimize a pair Seq2Seq models for multi-turn dialogue, the multi-turn objective is only applied at inference and not used for actual model training. Hence, the introduction of HRED models (Serban et al., 2016; 2017a;b; Xing et al., 2017) for modeling dialogue response in multi-turn conversations. However, these HRED models suffer from lack of diversity since they are trained with only MLE criteria. On other hand, adversarial system has been used for evaluating open domain dialogue models (Bruni & Fernndez, 2018; Kannan & Vinyals, 2017). Our work, hredGAN is closest to the combination of HRED generation models (Serban et al., 2016) and adversarial evaluation (Kannan & Vinyals, 2017).

heading: 7 ABLATION EXPERIMENTS
text: Before proposing the above adversarial learning framework for multi-turn dialogue, we carried out some experiments that are highlighted here.

heading: 7.1 GENERATOR:
text: First, we noted that by adding an additional attention memory to the HRED generator, we improved the test set perplexity score by more than 8 and 20 points on the MTC and UDC respectively as shown in Table 4. The addition of attention also shows a strong performance at autoregressive inference across multiple metrics as well as observed improvement in response quality. Hence, the decision for the modified HRED generator.
The adversarial training, however helps to address the lack diversity observed in the generated responses.

heading: 7.2 DISCRIMINATOR:
text: Before deciding on the word-level discrimination, we experimented with utterance-level discrimination. The utterance-level discriminator trains very quickly but it leads to mostly generic responses from the generator. We also note that utterance-level discriminator scores are mostly extreme (i.e.,
either low or high). Since we had used convolutional neural network discriminator (Yu et al., 2017) in our experiments, we hope to investigate this further with other architectures.

heading: 7.3 ADVERSARIAL TRAINING:
text: Lastly, we also tried a basic policy gradient approach (Li et al., 2017), where word-level discriminator score is used as a reward for each generated word token, but this leads to training instability. This is probably due to the instability of Monte Carlo sampling over large vocabulary size. We believe this might improve with other sampling methods such as importance sampling and hope to investigate further in the future.

heading: 8 OTHER GENERATED SAMPLES

Review summaries:
This paper presents an adversarial learning model for generating diverse responses for dialogue systems based on HRED (hierarchical recurrent encoder-decoder) network. The contribution of the work mainly lies in: 1. adversarial learning, and 2. injecting Gaussian noise at word-level and sentence-level to encourage the diversity. Overall, the idea is interesting, and the automatic evaluation based on perplexity, BLEU, ROUGE, etc shows that the proposed methods outperform existing methods.