A Synthetic Data Generation Framework for Grounded Dialogues
Year: 2023

Abstract:
Training grounded response generation models often requires a large collection of grounded dialogues. However, it is costly to build such dialogues. In this paper, we present a synthetic data generation framework (SynDG) for grounded dialogues. The generation process utilizes large pre-trained language models and freely available knowledge data (e.g., Wikipedia pages, persona profiles, etc.). The key idea of designing SynDG is to consider dialogue flow and coherence in the generation process. Specifically, given knowledge data, we first heuristically determine a dialogue flow, which is a series of knowledge pieces. Then, we employ T5 to incrementally turn the dialogue flow into a dialogue. To ensure coherence of both the dialogue flow and the synthetic dialogue, we design a two-level filtering strategy, at the flow-level and the utterance-level respectively. Experiments on two public benchmarks show that the synthetic grounded dialogue data produced by our framework is able to significantly boost model performance in both full training data and low-resource scenarios.

heading: 1 Introduction
text: Grounded dialogue systems are designed to engage in conversation with humans by incorporating external knowledge to provide relevant and informative responses (Ghazvininejad et al., 2018; Dinan et al., 2019; Gopalakrishnan et al., 2019; Zhou et al., 2018b). In recent years, various advanced techniques have been developed to train grounded dialogue models (Zheng et al., 2020; Cui et al., 2021; Xu et al., 2022; Li et al., 2022a). Despite the notable progress, training these models often requires large amounts of data. However, it is expensive and time-consuming to build a collection
∗ This work was partially done during the internship at Huawei Noah’s Ark Lab.
†Corresponding Author
of dialogue data that is naturally grounded on documents or knowledge (Li et al., 2020, 2022b).
One solution is to generate grounded dialogue data from unstructured knowledge, by using large pre-trained language models (LMs). Previous work on this topic has explored synthetic dialogue data generation with reinforcement learning (Lin et al., 2022) or user simulation (Wu et al., 2022). However, a key missing component in all these methods is the modeling of dialogue flow.
Dialogue flow can be viewed as the outline of a dialogue. The flow reflects the dialogue’s content and trajectory, i.e., the topics discussed in each session and the topic shifts between sessions. We consider the dialogue flow of a grounded dialogue as the sequence of the grounded knowledge pieces. Figure 1 shows an example dialogue along with
10866 Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics
Volume 1: Long Papers, pages 10866–10882 July 9-14, 2023 ©2023 Association for Computational Linguistics
its associated dialogue flow. In this example, the grounded knowledge is primarily from a Wikipedia page about “husky” dogs. This dialogue follows a smooth knowledge flow, transitioning from “husky” to “sled dogs” and then to “huskies as pets”. However, if we replace the second knowledge piece with “‘Esquimaux’ or ‘Eskimo’ was a common term for pre-Columbian Arctic inhabitants of North America.”, which is also from the same Wikipedia page, then the flow becomes less consistent. As the backbone guiding the dialogue generation process, a carefully planned dialogue flow is crucial for the coherence and smoothness of the resulting dialogue.
To this end, we propose a novel framework named SynDG, to synthetically generate coherent grounded dialogues. The generated dialogues are meant to be used as auxiliary training data. In SynDG, we first determine the dialogue flow by task-specific heuristics, from the unstructured knowledge data (e.g., Wikipedia pages, persona profiles, etc.). Then, we employ T5 (Raffel et al., 2020), a large pre-trained LM, to transform the dialogue flow into a synthetic dialogue, with sequential utterance generation, one at a time. To ensure the quality of the synthetic dialogue, we propose a two-level filtering strategy based on T5: flow-level filtering and utterance-level filtering. The flowlevel filtering is designed to select dialogue flows with higher consistency, whereas the utterancelevel filtering aims to eliminate the synthetic dialogues with poor coherence.
We conduct experiments on two grounded dialogue benchmarks, in both full training data and low-resource scenarios. We use the synthetic grounded dialogue data produced by our framework as additional training data for commonly used grounded dialogue models. Both the automatic and human evaluation results show that our synthetic data leads to significant improvement on model performance. Further analysis also reveals that model performance increases along the increase in the number of synthetic dialogues.

heading: 2 Related Work

