MTGP: Multi-turn Target-oriented Dialogue Guided by Generative Global Path with Flexible Turns
Year: 2023

Abstract:
Target-oriented dialogue guides the dialogue to a target quickly and smoothly. The latest approaches focus on global planning, which plans toward the target before the conversation instead of adopting a greedy strategy during the conversation. However, the global plan in existing works is fixed to certain turns by generating paths with certain nodes, which limits the optimization of turns and coherence of the target-oriented process. Toward flexible global planning, we propose to generate a global path as a natural language sentence instead of a sequence of nodes. With this path, the dialog is guided to the target with flexible turns of dialog. For model training, we also extract targetoriented dialogues from the chit-chat corpus with a knowledge graph. We conduct experiments on three datasets and simulate scenarios with and without user participation. The results show that our method has fewer turns, more coherent semantics, and a higher success rate in reaching the target than baselines.1

heading: 1 Introduction
text: Open-domain dialogue agents generate responses using large pre-trained language models and have a fluent multi-turn dialogue with users. It focuses on chit-chat, mostly responding passively to users. More often, we prefer the agent to guide the transition of a topic during dialogue proactively. Targetoriented dialogue is based on open-domain dialogue, which can actively guide the dialogue while communicating with the user fluently. It has many application scenarios, e.g., psychological counseling, dialogue recommendation, and education.
In target-oriented dialogue, we hope the dialogue agent can proactively guide the conversation to a goal with coherent semantics and fewer turns. The definition of the goal can be various. For example, Sevegnani et al. (2021) set the goal as a sentence,
∗*Corresponding author. 1Code chttps://github.com/sxnohnarla/MTGP
and Tang et al. (2019) set the goal as a specific keyword. Following the definition of Tang et al. (2019) to the task, we set the goal as a concept word. The task succeeds when a user or agent mentions the target word naturally during the dialogue.
Previous approaches simplify target-oriented dialogue tasks, and they predict the next-turn keywords based on the dialogue history. Moreover, it’s essential to model logical context. Therefore, many works combine predicting keywords with the common knowledge graph (Qin et al., 2020; Zhong et al., 2021; Zhou et al., 2022) and then generate the next-turn response by retrieval or generation. Current research concentrates more on global planning for a global target. Gupta et al. (2022) first generates a global path connecting the source and target words. Then, guided by this global path, they generate a more coherent one-turn dialogue by generating bridging utterances. Yang et al. (2022) plans a global dialogue path based on the knowledge graph and adjusts the model to adapt to the global goal through reinforcement learning.
Although the existing target-oriented dialogue methods have shown promising results in success rate and coherence, there are some issues to be solved. The traditional target-oriented dialogue models only consider the dialogue context in predicting the next-turn keywords and do not explicitly plan a global path for the global target. However, Kishinami et al. (2022) describes the targetoriented dialogue task, and their experiments show that global planning is an effective method for target-oriented dialogue. To introduce global planning to target-oriented dialogue, some existing global planning methods such as (Yang et al., 2022; Gupta et al., 2022). Yang et al. (2022) use a static knowledge graph to retrieve a global path. However, a static knowledge graph is still insufficient to track the logic path in target-oriented dialogue. We know that human conversation is complex, some transitions between concept words are plausible in
259
human dialogue, but they are not connected in the graph. Gupta et al. (2022) and Wang et al. (2020a) use a generative model to generate paths between two source and target words. This method combines the characteristics of pre-trained language models and can generate paths that are more relevant to a given source and target words. It is not only simple retrieval but the ability to summarize facts in a knowledge graph and connect relations that may not exist in the graph. However, Gupta et al. (2022) focuses on generating bridging sentences which means only one-turn dialogue is performed. And current research on global targetoriented dialogue can only generate fixed dialogue turns according to the global path.
To address these issues, we propose Multi-turn Target-oriented Dialogue Guided By Generative Global Path(MTGP) which generates a global path using generative model, and guide multi-turn dialogue through the path. We first generate a global path as a natural language sentence, which connects the concepts in the source context and global target. Then we train a response generator on the sampled dialogue corpus. Finally, we use the generated path to guide dialogue generation. In particular, we do not strictly limit the turns to achieve the target and complete the dialogue within six turns, so our model will generate multi-turn conversation with uncertain turns. Furthermore, we propose an atomic processing method of dialogue corpus for the multi-turn target-oriented task.
Due to the lack of suitable multi-turn targetoriented dialogue datasets, we must achieve data requirements through automatic processing. The existing chit-chat corpus can’t be directly used as training data for our task because the target is not explicitly set, and transition words in the dialogue are not labeled. But we can extract a corpus that meets the target-oriented task. Specifically, we match the dialogue corpus with the knowledge graph ConceptNet (Speer et al., 2016) and only extract the dialogue corpus that can find a clear turning path in the graph. Besides, the endpoint of the path is set to a target word. These data will be used as the training data of the dialogue generation model. The purpose is to learn the turning in the real dialogue. At the same time, the model can also ensure that the concept words in the path will also appear in the generated responses. We extract multi-turn dialogue corpus from two large-scale chit-chat datasets, DailyDialog (Li et al., 2017),
and ConvAI2 (Dinan et al., 2019). After generating an explicit commonsense path from source to target in the final dialogue generation stage, we follow this path for multi-turn dialogue. In this way, we learn from real human dialogue corpus and follow word transitions to achieve a smooth transition. The path generated by the pretrained language model within a limited number of hops also ensures that our multi-turn dialogue can reach the target faster. Our method performs well within existing baselines in both success rate and coherence. In addition, according to TGCP (Kishinami et al., 2022), we also try to generate multi-turn dialogue without users. Meanwhile, we have some experiments on one-turn dialogues using OTTers (Sevegnani et al., 2021).
We summarize our contributions as follows: (1) For target-oriented dialogue, given the context and target word, we generate a global path to guide the response generation and conduct multiturn dialogue with an uncertain number of turns.
(2) Based on ConceptNet, we propose a method to extract dialogue corpus with corresponding paths on the graph from the existing chit-chat corpus. This path guides the dialogue.
(3) We conduct experiments on the sampled corpus and simulate scenarios with and without the user. The results show that MTGP exceeds baselines and has fewer turns, more coherent semantics, and a higher success rate in reaching the target.

