Task-Optimized Adapters for an End-to-End Task-Oriented Dialogue System
Year: 2023

Abstract:
Task-Oriented Dialogue (TOD) systems are designed to carry out specific tasks by tracking dialogue states and generating appropriate responses to help users achieve defined goals. Recently, end-to-end dialogue models pre-trained based on large datasets have shown promising performance in the conversational system. However, they share the same parameters to train tasks of the dialogue system (NLU, DST, NLG), so debugging each task is challenging. Also, they require a lot of effort to fine-tune large parameters to create a task-oriented chatbot, making it difficult for non-experts to handle. Therefore, we intend to train relatively lightweight and fast models compared to PLM. In this paper, we propose an End-to-end TOD system with Task-Optimized Adapters which learn independently per task, adding only small number of parameters after fixed layers of pretrained network. We also enhance the performance of the DST and NLG modules through reinforcement learning, overcoming the learning curve that has lacked at the adapter learning and enabling the natural and consistent response generation that is appropriate for the goal. Our method is a model-agnostic approach and does not require prompt-tuning as only input data without a prompt. As results of the experiment, our method shows competitive performance on the MultiWOZ benchmark compared to the existing end-to-end models. In particular, we attain state-of-the-art performance on the DST task of 2.2 dataset.1

heading: 1 Introduction
text: Task-oriented dialogue systems are trained to achieve specific goal to enhance efficiency and convenience in various fields such as customer service centers and healthcare information retrieval.
*These authors contributed equally to this work. 1Our code is available at https://github.com/
sogang-isds/TOATOD.git
Task-oriented dialogue systems are divided into key components: understanding the user’s intent (NLU), tracking the current dialogue states (DST), and generating responses based on previous sessions (NLG). Pipeline-based systems separately train each component, so they have the advantage of optimizing each module and raising the performance of a given task. User feedback is, however, difficult to propagate to each module, and inputs to the component is dependent on the result of the previous module (Chen et al., 2017). Recently, dialogue systems have been trained in an end-toend manner with transfer learning or pre-training networks with large dialogue corpora. However, building efficient end-to-end TOD systems requires a large amount of data and has some limitations due to parameter sharing. End-to-end models backpropagate to transfer the gradients of the output and end back to the entire neural network. They pose an issue of parameter efficiency as updating all parameters for every downstream scenario. Also, it is challenging to debug each task and take task-flow characteristics into account.
Therefore, we propose a simple structure of adding adapters to the core modules (NLU, DST, NLG) of the TOD system as shown in Figure 1. By using the adapters, it is possible to optimize each task with only a small amount of training parameters, remaining the pre-trained model’s parameters fixed. Additionally, it is safe from the catastrophic forgetting problem (French, 1999), which causes pre-trained models to lose important skills acquired during the pre-training process. The key is to apply a transfer learning strategy that yields compact and extensible downstream models in the dialogue system (Houlsby et al., 2019). This makes it easy for people to train large-scale end-to-end TOD models. Also, by applying REINFORCE (Sutton et al., 1999), we attempt to reduce the expected score gap caused by the small parameters of adapter compared to the full fine-tuning. Specifically, we use
7355
Joint Goal Accuracy, and weighted sum of BLEU and Success rate as rewards for training DST and NLG adapter. To best of our knowledge, this is first work that use Joint Goal Accuracy as a reward for E2E TOD system.
To address the aforementioned problems, we propose a Task-Optimized Adapter for an end-toend Task-Oriented Dialogue system (TOATOD) applying reinforcement learning to DST and NLG tasks. In summary, our key contributions are as follows:
• We present a new architecture that can debug per task of the end-to-end model using the separated adapters.
• Without updating the original parameters of PLM, we train end-to-end TOD system efficiently with a few trainable parameters.
• It is a novel approach to design a reward function not just for NLG, but also for DST task with metric-aware reinforcement learning.
• The performance of the proposed approach outperforms on the DST task of MultiWOZ 2.2 and shows comparable results to full finetuning on the NLU and NLG tasks.

