Explanation Graph Generation via Generative Pre-training over Synthetic Graphs
Year: 2023

Abstract:
The generation of explanation graphs is a significant task that aims to produce explanation graphs in response to user input, revealing the internal reasoning process. This task is challenging due to the significant discrepancy between unstructured user queries and structured explanation graphs. Current research commonly fine-tunes a text-based pre-trained language model on a small downstream dataset that is annotated with labeled graphs. However, due to the limited scale of available datasets, this approach may prove to be insufficient in bridging the gap between natural language text and structured graphs. In this paper, to alleviate the above limitations, we propose a novel pre-trained framework EG3P(for Explanation Graph Generation via Generative Pre-training over synthetic graphs) for the explanation graph generation task. Specifically, we first propose a text-to-graph generative task to pre-train the model with the goal of bridging the text-graph gap. Additionally, we propose an automatic corpus synthesis strategy for synthesizing a large scale of high-quality corpus, reducing the reliance on costly manual annotation methods. Experimental results on ExplaGraphs show the effectiveness of EG3P that our model surpasses all baseline systems with remarkable margins. Besides, further analysis demonstrates that EG3P is able to generate better explanation graphs on actual reasoning tasks such as CommonsenseQA and OpenbookQA.1

heading: 1 Introduction
text: Generating an explanation to probe why the model obtains answers is a long-term goal in the development of intelligent systems, especially in reasoning-related tasks, such as E-SNLI(Camburu et al., 2018), ECQA(Aggarwal et al., 2021), HotpotQA(Yang et al., 2018) and ExplaGraphs(Saha
∗Corresponding author. 1Our code, checkpoints and corpus is released in
https://github.com/cccccent/EG3P
et al., 2021). According to the types of explanations, existing explanation generation tasks can be mainly divided into three types, including textual highlights explanation generation (Yang et al., 2018; Camburu et al., 2018), natural language explanation generation (Camburu et al., 2018; Wiegreffe et al., 2020; Inoue et al., 2021) and structured explanation generation (Xie et al., 2020; Saha et al., 2021). Among all these tasks, structured explanation generation achieve growing attention recently since the explanation in this task is usually a graph, which is clean enough, and easy to evaluate from the perspective of structure and semantics (denoted as an explanation graph). An example of a structured explanation generation task is shown in Figure 1.
Pre-trained language models, such as RoBERTa (Liu et al., 2019), BART (Lewis et al., 2020) and T5 (Raffel et al., 2020) have demonstrated their powerful capabilities in a great many language understanding tasks. As a result, when it comes to explanation graph generation, existing studies pri-
9916
marily fine-tune pre-trained language models on downstream tasks directly (Xie et al., 2020; Saha et al., 2020, 2022). While typical pre-trained language models (PLMs) are pre-trained on textual corpus only, fine-tuning on downstream tasks directly may lead to a significant discrepancy between text-based language models and explanation graphs. To mitigate this issue, we argue that pretraining over task data can be an ideal way to bridge the above gap. Such a pre-training manner can be a subtle solution to inject inductive bias into PLMs. However, the scale of existing datasets is relatively small since it costs a lot to label explanation graphs, and pre-training on existing data is insufficient to bridge the gap. To this end, an appealing solution is to continually pre-train PLMs on a large scale automatically synthetic corpus containing explanation graphs instead of human labeling before finetuning. The explanation graph is highly structured and contains diverse entities and relations, which is easily synthesized by randomly assigning different values to each entity and relation positions.
In this paper, we propose EG3P (Explanation Graph Generation via Generative Pre-training over Synthetic Graphs), a novel pre-trained framework for explanation graph generation. Specifically, as shown in Figure 2, EG3P is composed of two key components: the "Text-to-Graph" pre-training task and the construction of the pseudo training data. Different from previous natural language-based pre-training tasks, the “Text-to-Graph” task takes external knowledge sources and questions containing partial reasoning progress information as input, and its target is to generate relevant explanation graphs. In addition, to avoid the high cost of retrieving graphs for the simulated questions from the knowledge base, we propose a novel approach
to constructing questions from simulated graphs, which automatically constructs a large amount of pseudo data.
Experiment results on the ExplaGraphs benchmark demonstrate that our approach could improve the ability of the model to generate explanatory graphs significantly. Moreover, the model also shows excellent graph generation ability on other reasoning datasets.
Overall, we make the following key contributions:
• We propose a novel pre-training task by mapping the input question to a structural explanation graph, which guides the model to learn the connections between natural language questions and structured graphs.
• We propose a novel approach to synthesize corpus by automatically constructing structured graphs and queries to form the largescale corpus.
• Among the models with similar scales, our model achieves competitive results. Furthermore, the results of our experiments indicate that our model is capable of producing acceptable graphs on reasoning datasets without labeled graphs.