heading: 2 Related Work
text: Target-oriented dialogue systems. Current studies on target-oriented dialogue concentrate on global planning for response generation (Gupta et al., 2022; Yang et al., 2022). First, a global target should be set, then global planning for this global target, and finally, guide the dialogue generation according to the global planning. Typical works include TopKG (Yang et al., 2022), and CODA (Gupta et al., 2022), which correspond to a multiturn and one-turn dialogue model. They all plan a path before starting the dialogue, predicting all the keywords that may be mentioned in the dialogue in order. TopKG searches for global paths by retrieval, while CODA generates paths.
There is also some previous work on targetoriented dialogue predicting the next-turn of keywords and retrieving responses (Tang et al., 2019; Qin et al., 2020; Zhong et al., 2021). These work do not have global planning but only set up a global tar-
get, uses a greedy strategy, and gradually achieves the global target during the dialogue.
One problem of target-oriented dialogue studies is the datasets. There is a one-turn dialogue corpus named OTTers (Sevegnani et al., 2021), which is suitable for target-oriented dialogue tasks, but the dataset is still small. CODA uses OTTers and data augmentation methods to construct a one-turn dialogue model that generates bridging sentences. TopKG proposes a method to extract dialogue materials that meet the requirements of target-oriented dialogue from a small talk corpus.
Commonsense Knowledge for target-oriented dialogue systems. For target-oriented dialogue, we need to reach the global target faster and need context transitions in context to be coherent and logical. Naturally, we use commonsense graphs as external knowledge for global planning and dialogue generation. For example, Qin et al. (2020) constructs dialogue graph as the structural information for predicting the next-turn keywords, and Zhong et al. (2021); Yang et al. (2022); Zhou et al. (2021) use ConceptNet to search for keywords/paths. Some works, such as Gupta et al. (2022); Wang et al.
(2020a), use generative methods to convert structured knowledge graphs into unstructured knowledge. Building unstructured knowledge will also be more challenging than using knowledge graphs.