heading: 2 Background
text: Pipeline-based Task-Oriented Dialogue System Conventional task-oriented dialogue systems usually based on the pipeline method, consisted of language understanding (NLU), dialogue state tracking (DST), policy learning (POL), and language generation (NLG). This kind of modularization allows for each component to be optimized independently, making it easier to update and understand how the model is working. Pipeline-based systems, however, have several limitations. Each of the modules train sequentially, so it is hard to align modules to the common optimization targets (Liu and Lane, 2018). This makes the system more complex and harder to backpropagate cumulated errors. The performance of the previous components affects the next modules, so if upper modules perform poorly, errors that occurred earlier may propagate and be amplified in downstream components (Liu and Lane, 2018). End-to-end Task-Oriented Dialogue System Endto-end task-oriented dialogue systems, on the other hand, are easier to optimize and train to directly map the input to output in a single model. They can leverage large amounts of data for robust learning and the entire system can be optimized under end-to-end settings, which leads to better performance. A general approach for building end-to-end systems is to fine-tune pre-trained language models (Budzianowski and Vulić, 2019). This approach utilizes the strength of pre-trained networks, which help the models to leverage the pre-trained knowledge while also adapting to task-specific data. For example, SimpleTOD (Hosseini-Asl et al., 2020) solved task-oriented dialogue as causal language modeling task using several versions of GPT (Radford and Narasimhan, 2018; Radford et al.). Pre-training of Dialogue Language Model Recently, methods with pre-training dialogue language model (Wu et al., 2020; Zhang et al., 2020b; Peng et al., 2021; Su et al., 2022; He et al., 2022a), instead of fine-tuning pre-trained networks have outperformed the previous baselines on the benchmark. For instance, SPACE-3 (He et al., 2022a) captures the contextualized knowledge from largescale dialogue corpora by pre-training the unified language model. However, there are still some issues with these methods. A large amount of param-
eters is required for training backbone models like BERT, T5 (Raffel et al., 2020), GPT, and UniLM (Dong et al., 2019). As shown in Table 1, T5base and T5small require the trainable parameters over 220M and 60M respectively. And they disregard the task-flow features of task-oriented dialogue systems. Also, it’s still hard to debug per module because the model parameters are shared and jointly optimized. PPTOD (Su et al., 2022) integrated modules into a unified model with task-specific prompts and alleviated the error accumulation in plug-and-play way. Still, this method is not completely free from the interference among tasks due to fully shared parameters. Adapter tuning for NLP Since the pre-trained models for NLP tasks have become mainstream, they are mainly used for transfer learning downstream tasks. However, a parameter efficiency issue has been raised because updating all PLM parameters is expensive for every downstream scenario. To address the issue, the adapter module is proposed to transfer PLM like BERT with parameterefficient tuning (Houlsby et al., 2019) and shows comparable performance to full fine-tuning. The main idea behind the adapter is to train the network to the downstream task with task-specific parameters while maintaining the original pre-trained parameters. The module is composed of two feedforward layers and a non-linear layer, which can be
inserted into the transformer blocks of an end-toend model. It projects d-dimensional input features into a smaller dimension m, and then projects back into the original dimension, so the total of parameters add per layer with biases is 2md + d + m. The number of additional parameters per task can be restricted by setting m < d (Li et al., 2021). In most of the previous research, the adapter was used for efficient learning. But in this approach, we adapt the adapter modules not just for efficient learning (Stickland and Murray, 2019), but also task-optimized learning as recent studies that have mainly focused on separating parameters (Lin et al., 2021; Feng et al., 2022; Bapna and Firat, 2019). Reinforcement learning for Text Generation Although token-based supervised learning is a widely adopted training method in text generation tasks, as highlighted by Ranzato et al., 2016, there are two major problems associated with this approach. The first problem is the exposure bias problem, where during training, the model is exposed to the ground-truth outputs, thus allowing it to learn to generate text that is similar to the training data. However, during evaluation, the model is not exposed to the ground-truth outputs and instead, generates texts based on the previous words generated by the model itself. This can lead to errors and a significant deviation in the generated text from the training data. The second problem is the tokenlevel loss problem, where the training objective function is based solely on individual words’ prediction, neglecting the predicted token sequence’s overall coherence and fluency.
To address these problems, researchers have applied reinforcement learning to text generation tasks (Ranzato et al., 2016; Li et al., 2016; Paulus et al., 2018; Chen et al., 2020; Wang et al., 2021; Ye et al., 2022) using metrics such as BLEU (Papineni et al., 2002) or ROUGE (Lin, 2004) as rewards for sequence-level training. In our study, we also use the REINFORCE method and task-oriented dialogue metrics to continually train our model after supervised learning, not only to address these challenges but also to mitigate performance degradation caused by the use of an Adapter.

