Original: G RA DA: Graph Generative Data Augmentation for Commonsense Reasoning
Revised: G RA DA: Graph Generative Data Augmentation for Commonsense Reasoning

Original: Anonymous ACL submission

Original: Abstract
Revised: Abstract

Original: Recent advances in commonsense reasoninghave been fueled by the availability of largescale human annotated datasets.
Revised: Recent advances in commonsense reasoning have been fueled by the availability of largescale human annotated datasets.

Original: Manual annotation of such datasets, many of which arebased on existing knowledge bases, is expensive and not scalable.
Revised: Manual annotation of such datasets, many of which are based on existing knowledge bases, is expensive and not scalable.

Original: Moreover, it is challenging to build augmentation data for commonsense reasoning because the synthetic questionsneed to adhere to real-world scenarios.
Revised: Moreover, it is challenging to build augmentation data for commonsense reasoning because the synthetic questions need to adhere to real-world scenarios.

Original: Hence,we present G RA DA, a graph-generative dataaugmentation framework to synthesize factualdata samples from knowledge graphs for commonsense reasoning datasets.
Revised: Hence, we present G RA DA, a graph-generative data augmentation framework to synthesize factual data samples from knowledge graphs for commonsense reasoning datasets.

Original: First, we train agraph-to-text model for conditional generationof questions from graph entities and relations.
Revised: First, we train a graph-to-text model for conditional generation of questions from graph entities and relations.

Original: Next, we train a generator with GAN loss togenerate distractors for synthetic questions.
Revised: Then, we train a generator with GAN loss to generate distractors for synthetic questions.

Original: Wethen explore various filters to denoise the synthetic dataset.

Original: Our approach improves performance for SocialIQA, CODAH, HellaSwag and CommonsenseQA, and works well for generative tasks like ProtoQA.
Revised: Our approach improves performance for SocialIQA, CODAH, HellaSwag and CommonsenseQA, and works well for generative tasks like ProtoQA.

Original: We show improvementin robustness to semantic adversaries after training with G RA DA and provide human evaluation of the quality of synthetic datasets in termsof factuality and answerability.
Revised: We show improvement in robustness to semantic adversaries after training with G RA DA and provide human evaluation of the quality of synthetic datasets in terms of factuality and answerability.

Original: Our work provides evidence and encourages future researchinto graph-based generative data augmentation.
Revised: Our work provides evidence and encourages future research into graph-based generative data augmentation.

Original:  Introduction
Revised:  Introduction

Original: Recent work has seen the emergence of severaldatasets for improving commonsense reasoning oflanguage models through tasks like question answering (QA) (Sap et al., 2019b; Talmor et al.
Revised: Recent work has seen the emergence of several datasets for improving commonsense reasoning of language models through tasks like question answering (QA) (Sap et al., 2019b; Talmor et al., 2019;

Original: ,2019; Bisk et al., 2020) and natural language inference (Bhagavatula et al., 2020;
Revised: Bisk et al., 2020) and natural language inference (Bhagavatula et al., 2020;

Original: Zellers et al., 2019;
Revised: Zellers et al., 2019;

Original: Sakaguchi et al., 2020).
Revised: Sakaguchi et al., 2020).

Original: Some of these datasetsare based on existing knowledge graphs that represent different aspects of commonsense throughentities and relations.
Revised: Some of these datasets are based on existing knowledge graphs that represent different aspects of commonsense through entities and relations.

Original: For example, annotators for
Revised: For example, annotators for

Original: SocialIQA (Sap et al., 2019b) were shown an eventfrom the inferential knowledge graph ATOMIC(Sap et al., 2019a) and instructed to turn it into
Revised: SocialIQA (Sap et al., 2019b) were shown an event

Original: [Figure]
Revised: [Figure]

Revised: from the inferential knowledge graph ATOMIC (Sap et al., 2019a)

Original:  a sentence by adding names, filling placeholders and adding context, etc.
Revised: and instructed to turn it into a sentence by adding names, filling placeholders and adding context, etc.

Original: For multiple-choice QA datasets, annotators are also instructed to write distractor choices for each question.
Revised: For multiple-choice QA datasets, annotators are also instructed to write distractor choices for each question.

Original: These useful datasets are collected through a time-taking and money-intensive crowdsourcing process which is hard to scale.
Revised: These useful datasets are collected through a time-taking and money-intensive crowdsourcing process which is hard to scale.

Original: Large pretrained models like GPT (Radford et al., 2018) can be finetuned to generate sentences from narrow data distributions, and it has recently been leveraged to augment datasets for text classification (Anaby-Tavor et al., 2020) and question answering (Puri et al., 2020; Yang et al., 2020).
Revised: Large pretrained models like GPT (Radford et al., 2018) can be finetuned to generate sentences from narrow data distributions, and it has recently been leveraged to augment datasets for text classification (Anaby-Tavor et al., 2020) and question answering (Puri et al., 2020; Yang et al., 2020).

Original: However, it is challenging to generate augmentation data for commonsense reasoning because the generated questions and answers (referred to as “synthetic” in rest of the paper) need to depict plausible real-world scenarios accurately.
Revised: However, it is challenging to generate augmentation data for commonsense reasoning because the generated questions and answers (referred to as “synthetic” in rest of the paper) need to depict plausible real-world scenarios accurately.

Original: Hence, we develop G RA DA, a graph-based generative data augmentation framework to generate synthetic samples from existing knowledge graphs that encode information about the real world.
Revised: Hence, we develop G RA DA, a graph-based generative data augmentation framework to generate synthetic samples from existing knowledge graphs that encode information about the real world.

Original: Each sample in commonsense reasoning datasetscomprises a question which describes a real-worldscenario and can be mapped to a set of predefinedentities and relations from knowledge bases like
Revised: Each sample in commonsense reasoning datasets comprises a question which describes a real-world scenario and can be mapped to a set of predefined entities and relations from knowledge bases like

Original: ConceptNet and ATOMIC.
Revised: ConceptNet and ATOMIC.

Original: For instance, the question “Besides a mattress, name something peoplesleep on.”
Revised: For instance, the question “Besides a mattress, name something people sleep on.”

Original: from the ProtoQA dataset (Boratko et al. ,2020) can be mapped to the single-hop path (mattress, RelatedTo , people) using ConceptNet.
Revised: from the ProtoQA dataset (Boratko et al., 2020) can be mapped to the single-hop path (mattress, RelatedTo , people) using ConceptNet.

Original: Ifa pretrained language model is trained to conditionally generate questions from such input paths,we can expect it to generate sensible questionswhen it is provided new paths with similar relations.
Revised: If a pretrained language model is trained to conditionally generate questions from such input paths, we can expect it to generate sensible questions when it is provided new paths with similar relations.

Original: The model will likely generalize to unseen entitynodes and generate questions containing uniquecommonsense knowledge.
Revised: The model will likely generalize to unseen entity nodes and generate questions containing unique commonsense knowledge.

Original: Following this intuition, we finetune GPT2 (Radford et al., 2019) togenerate questions which explicitly depict the entities and relations in input path.
Revised: Following this intuition, we finetune GPT2 (Radford et al., 2019) to generate questions which explicitly depict the entities and relations in input path.

Original: When trainedon the aforementioned example (alongside othersimilar examples) and provided with the new path(mattress, RelatedTo , soft), our model generates“Besides a mattress, name something that’s soft. ”,which is a valid question for probing real-worldcommonsense.
Revised: When trained on the aforementioned example (alongside other similar examples) and provided with the new path (mattress, RelatedTo , soft), our model generates “Besides a mattress, name something that’s soft.”, which is a valid question for probing real-world commonsense.

Original: Usually, these paths contain multiple nodes with several hops and hence are referredto as graphs in rest of the paper.
Revised: Usually, these paths contain multiple nodes with several hops and hence are referred to as graphs in rest of the paper.

Original: In order to represent the graph, we explore both (a) encoding oflinearized graph and (b) augmentation of linear encodings with structure-aware encoding of graph,and find that the latter improves the transfer ofsemantic knowledge from graph to text.
Revised: In order to represent the graph, we explore both (a) encoding of linearized graph and (b) augmentation of linear encodings with structure-aware encoding of graph, and find that the latter improves the transfer of semantic knowledge from graph to text.

Original: Synthetic questions need to be accompaniedby synthetic answers and distractor choices (formultiple-choice datasets), which are similarly generated by finetuning GPT2 for conditional generation of answers/distractors from the question.
Revised: Synthetic questions need to be accompanied by synthetic answers and distractor choices (for multiple-choice datasets), which are similarly generated by finetuning GPT2 for conditional generation of answers/distractors from the question.

Original: However, Yang et al.
Revised: However, Yang et al.

Original: (2020) report that human annotators find it hard to pick a unique/unambiguousanswer in more than 50% of the synthetic datasetgenerated in this manner.
Revised: (2020) report that human annotators find it hard to pick a unique/unambiguous answer in more than 50% of the synthetic dataset generated in this manner.

Original: Therefore, we explorean alternative where we finetune the generativemodel within a GAN framework (Nie et al. , 2019a)where it is continuously challenged by a discriminator model to generate unique distractors that canfool the discriminator (see OptionGAN, Figure 1).
Revised: Therefore, we explore an alternative where we finetune the generative model within a GAN framework (Nie et al., 2019a) where it is continuously challenged by a discriminator model to generate unique distractors that can fool the discriminator (see OptionGAN, Figure 1).

Original: The synthetic questions and answers thus generated are assembled into synthetic samples whichare then used in a two-stage training pipeline (Mitra et al., 2019).
Revised: The synthetic questions and answers thus generated are assembled into synthetic samples which are then used in a two-stage training pipeline (Mitra et al., 2019).

Original: Additionally, since the generativepipeline is only an approximate imitation of the human annotation process, we are left with several ambiguous and inaccurate samples in the synthetic pool.
Revised: Additionally, since the generative pipeline is only an approximate imitation of the human annotation process, we are left with several ambiguous and inaccurate samples in the synthetic pool.

Original: We compare three methods to find the most informative data samples from this pool: Question
Revised: Hence, we retain the most informative data samples from the synthetic pool by using Question

Original: Answering Probability (Zhang and Bansal, 2019) to measure accuracy by answerability, Confidence and Variability (Swayamdipta et al., 2020) to measure generalizability, and Energy score (Liu et al., 2020) to filter out-of-distribution samples.
Revised: Answering Probability (Zhang and Bansal, 2019) to measure accuracy by answerability.

Original: Our contributions can be summarized as follows:
Revised: Our contributions can be summarized as follows:

Original: • We present a generative framework consisting of (i) a graph-to-text model to convert knowledge graphs to questions and (ii) a model finetuned with GAN loss to generate distractors for com-
Revised: • We present a generative framework consisting of (i) a graph-to-text model to convert knowledge graphs to questions, (ii) a model finetuned with GAN loss to generate distractors for commonsense reasoning QA datasets, and (iii) combined with a filter for selecting the most informative samples from synthetic datasets.

Original: monsense reasoning QA datasets.

Original: • We propose filters for selecting the most informa-