heading: 2.1 Grounded Dialogue
text: Recent years have witnessed a growing interest in developing dialogue systems that can carry out knowledge-grounded (Zhang et al., 2018; Dinan et al., 2019; Zheng et al., 2020; Tao et al., 2021; Jang et al., 2022) or persona-grounded (Zhang et al.,
2018; Cao et al., 2022) conversation. One line of research focuses on knowledge selection (Lian et al., 2019; Kim et al., 2020; Chen et al., 2020; Meng et al., 2020; Li et al., 2022a) or knowledge retrieval (Hedayatnia et al., 2020; Shuster et al., 2021; Li et al., 2022c). The models aim to identify the appropriate knowledge for each dialogue turn. Some other work aims to generate meaningful and informative responses by incorporating the grounded knowledge (Zhou et al., 2018a; Ghazvininejad et al., 2018; Li et al., 2019; Sun et al., 2022). Some recent studies have also explored retrieval-free approaches for end-to-end knowledge-grounded dialogues (Cui et al., 2021; Xu et al., 2022), with the goal of learning knowledge through the parameters of pre-trained LMs.
In particular, obtaining high-quality dialogue data that is naturally grounded on certain knowledge is known to be difficult (Zhao et al., 2020; Li et al., 2020). Zhao et al. (2020) and Liu et al. (2021) explore to train knowledge-grounded dialogue models in a low-resource scenario, where only limited knowledge-grounded dialogues are available. Li et al. (2020) and Tao et al. (2021) investigate the task of knowledge-grounded dialogue generation, in a zero-resource scenario, by using only independent knowledge resources and dialogues without knowledge grounding as training data. However, all aforementioned low-resource approaches rely on large-scale dialogue data and knowledge data for training. In this work, we explore an alternative solution to deal with the lowresource challenge, i.e., synthetic grounded dialogue data generation from unstructured knowledge. The synthetic data can then serve as extra training data for grounded dialogue models.

heading: 2.2 Synthetic Dialogue Data Generation
text: With the superior development of pre-trained models (Devlin et al., 2019; Brown et al., 2020; Bommasani et al., 2021), many researchers have started to exploit the generation of synthetic dialogue data for training better dialogue models (Zheng et al., 2022; Dai et al., 2022; Mehri et al., 2022).
Mohapatra et al. (2021) and Wu et al. (2022) both employ two pre-trained models, as a user bot and an agent bot respectively, to simulate the interaction between two human annotators. Zheng et al. (2022) use template prompts to guide GPTJ, a large-scale pre-trained LM with 6B parameters, to generate emotional support conversations.
Dai et al. (2022) propose to transform a document into a dialogue between the writer and the reader, in which they sequentially treat each sentence in the document as the writer’s utterance and generate the reader’s questions by pre-trained models. Closely related to our work, Lin et al. (2022) explore using the reinforcement learning-based generative conversational networks (Papangelis et al., 2021) to generate synthetic conversational data for knowledge-grounded dialogue models.
Yet, all the reviewed solutions above are dedicated to directly generating synthetic dialogues. The significance of explicitly simulating or modeling dialogue flows is overlooked, which is closely related to the quality of the synthetic dialogue. In this work, we explicitly construct a dialogue flow before turning it into a synthetic dialogue.

heading: 3 Task Formulation
text: Given a set of training grounded dialogues Dt = {Cti ,Kti , rti}Nti=1, where Cti is the dialogue context that is a concatenation of previous utterances, Kti = [k t 1, k t 2, . . . , kntk
] is the knowledge corpus containing several knowledge pieces, rti is the
knowledgeable response, the grounded dialogue generation task aims to learn a generation model P (rt|Ct,Kt) from Dt. In the following, we omit the subscript i for simplicity. Note that only certain knowledge pieces in Kt are associated to the response rt, while others are redundant. Besides, we use U t = [ut1, u t 2, . . . ] to denote all the utterances in a dialogue.
In this paper, we aim to automatically construct a set of synthetic grounded dialogues Ds = {Csi ,Ksi , rsi }Nsi=1 without any human annotation. Then, the generation model P could be better learned form {Dt ∪ Ds}.

heading: 4 Methodology
text: Our framework, named SynDG, is illustrated in Figure 2. SynDG first explicitly constructs a dialogue flow by task-specific heuristics, then realizes it into a synthetic dialogue with pre-trained models. Further, a two-level filtering strategy is proposed to ensure the quality of synthetic dialogues.