heading: 3 Methodology

heading: 3.1 Adapter for each task (NLU, DST, NLG)
text: The Adapter module is designed to adapt the pretrained network for each of the tasks (NLU, DST,
NLG) in a task-oriented dialogue system. As illustrated in Figure 2, the adapters are inserted after the feed-forward layer following the multi-head attention layer of the transformer blocks of the end-to-end model. It enables the model to learn task-specific representations while preserving the shared parameters learned during pre-training. As described in Table 1, our model consists of largesize frozen shared parameters per task and small size of trainable parameters that account for about 14% of the entire network. While original network’s parameters are frozen, the jth adapter of task i ∈ {NLU, DST, NLG}, Aij computes as below:
Aij = LN (Wup ∗ ReLU (Wdown ∗ Hj) + Hj) (1)
The output of the jth feed-forward layer with residual connection in the transformer block is represented as Hj ∈ Rn×d, where n is the input dimension, and d is the hidden dimension. As shown in Figure 2, the overall architecture of the adapter module includes multiple feed-forward projections, referred to as down-projection and up-projection, followed by layer normalization (LN). The downprojection with Wdown ∈ Rd×h projects the input Hj , which is passed by the ReLU activation function, and then the up-projection with Wup ∈ Rh×d projects the output back to the original dimension. The bottleneck dimension h is a hyperparameter to project the original input to a smaller dimension. And each adapter has a residual connection to avoid vanishing gradient (Rebuffi et al., 2017; He et al., 2016).

heading: 3.2 Metric-Aware Reinforcement Learning for DST & NLG module
text: The overall loss function for the metric-aware reinforcement learning is given by the equation (2):
J (θ) = α× Jpolicy (θ) + (1− α)× CE (y, ŷ) (2)
The equation describes how the network updates the parameters in order to maximize both the likelihood of the generated response (token loss) and the quality of the response (policy loss). The token loss can be described as a categorical cross-entropy loss. ŷ denotes the predicted probability of ground truth and y is the target probability. The token loss CE(y, ŷ), which measures how well a set of predicted token probabilities match the target tokens for a given context of dialogue when reinforcement learning. By applying REINFORCE method, the network can update weights towards the direction that allows the model for getting more rewards even when the reward function is non-differentiable.
Jpolicy (θ) = − logP (ŷ)×Reward(y, ŷ) (3)
The policy loss Jpolicy(θ) is introduced to measure of how well the model can generate a token sequence with high probabilities that result in high rewards. ŷ denotes the predicted token sequence by model. The policy loss described in the equation (3) is calculated as the negative log probability of the token sequence that has the highest probability multiplied by the reward.
The parameter α in the overall loss (2) is a hyperparameter, that is a scalar value between 0 and 1 to weigh the importance of these losses. In this way, the model is trained to predict the correct labels (categorical cross-entropy loss) and to make good decisions that result in high rewards (policy loss) at the same time. We define the reward functions of the DST and NLG modules as follows:
RewardDST = JGA(y, ŷ) + 1 (4)
The RewardDST is calculated as the sum of the Joint Goal Accuracy (JGA) and a constant value of 1. The JGA measures how well the model predicted the values for every slot in the dialogue turns. Using JGA as a reward, the model is encouraged to accurately track the state of the dialogue, which is crucial for generating appropriate responses and improving the performance of task-oriented dialogue systems.
RewardNLG =(1− β)× E[BLEU(yu, ŷu)] + β × Success(y, ŷ ) + 1 (5)
In the equation (5), BLEU score and Success rate are used as rewards to guide the learning process
of NLG module. yu denotes the ground truth token sequence of each utterance, and ŷu denotes the predicted token sequence. To calculate the success rate, we apply the batch of a session-level, not an utterance-level. y and ŷ without u mean the session level ground truth and prediction. The weighting factor β is adjusted to balance these two metrics. The hyperparameter β may have to be carefully chosen because there is a trade-off relationship between these two metrics in the RL setting (Wu et al., 2021), where increasing one metric may come at the cost of decreasing the other. We experiment to choose α and β on the Section 6.1.3 and 6.1.4.