Original: tive samples from synthetic datasets.

Original: • We improve performance on commonsense rea- soning datasets, and perform ablation analysis to show the impact of various modules in our frame- work as well as human evaluation of synthetic 
Revised: • We improve performance on commonsense reasoning datasets, and perform ablation analysis to show the impact of various modules in our framework as well as human evaluation of synthetic dataset quality.

Original: dataset quality.

Original:  Related Work
Revised:  Related Work

Original: Explicit reasoning over knowledge graphs has been a popular approach for improving commonsense understanding of QA models.
Revised: Explicit reasoning over knowledge graphs has been a popular approach for improving commonsense understanding of QA models.

Original: Bauer et al.
Revised: Bauer et al.

Original: Lin et al.
Revised: Lin et al.

Original: ; De Cao et al.
Revised: ; De Cao et al.

Original: ; Feng et al.
Revised: ; Feng et al.

Original: (2020) and Lv et al.
Revised: (2020) and Lv et al.

Original: (2020) extract relevant multi-hop relational commonsense from knowledge graphs and show significant improvements over models that operate solely on text.
Revised: (2020) extract relevant multi-hop relational commonsense from knowledge graphs and show significant improvements over models that operate solely on text.

Original: Devlin et al.
Revised: Devlin et al.

Original: ; Yang et al.
Revised: ; Yang et al.

Original: ; Ye et al.
Revised: ; Ye et al.

Original: (2019) expand the rich latent knowledge of large pretrained models by finetuning on similar corpora (Havasi et al., 2010) before finetuning on the target dataset.
Revised: (2019) expand the rich latent knowledge of large pretrained models by finetuning on similar corpora (Havasi et al., 2010) before finetuning on the target dataset.

Original: Mitra et al.
Revised: Mitra et al.

Original: (2019) convert external resources (Koupaee and Wang, 2018) to QA samples for data augmentation.
Revised: (2019) convert external resources (Koupaee and Wang, 2018) to QA samples for data augmentation.

Original: Yang et al.
Revised: Yang et al.

Original: (2020) generate randomly initialized samples from finetuned GPT2 as augmentation data for target datasets.
Revised: (2020) generate randomly initialized samples from finetuned GPT2 as augmentation data for target datasets.

Original: We ground the generated samples to real-world facts by providing knowledge graphs as input to the model.
Revised: We ground the generated samples to real-world facts by providing knowledge graphs as input to the model.

Original: There has been a surge of efforts in neural graphto-text modeling in the recent years.
Revised: There has been a surge of efforts in neural graphto-text modeling in the recent years.

Original: Marcheggiani and Perez-Beltrachini (2018) encode input graphs using a graph convolutional encoder (Kipf and Welling, 2017).
Revised: Marcheggiani and Perez-Beltrachini (2018) encode input graphs using a graph convolutional encoder (Kipf and Welling, 2017).

Original: Koncel-Kedziorski et al.
Revised: Koncel-Kedziorski et al.

Original: (2019) propose the model GraphWriter which improves on the graph attention networks presented in Velickovic et al.
Revised: (2019) propose the model GraphWriter which improves on the graph attention networks presented in Velickovic et al.