heading: 4.1 Dialogue Flow Construction
text: Formally, a dialogue flow is defined as a sequence of knowledge pieces F = [f1, f2, . . . , fnf ], where nf is the length of F , fi could be a single knowledge piece in Kt, a concatenation of several knowledge pieces, or a special token “[none]” indicating no knowledge. We let each fi correspond to an utterance, so that nf also denotes the number of utterances throughout a dialogue. Here, similar to most two-party dialogue benchmarks (Zhang et al., 2018; Dinan et al., 2019; Rashkin et al., 2019), we assume that the two participants take turns speaking, that is, [f1, f3, f5, . . . ] are from one speaker, while [f2, f4, f6, . . . ] are from another speaker.
From each training dialogue in Dt, we can easily obtain a training dialogue flow F t = [f t1, f t 2, . . . , f t nf ], because the knowledge pieces corresponding to each utterance are available. Following the dialogue flow patterns of the training set, we construct our synthetic dialogue flows, F s = [f s1 , f s 2 , . . . , f s nf ], by task-specific heuristics. In this work, we apply our framework to a persona-grounded dialogue benchmark, PersonaChat (Zhang et al., 2018), and an open-domain knowledge-grounded dialogue benchmark, Wizard of Wikipedia (WoW) (Dinan et al., 2019). For PersonaChat, we first randomly sample the persona sentences of the user and agent from the training set as the knowledge corpus Ks. Each persona sentence is viewed as a knowledge piece. Then, according to heuristic constraints, we sample zero, one, or more persona sentences from the knowledge corpus for each turn, thus forming a dialogue flow. For Wizard of Wikipedia, similar to Li et al. (2022a), we use the chosen topic passage and the retrieved passages in the first turn as the knowledge corpus Ks. Then, for each turn of a synthetic dialogue, at most one knowledge piece is sampled from Ks with heuristic constraints.
The heuristic constraints are defined based on our observation and summary of the dialogue flow patterns from the training set of PersonaChat/WoW. Although this heuristic sampling-based dialogue flow construction method is not universally applicable, it can be migrated to other grounded dialogue datasets with minor modifications. We describe in detail the aforementioned heuristic constraints and the specific process of constructing the dialogue flow in Appendix A. We also provide some suggestions for designing heuristic strategies on other datasets in Appendix A.3.

heading: 4.2 Dialogue Content Realization
text: After obtaining the synthetic dialogue flows, we train a dialogue content realization model to realize every piece of knowledge in a flow as an utterance, step by step. In this way, a synthetic dialogue flow is progressively transformed into a synthetic dialogue.
We fine-tune a pre-trained sequence-to-sequence model, T5, by a dialogue reconstruction task as our dialogue content realization model. The fine-tuning data is constructed from Dt. During fine-tuning, each utterance within a dialogue U t is considered as the target sequence, while its previous dialogue history and subsequent flows are combined as the source sequence. To be specific, for the i-th utterance uti, the target sequence is itself, and the source sequence is:
(ut1, u t 2, . . . , u t i−1, [t], f t i , [/t], f t i+1, . . . , f t i+m)
(1) where utj denotes the utterance in the dialogue history, [t] and [/t] indicate the target utterance to be generated should be mainly grounded to f ti , m is the number of subsequent knowledge pieces retained from its dialogue flow F t. By appending the subsequent knowledge pieces, the model can take into account the future of the dialogue (i.e., what will be talked about next). Thus, it can generate the i-th utterance more appropriately, making the final synthetic dialogue more coherent.
In practice, we prepend each utj and f t i with a special token “[user]” or “[agent]” to distinguish two speakers. The standard negative log-likelihood loss is used to optimize this model.
After fine-tuning T5, we leverage it to incrementally turn the previously constructed dialogue flow F s = [fs1 , f s 2 , . . . , f s nf ] into a synthetic dialogue U s = [us1, u s 2, . . . , u s nf ]. Further, by treating each agent utterance us,aj ∈ [us2, us4, . . . ] as a response rs, we can obtain a set of synthetic grounded dialogues Ds = {Csi ,Ksi , rsi }Nsi=1, where Ksi is the knowledge corpus used during dialogue flow construction.