heading: 3 Task Overview
text: Given a context u and a target word tc, we first extract concept word from u as uc, and then generate a path to connect the uc and tc. The path is consists of relations R = {r1, ..., rk} and entity words E = {e0, ..., ek}, such as p = {e0, r1, e1, ..., rk, ek}. Then we convert it into a semantic sentence Path. Our task is to guide multi-turn dialogue generation with the Path. For t-th turn generated sentence, it should contain the et in the Path. Naturally, the dialogue ends with the user or agent mentioning the target word or phrase, while the process is fluent and takes a few turns.

heading: 4 Model
text: We present the MTGP model, depicted in 1. Our approach involves two main components: a Path Generator (PG) model trained on paths sampled
from ConceptNet through random walks, and a Next-turn Response Generator (NRG) trained on dialogues extracted from a chit-chat corpus enriched with knowledge paths from ConceptNet. During inference, we use PG and NRG to generate responses that reflect both global paths from PG and the context of the conversation.

heading: 4.1 Path Generator
text: To train the Path Generator (PG), we follow the approach proposed by Wang et al. (2020b)2. First, we filter the ConceptNet according to our task definition. We exclude certain relations such as RelatedTo, HasContext, Synonym, and keep 24 relations in total. For relations that are not symmetric, we introduce reverse relations. Please refer to A.1 for the details of the filtered relations.
Next, we perform a random walk on the graph to generate a set of paths consisting of relations and entities. The starting nodes are chosen randomly from all nodes in ConceptNet. To avoid excessively long paths, we set a maximum path length of k = 6 in p 3 , which allows for paths’ length 1 to 6.
Finally, we use the sampled paths to train the PG based on the GPT-2. The input format is [tgt]ek[src]e0r1. . . ek, where the special tokens [tgt] and [src] prompt the target and source words.
It is worth noting that the decoding strategy for PG is important. Wang et al. (2020b) used a greedy decoder, while Gupta et al. (2022) applied a top-k sampling decoder to generate multiple paths and then filtered them based on perplexity scores. Since we only need one path with appropriate length and entities, we adopt beam search for decoding.

heading: 4.2 Multi-turn Dialogue Model
text: For the generation of multi-turn dialogue, we train a response generator based on the pre-trained language model. Then we use the response generator to take a multi-turn conversation. What’s more, the response generator can both be trained on the oneturn and multi-turn dialogue dataset, so we call it Next-turn Response Generator(NRG).