heading: 4 Experimental Setup

heading: 4.1 Datasets
text: We experiment our method for dialogue state tracking (DST) and end-to-end response generation (NLG) tasks on the MultiWOZ 2.1 and 2.2 datasets, and the intent prediction (NLU) task with the Banking77, CLINC150, and HWU64 datasets. MultiWOZ - 2.1, 2.2 The MultiWOZ (Budzianowski et al., 2018) dataset has been widely used to evaluate the performance of TOD systems. It consists of 8438, 1000, and 1000 for training, dev, test sets with multi-turn dialogues, collected through a Wizard-of-Oz (WOZ) setup. The dialogues cover a wide range of domains and topics. MultiWOZ 2.2 (Zang et al., 2020) is the improved version of MultiWOZ 2.1 (Eric et al., 2020) that has corrected annotation errors, inconsistencies, and ontology issues, also added span annotations to standardize. Banking 77 (Casanueva et al., 2020) This dataset is a collection of 77 real-life customer banking service queries. It consists of 13,083 utterances. Each query is labeled with a single intent, however, it is hard to differentiate because they correspond to very similar tasks. CLINC150 (Larson et al., 2019) This dataset is multi-domain dataset which contains 23,700 utterances that cover 150 intent classes over 10 domains. HWU64 (Liu et al., 2019) This dataset consists of 25,716 examples. It maps user utterances to structured, but mode abstract. The data provides annotation with the 64 intents from 21 different domains.

heading: 4.2 Baselines & Settings
text: For the DST task, we compare our models with other strong baselines including TRADE (Wu et al., 2019), DS-DST (Zhang et al., 2020a), DST-Picklist (Zhang et al., 2020a), TripPy (Heck et al., 2020), ConvBERT+DG+Multi (Mehri et al., 2020a), TripPy+SaCLog (Dai et al., 2021), SimpleTOD (Hosseini-Asl et al., 2020), AG-DST (Tian et al., 2021), UniLM, SPACE-3, D3ST (Zhao et al., 2022), SDP-DST (Lee et al., 2021), and PPTOD. On the NLG task, we choose models trained on PLM in an end-to-end setting such as DoTS (Jeon and Lee, 2021), PPTOD, UBAR (Yang et al., 2021), MTTOD (Lee, 2021), RSTOD (Cholakov and Kolev, 2022), GALAXY (He et al., 2022b), MinTL (Lin et al., 2020), SOLOLIST, BORT (Sun et al., 2022a) and Mars (Sun et al., 2022b). For the NLU task, we compare TOATOD with existing baselines of each dataset.
We use T5small and T5base as backbone models initialized with PPTOD (Su et al., 2022)’s pretrained weights, which are trained on a large dialogue dataset. As described in the Appendix A, the bottleneck dimension h of the adapter is 1/2 of
Model Backbone Model(Trainable Params) MultiWOZ 2.1 MultiWOZ 2.2
the hidden dimension of the T5 model. We use the Adafactor (Shazeer and Stern, 2018) optimizer with 15 epochs and set batch size as 16, learning rate of 1e-4 during supervised learning of DST and NLG tasks. We sweep a wide range of learning rates: {1e-5, 1e-6, 1e-7}. For reinforcement learning, we train models 10 epochs for DST and 3 epochs for NLG. We do not train NLG-optimized adapters for the MultiWOZ 2.2, because there are not significant changes of response annotations from MultiWOZ 2.1 and intend to train robust models with noised dataset.
We follow the preprocessing method from UBAR to delexicalize slot values for each system responses. We evaluate our models using the older version of the standardized evaluation script for MultiWOZ 2.1, and the newly opened version for MultiWOZ 2.2, released by Nekvinda and Dusek, 2021. It has been adopted by the official MultiWoZ dataset github 2. Other implementation details are described in Appendix C.