heading: 4.3 Two-level Filtering
text: To further improve the quality of the synthetic grounded dialogues, we design a two-level filtering strategy. It scores synthetic dialogues both at the flow-level and at the utterance-level to drop the low-quality dialogues. More precisely, inspired by Ke et al. (2022), we train two models based on T5
by a text infilling task to score the dialogue flow F s and the synthetic dialogue U s, respectively.
The training data is also constructed from Dt. At the utterance-level, we first mask each utterance in a dialogue U t in turn, then fine-tune a T5 model as our utterance-level scorer Pu to predict the masked utterance. Formally, for the i-th utterance uti in U
t, we mask it to obtain the source sequence U tm(i):
(ut1, . . . , u t i−1, [mask], ui+1t , . . . , u t nf ) (2)
Accordingly, the target sequence to predict is uti. This model is also optimized by the negative loglikelihood loss.
During inference, the utterance-level score of uti can be computed via the log probability:
su(u t i) = logPu ( uti|U tm(i) )
=
|uti|∑
j=1
P ( uti,j |U tm(i), uti,<j ) (3)
In this way, for each synthetic dialogue U s, we can obtain nf scores by masking each utterance. We take the average of these scores as the overall utterance-score Su.
Similarly, we fine-tune another T5 model as our flow-level scorer Pf by replacing U t with F t as the training data. We apply this model on our constructed dialogue flow F s to get the overall flowlevel score Sf . Lastly, we sum up Su and Sf as the final quality score S of a synthetic dialogue.

heading: 5 Experimental Setups

heading: 5.1 Datasets
text: We conduct experiments on two publicly available and widely used grounded dialogue benchmarks: Wizard of Wikipedia (WoW) (Dinan et al., 2019) and PersonaChat (Zhang et al., 2018).
The Wizard of Wikipedia benchmark (Dinan et al., 2019) is a collection of multi-turn knowledgegrounded dialogues between two speakers. One speaker (the “wizard”) has access to a collection of knowledge and the other (the “apprentice”) tries to learn about a specific topic. WoW is collected by crowd-sourcing and is divided into a training set, a validation set, and a test set. The validation/test set is further divided into two subsets: Validation/Test Seen and Validation/Test Unseen. Test Unseen contains dialogues about topics that are not present in the training or validation set, while Test Seen does not guarantee this.
The PersonaChat benchmark (Zhang et al., 2018) consists of dialogues between pairs of crowdworkers. Each crowdworker is assigned certain sentences defining his/her personality, and is asked to engage in a conversation with others according to the assigned personality.

heading: 5.2 Baselines
text: For WoW, we use baselines based on BlenderBot (Roller et al., 2021), since it is commonly used in recent work (Lin et al., 2022; Cui et al., 2021). For PersonaChat, we adopt the GPT2-based (Radford et al., 2019) baselines in order to compare with the recent work, Cao et al. (2022).

heading: 5.2.1 WoW Dataset
text: For WoW, we conduct experiments under two settings, i.e., grounded knowledge available (KA) and grounded knowledge unavailable (KU) settings. The former generates responses given the groundtruth knowledge, while the latter requires knowledge selection first. BB For both settings, we choose BlenderBot (BB) as our response generation model, and concatenate the dialogue context with the groundtruth/predicted knowledge as input. For the knowledge selection model under the KU setting, we finetune RoBERTa (Liu et al., 2019) for binary classification to rank and predict the grounded knowledge piece. The input is the concatenation of the dialogue context and each candidate knowledge piece. BB-SynDG We use the synthetic dialogue produced by our SynDG framework as extra training data for BB training.

heading: 5.2.2 PersonaChat Dataset
text: GPT2 We fine-tune GPT2 by concatenating the personas and the dialogue history as the input sequence. GPT2-BT Cao et al. (2022) augment the training dialogue data by back translation, and then finetune GPT2 with both the augmented and the original data. GPT2-D3 D3 (Cao et al., 2022) is a data augmentation method designed for PersonaChat, which incorporates multiple techniques and models, such as BERT, GPT2, back translation, etc. GPT2-SynDG We replace the augmented dialogues in GPT2-D3 with our synthetic dialogues.
Based on the models boosted by our SynDG framework (BB-SynDG and GPT2-SynDG), we
further conduct ablation studies by removing flowlevel filtering (w/o FF), utterance-level filtering (w/o UF), or both (w/o FF&UF). Besides, we also report the results using random sampling (BB-RS and GPT2-RS) instead of heuristic sampling when determining the dialogue flow for comparison.
Further, we demonstrate SynDG’s capability in low-resource scenarios by using only 1/16 and 1/32 of the original training data.1