heading: 2 Overview and Background
text: In this paper, we concentrate on the task of explanation graph generation. An example is depicted in Figure 1. Given a piece of natural language text T , the model needs to generate a graph G which encapsulates the internal reasoning path of the input text. The specific content of the input T is contingent upon the specific downstream tasks (belief + augment + stance in stance prediction, question + answer in QA, etc.). For output G, we organize the graph into a sequence of triples in the depth-first search order. In practice, we employ a generative model and treat graph generation as a standard text generation task.
A crucial point in this task is addressing the significant discrepancy in semantic expression structure between natural language texts and explanation inference graphs. An ideal way is to let the model learn this expression transfer on a large amount of natural language text and graph alignment data. However, due to the small size of labeled datasets, training on these datasets is difficult to address
the issue. Based on all of the above, we propose the two modules of our model: the "text-to-graph" pretraining strategy introduced in section 3, and the method of automatically constructing synthetic corpus introduced in section 4.

heading: 3 The Text2graph Pre-training Strategy
text: Typical pre-training strategies of various PLMs are based on the corpus of natural language text (e.g. MLM and NSP(BERT), text denoising(BART), and text-to-text generation(T5)). However, in the explanation graph generation task, the explanation graph is different from the natural language text both in the representation form and in the semantic structure, which leads to a huge gap between the two kinds of representations. Apart from typical tasks, some pre-training strategies are applied to recover the triples in the knowledge graph for knowledge graph question answering(KGQA)(Saxena et al., 2022). However, such a pre-training method is not able to cover the explanation graph generation task due to the separation of pre-training steps between
structured corpus and natural language, which is unable to bridge the gap between natural language and structured graphs.
Since the explanation graph generation task is required to translate natural language text into a graph, we believe the key point is to map the natural language texts to structured graphs in the learning process implicitly. To this end, we set the form of the pre-training task as "text-to-graph" in EG3P. As depicted in Figure 3, the format of the pre-training task is analogous to that of a normal generation task. Given a query in natural language question and a simulated knowledge source, the model concatenates the two part together as input and generate a sequence of triples representing the reasoning graph from the query to the answer. By learning aligned "text-to-graph" pairs, the model acquires text-to-graph mapping in the process, and its capability for structured text generation is also enhanced. Real input samples are presented in Appendix B for further reference.
The query and the graph of the answer come from the auto-construction method we propose, which will be discussed in the next section. To construct the simulated knowledge source (a collection of triples), we take the triples of the gold answer as a starting point and add random triples that are not relevant to the reasoning process to disrupt the collection. The final size of the simulated knowledge source is approximately 1.5 to 2 times the length of the graph.

heading: 4 The Construction of Synthetic Corpus
text: Pre-training tasks necessitate the support of largescale corpus. However, all the existing datasets with human-labeled graphs are small in scale due to the high cost of manually annotating, which is not enough to support the pre-training process. To address this issue, we propose an automatic method of constructing the pair of the natural language query and the explanation reasoning graph. The conventional way to get a graph from a piece of natural language text is to search in the external knowledge base. However, the complexity of searching would increase exponentially with the number of nodes and the length of edges in graphs. Therefore, we invert this process, synthesizing a reasoning graph first and then constructing a query based on the graph next.

