Imperfect also Deserves Reward: Multi-Level and Sequential Reward Modeling for Better Dialog Management

We first decompose an action into sub-actions, and learn to decompose and encode a state into sub-states from domain, act, and slot level.

For action decomposition, we decompose an action $\mathcal{A}$ by rules based on how the action vector is defined. Such a rule-based decomposer can be easily implemented by first defining an assignment matrix $M$, then multiply $M$ with $\mathcal{A}$ and select three sub-spans of $\mathcal{A}$ to form three sub-actions $a_{d}$, $a_{a}$ and $a_{s}$, which are all one-hot vectors.

For state decomposition and representation, we decompose a discrete state $\mathcal{S}$ into sub-states of domain, act and slot, and learn a continuous representation of them by DAE. As shown in Fig. 2, the DAE contains three encoders $\text{E}_{d}$, $\text{E}_{a}$ and $\text{E}_{s}$ to extract and encode the sub-states from $\mathcal{S}$:

To enforce each encoder learn the sub-state corresponding to domain, act and slot respectively, we adopt three auxilary classifiers ($C_{d}$, $C_{a}$ and $C_{s}$) which classify each sub-state representation ($s_{d}$, $s_{a}$ and $s_{s}$) with the corresponding sub-action ($a_{d}$, $a_{a}$ and $a_{s}$) as label. To enhance model generalization, we inject data-dependent noises into latent variables $h_{d}$, $h_{a}$ and $h_{s}$. In particular, a noise variance $\sigma^{2}$ is obtained via the Multilayer Perceptron (MLP) transformation from state $\mathcal{S}$: $\log\sigma^{2}=MLP(\mathcal{S})$. Then we sample noise $z$ from a Gaussian distribution $\mathcal{N}(h,\sigma^{2}I)$. The reparameterization trick Kingma and Welling (2013) is further exploited to achieve end-to-end training:

In this way, the sub-state representations are different for every training time of input state $\mathcal{S}$, and thus the model is provided with additional flexibility to explore various trade-offs between noise and environment.

Next, we reconstruct the state via a decoder:

After that, since the state $\mathcal{S}$ is a discrete vector, we can learn DAE by minimizing a binary cross entropy loss:

The loss for the auxilary classifiers are:

where $W_{i}\in\{W_{d},W_{a},W_{s}\}$ is the learnable parameters of the classifiers and $\mathcal{A}_{i}$ is the action space of the corresponding action level. Therefore, the overall loss for training DAE is given by:

Different from previous adversairal training methods in which generator (policy) and discriminator (reward estimator) are trained alternatively when interacting with simulated user, our GAN network Goodfellow et al. (2014) is trained offline without the need of simulated users. As shown in Fig. 2, our discriminator $\mathcal{D}$ is composed of three sub-discriminators$\{D_{{d}},D_{{a}},D_{{s}}\}$, our generator $\mathcal{G}$ consists a set of parallel sub-generators $\{G_{{d}},G_{{a}},G_{{s}},G_{{act}}\}$ with the same Gaussian noise $Z$ as input to generate sub-states $\{s_{d}^{z},s_{a}^{z},s_{s}^{z}\}$ and actioin $\hat{\mathcal{A}}$. Then $\hat{\mathcal{A}}$ is decomposed into $\{a_{d}^{z},a_{a}^{z},a_{s}^{z}\}$ by the same rule-based decomposer we described in Sec. 3.1. As a true action $\mathcal{A}$ is discrete, we use Straight-Through Gumbel Softmax Jang et al. (2016) to approximate the sampling process. The generators aim to approximate the distribution of expert dialog $(\mathcal{S}_{e},\mathcal{A}_{e})$ by learning distributions $\{f_{d}^{e},f_{a}^{e},f_{s}^{e}\}$ of sub state-actions with $\{G_{{d}},G_{{a}},G_{{s}}\}$ and $G_{act}$. We train the generators by the following loss:

where $\theta$ represents the parameters of generator $G$.

For discriminator, it consists of three paralleled and independent MLP networks with a sigmoid output layer. The discriminator outputs three scores $\{y_{d},y_{a},y_{s}\}$ that respectively denote the probability a sub state-action pair is from a true expert distribution. The traininig loss could be written as:

Reward shaping provides an RL agent with extra rewards in addition to the original sparse rewards $r_{ori}$ in a task to alleviate the problem of reward sparsity. We follow the same assumption of Liu and Lane (2018); Paek and Pieraccini (2008), in which state-action pairs similar to expert data will receive higher rewards.

The rewards from our discriminators are calculated as:

where $\{y_{d},y_{a},y_{s}\}$ are the outputs of discriminators $\{D_{d},D_{a},D_{s}\}$ in Fig. 2. Note that we impose Markov property into multi-level reward calculation by taking the reward of domain/act level into account when calculating the reward of act/slot level. An agent will receive a low reward when it chooses a wrong domain even if $y_{a}$ or $y_{s}$ is high. We accomplish this by the $sigmoid$ functions in Eq. 10. $\tau$ and $b$ are two hyper-parameters controlling the shape of the $sigmoid$ function. A smaller $\tau$ will introduce a softer penalty given by prior-level reward.

After getting the three-level rewards, we propose two reward integration strategies. The first strategy we denote as $R_{SeqPrd}$ is simply using $R_{S}$ from Eq. 10 as the combined reward. This strategy will bring reward to nearly 1 or 0. The second strategy we denote as $R_{SeqAvg}$ is computing the mean of the three rewards $\{R_{d}$, $R_{a}$, $R_{s}\}$ as the final reward. Finally, we augment the original reward $r_{ori}$ by adding $R_{SeqPrd}$ or $R_{SeqAvg}$ for reward shaping.

For the Disentangled Auto-Encoder, the input of its encoder is binary states $\mathcal{S}$. We use three paralleled MLP layers with same hidden size 64 as the sub-encoders to get hidden states $\{h_{d},h_{a},h_{s}\}$, which are the same with the architecture of the MLP network for generating noise variance $\sigma^{2}$. We train the encoder, decoder, and classifier network simultaneously.

For the generator part, we utilize four independent and parallel MLP layers. All layers share the same gaussian noise as input. The first three aim to capture the distribution in the field of $d$, $a$, $s$ with output size = 64. The output size of $G_{4}$ is 300 with an output layer of ST-Gumbel Softmax. To make the output of generators be similar with the encoding representation of DAE and bring noise to the discriminator as well, we further add two MLP networks separately after generation layer to simulate the sampling process of mean and variance. We add weight regularization in a form of $l2$ norm to avoid overfitting. In our experiments, the generator is weaker compared to the discriminator, therefore we set the training frequency ratio of generator and discriminator to be 5:1.

For the discriminator part, we utilize three parallel MLP layers followed by a sigmoid function as the output layer. Training a multi adversarial network is not easy. Three discriminator will be insensitive to its own field if training all $\mathcal{G}$ and $\mathcal{D}$ jointly. Thus, we train $\mathcal{G}$ and $\mathcal{D}$ in the following way. $\mathcal{D}$ takes all outputs from $\mathcal{G}$ as input, but only chosen sub-generator and sub-discriminator pair has gradient backpropagation and others are frozen. During the experiment, we found start training from one pairs to two pairs then to all pairs brings good results.

Dataset. We run evaluations based on the MultiWOZ dataset Budzianowski et al. (2018)¹¹1https://github.com/budzianowski/multiwoz . It is a multi-domain dialog dataset that constructed from human dialog records, mainly ranging from restaurant booking to hotel recommending scenarios. There are 3,406 single-domain dialogs and 7,032 multi-domain dialogs in total. The average number of turns is $8.93$ and $15.39$ for single and multi-domain dialogs, respectively.

Platform. We implement our methods and baselines based on the Convlab platform Lee et al. (2019)²²2https://github.com/sherlock1987/SeqReward. It is a multi-domain dialog system platform supporting end-to-end system evaluation, which integrates several RL algorithmns.

Implementation details. For fair comparisons, we follow the same experiment settings in Li et al. (2020). Specifically, an agenda-based user simulator Schatzmann et al. (2007) is embedded and exploited to interact with dialog agent. We set the training environment to a “dialog-act to dialog-act (DA-to-DA)” level, where the agent interacts with a simulated user in a dialog act way rather than an utterance way. We use a rule-based dialog state tracker (DST) to track $100\%$ of the user goals. We train on millions of frames (user-system turn pairs) with $392$-dimensional state vectors as inputs and $300$-dimensional action vectors as outputs. For all the RL networks, we use a hidden layer of $100$ dimensions and ReLU activation function.