heading: 4.2.1 Next-turn Response Generator
text: Sample Dialogue Corpus with Paths. To train the Next-turn Response Generator (NRG), we need to construct a suitable training dataset. To achieve this, we describe a sampling process in Algorithm
2https://github.com/wangpf3/ Commonsense-Path-Generator
1, which extracts a continuous dialogue corpus with global paths and target words.
Algorithm 1: Sampling dialogue corpus over ConceptNet
Input: ConceptNet, Gfull; Dialogue Corpus, C Output: Filtered Dialogue Corpus over ConceptNet foreach session in dialogue corpus do
Extract concept words;Count the dialogue turns;Initialize graph G; for Vcurr in current turn concept list do Find all related nodes N in Gfull; for Vnext in next turn concept list do
if Vnext in N then Add the nodes and edge in G, and
the edge is labeled with weight and dialogue turn;
end end
end Find all Paths in G; foreach path in Paths do
Find subpaths in path with consecutive turns and put them in a set, the turns are regarded as keys; Select the subpath with largest sum of weights, if two subpaths have same key;
end Select from C according to the consecutive
dialogue turns. end
First, we extract entity words from each sentence in the original corpus. Next, we create a dialogue sub-graph by adding entity words and relations from ConceptNet between two adjacent sentences. We also note the turns and weight for each relation.
Subsequently, we apply a path-finding algorithm to identify all the paths in the sub-graph. Finally, we filter the paths based on consecutive turns and maximum weight, to find a unique global path for each consecutive turns list. The resulting turns list extracts the dialogue corpus, which includes global paths with transitions from ConceptNet.
Table 1 shows examples of the resulting corpus. Notably, this approach can be applied to any dataset to extract a continuous dialogue corpus with global
paths and target words. Convert Global Paths into Natural Language Sentences. The format of a path, whether generated by a path generator or obtained by matching dialogue corpus with ConceptNet, is represented in triple format. We prefer to present the path in natural language sentences because we use it as input for the response generator and aim for it to be a reliable reference for the output. This allows the model to understand the connection between entities in the path and generate a similar response. To represent the path in a sentence, similar to CODA(Gupta et al., 2022), we use templates to replace relative words with more natural expressions. As shown in Table 1, replacing "_hasprerequisite" with "is a dependency of". Although these sentences may contain semantic errors, our model prioritizes natural narratives.
Training Model. We train the NRG model on sampled dialogue corpus. The input format is designed as [tgt]global target [ctx] context sentences(c) [pth] path sentence(p) [res] response sentence(r). The path here has been transformed into a sentence with semantics. And if there are more than two sentences of context, use [ctx] to splice them. We can describe the model as P (r|t, c, p), and we train it by minimizing the log-likelihood loss of the generated response. We should notice that the NRG model generates only one response, which means for a dialogue data of {A1, B1, A2, B2, A3} as shown in the Figure 2, every other sentence except the first is set as our response to training the model. The Ai, Bi represent the sentences of two speakers, and Caj , Cbj represent the extracted concepts in each sentence.

heading: 4.2.2 Multi-turn Dialogue Generation
text: Once a path is generated for the source and target word/phrase (represented as p = {e0, r1, e1, ..., rk, ek}), we break it down into triples. We start with an initial path of p0 = {e0, r1, e1} and gradually add ri and ei when generating a response in each turn. Also, add the generated response continuously to the context as dialogue history. Especially replace the prompt of
the target with the end of the word in the sub-path. By utilizing global paths and target prompts, multiturn dialogue can reach the target faster. With the help of a pre-trained language model, NRG can generate more natural and fluent responses.

heading: 5 Experiments

heading: 5.1 Datasets
text: We test MTGP on three dialogue corpus. For evaluating multi-turn dialogue, we use two open-domain dialogue datasets: ConvAI2 (Dinan et al., 2019) and DailyDialog (Li et al., 2017). Since our multiturn dialogue model is based on one-turn dialogue, we also evaluate the model on a one-turn dataset OTTers (Sevegnani et al., 2021).
ConvAI2 is a chit-chat dataset that contains highquality open-domain dialogues with diverse topics. DailyDialog includes a collection of conversations between people in daily situations, which are labeled with various dialogue acts and emotions. OTTers is a one-turn dataset including three sentences in each dialogue: source sentence, bridge sentence, and target sentence. Specifically, the bridge sentence is generated to connect the source and target sentence. In this way, these three sentences form a more coherent dialogue. And for our model MTGP, we also can generate the bridge sentence to evaluate one-turn dialogue.
We adopt the processing method for each dataset, and the result of statics for sampled corpus are shown in Table 2. It is worth noting that, as described earlier, some of the sampled dialogue corpora have overlapping parts, but their dialogue paths are all different.