Original: (2018) by replacingself-attention encoder with Transformer blocks(Vaswani et al.,2017).
Revised: by replacing self-attention encoder with Transformer blocks (Vaswani et al.,

Original: More recently, severalworks have shown that pretrained generative models outperform graph-to-text models by large margins (Mager et al., 2020;
Revised: Several recent works have shown that pretrained generative models can be finetuned with or without structure-aware graph encoding to improve graph-to-text generation (Mager et al., 2020;

Original: Ribeiro et al., 2020; Hoyleet al., 2020; He et al., 2020).
Revised: Ribeiro et al., 2020; Hoyle et al., 2020; He et al., 2020; Ke et al., 2021).

Revised: Query or question generation has also been shown to benefit from knowledge graphs in Shen et al.

Original:  We combine thestructure-aware encoding capabilities of graph-totext models with the rich contextual knowledge ofpretrained models in GraphGPT2 and generate richreal-world scenarios from sparse sub-graphs.
Revised: ; Bi et al. We combine the structure-aware encoding capabilities of graph-to-text models with the rich contextual knowledge of pretrained models in GraphGPT and generate rich real-world scenarios from sparse sub-graphs (Shen et al., 2022; Chen et al., 2020; Kumar et al., 2019).

Original: Good distractors are necessary for a task modelto learn the right reasoning towards answeringmultiple-choice datasets.
Revised: Good distractors are necessary for a task model to learn the right reasoning towards answering multiple-choice datasets.

Original: To this end, Liang et al.(2018) rank distractors using feature-based ensemble methods.
Revised: To this end, Liang et al. (2018) rank distractors using feature-based ensemble methods.

Original: Offerijns et al.
Revised: Offerijns et al.

Original: Yanget al.
Revised: ; Yang et al.

Original: (2020) finetune GPT2 to generate distractors.
Revised: (2020) finetune GPT2 to generate distractors.

Original: Chung et al.
Revised: Chung et al.

Original: (2020) approach distractor generation as a coverage problem and select distractorsfor maximizing sample difficulty.
Revised: (2020) approach distractor generation as a coverage problem and select distractors for maximizing sample difficulty.

Original: Cai and Wang(2018) use adversarial training to sample high quality negative training examples for knowledge graphembeddings.
Revised: Cai and Wang (2018) use adversarial training to sample high quality negative training examples for knowledge graph embeddings.

Original: In a similar line of work, we use generative adversarial networks (GANs) (Goodfellowet al., 2014) with the Gumbel-Softmax relaxation(Kusner and Hernández-Lobato, 2016; Nie et al.,2019b) and train a generator with GAN loss toimitate the creation of human-authored tricky, incorrect answer options.
Revised: In a similar line of work, we use generative adversarial networks (GANs) (Goodfellow et al., 2014) with the Gumbel-Softmax relaxation (Kusner and Hernández-Lobato, 2016; Nie et al., 2019b) and train a generator with GAN loss to imitate the creation of human-authored tricky, incorrect answer options.

Original: Most NLP applications use
Revised: Most NLP applications use

Original: REINFORCE (Sutton et al., 2000) algorithm andits variants (Yu et al., 2017; Cai and Wang, 2018;
Revised: REINFORCE (Sutton et al., 2000) algorithm and its variants (Yu et al., 2017; Cai and Wang, 2018;

Original: Qin et al., 2018; Zhang et al., 2018) to circumventthe discrete sampling issue for text-based GANs.
Revised: Qin et al., 2018; Zhang et al., 2018) to circumvent the discrete sampling issue for text-based GANs.

Original:  Methods
Revised:  Methods

Original: In this section, we describe the generative modelsin the G RA DA framework and the various filteringmethods.
Revised: In this section, we describe the various modules in the G RA DA framework.

Original: 3. Graph-to-Text Generation
Revised: 3. Graph-to-Text Generation

Original: In the first module of our pipeline, we generatesynthetic questions by using knowledge graphs asinput.
Revised: In the first module of our pipeline, we generate synthetic questions by using knowledge graphs as input.

Original: Given a dataset of input graphs ( g i ), we finetune GPT2 with cross-entropy loss for conditionalgeneration of questions ( q i ) from the graphs i.e.,
Revised: Given a dataset of input graphs ( g i ), we finetune GPT2 with cross-entropy loss for conditional generation of questions ( q i ) from the graphs i.e.,

Original: L q = (cid:80) Ni =1 logP ( q i | f ( g i )) , where f ( . ) is the function for encoding the graph.
Revised: L q = (cid:80) Ni =1 log p ( q i | f ( g i )) , where f ( . ) is the function for encoding the graph and p ( . ) represents the probabilities.

Original: We explore linearizedgraph encoding as well as structure-aware graphencoding for f ( . ) .
Revised: We explore linearized graph encoding as well as structure-aware encoding of graph.

Original: Linearized Graph Input.
Revised: Linearized Graph Input.

Original: Graph linearization is a simple way to use graphs like text when finetuning GPT2.
Revised: Graph linearization is a simple way to use graphs like text when finetuning GPT2.

Original: We adopt depth-first-search to linearize the input graphs and preserve edge information to some extent by augmenting GPT vocabulary with special tokens for edges.
Revised: We adopt depth-first-search to linearize the input graphs and preserve edge information to some extent by augmenting GPT vocabulary with special tokens for edges.

Original: GPT is finetuned for conditional generation of target question from this linearized graph input.
Revised: GPT is finetuned for conditional generation of target question from this linearized graph input.

Original: Recent work has revealed that using linearized graphs with pretrained language models (PTLMs) surpasses graph-basedencoder-decoder architectures at data-to-text generation by a large margin (Ribeiro et al., 2020).
Revised: Using linearized graphs with pretrained language models (PTLMs) surpasses graph-based architectures at data-to-text generation by a large margin (Ribeiro et al., 2020).

Original: However, Mager et al.
Revised: However, Mager et al.

Original: (2020) show that omitting the edge information from linearized graphs notably degrades performance, which means thatthe graph structure is beneficial for generation.
Revised: (2020) show that omitting the edge information from linearized graphs notably degrades performance, implying that graph structure is beneficial for generation.

Original: Hence, we propose GraphGPT2.
Revised: Hence, we propose GraphGPT2.

Original: GraphGPT2 for Structure-aware Graph Input.
Revised: GraphGPT2 for Structure-aware Graph Input.

Original: Instead of linearizing the input graph, we encode the graph using a Transformer-based graph encoder( f s ( . )) which preserves the graph structure by performing masked self-attention over edges and nodes (Koncel-Kedziorski et al., 2019). We use the Transformer-based graph encoder from Graph Writer  for structure-preserving encoding of graphs.
Revised: Instead of linearizing the input graph, we encode the graph using a Transformer-based graph encoder f s ( . ) which preserves the graph structure by performing masked self-attention over edges and nodes. We use the Transformer-based graph encoder from Graph Writer (Koncel-Kedziorski et al., 2019) for structure-preserving encoding of graphs.

Original: First, we convert the input graphs g i into unlabeled connected bipartite graphs
Revised: First, we convert the input graphs g i into unlabeled connected bipartite graphs

Original: G i =
Revised: G i =

Original: ( v i , e i ) , where v i is the list of entities, relations and global vertex, and e i is the adjacency matrix describing the directed edges (Beck et al., 2018).
Revised: ( v i , e i ) , where v i is the list of entities, relations and global vertex, and e i is the adjacency matrix describing the directed edges (Beck et al., 2018).

Original: The global vertex is connected to all entity vertices and promotes global context modelling by allowing information flow between all parts of the graph.
Revised: The global vertex is connected to all entity vertices and promotes global context modelling by allowing information flow between all parts of the graph.

Original: Next, v i is projected to a dense, continuous embedding space V i and is sent as input to the graph encoder (see Figure 2).
Revised: Next, v i is projected to a dense, continuous embedding space V i and is sent as input to the graph encoder (see Figure 2).

Original: The encoder is composed of L stacked Transformer blocks; each Transformer block consists of a N -headed self-attention layer followed by normalization and a two-layer feed-forward network.
Revised: The encoder is composed of L stacked Transformer blocks; each Transformer block consists of a N -headed self-attention layer followed by normalization and a two-layer feed-forward network.

Original: The resulting encodings  are referred to as graph contextualized vertex encodings.
Revised: The resulting encodings i.e. f s ( g i ) , are referred to as graph contextualized vertex encodings.

Original: These encodings are prepended to the embedded representation of linearized graph, and sent as input to the decoder.
Revised: These encodings are prepended to the embedded representation of linearized graph in the form of past key values, and sent as input to the decoder.

Original: The decoder i.e. pretrained GPT2 is finetuned to generate a coherent question from the combined embeddings.
Revised: The decoder i.e., pretrained GPT2, is finetuned to generate a coherent question from the combined embeddings.

Original: The graph encoder is initialized with
Revised: The graph encoder is initialized with

Original: GPT2 embeddings to force continuity in word representation across modules.
Revised: GPT2 embeddings to force continuity in word representation across modules.

Original: Figure 2 shows the integration of graph contextualized encodings with
Revised: Figure 2 shows the integration of graph contextualized encodings with

Original: GraphAttention
Revised: GraphAttention

Original: Feedforward
Revised: Feedforward

Original: Norm & Add x L
Revised: Norm & Add x L

Original: Linearized Graph
Revised: Linearized Graph

Original: Norm & Add
Revised: Norm & Add

Original: G r aph
Revised: G r aph

Original: E n c ode r
Revised: E n c ode r

Original: GPT2 Embeddings
Revised: GPT2 Embeddings

Original: Contextualized
Revised: Contextualized

Original: Embeddings Graph Embeddings
Revised: Embeddings Graph Embeddings

Original: Casey owed money for college and Remy paid her bill so she wouldn't owe.
Revised: Casey owed money for college and Remy paid her bill so she wouldn't owe.

Original: PersonX owes PersonY money money expensive payment college
Revised: PersonX owes PersonY money money expensive payment college

Original: HasWord
Revised: HasWord

Original: HasPrerequisite IsA
Revised: HasPrerequisite IsA

Original: HasContext
Revised: HasContext

Original: GPT2 in GraphGPT2.
Revised: GPT2 in GraphGPT2.

Original: The combined generativemodel is finetuned end-to-end for maximizing theconditional log-likelihood of target question q i i.e.
Revised: The combined generative model is finetuned end-to-end for maximizing the conditional log-likelihood of target question q i i.e.

Original: L q = (cid:80) Ni =1 logP ( q i |  f l ( g i ) , f s ( g i )) , where f l ( . )represents the linearized graph embeddings.
Revised: L q = (cid:80) Ni =1 log p ( q i | [ f l ( g i ); f s ( g i )]) , where f l ( . ) represents the linearized graph embeddings.

Original: During inference, both of the above models areprovided with graphs that do not appear in trainingdataset to generate synthetic questions containingnew knowledge.
Revised: During inference, both of the above models are provided with graphs that do not appear in training dataset to generate synthetic questions containing new knowledge.

Original: See Sec.
Revised: See Sec.

Original: 4.1 for details on creationof training and inference datasets.
Revised: 4.1 for details on creation of training and inference datasets.

Original: 3. Answer & Distractor Generation
Revised: 3. Answer & Distractor Generation

Original: We finetune two separate GPT2 models for conditional generation of answersand distractors respectively from questions, using cross entropy lossas:
Revised: We finetune a GPT2 model for conditional generation of answers from questions i.e., L a = (cid:80)

Original: L a = (cid:80) Ni =1 logP ( a i | q i ) .
Revised: Ni =1 log p ( a i | q i ) .

Original: As we discussed in
Revised: However, as we discussed in

Original: Sec. 1, this method  does not guarantee good distractors.
Revised: Sec. 1, a similar method for conditional generation of distractors does not guarantee good distractors.

Original: Hence, wefurther finetune the model forgenerating distractors within a GAN framework togenerate maximally adversarial choices, in a bid toimitate the best human annotator.
Revised: Hence, we finetune GPT2 within a GAN framework to generate maximally adversarial distractors, in a bid to imitate the best human annotator.

Original: OptionGAN for Adversarial Choices.
Revised: OptionGAN for Adversarial Choices.

Original: We traina model to generate distractors (in the multiplechoice QA task) for the synthetic questions obtained from GraphGPT2 (see Figure 1) using agenerator-discriminator framework.
Revised: We train a model to generate distractors (in the multiplechoice QA task) for the synthetic questions obtained from GraphGPT2 (see Figure 1) using a generator-discriminator adversarial framework.

Original: The discriminator  is trained for thebinary task of classifyinga pair of question and answer as true if the givenanswer correctly answers the question.
Revised: The discriminator D is a sequential classification model that takes the question q i , concatenated with the ground truth correct answer a

Revised: i i.e., [ q i ; a i ] or the distractor ˆ d i generated by generator G i.e., [ q i ; ˆ d i ] as input and classifies the pair as correct or otherwise.

Original: While training, the generator runs the risk of learning to generate correct answers instead of distractors, sinceit’s goal is to be able to fool the discriminator intoclassifying the answer as correct.
Revised: While training, the generator runs the risk of learning to generate correct answers instead of distractors, since it’s goal is to be able to fool the discriminator into classifying the questiondistractor pair [ q i ; ˆ d i ] as correct.

Original: To prevent this,we heavily bias the model by first pretraining itto generate only distractors using the conditionalcross-entropy loss and then continue training Op-
Revised: To prevent this, we heavily bias the model by first pretraining it

Original: [Figure]
Revised: [Figure]

Original: tionGAN from the saved weights.
Revised: to generate only distractors using the conditional cross-entropy loss and then continue with adversarial training from the saved weights.

Original: The generator 
Revised: Mathematically, we pretrain the generator G with the loss

Original: [Figure]
Revised: L g = (cid:80) Ni =1 log p ( d i | q i ) , where q i , d i are question and distractor, respectively. We use the question as input instead of the knowledge sub-graph, since most generated questions contain additional semantics from the latent knowledge of the pretrained generative model which is not present in the original sub-graph.

Original:  is trained to produce distractors that successfully fool the discriminator, so that we get adversarial options that are as tricky as human-annotated options (see Figure 3).
Revised: Then, the pretrained generator is finetuned within an adversarial framework to produce distractors that successfully fool the discriminator, so that we get adversarial options that are as tricky as human-annotated options (see Figure 3).

Original: We use the Gumbel-Softmax relaxation (Nie et al., 2019a) while sampling from generator to allow flow of gradients through the discriminator model. Mathematically, we first finetune the generator with: L g = (cid:80) Ni =1 logP
Revised: We use the Gumbel-Softmax relaxation (Nie et al., 2019a) while sampling from generator to allow flow of gradients through the discriminator model i.e. z = softmax ( 1 τ ( h + g )) , where h , g and τ are the logits generated from G ,

Original: ( d i | q i ) , where q i , d i are question and distractor, respectively.
Revised: Gumbel distribution sample and temperature respectively.

Original: Then, we finetune the generator G and discriminator D iteratively in a mini-max game: L d = (cid:80) [Equation] log sigmoid ( P
Revised: The temperature is annealed using an exponential function during training.

Original: [Equation]
Revised: Following

Original: i | [Equation] [Equation] P ( G  (  q i ) | q i )) , where a i is the correct answer for question q i  .
Revised: RelGAN (Nie et al., 2019a), we use the Relativistic standard GAN loss for the adversarial training i.e. min G max D log sigmoid ( D ([ q i ; a i ]) − D ([ q i ; ˆ d i ])) .

Original: Generator G is trained to minimize the loss while discriminator D is trained to maximize the loss.
Revised: Generator G is trained to minimize the loss while discriminator D is trained to maximize the loss.

Revised: In practice, we use GPT2 for both roles i.e., generator as well as discriminator.

Original: 3. Filtering and Selection of Samples
Revised: 3. Filtering and Selection of Samples

Original: Inspite of the careful construction of synthetic samples using knowledge graphs, the pool of synthetic samples can be noisy and may consist of incoherent text, incorrect question-answer pairs or outof-distribution samples.
Revised: Inspite of the careful construction of synthetic samples using knowledge graphs, the pool of synthetic samples can be noisy and may consist of incoherent text, incorrect question-answer pairs or outof-distribution samples.

Original: Hence, we compare the effect of three different methods to filter samples on downstream task performance.

Original: Question Answering Probability (QAP).

Original: The

Original: QAP score ( µ ) (Zhang and Bansal, 2019) is the prediction probability of the true class by a model with parameters θ which has been trained on the original dataset i.e. µ i = p θ ( y ∗ i | x i ) . Samples with low prediction probabilities for the correct choices are either annotated incorrectly or are especially difficult instances for the model. We define a low and high threshold for the QAP filter and samples lying within this range are retained in the dataset.
Revised: Hence, we use Question

Original: Model

Original: Confidence and Variability. Swayamdipta et al. (2020) propose the model confidence ( ˆ µ i ) and variability ( ˆ σ i ) measures to identify
Revised: Answering Probability (QAP) (Zhang and Bansal, 2019) to measure accuracy of synthetic samples.

Original: The Sunday paper ran an important story about global warming.
Revised: The Sunday paper ran an important story about global warming.

Original: The article was __.
Revised: The article was __.

Original: begin in morning story news newspaper morning
Revised: begin in morning story news newspaper morning

Original: CapableOf
Revised: CapableOf

Original: PartOf
Revised: PartOf

Original: AtLocation
Revised: AtLocation

Original: RelatedTo
Revised: RelatedTo

Original: RelatedTothe effect of data samples on the model’s generalization error. Specifically, ˆ µ i = 1 E (cid:80) Ee =1 p θ ( y [Equation] i | x i )and ˆ σ i = (cid:114)(cid:80) E e
Revised: RelatedTo

Original: =1 ( p [Equation] ( y [Equation]
Revised: The QAP score ( µ ) is the prediction probability of the true class by a model with parameters θ which has been trained on the original dataset i.e. µ i =

Original:  i [Equation] x 
Revised: p θ ( a i | x i ) .

Original: [Equation] ) − ˆ µ i ) E , where E istraining epochs. They find that ambiguous samplesi.e.
Revised: Samples with low prediction probabilities for the correct choices are either annotated incorrectly or are especially difficult instances for the model.

Original: , high variability and mid-range confidence,contribute the most to test performance on downstream task. Following this, we define  low andhigh thresholds for both confidence and variabilityin order to find the most informative samples. Energy.
Revised: We define a low and high threshold for the QAP filter and samples lying within this range are retained in the dataset.

Original: Liu et al. (2020) show that the energyscore can be reliably used for distinguishing between in- and out-of-distribution (OOD) samples,as compared to the traditional approach of using thesoftmax scores. We introduce an energy thresholdto select samples which are out-of-distribution i.e. E i =
Revised: See supplementary for a comparison of QAP with two other methods for filtering i.e. Energy (Liu et al., 2020) and Model Confidence & Variability (Swayamdipta et al., 2020).

Original: − log (cid:80) Cj e p θ ( y ji | x ) where C is the number ofchoices in the QA sample, and measure the effectof using OOD samples as augmentation data.

Original:  Experimental Setup 
Revised:  Experimental Setup 4. Datasets

Original: 4. Datasets

Original: SocialIQA (Sap et al., 2019b) and CommonsenseQA (Talmor et al., 2019) are annotated usingknowledge graphs, making them a suitable choicefor testing our approach.
Revised: SocialIQA (Sap et al., 2019b) and CommonsenseQA (Talmor et al., 2019) are annotated using knowledge graphs, making them a suitable choice for testing our approach.

Original: SocialIQA is a questionanswering dataset based on ATOMIC (Sap et al.,2019a), containing 33,410/1954/2224 samples intraining, development and test set, resp.
Revised: SocialIQA is a question answering dataset based on ATOMIC (Sap et al., 2019a), containing 33,410/1954/2224 samples in training, development and test set, resp.

Original: CommonsenseQA (CQA) is a similarly crowd-sourceddataset based on ConceptNet (Speer et al., 2017)containing an official split of 9741/1221/1241 samples.
Revised: CommonsenseQA (CQA) is a similarly crowd-sourced dataset based on ConceptNet (Speer et al., 2017) containing an official split of 9741/1221/1241 samples.

Original: Following Yang et al.
Revised: Following Yang et al.

Original: , we also testour method on HellaSwag-2K (Zellers et al.
Revised: (2020), we also test our method on HellaSwag-2K (Zellers et al., 2019) and CODAH

Original: , 2019)and CODAH (Chen et al., 2019) for low-resourcescenario.
Revised: (Chen et al., 2019) for low-resource scenario.

Original: HellaSwag-2K is created by sampling2000/1000/1000 examples from HellaSWAG training and validation sets.
Revised: HellaSwag-2K is created by sampling 2000/1000/1000 examples from HellaSWAG training and validation sets.

Original: We test our approach onthe CoDAH folds (2.8k samples) released by Yanget al.
Revised: We test our approach on the CoDAH folds (2.8k samples) released by Yang et al.

Original: (2020) for comparison.
Revised: (2020) for comparison.

Original: Apart from thesefour MCQ datasets, we also experiment with thegenerative QA dataset ProtoQA (9762/52/102) (Boratko et al., 2020) and find that our approach worksespecially well with it.
Revised: Apart from these four MCQ datasets, we also experiment with the generative QA dataset ProtoQA (9762/52/102) (Boratko et al., 2020) and find that our approach works especially well with it.

Original: See Appendix for details.
Revised: See Appendix for details.

Original: Data Preparation.
Revised: Data Preparation.

Original: To prepare graph-to-text datasets for training GraphGPT2, we map the questions to multi-hop paths in ConceptNet (Bauer et al., 2018).
Revised: To prepare graph-to-text datasets for training GraphGPT2, we map the questions to multi-hop paths in ConceptNet (Bauer et al., 2018).

Original: We use Spacy 1 to tag the questions with part-of-speech and extract verbs and nouns as concepts, retaining those that appear in ConceptNet as entities and the connecting relations (see example in Fig. 4).
Revised: We use Spacy 2 to tag the questions with part-of-speech and extract verbs and nouns as concepts, retaining those that appear in ConceptNet as entities and the connecting relations (see example in Fig. 4).

Original: 2 We remove inverse relations from the set of triples.
Revised: 3 We remove inverse relations from the set of triples.

Original: The graphs extracted in this manner are acyclic and can be linearized with a depth-first search.
Revised: The graphs extracted in this manner are acyclic and can be linearized with a depth-first search.

Original: For SocialIQA, we map the questions to a combination of ATOMIC and ConceptNet.
Revised: For SocialIQA, we map the questions to a combination of ATOMIC and ConceptNet.

Original: ATOMIC events contain nouns and verbs which are representative of the social scenario being described in the event and are further extended in the context by SocialIQA annotators.
Revised: ATOMIC events contain nouns and verbs which are representative of the social scenario being described in the event and are further extended in the context by SocialIQA annotators.

Original: We tokenize and stem the events and contexts to extract these representative words, and compute the percentage of overlapping words in the context with respect to each event.
Revised: We tokenize and stem the events and contexts to extract these representative words, and compute the percentage of overlapping words in the context with respect to each event.

Original: The event with maximum overlap with context is selected as the corresponding ATOMIC subject.
Revised: The event with maximum overlap with context is selected as the corresponding ATOMIC subject.

Original: The ATOMIC relation is selected from the predefined map of ATOMIC relations to SocialIQA questions.
Revised: The ATOMIC relation is selected from the predefined map of ATOMIC relations to SocialIQA questions.

Original: This way, we recover the ATOMIC alignments of nearly 20,000 samples from training set of SocialIQA (88% acc.).
Revised: This way, we recover the ATOMIC alignments of nearly 20,000 samples from training set of SocialIQA (88% acc.).

Original: Generation of Synthetic Data.
Revised: Generation of Synthetic Data.

Original: In order to prepare synthetic datasets, we create a dataset of unseen input graphs by mutating the graphs from training sets of graph-to-text datasets.
Revised: In order to prepare synthetic datasets, we create a dataset of unseen input graphs by mutating the graphs from training sets of graph-to-text datasets.

Original: One or two entities are replaced by a randomly selected entity (or relation-entity pair) with similar adjacency to other entities in the input graph, to create a mutated graph.
Revised: One or two entities are replaced by a randomly selected entity (or relation-entity pair) with similar adjacency to other entities in the input graph, to create a mutated graph.

Original: The maximum sequence length of graph contextualized embeddings is set to 64, while that of GPT2 is set to 128.
Revised: The maximum sequence length of graph contextualized embeddings is set to 64, while that of GPT2 is set to 128.

Original: The synthetic dataset size (pre-filtering) is 100k/50k/10k/10k/50k for SocialIQA, CQA, HellaSwag-2K, Codah, and
Revised: The synthetic dataset size (pre-filtering) is 100k/50k/10k/10k/50k for SocialIQA, CQA, HellaSwag-2K, Codah, and

Original: ProtoQA respectively.
Revised: ProtoQA respectively.

Original: For generation of synthetic data for SocialIQA, we use the set of tuples from
Revised: For generation of synthetic data for SocialIQA, we use the set of tuples from

Original: ATOMIC that do not appear in the original dataset.
Revised: ATOMIC that do not appear in the original dataset.

Original: To prepare the synthetic dataset for CommonsenseQA, we select two adversarial choices from
Revised: To prepare the synthetic dataset for CommonsenseQA, we select two adversarial choices from

Original: ConceptNet and two choices generated by OptionGAN.
Revised: ConceptNet and two choices generated by OptionGAN.

Original: For ProtoQA, we find accurate answers by generating 30 sets of answers for each synthetic question, ranking the answer choices by frequency and retaining the ones that appear at least 5 times[Table] [Table] in the 30 sets.
Revised: For ProtoQA, we find accurate answers by generating 30 sets of answers for each synthetic question, ranking the answer choices by frequency and retaining the ones that appear at least 5 times in the 30 sets.

Original: See example of synthetic context generation in Fig.
Revised: See example of synthetic context generation in Fig.

Original: Evaluation.
Revised: Evaluation.

Original: To evaluate graph-to-text generation,we define an O RACLE score which measures thesemantic relevance of synthetic question whenpaired with the original answer options.
Revised: To evaluate graph-to-text generation, we define an O RACLE score which measures the semantic relevance of synthetic question when paired with the original answer options.

Original: We replace the original question in validation set sampleswith the synthetic question and re-evaluate models on this modified dataset.
Revised: We replace the original question in validation set samples with the synthetic question and re-evaluate models on this modified dataset.

Original: In addition, we adoptthe following NLG metrics: BLEU-4 (Papineniet al., 2002), METEOR (Banerjee and Lavie, 2005),
Revised: In addition, we adopt the following NLG metrics: BLEU-4 (Papineni et al., 2002), METEOR (Banerjee and Lavie, 2005),

Original: CIDEr 3 (Vedantam et al., 2015) and BERTScore(F1 score) (Zhang et al., 2020).
Revised: CIDEr 4 (Vedantam et al., 2015) and BERTScore (F1 score) (Zhang et al., 2020).

Original: Models trainedon the synthetic and original commmonsense reasoning datasets are evaluated using their respectivetask-specific accuracies (see Appendix).
Revised: Models trained on the synthetic and original commmonsense reasoning datasets are evaluated using their respective task-specific accuracies (see Appendix).

Original: For ProtoQA, we report the accuracy in top-k answerswhere k
Revised: For ProtoQA, we report the accuracy in top-k answers where k

Original: = 1 , 3 , 5 .
Revised: = 1 , 3 , 5 .

Original: We also perform human evaluation of the samples generated using GraphGPT2and OptionGAN.
Revised: We also perform human evaluation of the samples generated using GraphGPT and OptionGAN.

Original:  Results & Analysis
Revised:  Results & Analysis

Original: First, we present results from the complete G RA DAframework followed by results from ablation experiments.
Revised: First, we present results from the complete G RA DA framework followed by results from ablation experiments.

Original: Then, we discuss evaluation of thevarious generative models in G RA DA using automated metrics as well as human annotators.
Revised: Then, we discuss evaluation of the various generative models in G RA DA using automated metrics as well as human annotators.

Original: Finally, we evaluate the robustness of models trained with and without G RA DA to semantic adversaries and discuss upper bounds of our data augmentation pipeline.
Revised: Finally, we evaluate the robustness of models trained with and without G RA DA to semantic adversaries and discuss upper bounds of our data augmentation pipeline.

Original: See Appendix for visualization of the quality of the synthetic datasets.
Revised: See Appendix for visualization of the quality of the synthetic datasets.

Original: 5. Data Augmentation Results
Revised: 5. Data Augmentation Results

Original: Results from the best G RA DA model are presented in Table 1.
Revised: Results from the best G RA DA model are presented in Table 1.

Original: The baseline row represents results from the same task models used for G RA DA but trained without any data augmentation i.e. T5-3B for ProtoQA and RoBERTa for all other datasets.
Revised: The baseline row represents results from the same task models used for G RA DA but trained without any data augmentation i.e. T5-3B for ProtoQA and RoBERTa for all other datasets.

Original: We see 1-2% improvements over baseline across all multiple-choice datasets using G RA DA.
Revised: We see 1-2% improvements over baseline across all multiple-choice datasets using G RA DA.

Original: For the best G RA DA models (selected using validation results), synthetic samples are generated from structured GraphGPT2 and OptionGAN, and filtered using QAP.
Revised: For the best G RA DA models (selected using validation results), synthetic samples are generated from structured GraphGPT2 and OptionGAN, and filtered using QAP.

Original: 5 G RA DA results in large improvements for ProtoQA i.e. 4-6% higher values on the Max
Revised: 6 G RA DA results in large improvements for ProtoQA i.e. 4-6% higher values on the Max

Original: Answers 1/3/5 metrics (see Appendix), suggesting the effectiveness of our approach for similar generative tasks.
Revised: Answers 1/3/5 metrics (see Appendix), suggesting the effectiveness of our approach for similar generative tasks.

Original: We see 0.3%, 0.3% and 0.26% improvement with G RA DA over G-D AUG for CQA, Codah and HellaSwag-2K respectively.
Revised: We see 0.3%, 0.3% and 0.26% improvement with G RA DA over G-D AUG for CQA, Codah and HellaSwag-2K respectively.

Original: Our approach also performs similar to the Option Comparison
Revised: Our approach also performs similar to the Option Comparison

Original: Network in HyKAS (Ma et al., 2019) for CQA (row 3 in Table 1).
Revised: Network in HyKAS (Ma et al., 2019) for CQA (row 3 in Table 1).

Original: Our approach is orthogonal to HyKAS, KG-Fusion as their instance-level approach retrieves information for each sample while
Revised: Our approach is orthogonal to HyKAS, KG-Fusion as their instance-level approach retrieves information for each sample while

Original: G RA DA augments knowledge on a global level.
Revised: G RA DA augments knowledge on a global level.

Original: Ablation results from the G RA DA framework on validation sets are presented in Table 2.
Revised: Ablation results from the G RA DA framework on validation sets are presented in Table 2.

Original: The first row of Table 2 presents results from baseline task models i.e., trained without data augmentation.
Revised: The first row of Table 2 presents results from baseline task models i.e., trained without data augmentation.

Original: Next, we compare results from two-stage training and see upto 1.7% (p<0.05 for all datasets) improvements (row 1 vs. 4 in Table 2) with the addition of synthetic data without filtering.Using filter.
Revised: Next, we compare results from two-stage training and see upto 1.7% (p<0.05 for all datasets) improvements (row 1 vs. 4 in Table 2) with the addition of synthetic data without filtering.

Original: [Table] structured GraphGPT2 leads to 0.47% (p=0.043),0.39% (p=0.078), 1.46% (p=0.12) 7 improvementsover linearized GraphGPT2 for SocialIQA, CQA,
Revised: 7 Using structured GraphGPT2 leads to 0.47% (p=0.043), 0.39% (p=0.078), 1.46% (p=0.12) 8 improvements over linearized GraphGPT2 for SocialIQA, CQA,

Original: ProtoQA and diminishing improvements for thesmaller datasets.
Revised: ProtoQA and diminishing improvements for the smaller datasets.

Original: We see consistent but modestimprovements which are not significant, from addition of distractors generated from OptionGAN.
Revised: We see consistent but modest improvements which are not significant, from addition of distractors generated from OptionGAN.

Original: Even though improvements with OptionGAN aremarginal, it is necessary for the completeness ofthe pipeline for synthetic generation.
Revised: Even though improvements with OptionGAN are marginal, it is necessary for the completeness of the pipeline for synthetic generation.

Original: Next, addingfilters to denoise the synthetic pool unequivocallyimproves results by large margins for all datasetsexcept CQA.
Revised: Next, adding filter to denoise the synthetic pool unequivocally improves results by large margins for all datasets except CQA.

Original: Filtering by QAP (row 5 in Table 2)provides the most additional benefit (p=0.069 andp=0.093 for SocialIQA and CQA, p<0.05 for otherdatasets) to downstream task models over unfiltered synthetic data augmentation (row 4).
Revised: Filtering by QAP (row 5 in Table 2) provides additional benefit (p=0.069 and p=0. for SocialIQA and CQA, p<0.05 for other datasets) to downstream task models over unfiltered synthetic data augmentation (row 4).

Original: 8 Seeexamples of high and low quality synthetic datasamples filtered using QAP in Table 6.
Revised: 9 See examples of high and low quality synthetic data samples filtered using QAP in Table 7.

Original: Smallerdatasets benefit the most from G RA DA.
Revised: Smaller datasets benefit the most from G RA DA.

Original: Single-hop vs. Multi-hop Paths.
Revised: Single-hop vs. Multi-hop Paths.

Original: Additionally,we finetune GraphGPT2 with sub-graphs madeof single-hop paths only to generate the context.
Revised: Additionally, we finetune GraphGPT2 with sub-graphs made of single-hop paths only to generate the context.

Original: We perform data augmentation using the syntheticquestions generated through this approach and compare to the G RA DA results on validation sets.
Revised: We perform data augmentation using the synthetic questions generated through this approach and compare to the G RA DA results on validation sets.

Original: Seeresults in Table 3.
Revised: See results in Table 4.

Original: We observe 0.92%, 0.08%,1.48% and 1.05% drops in performance for validation sets of SocialIQA, CQA, CODAH and HellaSwag respectively.
Revised: We observe 0.92%, 0.08%, 1.48% and 1.05% drops in performance for validation sets of SocialIQA, CQA, CODAH and HellaSwag respectively.

Original: The larger drops for smallerdatasets suggest that multi-hop paths are effectivein low-resource scenarios. 
Revised: The larger drops for smaller datasets suggest that multi-hop paths are effective in low-resource scenarios. [Table] [Table] [Table]

Original: Generalization to Unseen Concepts.
Revised: Generalization to Unseen Concepts.

Original: We lookedfor %overlap of entity nodes and single-hop paths(subject– relation– object) between the multi-hop
Revised: We looked for %overlap of entity nodes and single-hop paths (subject– relation– object) between the multi-hop

Original: KGs spanning the questions of correctly answeredsamples after GraDA training and the questions ofsynthetic data, and observed 5-60% entity overlap[Table] [Table] and < 20% path overlap.
Revised: KGs spanning the questions of correctly answered samples after GraDA training and the questions of synthetic data, and observed 5-60% entity overlap and < 20% path overlap.

Original: This suggests G RA DA

Original: [Table]

Original:  also promotes reasoning capabilities of the down- [Table] stream models for unseen concepts.[Table]
Revised: This suggests G RA DA also promotes reasoning capabilities of the downstream models for unseen concepts.

Original: 5. Generative Model Evaluation Results
Revised: 5. Generative Model Evaluation Results

Original: [Table]

Original: O RACLE scores for the two variations of
Revised: O RACLE scores for the two variations of

Original: [Table] GraphGPT2 are presented in Table 4.
Revised: GraphGPT2 are presented in Table 3.

Original: The scores in first column refer to the validation set performance of baseline models on original datasets.
Revised: The scores in first column refer to the validation set performance of baseline models on original datasets.

Original: These models are re-evaluated on the questions generated by GraphGPT2 (as described in Sec. 4.1).
Revised: These models are re-evaluated on the questions generated by GraphGPT2 (as described in Sec. 4.1).

Original: The largest improvement i.e. 2.16% (p=0.068) is observed for SocialIQA, which may be attributed to  its large dataset size.
Revised: The largest improvement i.e. 2.16% (p=0.068) is observed for SocialIQA, which may be attributed to [Table] [Table] its large dataset size.

Original: We see diminishing improvements for low-resource scenarios i.e. Codah and
Revised: We see diminishing improvements for low-resource scenarios i.e. Codah and

Original: HellaSwag-2K. We observe a similar trend when the synthetic questions are evaluated using NLG metrics (see Appendix).
Revised: HellaSwag-2K. We observe a similar trend when the synthetic questions are evaluated using NLG metrics (see Appendix).

Original: More importantly, since phrase-matching metrics are not ideal for NLG evaluation (Novikova et al., 2017), we also perform human evaluation to judge the quality of generation for SocialIQA and CQA as we see significant improvements from structured GraphGPT2 vs. linearized GraphGPT2.
Revised: More importantly, since phrase-matching metrics are not ideal for NLG evaluation (Novikova et al., 2017), we also perform human evaluation to judge the quality of generation for SocialIQA and CQA as we see significant improvements from structured GraphGPT vs. linearized GraphGPT2.

Original: We ask annotators on Amazon Mechanical Turk 9 (AMT) to select the sentence which is more representative of the information encoded in input graph, for 100 samples from validation set.
Revised: We ask annotators on Amazon Mechanical Turk 10 (AMT) to select the sentence which is more representative of the information encoded in input graph, for 100 samples from validation set.

Original: Questions generated from GraphGPT are preferred 46% and 53% of the times for So-
Revised: Questions generated from GraphGPT2 are preferred 46% and 53% of the times for SocialIQA and CQA resp.

Original: S I
Revised: , compared to those from linearized inputs only, showing that the addition of graph encoder improves integration of knowledge in generated text. We perform human evaluation (AMT) of answerability of the generated questions/answers/distractors on randomly selected samples from the filtered augmentation [Table] Yang et al., 2020)