heading: 4.1 The Synthesizing of the Graph
text: Observing the reasoning process of the downstream reasoning tasks, it is evident that the reasoning path of a specific instance not solely depends on the problem entity as the starting point of reasoning, but also depends on other entities in the problem as constraints, which ultimately lead to the sink point. So we construct the explanation graph from back to front to ensure that there is only one sink (i.e. the answer) in the graph and the relationship of each edge is used.
The process of construction is shown in Figure 4. Initially, a concept is randomly selected as the sink of the graph (also the answer to the query in the following steps). Subsequently, triples are retrieved recursively, and a random number of them (ranging from 0 to 2) are incorporated into the graph. All the triples are retrieved from ConceptNet(Speer et al., 2017), which is an external knowledge base containing concepts as nodes and relations as edges. Additionally, the relationship “relatedTo” is prevalent among the concepts, which will seriously affect the reasoning process, so it is deleted. Furthermore, certain other relations are merged, resulting in a total of 16 distinct relations. The distribution of the relations is introduced in Appendix A.

heading: 4.2 The Construction of the queries
text: Inspired by the work of Liu et al. (2021), we construct three queries with different difficulty levels: easy, normal, and hard for each instance of the graph, as shown in Figure 4. The easy level in-
volves retaining the start node and relation in the intermediate stages of reasoning, while hiding the sink node (which is treated as the answer) and the nodes present in the intermediate stages. The relation is then replaced with natural language annotations based on a predefined template, and the resulting triples are subsequently concatenated in their original order. For the normal level, a similar amount of information is retained as in the easy level, but the concatenated query is further converted into a natural language expression using a predefined template, in order to simulate a realistic question-answering scenario. For the hard difficulty level, only the start node and the first relation are retained, with all other auxiliary information removed, and the question is formulated in natural language. All the template is shown in Appendix B.

heading: 5 Experiments

heading: 5.1 Datasets and metrics
text: ExplaGraphs The main dataset we use is ExplaGraphs(Saha et al., 2021), a commonsense explanation graph generation task. The task requires an agent to predict the stance of a given belief and argument, and subsequently generate an explanation graph that illustrates the reasoning process behind the predicted stance. Specifically, the explanation graph is a DAG, demonstrating the internal reasoning process between the belief and the argument. As shown in Figure 2, the nodes in the graph correspond to concepts from the given text or external
commonsense phrases, while the edges represent commonsense relations present in the dataset. Each edge in the graph is an expression of one of the reasoning steps, and the ordered links of all edges provide an overall representation of the reasoning process for the user.
In terms of the metrics, the dataset defines 6 test metrics, two of which are selected as main metrics by the prior works(Saha et al., 2022): Structural Correctness Accuracy (StCA) evaluating if the graphs satisfy all structural constraints, and Semantic Correctness Accuracy (SeCA) evaluating if the graphs are both structurally and semantically correct. The structural constraints contain several parts: the graph should be a connected DAG, the relations belong to the relation list defined by the dataset and there are at least two concepts from the belief and two from the argument. The semantic correctness is evaluated by a model-based metric (Saha et al., 2021), checking whether the semantics of the graph and the standard answer are matched. All the metrics in detail could be found in the Appendix D.
Other reasoning datasets To prove the generalization ability of the model, we also conducted experiments on two other general commonsense reasoning datasets in addition to ExplaGraphs: CommonsenseQA(Talmor et al., 2019) and OpenbookQA(Mihaylov et al., 2018). CommonsenseQA is a 5-way multiple-choice question answering dataset that focuses on commonsense reasoning, while OpenBookQA is a 4-way multiple-choice question answering dataset that requires reasoning with elementary science knowledge. Since there is no labeled commonsense reasoning graph on these datasets, we evaluate the results of the dev set of these two datasets manually from the point of semantics and analyze the model for specific examples. The evaluation of semantics is to check whether the semantics of the graph matches the reasoning process properly.

heading: 5.2 Generative Baseline
text: In line with the previous work(Saha et al., 2021, 2022), we generate the explanation graphs in a post-hoc manner, with a condition of the belief, the argument, and the predicted stance. In order to objectively compare the results of graph generation, the part of stance prediction in all our experiments is finished by an identical RoBERTabased model. The first baseline model is BART,
our backbone of EG3P. Furthermore, we also implement other pre-training methods that have been introduced in recent studies(Saxena et al., 2022) on knowledge graph question answering (KGQA), such as link prediction and tail prediction. Link prediction is a common task in knowledge graph embedding(KGE) learning. Given two parts of a knowledge triple (head+relation, head+tail, or relation+tail), the model is required to complete the missing element of the input. For the tail prediction task, the training process is basically the same as link prediction, but the model only needs to predict the tail entity in all instances, which is more similar to the process of step-by-step reasoning from front to back. In order to facilitate the model’s understanding of the task, we add a prompt before the input triple: “Predict the head/relation/tail: xxx”. The input sample of the two tasks is shown in Appendix B.