heading: 5 Experimental Results

heading: 5.1 Dialogue State Tracking
text: We evaluate our models on the DST task with the MultiWOZ 2.1 & 2.2 datasets. We compute Joint Goal Accuracy on the test set, which measures how many values are filled accurately compared to the ground truth states for all slots. Joint Goal Accuracy is considered as more difficult and important metric in most research (Zhou and Small, 2019;
2https://github.com/budzianowski/multiwoz
Dey et al., 2022), because once wrong prediction has been made, it cannot get the score at that turn.

heading: 5.1.1 Evaluation Result
text: We compare our best models, TOATODsmall and TOATODbase to the models trained with a pretrained network. Table 2 shows that our models are competitive to the end-to-end models on the current benchmark. In the 2.1 dataset, our models show a relatively good performance, despite the small number of trainable parameters. As shown in the Table 5, the Joint Goal Accuracy of TOATODbase only with task-optimized adapter (SL) is 53.33, which is slightly lower than other models using T5base as backbone. So, we reduce the performance degradation applying metric-aware REINFORCE and report the final results. Trainable parameters of our models are less than 1/2 of the models with the smallest parameters. The result implies that the adapter module helps the network more adaptable to the DST task by only activating a few parts of the model. Because of relatively small parameters, our model is more robust to overfitting problem with confused labels. As mentioned in Section 4.1, MultiWOZ 2.2 is the cleaned version of 2.1 dataset, so the performance is better in the 2.2. Among the top results on the 2.2 dataset, our models obtain state-of-the-art performance. It demonstrates that TOATOD optimizes well on the given task remaining the prior knowledge learned from the pre-trained network.

heading: 5.2 End-to-End Response Generation
text: We test our methods with end-to-end response generation (NLG) task on the MultiWOZ 2.1 & 2.2 as in DST evaluation. Four metrics are used to measure the quality of generated responses. We measure if the system provides the appropriate entity (Inform rate), answers all the requested information (Success rate), and responds fluently (BLEU score). And the Combined Score for end-to-end response generation is computed as ’BLEU+0.5 × (Inform+Success)’. Under the end-to-end settings, the models have to predict proper dialogue states and then generate responses based on the states.

heading: 5.2.1 Evaluation Result
text: From Table 3, our models achieve comparable results (1.x point different from SOTA model) in all datasets. The adapter module helps each part of the model be fine-tuned independently, therefore we can optimize the DST and NLG task respectively. Our model performs well on NLG task based on the belief states from DST modules and base knowledge gained from the large-scale dialog dataset during pre-training. TOATODbase attains the best score on the Inform and Success rate. It shows that the reinforcement learning of our approach is effective for adjusting trade-off problem between BLEU score and others.

heading: 5.3 Intent Classification
text: We test our models on the NLU task with Banking77, CLINC150, and HWU64. Intent prediction is the task to identify the intent behind a given in-
3https://eval.ai/web/challenges/ challenge-page/708/leaderboard/1943
put. The task is normally framed as a classification problem, so we set the metric as turn accuracy.

heading: 5.3.1 Evaluation Result
text: From Table 4, while our models do not achieve the highest score on NLU task, it is important to note that they perform well in relation to the size when compared to other models. This highlights the effectiveness of our task-optimized adapter approach in achieving a balance between model performance and efficiency.

heading: 6 Further Analysis and Discussion

heading: 6.1 Reinforcement Learning

heading: 6.1.1 w/o Reinforcement Learning
text: Described on the Table 5, after applying reinforcement learning, the performance of DST and NLG modules are enhanced. Models with reinforcement learning obtain best JGA on the DST task and get the highest Combined Score on the NLG task. The BLEU scores fall slightly but the Combined Score rise with Inform and Success, which means that incorporating reinforcement learning into the training process leads our model to complete tasks more efficiently. We conduct hyperparameter tuning only for the TOATODbase, so there is some gap in the degree of performance improvement between TOATODsmall and TOATODbase.