heading: 5.3 Evaluation Metrics
text: Automatic Evaluation. For the automatic evaluation, we adopt the widely used BLEU-4 (B-4) (Papineni et al., 2002), ROUGE-L (R-L) (Lin, 2004), and perplexity (PPL). Besides, for WoW, we follow Li et al. (2022c) to use F1 score to measure the unigram overlap between the generated response and the ground-truth response (F1), and the unigram overlap between the generated response and the ground-truth knowledge (KF1). Also, the knowledge selection performance under the KU setting is measured by the accuracy (ACC).
Human Evaluation. For a more comprehensive analysis, we conduct a human evaluation containing two aspects. (1) Human likeness: It measures the fluency, coherence, and engagement of the response, i.e., whether it resembles a human response. (2) Informativeness: For WoW, it indicates whether a response contains appropriate, correct, and factual knowledge information. For PersonaChat, it measures whether a response is consistent with at least one persona sentence. We respectively sample 100 responses from the test set of WoW (Seen/Unseen) and PersonaChat. We adopt pair-wise comparison to conduct human evaluation, where we compare models before and after using our synthetic dialogue data. For each pair of responses generated from two models, 3 annotators are assigned to give their preferences (win, lose, or tie) in terms of the two aspects.

heading: 5.4 Implementation Details
text: Settings for Generating Synthetic Dialogue. The dialogue content realization model, the flowlevel scorer, and the utterance-level scorer are all fine-tuned from T5-Large.2 The AdamW optimizer (Kingma and Ba, 2015) is employed for parameter optimization with a learning rate of 1e-4. We
1We also show the results using 1/4 and 1/8 training data in Appendix D.
2Using T5-Base also brings noticeable improvements, as shown in Appendix E.
train our model 3 epochs with a batch size of 8 and select the best checkpoint according to the loss on the validation set. The number of subsequent knowledge pieces m described in Equation 1 is set to 2 for WoW and 1 for PersonaChat.3 Our models are implemented in PyTorch (Paszke et al., 2019) and trained on a NVIDIA Tesla V100 GPU.4 For decoding at inference, we use a top-k sampling scheme with k = 70 and a temperature of 0.7.
The training data for the utterance-level scorer can be directly obtained from the training set of WoW/PersonaChat. Nevertheless, training the dialogue content realization model and the flow-level scorer needs the ground-truth dialogue flow data. Here, we can directly derive the dialogue flow from the training set of WoW since each utterance corresponds to one or zero knowledge piece in WoW. Unfortunately, the explicit correspondence between persona sentences and utterances is not given in PersonaChat, so we use the same method as in Cao et al. (2022) to predict the correspondence by a RoBERTa-based model first.
Settings for Baselines. On WoW, the response generation model and the knowledge selection model are respectively fine-tuned from BlenderBotsmall and RoBERTa-base. The hyper-parameters for training the response generation model are consistent with Cui et al. (2021). The knowledge selection model is trained by AdamW (lr = 2e-5) with 3 epochs and a batch size of 128, and the negative sampling strategy is used with 4 negative samples during training. We generate 36,860 synthetic dialogues and select 18,430 of them as extra training data, equal to the number of dialogues in the original WoW training set. On PersonaChat, we use the code released by Cao et al. (2022) to implement all baselines with the same hyper-parameters.5 The number of synthetic dialogues we include is 6,600 (selected from 10k synthetic dialogues by the twolevel filtering), yielding 52,800 training samples, which is less than the number of augmented samples in Cao et al. (2022).

heading: 6 Results and Analysis

