Comparing Data Augmentation Methods for End-to-End Task-Oriented Dialog Systems (2024)

Abstract: Creating effective and reliable task-oriented dialog systems (ToDSs) is challenging, not only because of the complex structure of these systems, but also due to the scarcity of training data, especially when several modules need to be trained separately, each one with its own input/output training examples. Data augmentation (DA), whereby synthetic training examples are added to the training data, has been successful in other NLP systems, but has not been explored as extensively in ToDSs. We empirically evaluate the effectiveness of DA methods in an end-to-end ToDS setting, where a single system is trained to handle all processing stages, from user inputs to system outputs. We experiment with two ToDSs (UBAR, GALAXY) on two datasets (MultiWOZ, KVRET). We consider three types of DA methods (word-level, sentence-level, dialog-level), comparing eight DA methods that have shown promising results in ToDSs and other NLP systems. We show that all DA methods considered are beneficial, and we highlight the best ones, also providing advice to practitioners. We also introduce a more challenging few-shot cross-domain ToDS setting, reaching similar conclusions.

heading: 1 Introduction
text: Task-oriented dialog systems (ToDSs) aim to understand and fulfil a user’s goal in a particular application domain (e.g., booking tickets, restaurant reservations) through natural language conversation (Bang et al., 2023; Zhao et al., 2022). They traditionally include several modules to handle a variety of processing stages. A natural language understanding (NLU) module typically extracts structured information from each user’s utterance, usually in the form of slot-value pairs (e.g., for destination, travel date). A dialog state tracker (DST) keeps track of the information that has been revealed about the user’s goal (dialog state) throughout the conversation. A policy optimizer (PO) de-
cides the system’s next action (e.g., request information for a particular unfilled slot of the dialog state, or recommend a restaurant). A natural language generation (NLG) module realises communication actions of the system in natural language. In spoken conversations, automatic speech recognition (ASR) and text-to-speech (TTS) modules are also included (Oesterreich et al., 2023), though here we consider only written conversations.
When the modules of a ToDS are trained separately, large volumes of annotated training data are needed, since each module requires its own input/output training examples. In end-to-end ToDSs (Wen et al., 2017; Lei et al., 2018), a single system is jointly trained to handle all (or most) of the processing stages, reducing (or at least harmonising) the kinds of annotated training data required, since each training example can be used by all (or most) of the modules (Deriu et al., 2021). Recent Transformer-based end-to-end ToDSs (Ham et al., 2020; Peng et al., 2021; Sun et al., 2022) aim to reduce the necessary training data further, by leveraging pre-training on unlabelled data. However, the best performance is still obtained by fine-tuning on domain-specific annotated training datasets (Hudeček and Dusek, 2023), which are costly to obtain, especially when moving to a new domain (e.g., from booking airline tickets to reserving restaurants). LLMs that promise adequate results in few- or even zero-shot settings (Radford et al., 2019; Brown et al., 2020) have been underexplored in ToDSs, and work along this direction has focused mostly on the DST module, with contradicting results (Hudeček and Dusek, 2023; Hu et al., 2022). Thus cost-effective methods to obtain or augment training sets for ToDSs are needed.
We experiment with data augmentation (DA), which adds synthetic training examples to an existing annotated (possibly small) training set. DA methods have shown promising results in various NLP tasks, e.g., text classification, text generation,
7216
question answering (Feng et al., 2021; Shorten et al., 2021; Pappas et al., 2022), but have not been systematically compared in end-to-end ToDSs (Section 6). We simulate the case where the available annotated training set is limited, which is often the case with real-life ToDS applications, especially when moving to new application domains. We experiment with two end-to-end pre-trained Transformer-based TODSs, namely UBAR (Yang et al., 2021) and GALAXY (He et al., 2022b), and two English textual conversational datasets, MultiWOZ 2.0 (Budzianowski et al., 2018) and KVRET (Eric et al., 2017). We vary both the size of the initial annotated training set (e.g., 2%, 10%, 25% of MultiWOZ’s training set) and the expansion factor (generating one, two, or four synthetic examples from each original one, i.e., x2, x3, x5 expansion). We also introduce a more challenging few-shot cross-domain setting: in each iteration, we select a single domain as the target one, we remove from the training set all but 20 (few-shot) dialogs of the target domain, we generate synthetic training dialogs from the 20 dialogs, and evaluate only on test dialogs from the left-out target domain.1
We compare eight DA methods that have shown promising results in ToDSs (mostly when training individual modules) and other NLP systems. The DA methods we consider are of three types. Word-level augmentation methods replace words of the original training examples by similar words, e.g., words that have similar word embeddings or words suggested by models that predict masked words. Sentence-level augmentation includes paraphrasing sentences of the original training data via back-translation (translating to another language and back), invoking systems trained specifically to perform paraphrasing, or by prompting Large Language Models (LLM); we also include in this type methods that rotate (swap) parts of the dependency tree of the original sentence. Finally, dialog-level augmentation methods exploit dialog-specific annotations of the original training examples (e.g., dialog states), which are available in ToDS datasets.
Our contributions are: (1) We conduct a systematic comparison of DA methods in an end-to-end ToDS setting, the largest (in terms of DA methods) comparison to date in this setting. (2) We show that substantial performance gains can be obtained with DA methods, even when using pre-trained models,
1For example, the domains of MultiWOZ are: train, taxi, hotel, restaurant, hospital, police and attraction.
and we offer concrete advice to ToDS practitioners (Section 5). (3) We introduce and utilise a new few-shot cross-domain evaluation setting for DA approaches in ToDS, where we show that DA methods again boost performance.