Original: QA
Revised: [Table] [Table]

Original: Riley provided help to the community through his many charity events over the years.
Revised: Riley provided help to the community through his many charity events over the years.

Original: How would Others feel as a result?
Revised: How would Others feel as a result?

Original: [A] selfish [B] appreciative [C] bored
Revised: [A] selfish [B] [Table] bored

Original: C QA
Revised: [Table]

Original: When a child is upset by something, what may they do?
Revised: When a child is upset by something, what may they do?

Original: [A] fall down [B] wish to fly [C] start crying [D] play tag [E] boy or girl 
Revised: [A] fall down [B] wish to fly [C] start crying [D] play tag [E] boy or girl P QA

Revised: Name something you worry you’re still doing when you’re not supposed to.

Revised: drinking, smoking, sleeping, working, using cell phone

Original: Low-quality synthetic samples
Revised: Low-quality synthetic samples

Original: S I
Revised: S I

Original: QA
Revised: QA

Original: Tracy raised her arm to her face to cover her eyes during the scary movie.
Revised: Tracy raised her arm to her face to cover her eyes during the scary movie.

Original: What does Tracy need to dobefore this?
Revised: What does Tracy need to dobefore this?

Original: [A] scared [B] be scared of the movie [C] to have a fundraiser
Revised: [A] scared [B] be scared of the movie [C] to have a fundraiser