heading: 5.3 Fine-tuning on Downstream Datasets
text: For the fine-tuning process on ExplaGraphs, we follow the pipeline outlined in previous work as described above. For the fine-tuning process on CommonsenseQA and OpenbookQA, we did not use the model to generate the graph in zero-shot style, because we found that BART-Large without any learning process can hardly generate an acceptable graph in the comparison tests. To improve comparability, we fine-tune the model with the ExplaGraphs dataset before generating explanation graphs on other datasets in different groups of experiments. All the input samples are shown in Appendix B.

heading: 5.4 Experimental Setup
text: The experiments include three parts: the construction of the corpus, the process of pre-training, and the process of fine-tuning.
For corpus construction, we first synthesize 20 million reasoning graph instances and construct three questions of varying difficulty for each instance. Then, the “query-graph” pairs in three difficulty levels are mixed in equal proportion, ensuring that the total amount of data meets the experimental requirements. Except for experiments discussing the effect of the corpus scale, the scale of the corpus in other experiments is set to 0.3 million.
For the pre-training process, we utilize the BART-Large(Lewis et al., 2020) model in fairseq(Ott et al., 2019), a widely-employed seq2seq model that follows the standard trans-
former structure, as the backbone of our model. The pre-training process runs up to 50000 steps with a learning rate of 3e-5, a dropout rate of 10%, and a max length of 1536.
For the process of fine-tuning, we build the classification model based on RoBERTa-Large(Liu et al., 2019), with a batch size of 32, an initial learning rate of 1e-5 with linear decay, a weight decay of 0.1, and a maximum input length of 128. The model is trained for 10 epochs. Then the finetuning step on ExplaGraphs for graph generation runs up to 10000 steps with a batch size of 8 and a max length of input and output of 150, keeping other parameters the same as the pre-training process. The whole training process is conducted on Nvidia-A100-40G.

heading: 6 Results and Analysis

heading: 6.1 Results on ExplaGraphs
text: In this section, we compare the result of our EG3P with other baselines introduced in Sec 5.2 and some released works on the same task. Following prior work (Saha et al., 2022), we report all the metrics on the ExplaGraphs dataset.
Effect of “Text-to-Graph” pre-training method In this part, we report all the evaluation results on the dev set. As depicted in Table 1, our pre-training method in EG3P improves StCA by 12.56% and SeCA by 11.3% compared to BART-Large without “text-to-graph” pre-training, indicating our method could significantly enhance the model’s capability for graph generation in terms of both structure and semantic understanding.
Furthermore, based on the same backbone model, the pre-training method in EG3P also outperforms other listed pre-training methods in the table across all the metrics, as evident in Table 1, which demonstrates the efficacy of our modeling approach. The gains on the task of link prediction and tail prediction are not relatively significant on structural correctness and semantic correctness, which means the aligned input pair of “text-graph” and the output of graph is crucial for the model to learn the mapping between natural language text and structural graph. The case study is discussed in Appendix E.1.
Comparison with other works In this part, we compare our results with some other representative results on the ExplaGraphs dataset.
• Saha et al. (2022) proposes some methods to construct structurally and semantically positive and negative graphs and leverages these graphs in different contrastive learning models. In order to make a fair comparison, we take the results of this method on BARTLarge.
• COCOGEN(Madaan et al., 2022) treats the structured commonsense reasoning task as a code generation task and uses a code generation language model CODEX(Chen et al., 2021) to generate the graph with few-shot prompting. There are also other results of the same method on different natural language large language models(LLMs), such as CURIE and DAVINCI. We only compare with the best result of them.
The results of the test set are summarized in Table 1. The comparison demonstrates that our proposed method, EG3P, outperforms both of the aforementioned methods, particularly in terms of semantic correctness accuracy (SeCA). The results show that the pre-training method on aligned “textgraph” pair could help the model learn the mapping between natural language and graphs better than training on a single downstream task. Besides, specific pre-training methods could also endow small models with a better ability of semantic understanding on the specific task (graph generation here) than large language models.