Evaluation metrics. During evaluation, the simulated user will generate a random goal first for each conversation and then complete the session successfully if the dialog agent has accomplished all user requirements. We exploit average turn, success rate and reward score to evaluate the efficiency of proposed reward model. In particular, the reward score metric is defined as

where $T$ denotes the number of system-user turns in each conversation session. The performances averaged over $10$ times with different random seeds are reported as the final results. Besides, we evaluate our RL models in every $1,000$ frames (system-user turn) by using $1,000$ dialogs interacting with simulated user.

We evaluate the proposed reward estimator via two classical RL algorithms: \romannum1) Deep Q-Network (DQN) Mnih et al. (2015), which is a value-based RL algorithm; \romannum2) Proximal Policy Optimization (PPO) Mnih et al. (2015), which is a policy-based RL algorithm.

In terms of the DQN-based methods, we compare our method $\text{DQN}_{SeqAvg}$ and $\text{DQN}_{SeqPrd}$ (corresponding to $R_{SeqAvg}$ and $R_{SeqPrd}$, respectively) with $\text{DQN}_{vanilla}$, whose reward function is defined in Eq. 11, and $\text{DQN}_{offgan}$ Li et al. (2020), which also pretrains an reward function to achieve performance gains. Similarly, we also evaluate on Warm-up DQN(WDQN) with different reward function, named $\text{WDQN}_{vanilla}$, $\text{WDQN}_{offgan}$, $\text{WDQN}_{SeqAvg}$ and $\text{WDQN}_{SeqPrd}$, respectively.

For the implementation details of DQN-based agents, we use $\epsilon-$greedy action exploration and set a linear decay from $0.1$ in the beginning to 0.01 after $500k$ frames. We train DQN on 500 batches of size 16 every 200 frames. Besides, we use a relay buffer of size $50,000$ to stabalize training.

In terms of the PPO-based methods, we pick up two adversarial methods: \romannum1) Guided Dialog Policy Learning (AIRL) Takanobu et al. (2019); and \romannum2) Generative Adversarial Imitation Learning (GAIL) Ho and Ermon (2016). AIRL works on turn level and gives reward scores based on state-action-state triple $(s_{t},a_{t},s_{t+1})$. For GAIL, it works on dialog level and gives rewards after dialog ends.

Similar to DQNs, we also compare our methods with $\text{PPO}_{vanilla}$ and $\text{PPO}_{offgan}$ Li et al. (2020). There is one extra hyperparameter named training epoch for GAIL and AIRL, which represents the training ratio of discriminator and PPO models. Here we set it to $4$. Apart from these, all the other hyperparamaters stay the same. Different from the settings for DQN, the $\epsilon-$greedy stays $0.001$ without decay. Besides, we set val-loss-coef to be $1$, meaning no discount for value loss. We also set the training frequency to be $500$ frames.

From Fig. 3 (a), $\text{DQN}_{SeqPrd}$ achieves the best performance with a success rate of 0.990 and converges after 130K, which speeds up the training process by almost 300$\%$ compared to $\text{DQN}_{vanilla}$. Compared with $\text{DQN}_{vanilla}$, the methods using pre-trained reward functions $R_{offgan}$, $R_{SeqArg}$, $R_{SeqPrd}$ are better than vanilla in terms of both convergence speed and success rate. This phenomenon suggests that these three reward estimator could speed up dialog policy training.

Different from $\text{DQN}_{offgan}$, whose reward function is also learned by adversarial training, we further apply disentagled learning and multi-view discriminator to obtain fine-grained rewards. The performance of $\text{DQN}_{SeqPrd}$ and $\text{WDQN}_{SeqPrd}$ gains recieved in convergence speed and final performance of our methods confirm the superiorty of the hierarchical reward.

For WDQN agent, since first warmed up with human dialogs, the WDQN-based methods share similar success rate (around 6%) before training and consistently converge faster than DQN-based models. However, the usage of warm-up operation will mislead the model to local optimum and deteriorate the final success rate. This phenomenon can be found in the last $100$ frames, the performances of $\text{WDQN}_{vanilla}$ and $\text{WDQN}_{offgan}$ drop significantly. Another attractive property of our method, compared with $\text{WDQN}_{vanilla}$ and $\text{WDQN}_{offgan}$, is the variance of success rate is obviously small, which strongly supports the remarkable benefit of exploiting disentangled representation to learn profitable sequential reward in dialog management.