Original: C QA
Revised: C QA

Original: What will you do if you want to go public?
Revised: What will you do if you want to go public?

Original: [A] prepare for worst [B] tell family first [C] own private company 
Revised: [A] prepare for worst [B] tell family first [C] own private company [

Original: [Table]
Revised: [Table]

Original: telegram

Original: [Table] charming cialIQA and CQA resp. , compared to those fromlinearized inputs only, showing that the addition ofgraph encoder improves integration of knowledgein generated text. We perform human evaluation (AMT)of answerability of the generated questions/answers/distractors on randomlyselected samples from the filtered augmentationdata (see Table 5).
Revised: data (see Table 5).

Original: Annotators were provided withthe question, answer and distractors, and askedto evaluate a) if the question can be answered ina few words (b) if the question can be answeredby the given answer and (c) if the distractorsare wrong answers for the question.
Revised: Annotators were provided with the question, answer and distractors, and asked to evaluate a) if the question can be answered in a few words (b) if the question can be answered by the given answer and (c) if the distractors are wrong answers for the question.

Original: More than90% of the questions were judged as answerable,75-90% of the answers were judged as correctanswers for the respective questions.
Revised: More than 90% of the questions were judged as answerable, 75-90% of the answers were judged as correct answers for the respective questions.

Original: The qualityof distractors ranged from 50% for SocialIQAto 20-30% for smaller datasets.
Revised: The quality of distractors ranged from 50% for SocialIQA to 20-30% for smaller datasets.