heading: 6.2 Other Analysis
text: Effect of the difficulty of the query In EG3P we construct a query in three different difficulties and mix the corpus in the main experiment as multitask training. Table 2 shows the results on different queries. It is significant that the utilization of a mixed corpus leads to a more substantial improvement than training on a single sub-task alone. Due to the same graph generation form, the structural accuracy(StCA) of all sub-task is improved significantly; the benefits brought by the mixed corpus are mainly reflected in the semantic accuracy(SeCA).
A comparison of different sub-tasks reveals that the results for queries of normal difficulty are the most favorable. The queries in normal difficulty retain the form of a natural language compared to easy and retain more intermediate reasoning information compared to hard. This suggests that, in the training process based on a large-scale synthetic corpus, the closer the training task is to the
downstream task and the simpler it is, the better the model learns.
The model pre-trained on simple corpus demonstrates superior performance in comparison to the one based on the easy corpus. Compared to easy difficulty, the pair of simple query and graph has a form that is more congruent to the explanation graph generation task. This finding aligns with previous work(Devlin et al., 2019), which suggests that pre-training on a task that is more closely aligned to the downstream task leads to improved performance. Besides, the model pre-trained on simple corpus also outperforms the one based on the hard corpus, despite the fact that both present the same form. This highlights the importance of selecting an appropriate difficulty level for pretraining tasks in order to achieve optimal efficiency.
Effect of the scale of corpus Figure 5 shows the results of the model pre-trained on a different scale of the corpus. We compare the effect of six different scales of corpus on the experiment. Within a certain range, the experimental results are improved by the scale of the corpus. However, when the corpus size exceeds a certain threshold, the marginal benefit of a larger corpus becomes
increasingly diminishing, likely due to the limitations of computational resources and insufficient training on a large-scale corpus. Considering all factors, we select a corpus size of 0.3M as the optimal setting for our main experiments, as it yields the best results under the current conditions.
9922

heading: 6.3 Results on other reasoning datasets
text: Table 3 shows the results of human evaluation on CommonsenseQA(CSQA) and OpenbookQA(OBQA). The “text-to-graph” pre-training step improves the semantic accuracy by 10.5 on CSQA and improves the semantic accuracy by 12.0 on OBQA. The experimental results show that the model after “text-to-graph” pre-training is able to generate a fairly exciting explanation graph on other downstream tasks as well. Additionally, this serves as evidence that our methodology enhances the model’s capacity for generalization. Observing the generated graph, we find that the explanation graph generated by the model without pre-training only mechanically merely connects the question and the answer with a short path, and even generates some meaningless relations in it. More case study on these two datasets is discussed in Appendix E.2.

heading: 7 Related Work

heading: 7.1 Explanation generation
text: In the task of explanation generation, the model takes a piece of natural language text as input and outputs an explanation in various formats, including (a) textual highlights using a subset of the input text(Zaidan et al., 2007; Lei et al., 2016; Yu et al., 2019; DeYoung et al., 2020), (b) natural language explanation(Camburu et al., 2018; Wiegreffe et al., 2020; Zhang et al., 2020; Inoue et al., 2021) and c) structured explanation, including semi-structured text explanation(Khot et al., 2019; Jhamtani and Clark, 2020; Geva et al., 2021; Ye et al., 2020) and structured explanation graphs(Jansen et al., 2018; Xie et al., 2020; Saha et al., 2021). The explanation based on natural language is more expressive and easier understood by readers, but its evaluation process from the perspective of reasoning is often not standardized and rigorous(Wiegreffe and Marasović, 2021). Therefore, structured explanations have attracted more and more attention from researchers for they are better evaluated in terms of structure
and semantics. In this paper, we choose ExplaGraphs(Saha et al., 2021) as the main experiment dataset because it is constructed based on commonsense knowledge and comes with relatively comprehensive automated evaluation metrics.