heading: 5.2 Baselines
text: We select five methods as our baselines. MultiGen (Ji et al., 2020) based on GPT-2, which extends GPT-2 with dynamic multi-hop reasoning on a commonsense knowledge graph.
DKRN (Qin et al., 2020) learns the transfer of keywords from the dialogue corpus and predicts
the next-turn keywords, finally using the retrieval method to generate the response.
CKC (Zhong et al., 2021) uses ConceptNet to predict next-turn keywords and generates a response by retrieval.
TopKG (Yang et al., 2022) retrieves a global path on ConceptNet and uses a reinforcement learning method to guide the dialogue close to the target.
CODA (Gupta et al., 2022) only generate one bridge sentences. Here we extend it to a multi-turn dialogue model CODA-multi.
Details of CODA-multi. We train a multi-turn version of CODA as a baseline. CODA aims to insert a transitive response in two source and target sentences to generate smooth dialogue, which we have adopted. To train CODA-multi, we first trained the Knowledge Path Generator (KPG) using the method provided by CODA. Then, we constructed CODA-multi by continuously adding new sentences between the newly generated response and the target sentence. We divided the dataset into sets of three sentences and used the paths generated by KPG to train the Commonsense Response Generator (CRG). During the reasoning stage, we set the last sentence as the target sentence and used KPG and CRG until the generated response contained the target word. Ultimately, we also can regard CODA-multi as a global planning method. It also plans a global path from the source and target sentence. We have included the code for training and inference of CODA-multi in GitHub.

heading: 5.3 Ablation Studies
text: We construct some CODA variants as follows. MTGP-noedge has only entities in ConceptNet nodes but no relation words. Because we turn the generated path into a sentence, it is used for testing whether paths with complete semantic information have a significant effect on experimental results.
MTGP-kbpath replaces generated path with retrieval 2-hop path on ConceptNet. It is used for contrasting with the retrieval path whether the generated path that is expanded with more knowledge is better than the retrieval way.
MTGP-notarget cancels the prompt of the target.
MTGP-upper replaces the generated path with the ground-truth path sampled from ConceptNet.
Implementation Details are in Appendix A.4.

heading: 5.4 Metrics
text: Path Generation Evaluation. We perform an automatic evaluation on the generated paths, referring to the settings of Wang et al. (2020b). The results are shown in Table 5. Connection represents the proportion of the paths successfully connecting the head, and tail entities, Valid Entity represents the proportion of entities found in ConceptNet, Triple in Cpnet represents the proportion of triples in all generated paths present in the ConceptNet. Scores comes from Bilinear AVG (Li et al., 2016), which produces scores for a given triplet. But we use it to score all triples in the path. For one pair of head and tail entities, the score of each relation is between 0-1, representing the confidence of the triple. Here we select three modes to score the triplets in the path, namely sum score, best score and max score. sum score is the proportion that the sum of the scores of all relations that can connect the head and tail is greater than 3. max score represents the proportion of the maximum relation score is greater than 0.5. best score means the proportion of the triples whose relation score is greater than 0.5.
Multi-turn Dialogue evaluation. To evaluate
the performance of MTGP to guide the target and generate a response in multi-turn dialogue, as previous work do (Qin et al., 2020; Zhong et al., 2021; Yang et al., 2022), we set three automatic metrics. Succ. measures the success rate of the model achieving the global target within six turns. Turns indicates the average turns of all dialogues which achieve the global target successfully. Coh. measures the contextual semantic similarity between the last sentence in context and generated response.
One-turn Dialogue evaluation. We also set some metrics to evaluate MTGP on one-turn dialogue. We use the same metrics as CODA, they are BLEU (Papineni et al., 2002), ROUGE-L (Lin, 2004), METEOR (Banerjee and Lavie, 2005), BertScore (BS-rec and BS-F1) (Zhang et al., 2019) and TC (Target-Coherence) (Gupta et al., 2022). Especially, TC is based on a classification model trained to classify a transition response as either positive, that is, it is coherent to the context and smoothly transitions towards the target, or negative, that is, the response is either not coherent to the context or does not transition towards the target.