heading: 6.1 Automatic Evaluation
text: WoW Table 1 shows the automatic evaluation results on WoW Test Seen and Test Unseen sets. In
3We discuss the impact of m in Appendix C. 4Code is available at https://github.com/HITSZ-HLT/
SynDG. 5https://github.com/caoyu-noob/D3
the full training data scenario, BB-SynDG under the KA setting achieves significantly better BLEU4, ROUGE-L, F-1, and KF-1 scores than BB on both seen and unseen topics, demonstrating the usefulness of our generated synthetic dialogues. Under the KU setting, our BB-SynDG can improve the performance on both the response generation task and the knowledge selection task on top of BB. These observations suggest that the synthetic dialogues generated by our proposed framework not only help the model to generate better responses, but also enhance its ability to ground knowledge. Also, we can observe that both the flow-level filtering and the utterance-level filtering contribute noticeable improvement on BB-SynDG under the KA/KU setting. Concretely, either removing the flow-level filtering (w/o FF) or the utterance-level filtering (w/o UF) causes some performance degradation, and removing both of them (w/o FF&UF) results in further decreases. By comparing (BBSynDG w/o FF&UF) with BB-RS, we find that random sampling to obtain dialogue flow is less effective and even harms the performance (BBRS on WoW Seen under the KU setting), while our proposed heuristic sampling method works better. Also, adding two-level filtering to BB-RS also achieves a considerable performance improvement, again demonstrating the usefulness of the two-level
filtering strategy. In the low resource scenario, more significant performance improvements can be observed. Surprisingly, under the KA setting, BB-SynDG with only 1/16 of the training data can already achieve comparable performance to BB with full training data, indicating that SynDG can mitigate the low resource problem in grounded dialogues.
PersonaChat Table 2 shows the automatic evaluation results on PersonaChat. In the full training data scenario, compared to GPT2, adding our synthetic dialogues (GPT2-SynDG) significantly improves the performance. Although GPT2-D3 includes more augmented training data generated through sophisticated techniques, GPT2-SynDG still outperforms it. In general, GPT2-SynDG performs better than GPT2-BT, GPT2-CVAE, and GPT2-D3, showing that our framework for generating synthetic dialogues is superior to existing data augmentation techniques on PersonaChat. In addition, the ablation experiments (w/o FF, w/o UF, w/o FF&UF, and GPT2-RS) demonstrate similar results to those on WoW, that is, our proposed heuristic sampling and two-level filtering strategy are essential for generating high-quality and useful synthetic dialogues. Also, incorporating the SynDG framework can improve the model results more significantly in the low-resource scenario.
It is worth noting that introducing synthetic dialogues on WoW makes the PPL score decrease, while it improves on PersonaChat. We hypothesize that the reason may be that the dialogues in WoW involve more complicated knowledge and more diverse utterance than dialogues in PersonaChat.
As a result, on WoW, the quality of synthetic dialogues automatically generated by the large LM has a larger gap with the human-written dialogues.

heading: 6.2 Human Evaluation
text: Human evaluation results are shown in Table 3. The results indicate that the introduction of SynDG brings the base model (BB and GPT2) a significant improvement in generating more natural and knowledgeable responses. On WoW, the advantage of SynDG under the KA setting is more evident than under the KU setting, which follows the results of the automatic metrics.

heading: 6.3 Impact of the Number of Synthetic Dialogues
text: With SynDG, we can automatically generate numerous synthetic dialogues. However, how many synthetic dialogues are appropriate to integrate as extra training samples? To answer this question, we show the model performance on WoW with respect to different numbers of synthetic dialogues in Figure 3.
From Figures 3(a) and 3(b), we can observe that the BLEU-4 and ROUGE-L scores tend to increase as the number of synthetic dialogues grows, showing the potential of our proposed SynDG framework. However, through Figure 3(c), we found that the KF-1 score tends to be stable after a rapid increase. We speculate that this may be due to that the scale of the LM we used limits the upper bound of the quality of the synthesized dialogues. We can also find that increasing the amount of synthetic data may not improve performance indefinitely. The improvement becomes less obvious
when the amount of synthetic data reaches twice the amount of the original data. The results of F1 and PPL scores are not shown. This is because the trend of F1 score is similar to that of BLUE-4 and ROUGE-L scores, while the variation of PPL score is not significant.

heading: 7 Conclusion
text: In this paper, we propose a framework, SynDG, to automatically construct synthetic training data for the grounded dialogue task. We first construct dialogue flows based on unstructured knowledge, then transform them into synthetic dialogues by large LMs, and finally filter and retain the generated dialogues with high quality. The experimental results demonstrate the effectiveness of our proposed framework in both full training data and lowresource scenarios. Further analysis shows that the model performance tends to increase as the number of synthetic dialogues increases. For future work, we plan to investigate more efficient strategies for determining dialogue flows and take larger LMs to produce synthetic dialogues with higher quality.
Limitations
As discussed in Appendix B, there is still a gap between the synthetic dialogues and the humanwritten dialogues in terms of quality. The synthetic dialogues sometimes do not express knowledge with sufficient accuracy. Also, some of the synthetic dialogues are less coherent and diverse than the human-written ones. We believe that these issues can be mitigated in two aspects. First, similar to (Zheng et al., 2022), employing larger LMs can help generate utterances with higher quality. Second, introducing knowledge graph and textual reasoning techniques to produce better dialogue flows.
In addition, using large LMs inevitably requires more computational resources. However, it is still a cheaper and promising alternative to hiring expensive labor.
Ethics Statement
The paper focuses on generating synthetic dialogues for training grounded dialogue systems. Our framework is developed based on the commonly used large pre-trained LM, T5 (Raffel et al., 2020). It is trained on large scale web data that is known to contain biased or discriminatory content. However, how to remove bias from large LMs is still
a hard research problem so far. The datasets we use are publicly available and contain no personal identifiable information.