heading: 7.2 Structured content generation from language models
text: There are many kinds of works to generate structured content through language models, one of which is graph generation. Graph generation methods can be combined with various tasks, such as event influence graphs generation(Tandon et al., 2019; Madaan et al., 2020), temporal graphs generation(Rajagopal et al., 2021; Madaan and Yang, 2021), entailment trees generation(Dalvi et al., 2021), knowledge graph completion(Li et al., 2016; Bosselut et al., 2019) and methods for no specific semantics attached graphs generation(Simonovsky and Komodakis, 2018; Shi et al., 2020; Hwang et al., 2021). In some other semantic parsingrelated tasks, there is also the generation of structured content, such as scripts generation(Sakaguchi et al., 2021; Dalvi et al., 2019; Shi et al., 2022) and program generation(Chen et al., 2021; Liu et al., 2021). The graphs generated in our paper focus on all kinds of commonsense reasoning tasks. Besides, the main role of our generated graph is an explanation of the internal commonsense reasoning process based on the input.

heading: 8 Conclusion
text: In this paper, we propose a pre-training framework EG3P for a structured explanation generation task. Distinct from existing pre-training tasks based on natural language text, EG3P focuses more on training mapping between natural language and graphs. Meanwhile, due to the high cost of manually tagging, we construct queries from the synthetic graph automatically to get a large-scale corpus to support the pre-training process. Using ExplaGraph as a main benchmark, experimental results show that EG3P could significantly improve the ability of the model to generate explanations. In addition, on the other dataset, the results of the model after pre-training also showed a considerable improvement. Our approach offers a new possibility for addressing the challenges of limited labeled data in natural language processing tasks.
In the future, the ability of the model to generate explanation graphs will benefit from more datasets
released with labels and more and more objective evaluation indicators put forward. Additionally, while our current approach processes graphs as strings, utilizing a model architecture that is more suitable for graph generation may further enhance the model’s graph generation ability.
Limitations
In our experiments, the most significant limitation is the lack of computational resources. Experimental results in this paper and previous work(Saha et al., 2022) have shown that a larger scale of models could lead to higher structural and semantic accuracy of explanation graphs in this task. Constrained by computational resources, BART-Large is the largest model on which we can perform the complete process of experiments. We believe that graph generation would be better if sufficient resources were available to perform synthetic data based pre-training on a larger model. In addition, since the evaluation metrics for graph generation tasks are incomplete yet, we can only evaluate a few samples manually outside of the metrics of the dataset, which is more subjective. With more evaluation methods with standardized processes proposed, the results of the experiment will be evaluated more objectively.

heading: Acknowledgements
text: We would like to thank the anonymous reviewers for their helpful comments. This work was supported by the National Natural Science Foundation of China (No.61976068 and No.62277002).
Ethics Statement
In this paper, we propose a pre-training framework based on synthetic data to improve the ability of the model to generate explanation graphs. The datasets and model we used are all open-source and all the references that draw on the work of others are marked with citations. In the process of constructing the corpus, we ensure that all the triples come from ConceptNet, an open source knowledge base. All the steps involving selection are completely random, so that nothing such as bias or discrimination is introduced in following steps. Finally, our approach is designed to improve the interpretability of the model and won’t deviate from the semantics in the input text, so there is no ethical issues in this work.

heading: A The Distribution of Relations in the Synthetic Corpus
text: Table 5 shows the distribution of the 16 relations in the synthetic data. In the process of corpus construction, the process of relation extraction is completely random, so the distribution of relations in corpora of different sizes remains consistent. The only difference between the groups of experiments is the size of the corpus.

heading: B Samples of Input and Output
text: Table 4 shows the samples from the synthetic data and different datasets. The samples shown in the upper part of the table are from the pre-training task, and the samples shown in the lower part are from the generation process of the downstream dataset.

heading: C The Templates For Converting Triples to Natural Language
text: Table 6 shows all the templates we use in the experiments. We construct several different templates for a single relation to ensure the diversity after converting and randomly select one template each time for the expression of the triple.