heading: 5.5 Results
text: Quality of Generated Paths. From the results, we can see that almost all paths can successfully connect source and target entities, and the generated entities are almost derived from ConceptNet. It is worth noting that only half of the generated triples are in ConceptNet, indicating that through the path generator, a lot of triplets that are not in the ConceptNet are generated, which makes the commonsense in the path not limited to the ConceptNet, and further expands the knowledge through pre-trained language model. More details show in the Appendix A.2.
Multi-turn Evaluation. We take experiments on two chit-chat corpus and simulate two scenarios with the user and without the user’s participation. We use GPT-2 to fine-tune a user simulator using a chit-chat corpus. For the no-user scenario, we just let the model self-play. The results show in Table 3 and Table 4. We observe that : (1) The results of global planning(TopKG, CODA-multi, MTGP) are
generally better than the results of greedy strategies(MultiGen, DKRN, CKC). Among the global planning methods, MTGP has the highest success rate, but its coherence is slightly lower than CODAmulti. Because CODA-multi inserts a response between two sentences, MTGP considers the contexts above. (2) Generating paths(CODA-multi, MTGP) is better than retrieving paths(MultiGen, DKRN, CKC, TopKG).(3) Scenarios with users have a higher success rate than scenarios without users. The global path does not limit the user response, and the model needs to guide new topics while replying to the user. This is less biased than model self-play. Also, in terms of coherence, the user simulator only needs to reply to the previous sentence, so it has higher coherence. However, there are more turns with users.
One-turn Evaluation. The result in OTTers shows in Table 6. Although the reference-based metrics are slightly biased, we still observe that MTGP outperforms all the baselines under OTTers data about TC score, demonstrating that the proposed method leads to some improvements in response quality.
Relationship between turns and path length. In Table 7, we observe that with user participation, the turns are mostly longer than the path length. This is also because the global path does not guide users and only responds based on common sense.
For scenarios without users, the turns are roughly the same as or slightly lower than the path length. Duplicate entities in some paths, a small semantic span of entities, or multiple entities in response will lead to this result, which is also within our expectations.
Ablations. From the ablation experiments results, we can draw the following conclusions: (1) Path sentences with complete semantic information perform better than sentences composed of entity words, which shows that paths with edges are essential for response generation. (2) The performance has dropped significantly by retrieving two-hop paths instead of generating paths for global planning. On the one hand, some paths from the source target cannot be found within two hops; on the other hand, some nodes have no specific paths in the graph. (3) The performance of canceling the target prompt is somewhat reduced. Still, the impact is insignificant because, during training, the model can also learn that the last word in the path is the target word. (4) Replacing the generated path with the grounded path improves performance. However, the performance is still not as good as the original model. It also shows that improving the quality of the path obtained by retrieval can improve performance, but the generated path with richer information is more dominant.
Case Study. In the case Table 8, we give the source sentence, the target sentence, the global target extracted from the target sentence, and a generated global path. In a dialog with user participation, A represents the user, and B represents the model. The case study demonstrates MTGP can carry out coherent dialogue according to the global path and reach the target in the appropriate turns. For example, in the first case, without user participation, MTGP generates a coherent dialogue along the entity words mentioned in the path. Still, for the CODA-multi model, the information in the global path is not well applied, although it reaches the target word walk. For the with-user case, the user response is not affected by the global path, but MTGP can reply to the user while guiding new topics appropriately according to the global path. However, we can find from the two cases that the sentences generated by the CODA-multi have a case of self-repeating or repeating contexts, that is, the guidance of the global path is invalid and generate the same sentence as context. Some fail cases are shown in Appendix A.3.

heading: 6 Conclusions
text: In this work, we propose a multi-turn targetoriented dialogue model which can achieve global target guiding by a generative global path. We also offer an automatic method to match dialogue corpus with commonsense graphs and sample dialogue corpus with paths. The extensive experiments show that our approach can make the dialogue simple and effective to reach the target with a higher success rate. In future work, we will explore using unstructured knowledge for global planning.
Limitations
The main limitation of this work is the usage of explicit knowledge in the knowledge graph. Although using knowledge graphs is a common advantage of most current target-oriented dialogue studies, and explicit relations between entities help to effective and reliable reasoning for the recommendation, there is still a large amount of implicit knowledge in unstructured resources that cannot be extracted as explicit triplets, e.g., the multidimensional similarity between entities, but can be a further extra supplement to dialog context. In this work, we involve implicit knowledge by generating a path as a natural language sentence, but the knowledge graph is still necessary. In future work, we will explore only using unstructured knowledge for global planning.
Ethics Statement
Our multi-turn target-oriented dialogue model can facilitate and quickly conduct dialogues with users. It can be used in many applications, such as movie recommendation, product recommendation, psychological consultation, educational dialogue on a particular topic, etc. All models in this paper are trained on the public corpus. The used datasets do not contain personal information or unethical language. We also ensure the anonymization of the human evaluation.