heading: 6.1.2 Hyperparameters of REINFORCE
text: The hyperparameter α is used for balancing the importance between cross-entropy loss and policy loss. We re-train DST and NLG modules by optimizing the mixed objective function to get higher rewards. The second hyperparameter β is a scaling factor to control the trade-off between BLEU score
and Success rate for NLG module. The BLEU score is calculated based on the number of matching n-grams between the generated text and the reference text. A higher score indicates that the generated text is more similar to the label text. Success rate measures the proportion of dialogues, where the model successfully completes the task. A higher success rate means the model is better at achieving the user’s goal of the dialogue. In some cases, however, the model may generate text that is close to the reference text (high BLEU score) but not relevant to the current dialogue (low Success rate). So, we aim to reduce the gap between two metrics via hyperparameter tuning.

heading: 6.1.3 α of DST-optimized adapter
text: In the Table 7, the result of α experiment on DST task indicates that 1.0 yielded the best performance, suggesting the significance of the policy loss in the overall loss function. By maximizing policy loss, the model is encouraged to make decisions that result in high rewards, which improves the performance of the DST task.

heading: 6.1.4 α and β of NLG-optimized adapter
text: We experiment with several combinations of α and β within {α: 0.3, 0.5, 0.7, 0.9, 1.0 / β: 0.4, 0.5, 0.6, 0.7}. Regardless of hyperparameters, performances improve after applying the reinforcement learning. The hyperparameters of α=0.5 and β=0.7, result the best Combined Score, which is 5.44 point higher than the performance of the supervised learning. As shown in the Figure 3, on the experiment
after removing impact of CE loss (α=1), we found that the higher the β, success rate increases compared to BLEU score as we expected.
As shown in Table 6, when the β is fixed, the bigger weight (smaller α) on the CE loss ensures the higher BLEU score. On the other hand, the success rate started to decline from the certain point. Trade-off issue appears at this point. Therefore, α and β need to be properly tuned in NLG task for good performance.

heading: 7 Conclusion
text: We propose TOATOD, task-optimized adapters for an end-to-end task dialogue system. By adapting task-optimized adapters, we utilize the end-to-end models without updating the pre-trained parameters and enabling debugging per task, which is different from previous research. In addition, we apply REINFORCE algorithm with metric-aware reward function directly not only on the NLG task but also DST task to prevent score degradation. As a result, we attain comparable performance to the previous SOTA models on every benchmark with very small number of trainable parameters. For the DST task of MultiWOZ2.2, our TOATOD model outperforms the current SOTA systems.
Limitations
We train the task-optimized adapters based on the pre-trained weights of dialogue LM. Therefore, if applied to other dialogue tasks such as chit-chat and conversational QA system, the performance could be lower than that shown in our research. And we need future works to clarify the reason why the performance was better on the MultiWOZ 2.2 dataset, which is expected that our model does not overfit to the confused labels. Our model inferences in on the end-to-end manner, but trains like modular system for each task. End-to-end learning is currently under study. We could adapt the multitask end-to-end learning to our method, which may lead to the better performance. Also, we could analyze the inner working of task-optimized adapters applying XAI technologies.
Ethics Statement
We honor the ethical codes set out in the ACL code of Ethics. All of the datasets used in our study are from previous studies and do not have privacy issues.

heading: Acknowledgements
text: This work was supported by Institute of Information & communications Technology Planning & Evaluation (IITP) grant funded by the Korea government(MSIT) (No.2022-0-00621,Development of artificial intelli- gence technology that provides dialog-based multi-modal explainability)

heading: A Units of Adapters
text: In this experiment, we evaluate the performance with several bottleneck dimensions, h = 256, 128, 64 with TOATODsmall, which is 1/2, 1/4, 1/8 size of T5small’s embedding dimension of 512. The main focus of the experiment is to investigate the effect of the bottleneck dimension h of the adapter module on the performance of the model. To evaluate the performance of the model, we use the Joint Goal Accuracy for DST task. We keep the other hyperparameters constant across all the experiments, including learning rate of 1e-4 and evaluate the performance on the test set of MultiWOZ 2.1. We report the result on the Table 8.
The result implies that there is a trade-off between the bottleneck dimension and the performance of the model. As the bottleneck dimension increases, the performance of the model also improves. The best performance is achieved with a bottleneck dimension of 256, where the JGA is
51.59. It is important to carefully choose the bottleneck dimension when using the adapter module in the task-oriented dialogue system. As described in the Table 1, the trainable parameters of our model with bottleneck dimension of 256 is still significantly smaller than the PLM’s parameters, so we choose the size of 1/2.