heading: 2 Data Augmentation Methods

heading: 2.1 Word-level Augmentation
text: Word-level DA methods replace words of the original training examples by similar words, e.g., words with similar word embeddings or words suggested by models that predict masked words (Wei and Zou, 2019; Wang and Yang, 2015). We experiment with word substitutions using either Word2Vec (Mikolov et al., 2013) or RoBERTa (Liu et al., 2019). Apart from boosting performance, word-level DA can generate more synthetic instances per original one, compared to other DA types considered.

heading: 2.1.1 Word2Vec-based Word Substitution
text: We employ Google’s 300-dimensional embeddings, created using Word2Vec.2 We exclude stop-words or delexicalised tokens (special tokens replacing slot values) as candidates for DA. For every word in each dialog utterance, we find the 10 most similar ones in terms of cosine similarity of word embeddings. Preliminary testing showed that this may actually deteriorate performance, as some word replacements create dialog states and system actions inconsistent with the original ones, in agreement with Mi et al. (2021), who note that swapping certain words may change the original semantics. Instead, for every experiment, we train the ToDS with the original training data (the percentage available per experiment). For every word position, we test every candidate substitution from the pool of 10 most similar ones selecting at random, by passing the augmented sentence to that model. If the model’s prediction (in terms of dialog state and system action) is different than the original one, the augmentation is discarded and the next word replacement from the pool is considered.

heading: 2.1.2 LM-based Word Substitution
text: Masking a word and using a language model (LM) to predict the masked token is a more advanced case of word substitution, previously used in numerous cases (Pantelidou et al., 2022; Kobayashi, 2018; Mi et al., 2021). We leverage the large version of an out-of-the-box RoBERTa (Liu et al., 2019).
2Available via Gensim (Rehurek and Sojka, 2010).
The list of candidate substitutions now comprises words that the LM deemed more likely, otherwise the method remains as in Word2Vec-based substitution, including the requirement that the dialog state and system action must remain the same.

heading: 2.2 Sentence-level Augmentation
text: Sentence-level augmentation includes paraphrasing (via back-translation, with systems trained specifically to perform paraphrasing, or by prompting LLMs) and fragment rotation (which moves parts of the dependency tree). These methods cannot generate as many synthetic training instances as word-level substitution, but their synthetic utterances are semantically closer to the original ones.