heading: D The Metrics in ExplaGraphs
text: The evaluation part of the main experiment directly adopts the evaluation metrics in the ExplaGraphs dataset. For a generated graph of the model, it must be ensured that the result of stance prediction of the corresponding instance is correct before entering the subsequent evaluation steps. The metrics of the graph mainly include the following points:
Structural Correctness Accuracy of Graphs (StCA) The StCA metric represents the proportion of all generated graphs that satisfy the structural constraints introduced following:
* The explanation graph needs to contain at least two nodes from the belief and two nodes from the argument. Each node has three words at most. The relationships represented by the edges in the graph must all come from predefined relationships.
* The explanation graph must be a connected DAG.
* The number of triples in the explanation graph must be between 3 and 8.
Semantic Correctness Accuracy of Graphs (SeCA) The SeCA metric judges the relationship (support, counter or incorrect) between the belief and the generated graph. If the judgment is consistent with the results of the stance prediction task, we consider the graph semantically correct. A RoBERTa-based three-class model is used during this process, and the evaluation process for this metric is entirely independent of structural features.
G-BERTScore (G-BS) This metric is based on BERTScore(Zhang et al., 2019) and calculates the similarity between standard graph and generated one. We treat the graph as a set of edges and try to find the best matching result between the predicted graph and the gold one, where the similarity between the two edges is calculated according to the F1 value of BERTScore given the best assignment.
Graph Edit Distance (GED) The edit distance of a graph measures the difference between the generated graph and the gold graph, specifically referring to the number of changing operations that need to be performed between the two, where the changing operation refers to adding, deleting, or replacing edges or nodes in the graph.
Edge Importance Accuracy (EA) Edge importance accuracy measures the proportion of edges that are important enough in the generated graph. We consider an edge important as long as removing this edge will lead to a significant drop in the accuracy of stance prediction. This part of the evaluation is based on a separate RoBERTa model.

heading: E Case Study
text: E.1 Case study on ExplaGraphs
Figure 6 and Figure 7 shows two examples on the dev set generated from our model. The semantic expression of the graph after pre-training is more accurate than the one without pre-training. In case 1, the graph reaches the proper concept with a longer reasoning path, and in case 2 the process of reasoning is more precise. Besides, comprehensively observing other examples, we found that our model is more inclined to reason step by step based on commonsense knowledge, and the reasoning process is less jumpy. In the golden graph, "entrapment" and "effective" are linked directly in the in the human labeling. However, in the generated graph, there is an additional node "catch criminals" between "entrapment" and "effective", refining the process.
Moreover, in case 2 and other instances, we found the model could generate the counter relation (not desires) which is not introduced in the pre-training corpus. This indicates that our model can quickly learn new relationships from small amounts of data in downstream tasks and apply them to the graph generation process.
E.2 Case study on CommonsenseQA and OpenbookQA
Figure 8 shows graph generated on CommonsenseQA. Figure 9 shows graph generated on OpenbookQA. Observing the graphs generated, we find that our model is more inclined to generate the graph with basic commonsense knowledge rather than scientific knowledge or certain reasoning processes that are obvious to humans, especially on OpenbookQA. The model prefers to explain the reasoning process of some scientific questions with the relations contained in the pre-training corpus.
Belief: Entrapment serves to bust criminals but results in them being let go. Argument: Entrapment is an effective way to make sure criminals are off the streets.
Stance: Counter
Cases on CommonsenseQA：
Cases on OpenbookQA：
Relation Template
[X, antonym, Y] X is opposite to Y Y is opposite to X
X is the opposite of Y
[X, atlocation, Y]
X is located in Y X , which is located in Y
X, located in Y X has the position of Y
X, who has the position of Y X, whose position is that of Y
X’s position is Y X, who holds the position of Y
X holds the position of Y
[X, capableof, Y]
X is capable of Y X can Y
X has the ability of Y Y is the ability of X Y can be done by X
[X, causes, Y]
X causes Y X is a cause of Y
Y because X Y is because of X X has a result of Y Y is a result of X
[X, createdby, Y]
X is created by Y Y created X
X is made by Y Y made X
[X, isa, Y] X is a Y
X is also a Y X is equal to Y
[X, desires, Y]
X desires Y X wants Y
Y is desired by X Y is wanted by X
[X, hassubevent, Y] X has a subevent of Y Y is a subevent of X
[X, partof, Y] X is part of Y
X is a part of Y X, which is part of Y
[X, hascontext, Y]
X has context of Y X has a context including Y
when talking about X, we also talking about Y X is close to Y in context
[X, hasproperty, Y] X has a property of Y Y is a property of X
X, with a property of Y
[X, madeof, Y]
X is made of Y Y is used to make X
X’s material is Y the material of X is Y
[X, notcapableof, Y]
X is not capable of Y X can not Y
Y can’t be done by X X doesn’t has the ability of Y
X is not able that Y Y is not a ability of X
[X, notdesires, Y]
X doesn’t desire Y X don’t want X X don’t desire Y X doesn’t want Y X doesn’t need Y
ACL 2023 Responsible NLP Checklist