For the policy gradient based agents, we compare our models with two other strong baselines, i.e., GAIL and AIRL, whose reward functions are updated during RL training. Similar to DQN-based methods, we employ PPO algorithms to train dialog agents with different reward functions. Before training a PPO agent, we perform imitation learning with human dialogs to warm-up PPO agents, achieving around $33\%$ success rate. For fair comparisons, we also pretrain the discriminator in GAIL and reward model in AIRL by feeding positive samples and negative samples from pretrain process of dialog agents.

As demonstrated in Fig. 3 (c), although AIRL rises faster than others during the first 50 frames, it converges to a worse result, compared with $\text{PPO}_{SeqAvg}$. An interesting observation is that $\text{PPO}_{vanilla}$ even performs better than AIRL. This may be due to the fact that adversarial learning is extremely unstable in RL. Therefore, we aim to learn an off-line reward function to guide the evolution of agents, as we motivate in the introduction. In the comparison between $\text{PPO}_{offgan}$ and $\text{PPO}_{SeqAvg}$, the performance gains obtained by our model verifies the advantage of exploiting multi-level reward signals. Moreover, it can be seen that, in the PPO-based RL algorithm, the performance of the agent with the reward function $R_{SeqPrd}$ is worse than that of $R_{SeqAvg}$, but the opposite is true in the DQN and WDQN-based methods. This may be caused by that the multiplicative reward (i.e., $R_{SeqPrd}$) may cause the gradient to be very steep, which makes the training of the policy gradient-based model unstable. However, in the value-based RL method, an average reward (i.e., $R_{SeqAvg}$) might degenerate the performance, as a hierarchical reward is more general and intuitive, which has access to precise intermediate reward signals. The performances of the last frame in terms of success rate, reward score and average turn are shown in Table 1, in which we could claim again that our method $\text{PPO}_{SeqAvg}$ outperforms all baseline models by a substantial margin.

To visualize the model performance and what benefits a sequential reward will bring, we view the evaluation as a binary classification and distribution distance problem. we use accuracy, precision, recall and F1 to find out how good this binary model is, and use JS divergence to evaluate the ability of reward model to divide positive and negative distributions, the larger the better. We construct a test dataset with equal numbers ($7,372$) of positive and negative samples from the test dataset. All positive samples are original state-action pairs. For negative samples, we fix states and randomly pick actions from those with different domains. We evaluate three reward models separately in Table 2. $R_{d}$ is the best one among the three with the highest five scores. This is pretty straight forward since domain is the first identity to divide action space as groups. And for $R_{a}$ and $R_{s}$, the JS divergence is lower, this is because some actions could have different domains with the same action-slot. For example, action “Train-Inform-Arrive” and “Hotel-Inform-Arrive” have the same action-slot with different domains. Thus, $R_{a}$ and $R_{s}$ will only give an ambiguous decision boundary. But from a sequential view, we make a new combination of $R_{SeqAvg}$ and $R_{SeqPrd}$, which gives good results.

$R_{offgan}$ could give right rewards to some extent, but from Fig. 4 (c), there is a large intersection between fake and real distributions among three, which means it wrongly classifies fake action as right. And this is the reason why its F1 score is lower. Besides, this reward model is a biased model, its ratio of true negative and true positive samples is 0.89 thus it tends to give fake results. For both of our model, there is little bias, $R_{SeqPrd}$ is 0.99 and $R_{SeqAvg}$ is 0.98, which benefits from sequential combination.

For $R_{SeqPrd}$, $R_{SeqAvg}$ and $R_{offgan}$, $R_{SeqPrd}$ perform the best, no matter from the view of binary classification or JS divergence. And the distribution is much sharper than $R_{SeqAvg}$ with prediction score centering at 0 or 1. For $R_{SeqAvg}$, the distribution is softer than $R_{SeqPrd}$ as shown in Fig. 4. Although there is no exact evaluation to say how bad one action is, but from the good results of $\text{PPO}_{SeqAvg}$, nearly the same binary classification score with $R_{SeqPrd}$ as well as lower JS divergence, we could get the conclusion that it is the most accurate rewards among the three.