Original: However, theoverall quality of distractors is high enough tobenefit data augmentation.
Revised: However, the overall quality of distractors is high enough to benefit data augmentation.

Original: See examples in
Revised: See examples in

Original: Table 6.
Revised: Table 7.

Original: We also perform human evaluation for thefactuality of samples generated using our method GraDA and GDaug (Yang et al., 2020).
Revised: We also perform human evaluation for the factuality of samples generated using our method GraDA and GDaug (Yang et al., 2020).

Original: We pickeda randomly sampled set of 100 synthetic QApairs from G-Daug for the datasets CQA, Codahand HellaSWAG-2K. For a fair comparison, wecollected 100 synthetic pairs from GraDA for thesame datasets.
Revised: We picked a randomly sampled set of 100 synthetic QA pairs from G-Daug for the datasets CQA, Codah and HellaSWAG-2K. For a fair comparison, we collected 100 synthetic pairs from GraDA for the same datasets.

Original: We asked an annotator to evaluate ifeach of the synthetic QA pair adheres to a plausiblereal-world scenario, and found that 56% G-Daugsamples were judged as factual as compared to68% of the GraDA samples (see Appendix).
Revised: We asked an annotator to evaluate if each of the synthetic QA pair adheres to a plausible real-world scenario, and found that 56% G-Daug samples were judged as factual as compared to 68% of the GraDA samples (see examples in Table 6).

Original: [Table]
Revised: We ran experiments for augmentation with 20%, 40%, 60%, 80% and 100% training data from the original set (see Fig. 5). The improvement margins from the augmentation dataset is upto 4% at 20% of the original SocialIQA dataset. We see similar trends for CODAH, HellaSwag and ProtoQA, while the improvements for CQA were <1.5%.

Original: 5. Robustness Evaluation
Revised: 5. Robustness Evaluation

Original: We expect that data augmentation exposes the task model to diverse language and improves its robustness to semantic adversaries in addition to boosting its performance on the target task.
Revised: We expect that data augmentation exposes the task model to diverse language and improves its robustness to semantic adversaries in addition to boosting its performance on the target task.

Original: To evaluate this, we use the TextFooler system (Jin et al., 2020;
Revised: To evaluate this, we use the TextFooler system (Jin et al., 2020;

Original: Yang et al., 2020; Wei and Zou, 2019) to generate adversarial text by computing word importance ranking and replacing the most influential words  with their synonym in the vector space.
Revised: Yang et al., 2020; Wei and Zou, 2019) to generate adversarial text by computing word importance ranking and replacing the most influential words [Table] with their synonym in the vector space.

Original: Overall,
Revised: Overall,

Original: G RA DA benefits the robustness of task models and improves their failure rate by 1-3% (see Table 7).
Revised: G RA DA benefits the robustness of task models and improves their failure rate by 1-3% (see Table 8).

Original: 5. Upper Bounds

Original: We ran experiments for augmentation with 20%, 40%, 60%, 80% and 100% training data from the original set (see Fig. 5).

Original: The improvement margins from the augmentation dataset is upto 4% at 20% of the original SocialIQA dataset.

Original: We see similar trends for CODAH, HellaSwag and ProtoQA, while the improvements for CQA were <1.5%.

Original:  Conclusion
Revised:  Conclusion

Original: We present G RA DA, a graph-based data augmentation framework for commonsense reasoning QA datasets.
Revised: We present G RA DA, a graph-based data augmentation framework for commonsense reasoning QA datasets.

Original: We train a graph-to-text question generator and GAN-based adversarial choice generator for creating synthetic data samples, which arefurther filtered and used to augment the original datasets.
Revised: We train a graph-to-text question generator and GAN-based adversarial choice generator for creating synthetic data samples, which are used to augment the original datasets.

Original: G RA DA  improves results on five  datasets.
Revised: G RA DA promotes factuality in synthetic samples and improves results on five downstream datasets.

Original:  Ethical Considerations
Revised:  Ethical Considerations

Original: The usage of pretrained generative models in anydownstream application requires careful consideration of the real-world impact of generated text.
Revised: The usage of pretrained generative models in any downstream application requires careful consideration of the real-world impact of generated text.

Original: In our approach, we provide concrete inputs forgrounding the generated text to specific entities andrelations which encode real-world facts, thereby reducing the possibility of propagating unintendedstereotypical and social biases embedded within thepretrained models.
Revised: In our approach, we provide concrete inputs for grounding the generated text to specific entities and relations which encode real-world facts, thereby reducing the possibility of propagating unintended stereotypical and social biases embedded within the pretrained models.

Original: However, since these entitiesand relations are derived from existing knowledgebases like ConceptNet (Speer et al., 2017), thereis potential for transfer of bias present in these resources to the generated texts.
Revised: However, since these entities and relations are derived from existing knowledge bases like ConceptNet (Speer et al., 2017), there is potential for transfer of bias present in these resources to the generated texts.

Original: Additionally, thegraph-to-text generative models in G RA DA posethe same risk as other data-to-text generative models (Ribeiro et al., 2020; Hoyle et al., 2020; Mageret al., 2020) i.e. the models can be made to generate incorrect facts by providing incorrect data asinput.
Revised: Additionally, the graph-to-text generative models in G RA DA pose the same risk as other data-to-text generative models (Ribeiro et al., 2020; Hoyle et al., 2020; Mager et al., 2020) i.e. the models can be made to generate incorrect facts by providing incorrect data as input.

Original: Therefore, we recommend restricting the useof G RA DA to low-risk, unbiased graphs inputs. 
Revised: Therefore, we recommend restricting the use of G RA DA to low-risk, unbiased graphs inputs. Acknowledgments

Revised: We thank the reviewers for their useful feedback.

Revised: This work was supported by DARPA MCS Grant

Revised: N66001-19-2-403, ONR Grant N00014-18-1-2871, and NSF-CAREER Award 1846185.

Revised: The views are those of the authors and not of the funding agency.

Original: A Experiment Setup
Revised: Information Processing

Revised: Liu Myle Goyal

Revised: Du

Revised: Stoyanov

Revised: Shangwen Lv, Daya Guo, Jingjing Xu, Duyu Tang, Nan

Revised: Duan

Revised: Linjun

Revised: Kaixin Ma, Jonathan Francis, Quanyang Lu, Eric Nyberg, and Alessandro Oltramari question

Revised: Manuel Mager, Ramón Fernandez Astudillo, Tahira

Revised: Naseem, Md Arafat Sultan, Young-Suk Lee, Radu

Revised: Florian, and Salim Roukos. 2020.

Revised: Gpt-too

Revised: A language model for amr

Revised: - ation

Revised: 58th the Association for Computational Linguistics

Revised: Diego Marcheggiani and Laura Perez-Beltrachini. 2018.

Revised: Deep graph convolutional encoders for structured data to text generation.

Revised: In Proceedings of the 11th

Revised: International Conference on Natural Language Generation , pages 1–9.

Revised: Arindam Mitra, Pratyay Banerjee, Kuntal Kumar Pal,

Revised: Swaroop Mishra, and Chitta Baral. 2019.

Revised: Exploring ways to incorporate additional knowledge to improve natural language commonsense question answering.

Revised: arXiv preprint arXiv:1909.08855 .

Revised: Weili Nie, Nina Narodytska, and Ankit Patel. 2019a.

Revised: Relgan: Relational generative adversarial networks for text generation.

Revised: In 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019 .

Revised: OpenReview.net.

Revised: Weili Nie, Nina Narodytska, and Ankit Patel. 2019b.

Revised: Relgan: Relational generative adversarial networks for text generation.

Revised: In 7th International Conference on Learning Representations, ICLR 2019, New Or preprint arXiv:2010.

Revised: a machine really finish your sentence?

Revised: In Proceedings of the 57th Annual Meeting of the Association for

Revised: Computational Linguistics , pages 4791–4800.

Revised: Shiyue Zhang and Mohit Bansal. 2019.

Revised: Addressing semantic drift in question generation for semisupervised question answering.

Revised: In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International

Revised: Joint Conference on Natural Language Processing (EMNLP-IJCNLP) , pages 2495–2509.

Revised: Tianyi Zhang, Varsha Kishore, Felix Wu, Kilian Q Weinberger, and Yoav Artzi. 2020.

Revised: Bertscore:

Revised: Evaluating text generation with bert.

Revised: In 8th International Conference on Learning Representations, ICLR 2020, Addis

Revised: Ababa, Ethiopia, April 26-30, 2020 .

Revised: OpenReview.net.

Revised: Zhirui Zhang, Shujie Liu, Mu Li, Ming Zhou, and Enhong Chen.

Revised: Bidirectional generative adversarial networks for neural machine translation.

Revised: In

Revised: Proceedings of the 22nd Conference on Computational Natural Language Learning , pages 190–199.

Revised: Association for Computational Linguistics.

Revised: A Experiment Setup

Original: Datasets: Social IQA (Sap et al., 2019b) and
Revised: Datasets: Social IQA (Sap et al., 2019b) and

Original: CommonsenseQA (Talmor et al., 2019) are popular datasets based on knowledge graphs, makingthem a suitable choice for testing our approach.
Revised: CommonsenseQA (Talmor et al., 2019) are popular datasets based on knowledge graphs, making them a suitable choice for testing our approach.

Original: Social IQA is a multiple-choice question answeringdataset.
Revised: Social IQA is a multiple-choice question answering dataset.

Original: Each sample consists of a context, question and three multiple choices.
Revised: Each sample consists of a context, question and three multiple choices.

Original: CommonsenseQAis also a multiple-choice QA dataset, wherein eachsample consists of a context and five multiplechoices.
Revised: CommonsenseQA is also a multiple-choice QA dataset, wherein each sample consists of a context and five multiple choices.

Original: Of those 5 choices, three are taken from
Revised: Of those 5 choices, three are taken from

Original: ConceptNet and the other two are authored by annotators.
Revised: ConceptNet and the other two are authored by annotators.

Original: We only use the human-authored incorrect choices to train our adversarial choice generator
Revised: We only use the human-authored incorrect choices to train our adversarial choice generator

Original: OptionGAN.
Revised: OptionGAN.

Original: The ATOMIC knowledge graph contains 24K base events and 877K tuples describing a variety of social scenarios.
Revised: The ATOMIC knowledge graph contains 24K base events and 877K tuples describing a variety of social scenarios.

Original: We use the 710K training split introduced in Bosselut et al.
Revised: We use the 710K training split introduced in Bosselut et al.

Original: (2019) to randomly sample 100K tuples as the seed subgraphs for generation of synthetic data dataset for
Revised: (2019) to randomly sample 100K tuples as the seed subgraphs for generation of synthetic data dataset for

Original: Social IQA.
Revised: Social IQA.