heading: 2.2.1 Back-translation
text: Back-translation has been used in many NLP tasks (Kumar et al., 2019; Huang et al., 2021; Federmann et al., 2019). It translates a piece of text (an utterance in our case) to a different (pivot) language and back to the original one. We use French as the pivot language and the Google translate API.3 As explained by Ding et al. (2022), it is important to retain the original names of entities, such as attraction names and addresses. Special tokens used for delexicalisation also face the same issue. To avoid wrongly back-translating these special tokens, we apply back-translation to each utterance only after delexicalising and replacing the special tokens with special numbers (preceded by ’#’), which remain unchanged during translation. The special tokens are relexicalized after DA.

heading: 2.2.2 PEGASUS Paraphrasing
text: The utilisation of LMs for paraphrasing was beneficial in the ToDS work of Gao et al. (2020), Hou et al. (2018), and Quan and Xiong (2019). Following Sharma et al. (2022), we leverage an instance of the Transformer-based PEGASUS (Zhang et al., 2020a), fine-tuned for paraphrasing.4 We set PEGASUS to generate up to two paraphrased utterances, and randomly select one, an approach that allows us the generate multiple synthetic dialogs per training instance.5 For each synthetic utterance, we check whether the delexicalisable tokens are preserved. If not, the augmentation is not applied.
3More languages could be used to generate more data. 4huggingface.co/tuner007/PEGASUS_paraphrase 5More paraphrases can be generated, but most of them tend
to be of lower quality and may lead to wrong dialog states.

heading: 2.2.3 Fragment Rotation
text: Cropping or rotating/flipping images is a popular label preserving DA approach in Computer Vision (Krizhevsky et al., 2017; Engstrom et al., 2019). An NLP analog of rotation was proposed by Şahin and Steedman (2018) and has also been tested in a ToDS setting (Louvan and Magnini, 2020, 2021). The main idea is to rotate (swap) in the dependency tree of a sentence, fragments (such as subjects/objects) around the root (usually a verb). We leverage Stanford’s dependency parser (Qi et al., 2020) to generate annotations for MultiWOZ 2.0, consistent with the Universal Dependencies 2.1 (Nivre et al., 2020) in Şahin and Steedman’s work. We then employ their method to generate synthetic utterances.6 This may generate multiple outputs per original training instance, from which we sample uniformly. This method is a better fit for more free word-order languages, but both in Louvan and Magnini (2020) and in our experiments, it leads to substantial improvements in English too.

heading: 2.2.4 LLM Paraphrasing
text: LLMs have shown impressive results in tasks they have not encountered during training (Brown et al., 2020; Ouyang et al., 2022). Here we leverage ChatGPT, GPT-3.5-turbo specifically, and prompt it to generate augmented data via paraphrasing. We limit ourselves to two synthetic utterances to minimise the LLM’s usage cost, randomly selecting one of the two, provided it includes all of the tokens that will be delexicalised. As a prompt we use a simple instruction and no in-context learning.7

heading: 2.3 Dialog-level Augmentation
text: Dialog-level DA methods exploit dialog-specific annotations that ToD datasets include (e.g., dialog states, system actions). These methods can generate more synthetic data than sentence-level DA methods, but fewer than word-level ones. Also, the dialog-level DA methods considered here assume that dialog turns (user utterance–system response pairs) that have the same dialog state convey the same information, which is not always the case; hence, they may produce erroneous data.

heading: 2.3.1 Dialog Tree
text: The first dialog-level DA method we test was originally proposed by Aksu et al. (2022). Based on
6https://github.com/gozdesahin/ crop-rotate-augment
7More information can be found in Appendix A.
their approach, we create a tree structure containing dialogs that can be formed by combining the turns of the available training data in three steps. The first step is the creation of turn templates. Each template comprises a delexicalised turn, along with the current delexicalised dialog state (Cds) and the delexicalised dialog states of the previous (Pds) and next (Nds) turns of the dialog they originate from. If a template refers to the first dialog turn, its Pds is “Root”. If a template refers to the last turn, its Nds is “Leaf”. Let the set of templates created in the first step be T = {r, t1, ..., tn}, where r is a special root template used in the second step.
In the second step, templates are linked in a tree structure under a certain condition. A template tj can be linked with a template ti as its child node, only if ti’s Nds matches tj’s Cds and tj’s Pds matches ti’s Cds (see Fig. 7 of Appendix D for an example). All templates t that appear at the beginning of a dialog are automatically assigned as children of the special root template r. The third step is surface realisation, where delexicalised slots are filled with slot values.
As the time complexity of this method increases exponentially in the number of dialogs, we sample only 50 dialogs from the original training set in the first step. We then create the tree and generate a new synthetic dialog by starting from the root and randomly selecting a child recursively until we reach a leaf. We then repeat, sampling again 50 dialogs (with replacement) from the original training set and generating another synthetic dialog.

heading: 2.3.2 Act-Response Substitution
text: Multi-Action Data Augmentation (MADA) is another DA approach based on dialog state matching, proposed by Zhang et al. (2020b). For every turn, they identify all other turns (of the original training dialogs) that have the same delexicalised dialog state and extract the system actions associated with the identified turns. They then train their ToDS using the original and extracted system actions per turn. Normally, a ToDS would encounter a single system action in each instance and Zhang et al. (2020b) observe that some system actions are more likely to be the ground truth actions, compared to others that may be correct as well. Instead, through MADA, the model encounters a more balanced set of system actions, helping it generate diverse responses during inference. In our case, along with valid system actions, we also store the corresponding system responses per turn, following the same
principle. Then, for each dialog turn we replace the original system action and response by sampling from the set created by the process discussed.

heading: 3 Experimental Setup
text: In all experiments, we use three different randomly sampled training subsets (e.g., 3 different 10% subsets) and report averages.

heading: 3.1 Main Experiments
text: MultiWOZ: For our main experiments, we use MultiWOZ, an English human-to-human conversational dataset produced by a Wizard-of-Oz experiment, which has been used extensively in previous work (Wu et al., 2019; Heck et al., 2020; Zhao et al., 2021; Kulhánek et al., 2021; Wu et al., 2023). MultiWOZ 2.0, the most commonly used version that we also use, includes dialogs spanning 7 domains. It includes 10,438 dialogs in total, of which 1,000 are reserved for validation and another 1,000 for testing. Most dialogs fall into two or more domains making it a challenging benchmark. Of the tasks supported by MultiWOZ 2.0 (e.g., DST, intent classification, action-to-response generation) we select the response generation (RG) task, which UBAR and GALAXY can handle end-to-end.
Evaluation measures: Following Budzianowski et al. (2018), we mainly report Score values for MutiWOZ. We also present Inform, Success, and BLEU results in the appendix. Inform is the percentage of dialogs where the system provided a correct recommendation based on the user’s constraints (e.g., cheap hotel). Success is the percentage of dialogs where the system satisfied the user’s constraints (Inform = 100%) and provided all the requested information (Budzianowski et al., 2018; Nekvinda and Dušek, 2021). BLEU (Papineni et al., 2002) measures the word n-gram similarity between the system and the gold response. Finally, Score = 12(Inform + Success) + BLEU. UBAR: For the MultiWOZ experiments, we use UBAR (Yang et al., 2021), a GPT2-based ToDS (Radford et al., 2019) that remains competitive as shown in recent studies (Nekvinda and Dušek, 2021; Sun et al., 2022), and is also easier (and much less expensive) to use compared to larger LLMs. UBAR is also based on the framework used by MADA (Zhang et al., 2020b), thus facilitating experimenting with dialog-level DA methods.
MultiWOZ with all DA methods: In a first set of experiments, we reduce the size of the MultiWOZ
training set to 850 dialogs (∼10% of the training set) and produce an extra synthetic dialog from each original one, doubling (×2 ) the training set. MultiWOZ with best three DA methods: In a second set of experiments, we consider only the best three DA methods of the previous experiments, but we now consider generating one, two, or four synthetic dialogs from each original dialog (×2, ×3, ×5), using only ∼2% (170), ∼10% (850), or ∼25% (2,125) of the MultiWOZ training dialogs. Few-shot cross-domain experiments: Finally, we test the best three DA methods of the first set of experiments, now in a few-shot, cross-domain setting for the restaurant, hotel and attraction domains of MultiWOZ. As in the first set of experiments, we use 10% of the MultiWOZ training dialogs. Additionally, in three iterations, we leave one domain out of the training set apart from 20 (few-shot) dialogs, and we use only test (and validation) dialogs that include the left-out domain. We generate four synthetic dialogs for each few-shot dialog (x5) in these experiments, which was the augmentation size that worked best in the second set of experiments when there were very few training instances.

heading: 3.2 Additional Experiments
text: To ensure that our previous findings are not datasetand model-specific, we repeat them using KVRET (Eric et al., 2017) and GALAXY (He et al., 2022b).
KVRET is also an English multi-domain dataset, the domains being weather, navigation, schedule. It includes 2,424 dialogs, with 302 being reserved for validation and 304 for testing. Contrary to MultiWOZ, each dialog belongs in a single domain.
Evaluation measures: Following He et al. (2022b), for KVRET we report Score (calculated using the same formula as in MultiWOZ), with slight modifications. Match is reported, which is equivalent to the Inform of MultiWOZ. Moreover, Lei et al. (2018) argues that the original Success rate favours recall, as a dialog would be considered successful if the model responded with every possible recommendation. Hence Success F1 is used to balance precision and recall instead of Success.
GALAXY is a more recent ToDS, pretrained using UniLM (Dong et al., 2019), currently among the best ToDSs on KVRET (He et al., 2022a).
Experiments: We conduct similar experiments on KVRET as on MultiWOZ. The initial training sets (before DA) include ∼5% (120), ∼10% (250),
∼25% (600) dialogs from KVRET’s training set. We select the three best performing DA approaches on the 5% subset and conduct the same experiments using the 10% and 25% subsets, generating one, two, or four synthetic instances from each original one (x2, x3, x5). KVRET has an average dialog length of 2.5 turns, contrary to MultiWOZ’s 13.68. We exclude the two dialog-level DA methods from the KVRET experiments, since they had the worst performance in the first set of experiments on MultiWOZ. As each dialog belongs in a single domain, our cross-domain evaluation setting is also not applicable to KVRET.

heading: 4 Experimental Results and Analysis

heading: 4.1 Results of the Main Experiments
text: MultiWOZ with all DA methods: The results of the first set of experiments (all 8 DA methods, 10% of MultiWOZ’s training set, x2 expansion) are presented in Table 1. All DA methods lead to a substantial performance boost. The three highest scores are obtained with Word2Vec substitution, PEGASUS paraphrasing and fragment rotation, improving UBAR without DA (“10% training set”) by about 9 points. Surprisingly, fragment rotation is among the best DA method, even though English is not particularly free word-order (Section 2.2.3). The worst results come from the dialoglevel DA methods, presumably because matching delexicalised dialog states introduces noise (Aksu et al., 2022).
MultiWOZ with best three DA methods: The results of the second set of experiments (best 3 DA methods, 2%, 10%, 25% of original training set, expansion by x2, x3, x5) are shown in Fig. 1. For each original training set size (horizontal axis), we show the Score (vertical axis) of each DA method (curves). To save space, we show scores using the best (per DA method and training set size) expansion size (x2, x3, x5). As expected, DA methods are more beneficial when the original annotated training set is limited (e.g. 2%, 10%), with much smaller improvements when more annotated data are available (25%). Also, when the original training set is very limited (2%), x5 expansion leads to the best results, but when the original training set is larger (10%, 25%), more conservative (x3 and x2, respectively) expansion is better, presumably because it becomes more important to avoid adding multiple variants of the same original training instance. Overall, the three best DA methods lead to
very similar performance boosts, in agreement with the results of the previous experiments (Table 1). Few-shot cross-domain experiments: The results of these experiments are shown in Fig. 2. All DA methods led to substantial improvements in all three few-shot domains, increasing the Score by up to 8, 9 and 10 points for the attraction, hotel and restaurant domains, respectively. Contrary to previous experiments, here PEGASUS paraphrasing was more effective overall compared to the other two DA methods.8

heading: 4.2 Results of the Additional Experiments
text: KVRET with all DA methods: GALAXY’s results with all 6 applicable (to KVRET) DA methods, using 5% of KVRET’s training dialogs, and x2 expansion are reported in Table 2. Word2Vec substitution and fragment rotation remain among the
8More detailed results of the main and additional experiments can be found in Appendix B.
top performers, with the LLM-based paraphrasing marginally overtaking PEGASUS paraphrasing.
KVRET with best three DA methods: Figure 3 shows results obtained with the best three DA methods of the previous experiment, now using 5%, 10%, 25% of KVRET’s training set, and x2, x3, x5 expansion. Interestingly, DA (any method) manages to improve performance only when 5% of KVRET’s training set is used.9 Although KVRET is smaller than MultiWOZ (2,424 dialogs in total vs. 10,438) and one would expect DA methods to be more useful in KVRET, it is also much easier than MultiWOZ, because each dialog concerns a single domain. This is evident by the fact that GALAXY with only 25% of the KVRET training set and no DA (Fig. 3, rightmost result of the red dashed line) is almost as good as GALAXY trained on the entire KVRET training set, again with no DA (horizontal dotted line). Even with only 10% of KVRET’s training set, GALAXY with no DA (red dashed line) obtains a Score of 92.16, leaving very little scope for improvement. When using 5% of the original training set, where there is much larger scope for improvement (Fig. 3, left), all DA methods substantially improve performance, and the best DA method (fragment rotation) improves performance by approx. 9 points (Table 2). The results of Figures 1 and 3 also indicate that there is no universal threshold of initial annotated training instances, below which DA is beneficial; the threshold depends on the difficulty of the particular task (e.g., whether dialogs are single- or multi-domain). Instead, one should examine performance; when it is very low (e.g., with 2% of MultiWOZ or 5%
9This is also why we select the best three DA methods using 5% of KVRET’s training set in the previous experiment.
of KVRET), DA methods are definitely worth considering, otherwise when performance is already very high (e.g., exceeding 90 Score when using 10% or 25% of KVRET), applying DA is probably pointless. In all cases, generating more than one or two synthetic examples per original one (more than x2 or x3 expansion) is not beneficial.

heading: 4.3 Response and Error Analysis
text: In MultiWOZ dialogs the domain may change from utterance to utterance making the benchmark much more challenging, compared to KVRET. Using DA approaches have proven beneficial in terms of the overall Score, but this is not always the case with the underlying metrics Success and BLEU score that concern the generated response as seen in Figures 3 - 23. To gain a better view of the effectiveness of the DA methods tested, we present an error rate per domain category based on Success. To do so, we calculate the percentage of unsuccessful dialogs (Success = 0) per dialog category in the test set. Consider for example the case of
using 25% data of the training set for DA leveraging the Word2Vec approach. A comparison of this approach when using x2 and x5 the amount of data is depicted in Figure 4. Additional comparisons for the case of PEGASUS and fragment rotations are presented in Appendix C. In the figure, “tx”, “at”, “re”, “ho” and “tr” refer to the taxi, attraction, restaurant, hotel, and train domains respectively. Multiple domains in each category denote domain switches. It comes as no surprise that the more domain switches a dialog contains, the more errors the model makes. Using x5 the amount of training data seems to amplify this behaviour; an observation that could be attributed to the additional noise introduced mostly in terms of the synthetically generated responses. Thus, generating more than a single synthetic dialog (especially in the x5 case) may not prove as beneficial for all cases (e.g. when 25% of the MultiWOZ dialogs are available). Overall, of the three best performing methods, Word2Vec and PEGASUS seem to perform similarly, making more errors is the same dialog categories (mostly the ones including the restaurant and hotel domains). On the other hand fragment rotation straggles more mostly with dialogs involving the attraction domain. One should keep in mind that, regardless of applying DA or not, many errors made by the model are also to be blamed to the automatic evaluation as during inference the user’s utterance remains static and is always in accordance with the ground truth system response, thus potentially confusing the model.
After careful, manual examination of system responses on a small sample of the test set across all experimental cases, the responses themselves are fluent and informative. Generally, it is very difficult to deduce which DA method was used to train the model that generated the response. The small differences in scores could be justified by this conclusion, especially when comparing two methods that perform DA at the same level (e.g. the sentence-level PEGASUS and fragment rotation methods). Even when generating multiple synthetic dialogs per training instance (e.g. x5 DA level), the responses remain fluent even though some DA methods may alter the structure of the sentence (e.g. Figure 13). Using fragment rotation to generate four synthetic dialogs is an exception to the above observation, as in few cases the resulting responses may also feature rotated fragments of the respective dependency trees. An example of a dia-
log and its corresponding response per DA method is depicted in Figure 17 of Appendix D. Moreover, a comparison of the models’ outputs when generating a single and four synthetic dialogs per training instance is depicted in Figure 18.

heading: 5 Advice to ToDS Practitioners
text: Based on our experiments, we provide the following advice to ToDS practitioners. (1) Although DA methods are currently not widely used in ToDS (Section 6), they can lead to very substantial gains when annotated training examples are scarce, even when using pre-trained end-to-end models. However, data scarcity depends on the difficulty of the task (e.g., whether the dialogues are single- or multi-domain), it cannot be judged using a universal threshold of initial annotated training instances, and is best assessed using performance scores. (2) Although all DA methods considered led to substantial improvements, dialog-state DA methods (at least the ones we considered) should be the last choices, as they led to a smaller performance boost and they also require dialog-specific annotations (e.g., dialog states) that are difficult to obtain in practice. (3) Among the other DA methods consid-
ered, the best overall performers were Word2Vecbased word substitution (Section 2.1.1), rotating parts of the dependency tree (Section 2.2.3), and paraphrasing the utterances by invoking paraphrasing models or prompting LLMs (Sections 2.2.2, 2.2.4). We recommend using any of these methods, provided that the resources they require are available; e.g., rotation requires a dependency parser for the target language, prompting requires an LLM supporting the target language and adds the cost of invoking an LLM. (4) Generating more than two synthetic instances per original one is worth considering only when the original annotated training instances are very scarce (e.g., when using only 2% of MultiWOZ’s multi-domain training set).

heading: 6 Related Work
text: DA has been applied to a wide range of tasks from Computer Vision (Krizhevsky et al., 2017; Engstrom et al., 2019) to Speech Processing (Ko et al., 2015) and NLP (Kumar et al., 2019; Huang et al., 2021; Wei and Zou, 2019; Kobayashi, 2018).
For NLP specifically, Pappas et al. (2022) carried out one of the most extensive comparisons of DA methods, in the context of biomedical QA, including Word2Vec-based word replacement (but without our semantics preserving test), LM-based word replacement, and back-translation. Word2Vecbased replacement was the most effective of the three methods, with back-translation and LM-based word replacement having similar performance.
Whitehouse et al. (2023) and Sahu et al. (2022) prompt off-the-self LLMs to produce synthetic data in cross-lingual commonsense reasoning and intent classification, respectively. Mehri et al. (2022) also leverage an LLM to produce synthetic data for intent classification, slot filling, and next action prediction in a zero-shot ToDS setting, showing improvements in performance. By contrast, Hudeček and Dusek (2023) reported that relying on LLMs to directly generate belief states and system actions was not beneficial, compared to a fine-tuned model.
Zhang et al. (2020b) propose the MADA (MultiAction Data Augmentation) framework that we modified in order to include both the system actions and responses as explained in Section 2.3.2. Aksu et al. (2022) also capitalise on dialog states to produce a tree of possible dialogs (Section 2.3.1). Both of these approaches proved beneficial in our work. Similar to the approach of Aksu et al. (2022), Gritta et al. (2021) also capitalise on a graph struc-
ture, linking dialog states across all dialogs. In a similar spirit, Qiu et al. (2022) propose clustering dialog turns based on their dialog states. The extracted cluster structure forms the base for an augmentation approach similar to MADA.
Louvan and Magnini (2020, 2021), inspired by Şahin and Steedman (2018), introduce an NLP version of image cropping and rotation, based on permutations of sentence fragments (Section 2.2.3). To improve performance on out-of-scope (OOS) dialog utterances (not represented in the training set, e.g., pertaining to new domains), Chen and Yu (2021) augment their training set by mixing OOS utterances with the ones found in their training set. Yin et al. (2020) use Reinforcement Learning to find the optimal (in terms of context) text span replacements (instead of word replacements).
Paraphrasing as a form of DA was also used by Hou et al. (2018) and Gao et al. (2020) for slot-tagging (subpart of DST) and RG; they implemented their own paraphrasing model based on RNNs. Similarly, Axman et al. (2023) train a BART model (Lewis et al., 2020) for paraphrasing in an end-to-end ToD setting. Mi et al. (2021), also employ DA in a ToDS setting, by substituting masked tokens of the input using an LM (much as in Section 2.1.1). Song et al. (2021) augment their dataset by replacing slot-values with randomly generated strings to simulate references to out-ofvocabulary (OOV) words, a simple yet effective approach for models that learn to copy words from input to output by incorporating the copy-mechanism (Gu et al., 2016). Huang et al. (2022) randomly change the letter order of slot-values to improve the robustness of their ToDS. Improving robustness is also the main goal of Li et al. (2021), who generate turns with replaced slot-values not encountered in the training set.
The closest previous work is that of Quan and Xiong (2019). They experiment with four DA methods in an end-to-end ToDS setting, including stopword removal, paraphrasing, back-translation, synonym substitution (and their combination). We compare more (eight) DA methods, of three different types (word-level, sentence-level, dialoglevel), while Quan and Xiong consider fewer (four) methods of the word-level and sentence-level types only. Furthermore, we also experiment with a more challenging dataset containing dialogs that may belong (the same dialog) in multiple domains (MultiWOZ), whereas Quan and Xiong use the single-
domain Camrest676 (Wen et al., 2017), and (like us) KVRET, which covers three domains, but each dialog pertains to a single domain. Contrary to the work of Quan and Xiong, we also experiment with several sizes of initial annotated training set (e.g., 2%, 10%, 25% in MultiWOZ) and different expansions (x2, x3, x5), and we also introduce a new few-shot cross domain setting (Section 3.1).

heading: 7 Conclusions and Future Work
text: We performed the largest to date (in terms of methods and types) empirical comparison of DA methods in the context of end-to-end ToDSs, using two pre-trained Transformer ToDSs (UBAR, GALAXY) and two datasets (MultiWOZ, KVRET). We varied both the size of the initial annotated training set (e.g., 2%, 10%, 25% of MultiWOZ’s training set) and the expansion factor (generating one, two, or four synthetic instances from each original one). We also introduced a new, more challenging few-shot cross-domain evaluation setting. We showed that substantial performance gains can be obtained with DA methods, even when using pre-trained end-to-end models, and we offered concrete advice to ToDS practitioners regarding when to use DA, which DA methods to prefer, and with which expansion factors (Section 5).
In future work, we plan to explore combinations of DA methods, to check if the synthetic training instances they produce are complementary. We also plan to investigate how well DA methods perform in low-resource languages (e.g., languages for which LLMs or reliable dependency parsers may not be available). Finally, we aim to measure the costs (computational, monetary) of DA methods.

heading: 8 Limitations
text: A major limitation of our work is based on the nature of the datasets. Most of our DA methods rely on dialog annotations to ensure that they preserve the original semantics of the dialogs (Subsection 2.1.1) or to directly generate synthetic dialogs (Subsection 2.3.1). Many ToD datasets lack such detailed annotation, as is the case with the second track of DSTC 11 (Soltau et al., 2023).10 In real world scenarios such annotations are even harder to come by, even though there is a plethora of structured dialogs covering a wide range of topics. In
10The dataset can be found at https://github.com/ amazon-science/dstc11-track2-intent-induction.
such cases, DA approaches that rely on the annotations of dialogs are not guaranteed to perform as well or at all on their own, compared to the experiments presented.
Another limitation of our work is the lack of detailed tuning/finetuning, in favour of a wider range of DA methods. Taking LLM-based paraphrasing as an example (Subsection 2.2.4), although we do experiment (up to a point) with different prompts during preliminary testing, a more detailed prompt tuning may have led to better results. In the same manner, for the case of PEGASUS paraphrasing (Subsection 2.2.2) or RoBERTa-based word substitution (Subsection 2.1.2), further specialised pretraining on other similar ToD datasets could have led to improved performance as shown by Wu et al. (2020). Similarly we avoid tuning the hyperparameters (e.g., learning rate, context window etc.) of the models used (UBAR and GALAXY). After all, the purpose of our work was not to achieve SOTA performance, but to compare DA methods and show their benefits under a common task (end-to-end).
Finally, we only take into account DA methods that can be applied regardless of the ToDS used. ToDSs such as the ones proposed by Gao et al. (2020) and Zhang et al. (2020b) consider online DA methods, that were not covered in our work. We recognise the advantages of such methods but opt not to include them as they are ToDS specific (they are build around a specific ToDS). Instead we experiment with offline DA methods that are architecture-free and have proven beneficial in ToD and NLP in general.

heading: 9 Ethical considerations
text: Implementing the DA methods and training the ToDS proposed in the settings mentioned in Section 3, requires a lot of GPU processing (excluding dialog-level DA and fragment rotation). Leaving aside the cost that comes as a result of the methods’ execution, such GPU usage also has environmental impact in the form of CO2 emissions. We hope to alleviate this effect by offering advice to ToDS practitioners (Section 5) and guiding them in choosing the best fit (in terms of DA methods) for their task, in order to avoid such costly experimentation in the future.

heading: 10 Acknowledgements
text: This work was partially supported by Omilia Natural Language Solutions Ltd; the Research Center
of the Athens University of Economics and Business (AUEB-RC); and project MIS 5154714 of the National Recovery and Resilience Plan Greece 2.0, funded by the European Union under the NextGenerationEU Program. Views and opinions expressed are however those of the author(s) only and do not necessarily reflect those of the European Union or European Commission-EU. Neither the European Union nor the granting authority can be held responsible for them.

heading: A LLM prompting
text: We initially construct a simplistic template prompt, without giving any in-context example paraphrases, that has the following form : "Paraphrase the following sentence twice. Maintain as much information as possible intact. The sentence to paraphrase is : {} ". The "{}" symbol denotes the placeholder for the utterance (not delexicalised) to be paraphrased. More elaborate templates were also tested (e.g. providing the LLM with the dialog history), such as "Your job is to augment the given utterance from a dialog between a user and an assistant. You will be given the dialog history as context. The user’s utterances start with USER :, while the assistant’s utterances with ASSISTANT :. Here is the dialog up to this point : {1} . Paraphrase the following sentence twice. Maintain as much information as possible intact. The sentence to paraphrase is : {2}", where "{1}" and "{2}" denote the placeholders for the dialog history and current utterance respectively. During preliminary testing such templates did not provide a significant improvement, and as a result we opted for the more cost-efficient approach.

heading: B More Detailed Results
text: In this section we present the detailed results of all the experiments conducted, including the additional metrics that accompany each dataset. For MultiWOZ, we include the Inform and Success score along with BLEU score, as explained in Subsections 3.1. Similarly for the case of KVRET the Match, Success F1 and BLEU scores are reported. For each case, we first present the performance on the initial experiments where we select the 3 best performing DA methods followed by the results of these there methods in various other settings. From the results, we observe that the additional metrics reported tend to follow the trends of the main metric (Score), especially BLEU and Success.

heading: C Additional error comparisons
text: We follow the same procedure of Section 4.3 for the cases of PEGASUS and fragment rotation. Once again, we count the number of unsuccessful dialogs Success = 0 (i.e. the ToDS did not provide all the requested information or a valid recommendation), and divide by the number of dialogs belonging to each category, for the case where 25% of the training dialogs of MultiWOZ was used. We focus on Success as it features greater variance compared to BLEU and Inform, which generally remains unaffected. As was the case with Word2Vec, DA using PEGASUS or fragment rotation to generate more that one synthetic dialog reduces the overall Success. Interestingly there are a few instances where using multiple synthetic dialogs managed to increase the performance on specific, stand-alone domain categories such as “tx, ho, re” for PEGASUS and “at, tr” for fragment rotation, but such results may vary from case to case.

heading: D Examples of synthetic and generated dialogs
text: In this section we present an example (Fig. 7) of the template matching performed by the dialog tree DA method (Subsection 2.3.1). In this case the Cds of the first turn of pmul3825 matches the Pds of mul0665’s second turn. Similarly, pmul3825’s Nds matches mul0665’s Cds, thus setting mul0665’s turn as the continuation of pmul3825. Repeating the process until reaching a “Leaf” node (turn), creates a new synthetic dialog.
Figures 9-16 depict a single delexicalised dialog (woz20572) after applying each of the DA methods, for the case of MultiWOZ. An example of the same dialog, that UBAR is trained on, without any DA is depicted in Figure 8.
Figure 7: Two templates (from MultiWOZ dialogs pmul3825 and mul0665) are linked as they satisfy the dialog state conditions (shown in green and purple).

heading: Future Work
text: We hope to alleviate this effect by offering advice to ToDS practitioners (Section 5) and guiding them in choosing the best fit (in terms of DA methods) for their task, in order to avoid such costly experimentation in the future