heading: Acknowledgements
text: This work was partially supported by the National Natural Science Foundation of China (62006062, 62176076), Natural Science Foundation of GuangDong 2023A1515012922, the Shenzhen Foundational Research Funding (JCYJ20220818102415032), the Major Key Project of PCL2021A06, Guangdong Provincial Key Laboratory of Novel Security Intelligence Technologies 2022B1212010005.

heading: A Details of Dialogue Flow Construction
text: We sample the dialogue flows according to several heuristic constraints, which are based on our observation and summary of the patterns of the dialogue flows from the training set of PersonaChat/WoW. The patterns we identified in PersonaChat/WoW are obvious and do not require much manual effort. So we think our task-specific heuristics are cheaper compared to manual data annotation. Also, this heuristic sampling-based dialogue flow construction method can be migrated to other grounded dialogue datasets with minor task-specific modifications. As a simple example, given an article, when determining the knowledge pieces corresponding to the first utterance, we can sample the first sentence of the article with a high probability. Afterwards, the remaining sentences of the article can be sampled evenly to obtain the subsequent knowledge pieces. The reason is that the beginning of an article usually expresses the main idea of the whole article and is more suitable for starting a conversation.
A.1 PersonaChat
First, all the persona sentences in the training set are collected as a candidate persona pool. Second, we randomly sample 10 persona sentences from the candidate persona pool, then divide them equally into two groups as the user and agent’s persona profiles, i.e., Ku and Ka. We can also regard Ku and Ka as the knowledge corpus Ks described in Section 3. Finally, based on Ku and Ka, we sample nf = 16 persona sentences to form the dialogue flow F s = [fs1 , f s 2 , ...f s nf ] according to the following constraints:
• [f1, f3, f5, ...] are sampled from Ku, while [f2, f4, f6, ...] are sampled from Ka.
• When sampling fi, there is a 0.5 probability that it is uniformly sampled from Ku/Ka. Otherwise, we set fi to “[none]”, indicating that the utterance in this turn does not need to be grounded to certain persona sentences.
• If fi is not “[none]”, there is a 0.1 probability that it contains two uniformly sampled persona sentences. Otherwise, it contains only one.
• Each persona sentence in Ku and Ka can only be sampled at most twice.
A.2 WoW
We sample dialogue flows based on the training instances in WoW. Each training instance in WoW can sample out multiple different dialogue flows.
Specifically, for each training instance, we use its chosen topic passage Kt and the retrieved passages in its first turn Kr as the knowledge corpus Ks. Usually, a dialogue in WoW mainly focuses on its chosen topic, and occasionally mentions other related topics of the retrieved passages. Thus, the knowledge pieces in its dialogue flow are mainly from Kt, and only a few of them are from Kr.
Based on the above observation, we sample nf = 10 knowledge pieces from Kt and Kr to obtain the dialogue flow F s = [fs1 , f s 2 , ...f s nf ] according to the following constraints:
• [f1, f3, f5, ...] are all “[none]”, while only [f2, f4, f6, ...] are sampled from Kt/Kr. This is because only the wizard’s utterances are grounded to knowledge.
• If fi is not “[none]”, there is a 0.9 probability that it should be sampled form Kt. Otherwise, it will be uniformly sampled form Kr.
• When sampling fi from Kt, there is a 0.9 probability that it is the first knowledge piece. Otherwise, it will be uniformly sampled from the rest of the knowledge pieces. The reason behind is that the first knowledge piece in Kt is usually the central topic sentence of a passage and is therefore more likely to be discussed in a dialogue.
• Each knowledge piece in Kt and Kr can only be sampled at most once.
A.3 Other Datasets
Different datasets may exhibit different dialogue flow patterns. Therefore, it is reasonable to summarize them manually. For other datasets, we suggest the following steps to design the dialogue flow:
• Calculate the distribution d1 of the number of knowledge pieces corresponding to each utterance.
• Calculate the distribution d2 of sources of knowledge pieces. For example, in WoW, the majority of knowledge pieces come from "chosen-topic-passages".
• Design a heuristic sampling strategy based on the results above. Specifically, when determining the knowledge pieces corresponding to each utterance, we need to first sample how many knowledge pieces are needed based on d1, and then sample the specific knowledge pieces based on d2.