heading: B w/o Reinforcement Learning of
text: TOATODsmall
C Implementation Details
We used 8 A100 (80G) GPUs, but they were fully used during only reinforcement learning. During supervised learning, we used 4 GPUs. While reinforcement learning of the DST task-optimized adapters, we set learning rate as 1e-5, and batch size as 32 (utterance-level). On the contrary, while reinforcement training of the NLG task-optimized adapters, we set learning rate as 1e-6 and batch size as 4 (session-level). During the entire training process, we set random seed as 42. And for the NLU task, we used 1 RTX A5000 (24GB) GPU and trained models without reinforcement learning. We set batch size as 64 and single run with random seeds. When training T5small and T5base for the Banking 77 and CLINC150, we used learning rates of 0.001 and 0.15. And we used learning rates of 0.01 and 0.1 for the T5small and T5base with the HWU64.
ACL 2023 Responsible NLP Checklist

heading: A For every submission:

heading: 3 A1. Did you describe the limitations of your work?
text: Limitations

heading: 3 A2. Did you discuss any potential risks of your work?
text: Limitations
3 A3. Do the abstract and introduction summarize the paper’s main claims? 1
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts? 3
3 B1. Did you cite the creators of artifacts you used? 2, 3
3 B2. Did you discuss the license or terms for use and / or distribution of any artifacts? 4

heading: 3 B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided
text: that it was specified? For the artifacts you create, do you specify intended use and whether that is compatible with the original access conditions (in particular, derivatives of data accessed for research purposes should not be used outside of research contexts)? 2
B4. Did you discuss the steps taken to check whether the data that was collected / used contains any information that names or uniquely identifies individual people or offensive content, and the steps taken to protect / anonymize it? Not applicable. All of the datasets used in our study are from previous studies and do not have privacy issues.
B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? Not applicable. Left blank.
3 B6. Did you report relevant statistics like the number of examples, details of train / test / dev splits, etc. for the data that you used / created? Even for commonly-used benchmark datasets, include the number of examples in train / validation / test splits, as these provide necessary context for a reader to understand experimental results. For example, small differences in accuracy on large test sets may be significant, while on small test sets they may not be. 4
C 3 Did you run computational experiments?

heading: 4.2 & Appendix C

heading: 3 C1. Did you report the number of parameters in the models used, the total computational budget
text: (e.g., GPU hours), and computing infrastructure used? Table 1 & Appendix C
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.

heading: 3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found
text: hyperparameter values? 4.2 & 6 & Appendix C

heading: 3 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary
text: statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? Appendix C

heading: 3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did
text: you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? 4.2
D 7 Did you use human annotators (e.g., crowdworkers) or research with human participants? Left blank.
D1. Did you report the full text of instructions given to participants, including e.g., screenshots, disclaimers of any risks to participants or annotators, etc.? Not applicable. Left blank.
D2. Did you report information about how you recruited (e.g., crowdsourcing platform, students) and paid participants, and discuss if such payment is adequate given the participants’ demographic (e.g., country of residence)? Not applicable. Left blank.
D3. Did you discuss whether and how consent was obtained from people whose data you’re using/curating? For example, if you collected data via crowdsourcing, did your instructions to crowdworkers explain how the data would be used? Not applicable. Left blank.
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? Not applicable. Left blank.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? Not applicable. Left blank.

heading: Future Work
text: And we need future works to clarify the reason why the performance was better on the MultiWOZ 2. 2 dataset, which is expected that our model does not overfit to the confused labels. Our model inferences in on the end-to-end manner, but trains like modular system for each task. End-to-end learning is currently under study. We could adapt the multitask end-to-end learning to our method, which may lead to the better performance. Also, we could analyze the inner working of task-optimized adapters applying XAI technologies