heading: A For every submission:
text: 3 A1. Did you describe the limitations of your work?
Section Limitation
7 A2. Did you discuss any potential risks of your work? The main goal of this article is to explain the reasoning process of the model, only relying on the input of the model. And the input comes from a known data set.
3 A3. Do the abstract and introduction summarize the paper’s main claims? Section Abstract and Section 1
7 A4. Have you used AI writing assistants when working on this paper? All the content are writen by human.
B 3 Did you use or create scientific artifacts? Section 5
3 B1. Did you cite the creators of artifacts you used? Section 5
7 B2. Did you discuss the license or terms for use and / or distribution of any artifacts? The data set is open source, and the license is not mentioned on the leaderboard.
3 B3. Did you discuss if your use of existing artifact(s) was consistent with their intended use, provided 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)? The usage is mainly about explaining the internal reasoning process. It is discussed in introduction and conclusion.
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? All the corpus in this paper is constructed ramdomly, which is not related to individual people or offensive content.
7 B5. Did you provide documentation of the artifacts, e.g., coverage of domains, languages, and linguistic phenomena, demographic groups represented, etc.? All we used are open-source dataset and knowledge base, has nothing related to linguistic phenomena, demographic groups represented.
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. In the part of experimental setup and appendix.
The Responsible NLP Checklist used at ACL 2023 is adopted from NAACL 2022, with the addition of a question on AI writing assistance.
C 3 Did you run computational experiments? Section 6
3 C1. Did you report the number of parameters in the models used, the total computational budget (e.g., GPU hours), and computing infrastructure used? Experimental setup in Section 5.
3 C2. Did you discuss the experimental setup, including hyperparameter search and best-found hyperparameter values? Section 5 and 6.
3 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? In Appendix.
3 C4. If you used existing packages (e.g., for preprocessing, for normalization, or for evaluation), did you report the implementation, model, and parameter settings used (e.g., NLTK, Spacy, ROUGE, etc.)? Section 5.
D 3 Did you use human annotators (e.g., crowdworkers) or research with human participants? Section 6
3 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.? We just gave the evaluation criteria that the evaluators need to refer to, which has been listed in Section5.
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)? We only have two people doing a small amount of evaluation, no payment is involved.
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? All participants knew that we were going to manually evaluate the explanatory graphs and learned about the evaluation rules in detail.
7 D4. Was the data collection protocol approved (or determined exempt) by an ethics review board? We use the open source dataset. And we didn’t collect data.
7 D5. Did you report the basic demographic and geographic characteristics of the annotator population that is the source of the data? Only 2 persons take part in the process, who are no related to the experiment from our experiments.

heading: Future Work
text: In the future, the ability of the model to generate explanation graphs will benefit from more datasets
released with labels and more and more objective evaluation indicators put forward. Additionally, while our current approach processes graphs as strings, utilizing a model architecture that is more suitable for graph generation may further enhance the model’s graph generation ability. Limitations
In our experiments, the most significant limitation is the lack of computational resources. Experimental results in this paper and previous work(Saha et al. , 2022) have shown that a larger scale of models could lead to higher structural and semantic accuracy of explanation graphs in this task. Constrained by computational resources, BART-Large is the largest model on which we can perform the complete process of experiments. We believe that graph generation would be better if sufficient resources were available to perform synthetic data based pre-training on a larger model. In addition, since the evaluation metrics for graph generation tasks are incomplete yet, we can only evaluate a few samples manually outside of the metrics of the dataset, which is more subjective. With more evaluation methods with standardized processes proposed, the results of the experiment will be evaluated more objectively