Original: For CommonsenseQA, we use the entire ConceptNet knowledge graph, subject to pruning as outlined in Talmor et al.
Revised: For CommonsenseQA, we use the entire ConceptNet knowledge graph, subject to pruning as outlined in Talmor et al.

Original: (2019), to sample seed tuples for synthetic dataset generation.
Revised: (2019), to sample seed tuples for synthetic dataset generation.

Original: For
Revised: For

Original: SocialIQA, CQA, Codah and HellaSwag-2K, we use simple accuracy for model evaluation.
Revised: SocialIQA, CQA, Codah and HellaSwag-2K, we use simple accuracy for model evaluation.

Original: ProtoQA (Boratko et al., 2020) is a generative
Revised: ProtoQA (Boratko et al., 2020) is a generative

Original: QA dataset which is evaluated by 7 different metrics 10 .
Revised: QA dataset which is evaluated by 7 different metrics 11 .

Original: We report the first 3 metrics i.e. Max Answers 1/3/5.
Revised: We report the first 3 metrics i.e. Max Answers 1/3/5.

Original: For tables showing only one number for ProtoQA, such as the ablation table in main text, we report the Max Answer 1 metric.
Revised: For tables showing only one number for ProtoQA, such as the ablation table in main text, we report the Max Answer 1 metric.

Original: In order to train T5-3B for ProtoQA, we concatenate the ranked choices for each question and finetune the model for conditional generation of this concatenated string from the input question.
Revised: In order to train T5-3B for ProtoQA, we concatenate the ranked choices for each question and finetune the model for conditional generation of this concatenated string from the input question.

Original: All of the above datasets are being for their intended purposes i.e. research only, in our work.
Revised: All of the above datasets are being for their intended purposes i.e. research only, in our work.

Original: All of these datasets are in the English language.
Revised: All of these datasets are in the English language.

Original: Data Preparation: To prepare graph-to-text datasets for training GraphGPT2, we map the questions to multi-hop paths in ConceptNet (Bauer et al., 2018).
Revised: Data Preparation: To prepare graph-to-text datasets for training GraphGPT2, we map the questions to multi-hop paths in ConceptNet (Bauer et al., 2018).

Original: We use Spacy 11 to tag the questions with part-of-speech and extract verbs and nouns as concepts, retaining those that appear in
Revised: We use Spacy 12 to tag the questions with part-of-speech and extract verbs and nouns as concepts, retaining those that appear in

Original: ConceptNet as entities 12 .
Revised: ConceptNet as entities 13 .

Original: For SocialIQA, we map the questions to a combination of ATOMIC and
Revised: For SocialIQA, we map the questions to a combination of ATOMIC and

Original: ConceptNet.
Revised: ConceptNet.

Original: ATOMIC events contain nouns and verbs which are representative of the social scenario being described in the event and are further extended in the context by Social IQA annotators (see Table 9).
Revised: ATOMIC events contain nouns and verbs which are representative of the social scenario being described in the event and are further extended in the context by Social IQA annotators (see Table 6).

Original: We tokenize and stem the events and contexts to extract these representative words, and compute the percentage of overlapping words in the context with respect to each event.
Revised: We tokenize and stem the events and contexts to extract these representative words, and compute the percentage of overlapping words in the context with respect to each event.

Original: The event with maximum overlap with context is selected as the corresponding ATOMIC subject.The ATOMIC
Revised: The event with maximum overlap with context is selected as the corresponding ATOMIC subject.

Original: 10 https://github.com/iesl/ protoqa-evaluator 11 https://spacy.io/

Original:  relation is selected from the predefined map of
Revised: The ATOMIC relation is selected from the predefined map of

Original: ATOMIC relations to Social IQA questions.
Revised: ATOMIC relations to Social IQA questions.

Original: Thisway, we recover the ATOMIC alignments of 20,000samples from training set of SocialIQA with 88%accuracy.
Revised: This way, we recover the ATOMIC alignments of 20, samples from training set of SocialIQA with 88% accuracy.

Original: Synthetic Data Generation.
Revised: Synthetic Data Generation.

Original: In order to preparesynthetic datasets, we create a dataset of unseeninput graphs by mutating the graphs from training sets of graph-to-text datasets.
Revised: In order to prepare synthetic datasets, we create a dataset of unseen input graphs by mutating the graphs from training sets of graph-to-text datasets.

Original: One or twoentities are replaced by a randomly selected entity (or relation-entity pair) with similar adjacencyto other entities in the input graph, to create amutated graph.
Revised: One or two entities are replaced by a randomly selected entity (or relation-entity pair) with similar adjacency to other entities in the input graph, to create a mutated graph.

Original: The synthetic dataset size (prefitering) is 100k/50k/10k/10k/50k for SocialIQA,
Revised: The synthetic dataset size (prefitering) is 100k/50k/10k/10k/50k for SocialIQA,

Original: CQA, HellaSwag-2K, Codah, and ProtoQA respectively.
Revised: CQA, HellaSwag-2K, Codah, and ProtoQA respectively.

Original: For generation of synthetic data, we use theset of tuples from ATOMIC and ConceptNet thatdo not appear in SocialIQA and CommonsenseQAdatasets respectively.
Revised: For generation of synthetic data, we use the set of tuples from ATOMIC and ConceptNet that do not appear in SocialIQA and CommonsenseQA datasets respectively.

Original: To prepare the syntheticdataset for CommonsenseQA, we select two adversarial choices from ConceptNet and two choicesgenerated by OptionGAN.
Revised: To prepare the synthetic dataset for CommonsenseQA, we select two adversarial choices from ConceptNet and two choices generated by OptionGAN.

Original: For ProtoQA, we findaccurate answers by generating 30 samples of answers for each synthetic question, ranking the answer choices by frequency and retaining the onesthat appear atleast 5 times in the 30 samples.
Revised: For ProtoQA, we find accurate answers by generating 30 samples of answers for each synthetic question, ranking the answer choices by frequency and retaining the ones that appear atleast 5 times in the 30 samples.

Original: Afterthis, the synthetic question and answer (concatenation of high-frequency answer choices) is subjectedto filtering.
Revised: After this, the synthetic question and answer (concatenation of high-frequency answer choices) is subjected to filtering.

Original: Due to lack of option for supplementary in this submission, we have included a sampleof the generated synthetic examples in Table 8.
Revised: Due to lack of option for supplementary in this submission, we have included a sample of the generated synthetic examples in Table 9.

Original: A. Training Details
Revised: A. Filtering and Selection of Samples

Revised: Inspite of the careful construction of synthetic samples using knowledge graphs, the pool of synthetic samples can be noisy and may consist of incoherent text, incorrect question-answer pairs or outof-distribution samples. Hence, we compare the effect of three different methods to filter samples on downstream task performance. Question Answering Probability (QAP).

Revised: The

Revised: QAP score ( µ ) (Zhang and Bansal, 2019) is the prediction probability of the true class by a model with parameters θ which has been trained on the original dataset i.e. µ i =

Revised: p θ ( y ∗ i | x i ) .

Revised: Samples with low prediction probabilities for the correct choices are either annotated incorrectly or are especially difficult instances for the model.

Revised: We define a low and high threshold for the QAP filter and samples lying within this range are retained in the dataset.

Revised: Model Confidence and Variability.

Revised: Swayamdipta et al.

Revised: (2020) propose the model confidence ( ˆ µ i ) and variability ( ˆ σ i ) measures to identify

Revised: [Table]

Revised: CODAH

Revised: [Table]

Revised: Besides

Revised: [Table]

Revised: , name a popular product in the dairy market

Revised: [Table]

Revised: the effect of data samples on the model’s generalization error.

Revised: Specifically, ˆ µ i = 1 E (cid:80) Ee =1 p θ ( y ∗ i | x i ) and ˆ σ i = (cid:113) (cid:80) Ee

Revised: [Equation]

Revised: ( y

Revised: [Equation]

Revised: i | x

Revised: [Equation]

Revised: [Equation]

Revised: ) 2 E , where E is training epochs.

Revised: They find that ambiguous samples i.e., high variability and mid-range confidence, contribute the most to test performance on downstream task.

Revised: Following this, we define low and high thresholds for both confidence and variability in order to find the most informative samples.

Revised: Energy.

Revised: Liu et al.

Revised: (2020) show that the energy score can be reliably used for distinguishing between in- and out-of-distribution (OOD) samples, as compared to the traditional approach of using the softmax scores.

Revised: We introduce an energy threshold to select samples which are out-of-distribution i.e.

Revised: E i =

Revised: − log (cid:80) Cj e p θ ( y ji | x ) where C is the number of choices in the QA sample, and measure the effect of using OOD samples as augmentation data.

Revised: A. Training Details

Original: Baselines: We use pretrained RoBERTa LARGE (Liuet al., 2019) for multiple-choice datasets and T53B (Raffel et al., 2020) for ProtoQA as the taskmodels.
Revised: Baselines: We use pretrained RoBERTa LARGE (Liu et al., 2019) for multiple-choice datasets and T53B (Raffel et al., 2020) for ProtoQA as the task models.

Original: The baseline task model is finetuned onoriginal datasets with no data augmentation, andis used as scoring model for filtering.
Revised: The baseline task model is finetuned on original datasets with no data augmentation, and is used as scoring model for filtering.

Original: We use
Revised: We use

Original: GPT2 MEDIUM for GraphGPT2, GPT2 SMALL as thepretrained generator and discriminator for OptionGAN.
Revised: GPT2 MEDIUM for GraphGPT2, GPT2 SMALL as the pretrained generator and discriminator for OptionGAN.

Original: For G RA DA, the model is first finetuned onsynthetic samples using label smoothing (Szegedyet al., 2016) and then on original dataset.
Revised: For G RA DA, the model is first finetuned on synthetic samples using label smoothing (Szegedy et al., 2016) and then on original dataset.

Original: We referthe reader to Koncel-Kedziorski et al.
Revised: We refer the reader to Koncel-Kedziorski et al.

Original: (2019) forfull implementation details of the Graph Encoderin GraphGPT2.
Revised: for full implementation details of the Graph Encoder in GraphGPT2.

Original: OptionGAN:
Revised: OptionGAN:

Original: It is tricky to train GAN models,especially with discrete data like text.
Revised: It is tricky to train GAN models, especially with discrete data like text.

Original: We followthe training method in Nie et al. (2019a) to finetune the adversarial choice generator in a minimaxgame with discriminator.
Revised: We follow the training method in Nie et al. (2019a) to finetune the adversarial choice generator in a minimax [Table] [Table] game with discriminator.

Original: In addition to the training parameters mentioned in Table 16, we restrict the number of training iterations to 5000, and perform one gradient descent step on generator for every gradient descent steps on discriminator.
Revised: In addition to the training parameters mentioned in Table 17, we restrict the number of training iterations to 5000, and perform one gradient descent step on generator for everygradient descent steps on discriminator.

Original: Training & Hyperparameter Tuning
Revised: Training & Hyperparameter Tuning.

Original: After generation of synthetic examples, we perform twostage training of the task models.
Revised: After generation of synthetic examples, we perform twostage training of the task models.