heading: B Case Study
text: In Table 6, we show a synthetic dialogue generated by our framework for WoW. The dialogue flow suggests smooth topic shifts within this synthetic dialogue, from the look of narcissus to their genus and then to their history. Regarding the utterance generated by the LM, they are grounded to the corresponding knowledge and are not simply copied. Overall, this synthetic dialogue is fluent, smooth and coherent. Nevertheless, there is still a gap between it and the human-generated dialogues. For example, in the last turn of the synthetic dialogue, the “adjacent areas of southwest Europe” is missed, which indicates that the knowledge is not expressed accurately enough.
C Impact of m
As described in Section 4.2, m is the number of subsequent knowledge pieces retained from F s when generating each utterance. The value of m determines how much of the future dialogue information the dialogue content realization model can see. In Table 4 and Table 5, we explore the impact of m on the performance of the downstream
model. Note that, we choose m ∈ {0, 2, 4, 6} for WoW, since only the utterances of “wizard” have grounded knowledge piece.
From the results, we can see that if the dialogue content realization model does not see any future information (m = 0), then the downstream model has poor performance. When m > 0, the impact of m on the downstream model is not significant. Considering the computational efficiency, we set m = 2 on WoW and m = 1 on PersonaChat.

heading: D More Results in the Low-resource Scenarios
text: The results of using 1/4 and 1/8 of the original training data are shown in Tables 7 and 9. Our SynDG consistently achieves performance improvements.

heading: E Results with T5-Base
text: The results of using T5-Base instead of T5-Large are shown in Tables 8 and 10. Using T5-Base can also achieve noticeable performance gains.
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: Ethics Statement

heading: 3 A3. Do the abstract and introduction summarize the paper’s main claims?
text: Abstract and Section 1

heading: 3 A4. Have you used AI writing assistants when working on this paper?
text: Grammarly is used to check the grammar.
B 3 Did you use or create scientific artifacts?

heading: 5.1, 5.4

heading: 3 B1. Did you cite the creators of artifacts you used?
text: 5.1, 5.4
7 B2. Did you discuss the license or terms for use and / or distribution of any artifacts? We follow the the license or terms of the used artifacts.

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)? 5.1, 5.4
7 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? The data is safe and are commonly used by many previous efforts.

heading: 3 B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and
text: linguistic phenomena, demographic groups represented, etc.? 5.1
7 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. These are consistent with previous work.
C 3 Did you run computational experiments? 5

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? 5.4
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? 5.4
7 C3. Did you report descriptive statistics about your results (e.g., error bars around results, summary statistics from sets of experiments), and is it transparent whether you are reporting the max, mean, etc. or just a single run? We use a single run because of the high computational overhead of the model. Also, we observe stable performance.

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.)? 5.4
D 3 Did you use human annotators (e.g., crowdworkers) or research with human participants? 5.3
7 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.? Our annotation is simple and does not use visualization tools. The principles of annotation are given in Section 5.3.
7 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)? Our annotations are few and simple. Three authors of this paper performed the annotation.
7 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? The annotators are the authors of this paper. We all agree to the use of these data.
7 D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? Our annotation does not include any ethic issues.
7 D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? We have only 3 annotators, all of whom are the authors of this paper.

heading: Future Work
text: The value of m determines how much of the future dialogue information the dialogue content realization model can see. In Table 4 and Table 5, we explore the impact of m on the performance of the downstream
model. Note that, we choose m ∈ {0, 2, 4, 6} for WoW, since only the utterances of “wizard” have grounded knowledge piece. From the results, we can see that if the dialogue content realization model does not see any future information (m = 0), then the downstream model has poor performance. When m > 0, the impact of m on the downstream model is not significant. Considering the computational efficiency, we set m = 2 on WoW and m = 1 on PersonaChat