heading: 7 Acknowledgements
text: This work was supported by the National Natural Science Foundation of China (62272340, 61876128, 61876129, 62276187, 61976154, 61402323), State Key Laboratory of Communication Content Cognition (Grant. No.A32003).

heading: A Appendix
text: A.1 Filtered Relation on ConceptNet
We remove the following relations: Antonym, DerivedFrom, EtymologicallyDerivedFrom, EtymologicallyRelatedTo, FormOf, HasContext, RelatedTo, Synonym, NotCapableof, NotDesires, NotHasproperty, Entails, Instanceof and all relations labeled with "dbpedia/" in ConceptNet 5.5 (Speer et al., 2016)3
A.2 Illegal Relations
We do not statics valid relations because we divide the paths into triples according to the relation. In fact, due to the limited number of relations in the training data, according to our statistics, although the effective relations do not reach 100%, the proportion of illegal relations does not exceed 0.1%. There are illegal relations in generated paths, like hasprevent, hassuberequisite, haslastsubewarm, hassube, hasfirstsube, and haslastsube. These words are morphologically close to the relative words at the beginning of has-, causing the pre-trained language model to fail to recognize their features accurately.
A.3 Fail Cases
We conduct an error analysis on results and find some error examples in Table 9. There are two main reasons for these examples. (1) The model does not understand the intermediate entity words
3https://github.com/commonsense/conceptnet5
generated by the path in time. (2) Words with similar semantics to the target words are generated. In the first case, the target is not reached for the target word pair because the model misses the output of the word young couple. But this is just a particular example, in most cases, the goal can be achieved. For the second case, the target word care, but the model generates a word nursing that has similar semantics to care.
A.4 Implementation Details Our code is based on Pytorch-lightning, Pytorch, and Huggingface4. We train both PG and NRG models on a Tesla P100-PCIE-16GB GPU. We use Adam optimizer with an initial learning rate of 5e-5 and 4 num_workers. We set batch size 32, input length 128, output length 32, epoch 5 for NRG. And PG’s batch size is 4, the input length is 16, the output length is 32, epoch is 10.
4https://huggingface.co/
ACL 2023 Responsible NLP Checklist

heading: A For every submission:

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

heading: 3 A2. Did you discuss any potential risks of your work?
text: Section Ethics Statement

heading: 3 A3. Do the abstract and introduction summarize the paper’s main claims?
text: Section 1 Introduction
7 A4. Have you used AI writing assistants when working on this paper? Left blank.
B 3 Did you use or create scientific artifacts? Section 4 5

heading: 3 B1. Did you cite the creators of artifacts you used?
text: Section 4 5

heading: 3 B2. Did you discuss the license or terms for use and / or distribution of any artifacts?
text: Section 4.1 Appendix A.1

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)? Section 4 5
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 widely used chat corpus dataset used in this paper has been anonymized.

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

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? A.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? A.4

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? A.3

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.)? A.4
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.? No response.
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)? No response.
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? No response.
D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? No response.
D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? No response.

heading: Future Work
text: In future work, we will explore using unstructured knowledge for global planning. Limitations
The main limitation of this work is the usage of explicit knowledge in the knowledge graph. Although using knowledge graphs is a common advantage of most current target-oriented dialogue studies, and explicit relations between entities help to effective and reliable reasoning for the recommendation, there is still a large amount of implicit knowledge in unstructured resources that cannot be extracted as explicit triplets, e. g. , the multidimensional similarity between entities, but can be a further extra supplement to dialog context. In this work, we involve implicit knowledge by generating a path as a natural language sentence, but the knowledge graph is still necessary. In future work, we will explore only using unstructured knowledge for global planning