Original: In the first phase, the model is finetuned on synthetic data only, In the second phase, the model is finetuned on the original dataset.
Revised: In the first phase, the model is finetuned on synthetic data only, In the second phase, the model is finetuned on the original dataset.

Original: The model trained in first phase is subject to bayesian optimization (Snoek et al., 2012) of filter parameters.
Revised: The model trained in first phase is subject to bayesian optimization (Snoek et al., 2012) of filter parameters.

Original: A. Human Evaluation
Revised: A. Human Evaluation

Original: Generative source of the sentences are omitted when presented to annotators.
Revised: Generative source of the sentences are omitted when presented to annotators.

Original: The input graphs are seed tuples from ATOMIC and ConceptNet for samples from the development sets of Social IQA and CommonsenseQA respectively.
Revised: The input graphs are seed tuples from ATOMIC and ConceptNet for samples from the development sets of Social IQA and CommonsenseQA respectively.

Original: The annotators can pick both the sentences if either of them are equally relevant in their subjective opinion.
Revised: The annotators can pick both the sentences if either of them are equally relevant in their subjective opinion.

Original: We allow for a single hit for each assignment in Amazon
Revised: We allow for a single hit for each assignment in Amazon

Original: Mechanical Turk.
Revised: Mechanical Turk.

Revised: [Table]

Original: B Results 
Revised: B Results B. Generative Model Evaluation

Original: B. Generative Model Evaluation

Original: As shown in Table 11, we see small improvements for BLEU-4 and METEOR, but larger improvements in other metrics from GraphGPT2 i.e., 3.07% ( p =0.027), 2.87% ( p =0.035) in CIDEr, and 2.71% ( p =0.042), 1.58% ( p =0.056) in BERTScore for Social IQA and CQA, resp.
Revised: As shown in Table 11, we see small improvements for BLEU-4 and METEOR, but larger improvements in other metrics from GraphGPT2 i.e., 3.07% ( p =0.027), 2.87% ( p =0.035) in CIDEr, and 2.71% ( p =0.042), 1.58% ( p =0.056) in BERTScore for Social IQA and CQA, resp.

Original: The phrase-matching metric scores are low for CQA, which may be attributed to its small sample size.
Revised: The phrase-matching metric scores are low for CQA, which may be attributed to its small sample size.

Original: However,
Revised: However,

Original: BERTScore for CQA lies between 85-88%, showing that the model manages to convey similar meaning as human-annotated context albeit with different words.
Revised: BERTScore for CQA lies between 85-88%, showing that the model manages to convey similar meaning as human-annotated context albeit with different words.

Original: More importantly, since phrase-matching metrics are not ideal for NLG evaluation (Novikova et al., 2017), we also perform human evaluation to judge the quality of generation for SocialIQA and CommonsenseQA as we see significant improvements from structured GraphGPT2 vs. linearized GraphGPT2.
Revised: More importantly, since phrase-matching metrics are not ideal for NLG evaluation (Novikova et al., 2017), we also perform human evaluation to judge the quality of generation for SocialIQA and CommonsenseQA as we see significant improvements from structured GraphGPT2 vs. linearized GraphGPT2.

Original: We ask annotators on Amazon Mechanical Turk 13 to select the sentence which is more representative of the information encoded [Table] CODAH [Table]
Revised: We ask annotators on Amazon Mechanical Turk 14 to select the sentence which is more representative of the information encoded in input graph, for 100 samples from validation set.

Original: Besides

Original: [Table]

Original: , name a popular product in the dairy market

Original: [Table]

Original: in input graph, for 100 samples from validationset.

Original: Results are shown in Table 12.
Revised: Results are shown in Table 12.

Original: Samples generated from structured input are selected significantlymore times than those from linearized inputs, forboth SocialIQA and CQA, showing that addition ofa graph encoder improves representation of knowledge in generated sample.
Revised: Samples generated from structured input are selected significantly more times than those from linearized inputs, for both SocialIQA and CQA, showing that addition of a graph encoder improves representation of knowledge in generated sample.

Original: Additionally, we perform human evaluation ofthe samples generated using GraphGPT2 and OptionGAN.
Revised: Additionally, we perform human evaluation of the samples generated using GraphGPT2 and OptionGAN.

Original: We randomly select 50 samples from thefiltered augmentation datasets for each of the fivedatasets, and ask 2 annotators to answer 3 yes/noquestions about the quality of the question, answerand distractors respectively.
Revised: We randomly select 50 samples from the filtered augmentation datasets for each of the five datasets, and ask 2 annotators to answer 3 yes/no questions about the quality of the question, answer and distractors respectively.

Original: We present resultsfrom the survey in Table 5.
Revised: We present results from the survey in Table 5.

Original: More than 90% ofthe questions in each dataset were judged as answerable, showing the effectiveness of GraphGPT2as well as the QAP-based filtering method. 
Revised: More than 90% of the questions in each dataset were judged as answerable, showing the effectiveness of GraphGPT as well as the QAP-based filtering method. Simi-

Original: Similarly, 75-90% of the answers were judged as correctanswers for the respective questions.
Revised: [Table] larly, 75-90% of the answers were judged as correct answers for the respective questions.

Original: The qualityof distractors were relatively lower, ranging from 50% for larger datasets like SocialIQA to 20-30% for rest of the datasets.
Revised: The quality of distractors were relatively lower, ranging from 50% for larger datasets like SocialIQA to 20-30% for rest of the datasets.

Original: The inter-annotator agreement was also low (<0.6) for distractor judgements, suggesting the general difficulty of both tasks: distractor generation and measurement of distractor quality.
Revised: The inter-annotator agreement was also low (<0.6) for distractor judgements, suggesting the general difficulty of both tasks: distractor generation and measurement of distractor quality.

Original: However, the overall quality of distractors in our datasets is high enough to benefit data augmentation.
Revised: However, the overall quality of distractors in our datasets is high enough to benefit data augmentation.

Original: For both human evaluation annotation tasks, it was made clear in the instructions that the data is being collected for research purposes only.
Revised: For both human evaluation annotation tasks, it was made clear in the instructions that the data is being collected for research purposes only.

Original: B. Robustness Evaluation
Revised: B. Comparison of Filtering Methods

Original: We expect that data augmentation exposes the task model to diverse language and improves its robustness to semantic adversaries in addition to boosting its performance on the target task.
Revised: Table 13 demonstrates the effect of using various methods of filtering i.e. QAP, Energy and Model Confidence/Variability.

Original: To evaluate this, we use the TextFooler system (Jin et al., 2020; Yang et al., 2020; Wei and Zou, 2019) to generate adver-
Revised: Results are shown on the validation sets the commonsense reasoning datasets. We see largest improvements with using

Original: [Table]
Revised: QAP as the filter. Similar improvements are seen with the confidence/variability scores; however, it requires scores from multiple finetuned models from various training checkpoints. B. Robustness Evaluation We expect that data augmentation exposes the task model to diverse language and improves its robustness to semantic adversaries in addition to boosting its performance on the target task.

Original: [Table] [Table] [Table] sarial text by computing word importance rankingand replacing the most influential words with theirsynonym in the vector space.
Revised: To evaluate this, we use the TextFooler system (Jin et al., 2020; Yang et al., 2020; Wei and Zou, 2019) to generate adversarial text by computing word importance ranking and replacing the most influential words with their synonym in the vector space.

Original: Failure rate is the%examples for which TextFooler fails to changethe original model prediction, and average perturbation ratio is the average % of words replaced when
Revised: Failure rate is the %examples for which TextFooler fails to change the original model prediction, and average perturbation ratio is the average % of words replaced when

Original: TextFooler succeeds at changing the prediction.
Revised: TextFooler succeeds at changing the prediction.

Original: Weuse our best G RA DA models in comparison withbaseline models (Table 7).
Revised: We use our best G RA DA models in comparison with baseline models (Table 8).

Original: Overall, G RA DA positively impacts the robustness of task models to
Revised: Overall, G RA DA pos- itively impacts the robustness of task models to

Original: TextFooler and improves the failure rate by >3%for Codah and upto 1% for all other datasets.
Revised: TextFooler and improves the failure rate by >3% for Codah and upto 1% for all other datasets.

Original: Weobserve similar trends for the perturbation ratiostoo.
Revised: We observe similar trends for the perturbation ratios too.

Original: This shows that G RA DA improves semanticrobustness of the models.
Revised: This shows that G RA DA improves semantic robustness of the models.

Original: It is also worthwhilenoting that generative task models like T5-3B for
Revised: It is also worthwhile noting that generative task models like T5-3B for

Original: [Table] ProtoQA are especially prone to adversarial attacks like TextFooler with a mere 5-6% failure rate and there needs to be more research towards improving their robustness.
Revised: ProtoQA are especially prone to adversarial attacks like TextFooler with a mere 5-6% failure rate and there needs to be more research towards improving their robustness.

Original: B. Cartography Quality Evaluation
Revised: B. Cartography Quality Evaluation

Original: We use dataset cartography Swayamdipta et al.
Revised: We use dataset cartography Swayamdipta et al.

Original: (2020) to visualize the quality of our synthetic datasets.
Revised: (2020) to visualize the quality of our synthetic datasets.

Original: Samples in top left of figure are easy, while samples towards bottom and right of the figure are difficult and ambiguous respectively.[Figure]
Revised: Samples in top left of figure are easy, while samples towards bottom and right of the figure are difficult and ambiguous respectively.

Original: We can observe from the figure that the synthetic

Original: [Figure] dataset for CQA (left) has a higher % of easy sam- [Figure] ples than HellaSwag-2K, suggesting that the qual-
Revised: We can observe from the figure that the synthetic dataset for CQA (left) has a higher % of easy samples than HellaSwag-2K, suggesting that the quality of synthetic samples generated by G RA DA improves with original dataset size.

Original: [Figure]

Original: ity of synthetic samples generated by G RA DA

Original: [Figure]

Original: improves with original dataset size.

Original: Moreover,

Original: [Figure] when applying QAP filtering, using the entire syn- [Figure] thetic dataset yields largest improvements for CQA 
Revised: Moreover, when applying QAP filtering, using the entire synthetic dataset yields largest improvements for CQA whereas for HellaSwag-2K (right), the lower cutoff for QAP is 0.3 which filters out most of the samples present in bottom part of the plot.

Original: [Figure]

Original: whereas for HellaSwag-2K (right), the lower cutoff

Original: [Figure]

Original: for QAP is 0.3 which filters out most of the samples [Figure] present in bottom part of the plot. This suggests 
Revised: This suggests that in low-resource scenarios, it is important to remove inaccurate samples, while larger datasets benefit from ambiguous and inaccurate samples.

Original: [Figure]
Revised: [Table]

Original: that in low-resource scenarios, it is important to

Original: [Figure]
Revised: [Table]

Original: remove inaccurate samples, while larger datasets

Original: [Figure]
Revised: [Table]

Original: benefit from ambiguous and inaccurate samples.

Original: [Figure] [Table] [Table] [Table]
Revised: [Table]

Original: [Table]