Original: R EINFORCEMENT L EARNING B ASED G RAPH - TO -S EQUENCE M ODEL FOR N ATURAL Q UESTION G ENERATION
Revised: R EINFORCEMENT L EARNING B ASED G RAPH - TO -S EQUENCE M ODEL FOR N ATURAL Q UESTION G ENERATION

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Natural question generation (QG) aims to generate questions from a passage and an answer.
Revised: Natural question generation (QG) aims to generate questions from a passage and an answer.

Original: Previous works on QG either (i) ignore the rich structure information hidden in text, (ii) solely rely on cross-entropy loss that leads to issues like exposure bias and inconsistency between train/test measurement, or (iii) fail to fully exploit the answer information.
Revised: Previous works on QG either (i) ignore the rich structure information hidden in text, (ii) solely rely on cross-entropy loss that leads to issues like exposure bias and inconsistency between train/test measurement, or (iii) fail to fully exploit the answer information.

Original: To address these limitations, in this paper, we propose a reinforcement learning (RL) based graph-to-sequence (Graph2Seq) model for QG.
Revised: To address these limitations, in this paper, we propose a reinforcement learning (RL) based graph-to-sequence (Graph2Seq) model for QG.

Original: Our model consists of a Graph2Seq generator with a novel Bidirectional Gated Graph Neural Network based encoder to embed the passage, and a hybrid evaluator with a mixed objective function that combines both the crossentropy and RL loss to ensure the generation of syntactically and semantically valid text.
Revised: Our model consists of a Graph2Seq generator with a novel Bidirectional Gated Graph Neural Network based encoder to embed the passage, and a hybrid evaluator with a mixed objective combining both cross-entropy and RL losses to ensure the generation of syntactically and semantically valid text.

Original: We also introduce an effective Deep Alignment Network for incorporating the answer information into the passage at both the word and contextual level.
Revised: We also introduce an effective Deep Alignment Network for incorporating the answer information into the passage at both the word and contextual levels.

Original: Our model is end-to-end trainable and achieves new state-of-the-art scores, outperforming existing methods by a signiﬁcant margin on the standard SQuAD benchmark for QG.
Revised: Our model is end-to-end trainable and achieves new state-of-the-art scores, outperforming existing methods by a signiﬁcant margin on the standard SQuAD benchmark.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Natural question generation (QG) has many useful applications such as improving the question answering task
Revised: Natural question generation (QG) has many useful applications such as improving the question answering task

Original: (Chen et al., 2017; 2019a) by providing more training data (Tang et al., 2017; Yuan et al., 2017), generating practice exercises and assessments for educational purposes (Heilman &
Revised: (Chen et al., 2017; 2019a) by providing more training data (Tang et al., 2017; Yuan et al., 2017), generating practice exercises and assessments for educational purposes (Heilman &

Original: Smith, 2010; Danon & Last, 2017), and helping dialog systems to kick-start and continue a conversation with human users (Mostafazadeh et al., 2016).
Revised: Smith, 2010; Danon & Last, 2017), and helping dialog systems to kick-start and continue a conversation with human users (Mostafazadeh et al., 2016).

Original: While many existing works focus on QG from images (Fan et al., 2018; Li et al., 2018) or knowledge bases (Serban et al., 2016; Elsahar et al., 2018), in this work, we focus on QG from text.
Revised: While many existing works focus on QG from images (Fan et al., 2018; Li et al., 2018) or knowledge bases (Serban et al., 2016; Elsahar et al., 2018), in this work, we focus on QG from text.

Original: Conventional methods (Mostow & Chen, 2009; Heilman & Smith, 2010; Heilman, 2011) for QG rely on heuristic rules or hand-crafted templates, leading to the issues of low generalizability and scalability.
Revised: Conventional methods (Mostow & Chen, 2009; Heilman & Smith, 2010; Heilman, 2011) for QG rely on heuristic rules or hand-crafted templates, leading to the issues of low generalizability and scalability.

Original: Recent attempts have been focused on exploiting Neural Network (NN) based approaches that do not require manually-designed rules and are end-to-end trainable.
Revised: Recent attempts have been focused on exploiting Neural Network (NN) based approaches that do not require manually-designed rules and are end-to-end trainable.

Original: Encouraged by the huge success of neural machine translation, these approaches formulate the QG task as a sequence-tosequence (Seq2Seq) learning problem.
Revised: Encouraged by the huge success of neural machine translation, these approaches formulate the QG task as a sequence-tosequence (Seq2Seq) learning problem.

Original: Speciﬁcally, attention-based Seq2Seq models (Bahdanau et al., 2014; Luong et al., 2015) and their enhanced versions with copy (Vinyals et al., 2015; Gu et al., 2016) and coverage (Tu et al., 2016) mechanisms have been widely applied and show promising results on this task (Du et al., 2017;
Revised: Speciﬁcally, attention-based Seq2Seq models (Bahdanau et al., 2014; Luong et al., 2015) and their enhanced versions with copy (Vinyals et al., 2015; Gu et al., 2016) and coverage (Tu et al., 2016) mechanisms have been widely applied and show promising results on this task (Du et al., 2017;

Original: Zhou et al., 2017; Song et al., 2018a; Kumar et al., 2018a).
Revised: Zhou et al., 2017; Song et al., 2018a; Kumar et al., 2018a).

Original: However, these methods typically ignore the hidden structural information associated with a word sequence such as the syntactic parsing tree.
Revised: However, these methods typically ignore the hidden structural information associated with a word sequence such as the syntactic parsing tree.

Original: Failing to utilize the rich text structure information beyond the simple word sequence may limit the effectiveness of these models for QG.
Revised: Failing to utilize the rich text structure information beyond the simple word sequence may limit the effectiveness of these models for QG.

Original: It has been observed that in general, cross-entropy based sequence training has several limitations like exposure bias and inconsistency between train/test measurement (Ranzato et al., 2015; Wu et al., 2016).
Revised: It has been observed that in general, cross-entropy based sequence training has several limitations like exposure bias and inconsistency between train/test measurement (Ranzato et al., 2015; Wu et al., 2016).

Original: As a result, they do not always produce the best results on discrete evaluation metrics on sequence generation tasks such as text summerization (Paulus et al., 2017) or question generation (Song et al., 2017).
Revised: As a result, they do not always produce the best results on discrete evaluation metrics on sequence generation tasks such as text summarization (Paulus et al., 2017) or question generation (Song et al., 2017).

Original: To cope with these issues, some recent QG approaches (Song et al., 2017; Kumar et al., 2018b) directly optimize evaluation metrics using Reinforcement Learning (RL) (Williams, 1992).
Revised: To cope with these issues, some recent QG approaches (Song et al., 2017; Kumar et al., 2018b) directly optimize evaluation metrics using Reinforcement Learning (RL) (Williams, 1992).

Original: However, existing approaches usually only employ evaluation metrics like
Revised: However, existing approaches usually only employ evaluation metrics like

Original: BLEU and ROUGE-L as rewards for RL optimization.
Revised: BLEU and ROUGE-L as rewards for RL training.

Original: More importantly, they fail to exploit other important metrics such as syntactic and semantic constraints for guiding high-quality text generation.
Revised: More importantly, they fail to exploit other important metrics such as syntactic and semantic constraints for guiding high-quality text generation.

Original: Early works on neural QG did not take into account the answer information when generating a question.
Revised: Early works on neural QG did not take into account the answer information when generating a question.

Original: Recent works have started to explore various means of utilizing the answer information.
Revised: Recent works have started to explore various means of utilizing the answer information.

Original: When question generation is guided by the semantics of an answer, the resulting questions become more relevant and readable.
Revised: When question generation is guided by the semantics of an answer, the resulting questions become more relevant and readable.

Original: Conceptually, there are three different ways to incorporate the answer information by simply marking the answer location in the passage (Zhou et al., 2017;
Revised: Conceptually, there are three different ways to incorporate the answer information by simply marking the answer location in the passage (Zhou et al., 2017;

Original: Zhao et al., 2018; Liu et al., 2019), or using complex passage-answer matching strategies (Song et al., 2017), or separating answers from passages when applying a Seq2Seq model (Kim et al., 2018; Sun et al., 2018).
Revised: Zhao et al., 2018; Liu et al., 2019), or using complex passage-answer matching strategies (Song et al., 2017), or separating answers from passages when applying a Seq2Seq model (Kim et al., 2018; Sun et al., 2018).

Original: However, they neglect potential semantic relations between passage words and answer words, and thus fail to explicitly model the global interactions among them in the embedding space.
Revised: However, they neglect potential semantic relations between passage words and answer words, and thus fail to explicitly model the global interactions among them in the embedding space.

Original: To address these aforementioned issues, in this paper, we present a novel reinforcement learning based generator-evaluator architecture that aims to: i) make full use of rich hidden structure information beyond the simple word sequence; ii) generate syntactically and semantically valid text while maintaining the consistency of train/test measurement; iii) model explicitly the global interactions of semantic relationships between passage and answer at both word-level and contextual-level.
Revised: To address these aforementioned issues, in this paper, we present a novel reinforcement learning based generator-evaluator architecture that aims to: i) make full use of rich hidden structure information beyond the simple word sequence; ii) generate syntactically and semantically valid text while maintaining the consistency of train/test measurement; iii) model explicitly the global interactions of semantic relationships between passage and answer at both word-level and contextual-level.

Original: In particular, to achieve the ﬁrst goal, weﬁrst explore two different means to either construct a syntax-based static graph or a semantics-aware dynamic graph from the text sequence, as well as its rich hidden structure information.
Revised: In particular, to achieve the ﬁrst goal, we explore two different means to either construct a syntaxbased static graph or a semantics-aware dynamic graph from the text sequence, as well as its rich hidden structure information.

Original: Then, we design a graph-to-sequence (Graph2Seq) model based generator that encodes the graph representation of a text passage and decodes a question sequence using a Recurrent Neural Network (RNN).
Revised: Then, we design a graph-to-sequence (Graph2Seq) model based generator that encodes the graph representation of a text passage and decodes a question sequence using a Recurrent Neural Network (RNN).

Original: Our Graph2Seq model is based on a novel bidirectional gated graph neural network, which extends theoriginal gated graph neural network (Li et al., 2015) by considering both incoming and outgoing edges, and fusing them during the graph embedding learning.
Revised: Our Graph2Seq model is based on a novel bidirectional gated graph neural network, which extends the gated graph neural network (Li et al., 2015) by considering both incoming and outgoing edges, and fusing them during the graph embedding learning.

Original: To achieve the second goal, we design a hybrid evaluator which is trained by optimizing a mixed objective function that combines both cross-entropy and RL loss.
Revised: To achieve the second goal, we design a hybrid evaluator which is trained by optimizing a mixed objective function that combines both cross-entropy and RL loss.

Original: We use not only discrete evaluation metrics like BLEU, but also semantic metrics like word mover’s distance (Kusner et al., 2015) to encourage both syntactically and semantically valid text generation.
Revised: We use not only discrete evaluation metrics like BLEU, but also semantic metrics like word mover’s distance (Kusner et al., 2015) to encourage both syntactically and semantically valid text generation.

Original: To achieve the third goal, we propose a novel Deep Alignment Network (DAN) for effectively incorporating answer information into the passage at multiple granularity levels.
Revised: To achieve the third goal, we propose a novel Deep Alignment Network (DAN) for effectively incorporating answer information into the passage at multiple granularity levels.

Original: Our main contributions are as follows:
Revised: Our main contributions are as follows:

Original: • We propose a novel RL-based Graph2Seq model for natural question generation.
Revised: • We propose a novel RL-based Graph2Seq model for natural question generation.

Original: To the best of our knowledge, we are the ﬁrst to introduce the Graph2Seq architecture for QG.
Revised: To the best of our knowledge, we are the ﬁrst to introduce the Graph2Seq architecture for QG.

Original: • We explore both static and dynamic ways of constructing graph from text and are the ﬁrst to systematically investigate their performance impacts on a GNN encoder.
Revised: • We explore both static and dynamic ways of constructing graph from text and are the ﬁrst to systematically investigate their performance impacts on a GNN encoder.

Original: • The proposed model is end-to-end trainable, achieves new state-of-the-art scores, and outperforms existing methods by a signiﬁcant margin on the standard SQuAD benchmark for QG.
Revised: • The proposed model is end-to-end trainable, achieves new state-of-the-art scores, and outperforms existing methods by a signiﬁcant margin on the standard SQuAD benchmark for QG.

Original: Our human evaluation study also corroborates that the questions generated by our model are more natural (semantically and syntactically) compared to other baselines.
Revised: Our human evaluation study also corroborates that the questions generated by our model are more natural (semantically and syntactically) compared to other baselines.

Original:  A N RL- BASED G ENERATOR -E VALUATOR A RCHITECTURE
Revised:  A N RL- BASED G ENERATOR -E VALUATOR A RCHITECTURE

Original: In this section, we deﬁne the question generation task, and then present our RL-based Graph2Seq model for question generation.
Revised: In this section, we deﬁne the question generation task, and then present our RL-based Graph2Seq model for question generation.

Original: We ﬁrst motivate the design, and then present the details of each component as shown in Fig.
Revised: We ﬁrst motivate the design, and then present the details of each component as shown in Fig.

Original: 2. P ROBLEM F ORMULATION
Revised: 2. P ROBLEM F ORMULATION

Original: The goal of question generation is to generate natural language questions based on a given form of data, such as knowledge base triples or tables (Bao et al., 2018), sentences (Du et al., 2017; Song et al., 2018a), or images (Li et al., 2018), where the generated questions need to be answerable from the input data.
Revised: The goal of question generation is to generate natural language questions based on a given form of data, such as knowledge base triples or tables (Bao et al., 2018), sentences (Du et al., 2017; Song et al., 2018a), or images (Li et al., 2018), where the generated questions need to be answerable from the input data.

Original: In this paper, we focus on QG from a given text passage, along with a target answer.
Revised: In this paper, we focus on QG from a given text passage, along with a target answer.

Original: We assume that a text passage is a collection of word tokens X p “ t x p 1 , x p 2 , ..., x pN u , and a target answer is also a collection of word tokens
Revised: We assume that a text passage is a collection of word tokens X p “ t x p 1 , x p 2 , ..., x pN u , and a target answer is also a collection of word tokens

Original: X a “ t x a 1 , x a 2 , ..., x a L u .
Revised: X a “ t x a 1 , x a 2 , ..., x aL u .

Original: The task of natural question generation is to generate the best natural language question consisting of a sequence of word tokens ˆ
Revised: The task of natural question generation is to generate the best natural language question consisting of a sequence of word tokens ˆ

Original: Y “ t y 1 , y 2 , ..., y T u which maximizes the conditional likelihood ˆ Y “ arg max Y P p Y | X p , X a q .
Revised: Y “ t y 1 , y 2 , ..., y T u which maximizes the conditional likelihood ˆ Y “ arg max Y P p Y | X p , X a q .

Original: Here N , L , and T are the lenghts of the passage, answer and question, respectively.
Revised: Here N , L , and T are the lengths of the passage, answer and question, respectively.

Original: We focus on the problem setting where we have a set of passage (and answers) and target questions pairs, to learn the mapping; existing QG approaches (Du et al., 2017;
Revised: We focus on the problem setting where we have a set of passage (and answers) and target questions pairs, to learn the mapping; existing QG approaches (Du et al., 2017;

Original: Song et al., 2018a;
Revised: Song et al., 2018a;

Original: Zhao et al., 2018;
Revised: Zhao et al., 2018;

Original: Kim et al., 2018) make a similar assumption.
Revised: Kim et al., 2018) make a similar assumption.

Original: 2. D EEP A LIGNMENT N ETWORK
Revised: 2. D EEP A LIGNMENT N ETWORK

Original: Answer information is crucial for generating relevant and high quality questions from a passage.
Revised: Answer information is crucial for generating relevant and high quality questions from a passage.

Original: Unlike previous methods that neglect potential semantic relations between passage and answer words, we explicitly model the global interactions among them in the embedding space.
Revised: Unlike previous methods that neglect potential semantic relations between passage and answer words, we explicitly model the global interactions among them in the embedding space.

Original: To this end, we propose a novel Deep Alignment Network (DAN) component for effectively incorporating answer information into the passage with multiple granularity levels.
Revised: To this end, we propose a novel Deep Alignment Network (DAN) component for effectively incorporating answer information into the passage with multiple granularity levels.

Original: Speciﬁcally, we perform attentionbased soft-alignment at the word level, as well as at the contextualized hidden state level, so that multiple levels of alignments can help learn hierarchical representations. 
Revised: Speciﬁcally, we perform attentionbased soft-alignment at the word-level, as well as at the contextual-level, so that multiple levels of alignments can help learn hierarchical representations. attention-based soft-alignment mechanism.

Original: Let X p P R F ˆ N and r X p P R r F p ˆ N denote two embeddings associated with passage text.
Revised: Let X p P R F ˆ N and r X p P R r F p ˆ N denote two embeddings associated with passage text.

Original: Similarly, let X a P R F ˆ L and r X a P R r F a ˆ L denoted two embeddings associated with answer text.
Revised: Similarly, let X a P R F ˆ L and r X a P R r F a ˆ L denote two embeddings associated with answer text.

Original: Conceptually, as shown in Fig. 2, the soft-alignment mechanism consists of three steps: i) compute the attention score
Revised: Conceptually, as shown in Fig. 2, the soft-alignment mechanism consists of three steps: i) compute the attention score

Original: β i,j for each pair of passage word x pi and answer word x aj : ii) multiply the attention matrix β with the answer embeddings r X a to obtain the aligned answer embeddings H p for the passage; iii) concatenate the resulting aligned answer embeddings H p with the passage embeddings r
Revised: β i,j for each pair of passage word x pi and answer word x aj : ii) multiply the attention matrix β with the answer embeddings r X a to obtain the aligned answer embeddings H p for the passage; iii) concatenate the resulting aligned answer embeddings H p with the passage embeddings r

Original: X p to get the ﬁnal passage embeddings r H p P R p r F [Equation] ` r F a qˆ N .
Revised: X p to get the ﬁnal passage embeddings r H p P R p r F p ` r F a qˆ N .

Original: Formally, we deﬁne our soft-alignment function as following:
Revised: Formally, we deﬁne our soft-alignment function as following:

Original: [Equation]
Revised: [Equation]

Original: where the matrix r H p is the ﬁnal passage embedding, the function CAT is a simple concatenation operation, and β is a N ˆ L attention score matrix, computed by
Revised: where the matrix r H p is the ﬁnal passage embedding, the function CAT is a simple concatenation operation, and β is a N ˆ L attention score matrix, computed by

Original: [Equation]
Revised: [Equation]

Original: where W P R d ˆ F is a trainable weight matrix, with d being the hidden state size and ReLU is the rectiﬁed linear unit (Nair & Hinton, 2010).
Revised: where W P R d ˆ F is a trainable weight matrix, with d being the hidden state size and ReLU is the rectiﬁed linear unit (Nair & Hinton, 2010).

Original: After introducing the general soft-alignment mechanism, we next introduce how we do soft-alignment at both word-level and contextualized hidden state level.
Revised: After introducing the general soft-alignment mechanism, we next introduce how we do soft-alignment at both word-level and contextual-level.

Original: 2.2. W ORD - LEVEL A LIGNMENT
Revised: 2.2. W ORD - LEVEL A LIGNMENT

Original: In the word-level alignment stage, we ﬁrst perform a soft-alignment between the passage and the answer based only on their pretrained GloVe embeddings and compute the ﬁnal passage embeddings by r H p “ Align p G p , G a , r G p ; B p ; L p s , G a q , where G p , B p , and L p are the corresponding
Revised: In the word-level alignment stage, we ﬁrst perform a soft-alignment between the passage and the answer based only on their pretrained GloVe embeddings and compute the ﬁnal passage embeddings by r H p “ Align p G p , G [Equation] , r G p ; B p ; L p s , G a q , where G p , B p , and L p are the corresponding

Original: GloVe embedding (Pennington et al., 2014), BERT embedding (Devlin et al., 2018), and linguistic feature (i.e., case, NER and POS) embedding of the passage text, respectively.
Revised: GloVe embedding (Pennington et al., 2014), BERT embedding (Devlin et al., 2018), and linguistic feature (i.e., case, NER and POS) embedding of the passage text, respectively.

Original: Then a bidirectional
Revised: Then a bidirectional

Original: LSTM (Hochreiter & Schmidhuber, 1997) is applied to the ﬁnal passage embeddings r H p “ t r h pi u Ni “to obtain contextualized passage embeddings s H p P R s F ˆ N .
Revised: LSTM (Hochreiter & Schmidhuber, 1997) is applied to the ﬁnal passage embeddings r H p “ t r h pi u Ni “to obtain contextualized passage embeddings s H p P R s F ˆ N .

Original: On the other hand, for the answer text X a , we simply concatenate its GloVe embedding G a and its BERT embedding B a to obtain its word embedding matrix H a P R d 1 ˆ L .
Revised: On the other hand, for the answer text X a , we simply concatenate its GloVe embedding G a and its BERT embedding B a to obtain its word embedding matrix H a P R d 1 ˆ L .

Original: Another BiLSTM is then applied to the concatenated answer embedding sequence to obtain the contextualized answer embeddings s H a P R s F ˆ L .
Revised: Another BiLSTM is then applied to the concatenated answer embedding sequence to obtain the contextualized answer embeddings s H a P R s F ˆ L .

Original: 2.2. H IDDEN - LEVEL A LIGNMENT
Revised: 2.2. C ONTEXTUAL - LEVEL A LIGNMENT

Original: In the hidden-level alignment stage, we perform another soft-alignment based on the contextualized passage and answer embeddings.
Revised: In the contextual-level alignment stage, we perform another soft-alignment based on the contextualized passage and answer embeddings.

Original: Similarly, we compute the aligned answer embedding, and concatenate it with the contextualized passage embedding to obtain the ﬁnal passage embedding matrix Align pr G p ; B p ; s H p s , r G a ; B a ; s H a s , s H p , s H a q .
Revised: Similarly, we compute the aligned answer embedding, and concatenate it with the contextualized passage embedding to obtain the ﬁnal passage embedding matrix Align pr G p ; B p ; s H p s , r G a ; B a ; s H a s , s H p , s H a q .

Original: Finally, we apply another BiLSTM to the above concatenated embedding to get a s F ˆ N passage embedding matrix X .
Revised: Finally, we apply another BiLSTM to the above concatenated embedding to get a s F ˆ N passage embedding matrix X .

Original: 2. B IDIECTIONAL G RAPH - TO -S EQUENCE G ENERATOR
Revised: 2. B IDIECTIONAL G RAPH - TO -S EQUENCE G ENERATOR

Original: While RNNs are good at capturing local dependencies among consecutive words in text, GNNs have been shown to better utilize the rich hidden text structure information such as syntactic parsing (Xu et al., 2018b) or semantic parsing (Song et al., 2018b), and can model the global interactions (relations) among sequence words to further improve the representations.
Revised: While RNNs are good at capturing local dependencies among consecutive words in text, GNNs have been shown to better utilize the rich hidden text structure information such as syntactic parsing (Xu et al., 2018b) or semantic parsing (Song et al., 2018b), and can model the global interactions (relations) among sequence words to further improve the representations.

Original: Therefore, unlike most of the existing methods that rely on RNNs to encode the input passage, we ﬁrst construct a passage graph G from text where each passage word is treated as a graph node, and then employ a novel
Revised: Therefore, unlike most of the existing methods that rely on RNNs to encode the input passage, we ﬁrst construct a passage graph G from text where each passage word is treated as a graph node, and then employ a novel

Original: Graph2Seq model to encode the passage graph (and answer), and to decode the natural language question.
Revised: Graph2Seq model to encode the passage graph (and answer), and to decode the question sequence.

Original: 2.3. P ASSAGE G RAPH C ONSTRUCTION
Revised: 2.3. P ASSAGE G RAPH C ONSTRUCTION

Original: Existing GNNs assume a graph structured input and directly consume it for computing the corresponding node embeddings.
Revised: Existing GNNs assume a graph structured input and directly consume it for computing the corresponding node embeddings.

Original: However, we need to construct a graph from the text.
Revised: However, we need to construct a graph from the text.

Original: Although there are early attempts on constructing a graph from a sentence (Xu et al., 2018b), there is no clear answer as to the best way of representing text as a graph.
Revised: Although there are early attempts on constructing a graph from a sentence (Xu et al., 2018b), there is no clear answer as to the best way of representing text as a graph.

Original: We explore both static and dynamic graph construction approaches, and systematically investigate the performance differences between these two methods in the experimental section.
Revised: We explore both static and dynamic graph construction approaches, and systematically investigate the performance differences between these two methods in the experimental section.

Original: Syntax-based static graph construction
Revised: Syntax-based static graph construction

Original: : We construct a directed and unweighted passage graph based on dependency parsing.
Revised: : We construct a directed and unweighted passage graph based on dependency parsing.

Original: For each sentence in a passage, we ﬁrst get its dependency parse tree.
Revised: For each sentence in a passage, we ﬁrst get its dependency parse tree.

Original: We then connect neighboring dependency parse trees by connecting those nodes that are at a sentence boundary and next to each other in text.
Revised: We then connect neighboring dependency parse trees by connecting those nodes that are at a sentence boundary and next to each other in text.

Original: Semantics-aware dynamic graph construction: We dynamically build a directed and weighted graph to model semantic relationships among passage words.
Revised: Semantics-aware dynamic graph construction: We dynamically build a directed and weighted graph to model semantic relationships among passage words.

Original: We make the process of building such a graph depend on not only the passage, but also on the answer.
Revised: We make the process of building such a graph depend on not only the passage, but also on the answer.

Original: The graph construction procedure consists of three steps: i) we compute a dense adjacency matrix A for the passage graph by applying self-attention to the word-level passage embeddings r H p , ii) a kNN-style graph sparsiﬁcation strategy (Chen et al., 2019b) is adopted to obtain a sparse adjacency matrix ¯ A , where we only keep the
Revised: The graph construction procedure consists of three steps: i) we compute a dense adjacency matrix A for the passage graph by applying self-attention to the word-level passage embeddings r H p , ii) a kNN-style graph sparsiﬁcation strategy (Chen et al., 2019c) is adopted to obtain a sparse adjacency matrix ¯ A , where we only keep the

Original: K nearest neighbors (including itself) as well as the associated attention scores (i.e., the remaining attentions scores are masked off) for each node; and iii) inspired by BiLSTM over LSTM, we also compute two normalized adjacency matrices A % and A $ according to their incoming and outgoing directions, by applying softmax operation on the resulting sparse adjacency matrix ¯ A and its transpose, respectively.
Revised: K nearest neighbors (including itself) as well as the associated attention scores (i.e., the remaining attentions scores are masked off) for each node; and iii) inspired by BiLSTM over LSTM, we also compute two normalized adjacency matrices A % and A $ according to their incoming and outgoing directions, by applying softmax operation on the resulting sparse adjacency matrix ¯ A and its transpose, respectively.

Original: [Equation]
Revised: [Equation]

Original: where U is a d ˆ p r F p ` r F a q trainable weight matrix.
Revised: where U is a d ˆ p r F p ` r F a q trainable weight matrix.

Original: Note that the supervision signal is able to back-propagate through thekNN-style graph sparsiﬁcation operation since the K nearest attention scores are kept.
Revised: Note that the supervision signal is able to back-propagate through the graph sparsiﬁcation operation as the K nearest attention scores are kept.

Original: 2.3. B IDIRECTIONAL G ATED G RAPH N EURAL N ETWORKS
Revised: B IDIRECTIONAL G ATED G RAPH N EURAL N ETWORKS

Original: To effectively learn the graph embeddings from the constructed text graph, we propose a novel Bidirectional Gated Graph Neural Network (BiGGNN) which extends Gated Graph Sequence Neural
Revised: To effectively learn the graph embeddings from the constructed text graph, we propose a novel Bidirectional Gated Graph Neural Network (BiGGNN) which extends Gated Graph Sequence Neural

Original: Networks (Li et al., 2015) by learning node embedding from both incoming and outgoing edges in an interleaved fashion when processing the directed passage graph.
Revised: Networks (Li et al., 2015) by learning node embeddings from both incoming and outgoing edges in an interleaved fashion when processing the directed passage graph.

Original: Similar idea has also been exploited in (Xu et al., 2018a), which extended another popular variant of GNNs - GraphSAGE (Hamilton et al., 2017).
Revised: Similar idea has also been exploited in (Xu et al., 2018a), which extended another popular variant of GNNs - GraphSAGE (Hamilton et al., 2017).

Original: However, one of key difference between our BiGGNN and their bidirectional GraphSAGE is that we fuse the intermediate node embeddings from both incoming and outgoing edges in every iteration during the training, whereas their model simply trains the node embeddings of each direction independently and concatenates them in the ﬁnal step.
Revised: However, one of key difference between our BiGGNN and their bidirectional GraphSAGE is that we fuse the intermediate node embeddings from both incoming and outgoing directions in every iteration, whereas their model simply learns the node embeddings of each direction independently and concatenates them in the ﬁnal step.

Original: In BiGGNN, node embeddings are initialized to the passage embeddings X returned by DAN.
Revised: In BiGGNN, node embeddings are initialized to the passage embeddings X returned by DAN.

Original: The same set of network parameters are shared at every hop of computation.
Revised: The same set of network parameters are shared at every hop of computation.

Original: At each computation hop, for every node in the graph, we apply an aggregation function which takes as input a set of incoming (or outgoing) neighboring node vectors and outputs a backward (or forward) aggregation vector.
Revised: At each computation hop, for every node in the graph, we apply an aggregation function which takes as input a set of incoming (or outgoing) neighboring node vectors and outputs a backward (or forward) aggregation vector.

Original: For the syntax-based static graph, we use a mean aggregator for simplicity although other operators such as max or attention (Veli ˇ ckovi ´ c et al., 2017) could also be employed, 
Revised: For the syntax-based static graph, we use a mean aggregator for simplicity although other operators such as max or attention (Veliˇckovi´c et al., 2017) could also be employed, [Equation]

Original: [Equation]
Revised: [Equation]

Original: For the semantics-aware dynamic graph we compute a weighted average for aggregation where the weights come from the normalized adjacency matrices A % and A $ , deﬁned as,
Revised: For the semantics-aware dynamic graph we compute a weighted average for aggregation where the weights come from the normalized adjacency matrices A % and A $ , deﬁned as,

Original: [Equation]
Revised: [Equation]

Original: While (Xu et al., 2018a) learn separate node embeddings for both directions independently, we choose to fusethe information aggregated inthe two directions at each hop, which we ﬁnd works better in general.
Revised: While (Xu et al., 2018a) learn separate node embeddings for both directions independently, we opt to fuse information aggregated in two directions at each hop, which we ﬁnd works better in general.

Original: [Equation]
Revised: [Equation]

Original: We design the fusion function as a gated sum of two information sources,
Revised: We design the fusion function as a gated sum of two information sources,

Original: [Equation]
Revised: [Equation]

Original: where d is the component-wise multiplication, σ is a sigmoid function, and z is a gating vector.
Revised: where d is the component-wise multiplication, σ is a sigmoid function, and z is a gating vector.

Original: Finally, a Gated Recurrent Unit (GRU) (Cho et al., 2014) is used to update the node embeddings by incorporating the aggregation information.
Revised: Finally, a Gated Recurrent Unit (GRU) (Cho et al., 2014) is used to update the node embeddings by incorporating the aggregation information.

Original: [Equation]
Revised: [Equation]

Original: After n hops of GNN computation, where n is a hyperparameter, we obtain the ﬁnal state embedding h nv for node v .
Revised: After n hops of GNN computation, where n is a hyperparameter, we obtain the ﬁnal state embedding h nv for node v .

Original: To compute the graph-level embedding, we ﬁrst apply a linear projection to the node embeddings, and then apply max-pooling over all node embeddings to get a d -dim vector h G .
Revised: To compute the graph-level embedding, we ﬁrst apply a linear projection to the node embeddings, and then apply max-pooling over all node embeddings to get a d -dim vector h G .

Original: 2.3. RNN D ECODER
Revised: 2.3. RNN D ECODER

Original: On the decoder side, we adopt the same model architecture as other state-of-the-art Seq2Seq mdoels where an attention-based (Bahdanau et al., 2014; Luong et al., 2015) LSTM decoder with copy (Vinyals et al., 2015; Gu et al., 2016) and coverage mechanisms (Tu et al., 2016) is empolyed.
Revised: On the decoder side, we adopt the same model architecture as other state-of-the-art Seq2Seq models where an attention-based (Bahdanau et al., 2014; Luong et al., 2015) LSTM decoder with copy (Vinyals et al., 2015; Gu et al., 2016) and coverage mechanisms (Tu et al., 2016) is employed.

Original: The decoder takes the graph-level embedding h G followed by two separate fully-connected layers as initial hidden states (i.e., c 0 and s 0 ) and the node embeddings t h nv , @
Revised: The decoder takes the graph-level embedding h G followed by two separate fully-connected layers as initial hidden states (i.e., c 0 and s 0 ) and the node embeddings t h nv , @

Original: v P G u as the attention memory, and generates the output sequence one word at a time.
Revised: v P G u as the attention memory, and generates the output sequence one word at a time.

Original: The particular decoder used in this work closely follows (See et al., 2017).
Revised: The particular decoder used in this work closely follows (See et al., 2017).

Original: We refer the readers to Appendix A for more details.
Revised: We refer the readers to Appendix A for more details.

Original: 2. H YBRID E VALUATOR
Revised: 2. H YBRID E VALUATOR

Original: It has been observed that optimizing such cross-entropy based training objectives for sequence learning does not always produce the best results on discrete evaluation metrics (Ranzato et al., 2015;
Revised: It has been observed that optimizing such cross-entropy based training objectives for sequence learning does not always produce the best results on discrete evaluation metrics (Ranzato et al., 2015;

Original: Wu et al., 2016; Paulus et al., 2017).
Revised: Wu et al., 2016; Paulus et al., 2017).

Original: Major limitations of this strategy include exposure bias and evaluation discrepancy between training and testing.
Revised: Major limitations of this strategy include exposure bias and evaluation discrepancy between training and testing.

Original: To tackle these issues, some recent QG approaches (Song et al., 2017; Kumar et al., 2018b) directly optimize evaluation metrics using REINFORCE.
Revised: To tackle these issues, some recent QG approaches (Song et al., 2017; Kumar et al., 2018b) directly optimize evaluation metrics using REINFORCE.

Original: We further use a mixed objective function with both syntactic and semantic constraints for guiding text generation.
Revised: We further use a mixed objective function with both syntactic and semantic constraints for guiding text generation.

Original: In particular, we present a hybrid evaluator with a mixed objective function that combines both cross-entropy loss and RL loss in order to ensure the generation of syntactically and semantically valid text.
Revised: In particular, we present a hybrid evaluator with a mixed objective function that combines both cross-entropy loss and RL loss in order to ensure the generation of syntactically and semantically valid text.

Original: For the RL part, we employ the self-critical sequence training (SCST) algorithm (Rennie et al., 2017) to directly optimize the evaluation metrics.
Revised: For the RL part, we employ the self-critical sequence training (SCST) algorithm (Rennie et al., 2017) to directly optimize the evaluation metrics.

Original: SCST is an efﬁcient REINFORCE algorithm that utilizes the output of its own test-time inference algorithm to normalize the rewards it experiences.
Revised: SCST is an efﬁcient REINFORCE algorithm that utilizes the output of its own test-time inference algorithm to normalize the rewards it experiences.

Original: In SCST, at each training iteration, the model generates two output sequences: the sampled output
Revised: In SCST, at each training iteration, the model generates two output sequences: the sampled output

Original: Y s , produced by multinomial sampling, that is, each word y st is sampled according to the likelihood
Revised: Y s , produced by multinomial sampling, that is, each word y st is sampled according to the likelihood

Original: P p
Revised: P p

Original: y t | X, y ă t q predicted by the generator, and the baseline output ˆ Y , obtained by greedy search, that is, by maximizing the output probability distribution at each decoding step.
Revised: y t | X, y ă t q predicted by the generator, and the baseline output ˆ Y , obtained by greedy search, that is, by maximizing the output probability distribution at each decoding step.

Original: We deﬁne r p Y q as the reward of an output sequence Y , computed by comparing it to corresponding ground-truth sequence
Revised: We deﬁne r p Y q as the reward of an output sequence Y , computed by comparing it to corresponding ground-truth sequence

Original: Y ˚ with some reward metrics.
Revised: Y ˚ with some reward metrics.

Original: The loss function is deﬁned as:
Revised: The loss function is deﬁned as:

Original: [Equation]
Revised: [Equation]

Original: As we can see, if the sampled output has a higher reward than the baseline one, we maximize its likelihood, and vice versa.
Revised: As we can see, if the sampled output has a higher reward than the baseline one, we maximize its likelihood, and vice versa.

Original: One of the key factors for RL is to pick the proper reward function.
Revised: One of the key factors for RL is to pick the proper reward function.

Original: To take syntactic and semantic constraints into account, we consider the following metrics as our reward functions:
Revised: To take syntactic and semantic constraints into account, we consider the following metrics as our reward functions:

Original: Evaluation metric as reward function: We use one of our evaluation metrics, BLEU-4, as our reward function f eval , which lets us directly optimize the model towards the evaluation metrics.
Revised: Evaluation metric as reward function: We use one of our evaluation metrics, BLEU-4, as our reward function f eval , which lets us directly optimize the model towards the evaluation metrics.

Original: Semantic metric as reward function: One drawback of some evaluation metrics like BLEU is that they do not measure meaning, but only reward systemsfor n-grams that have exact  matches in the reference system.
Revised: Semantic metric as reward function: One drawback of some evaluation metrics like BLEU is that they do not measure meaning, but only reward systems that have exact n-gram matches in the reference system.

Original: To make our reward function more effective and robust, we additionally use word movers distance (WMD) as a semantic reward function f sem .
Revised: To make our reward function more effective and robust, we additionally use word movers distance (WMD) as a semantic reward function f sem .

Original: WMD is the state-of-the-art approach to measure the dissimilarity between two sentences based on word embeddings (Kusner et al., 2015).
Revised: WMD is the state-of-the-art approach to measure the dissimilarity between two sentences based on word embeddings (Kusner et al., 2015).

Original: Following Gong et al.
Revised: Following Gong et al.

Original: (2019), we take the negative of the WMD distance between a generated sequence and the ground-truth sequence and divide it by the sequence length as its semantic score.
Revised: (2019), we take the negative of the WMD distance between a generated sequence and the ground-truth sequence and divide it by the sequence length as its semantic score.

Original: We deﬁne the ﬁnal reward function as r p Y q “ f eval p Y, Y ˚ q ` αf sem p Y, Y ˚ q where α is a scalar.
Revised: We deﬁne the ﬁnal reward function as r p Y q “ f eval p Y, Y ˚ q ` αf sem p Y, Y ˚ q where α is a scalar.

Original: 2. T RAINING AND T ESTING
Revised: 2. T RAINING AND T ESTING

Original: We train our model in two stages.
Revised: We train our model in two stages.

Original: In the ﬁrst state, we train the model using regular cross-entropy loss, deﬁned as,
Revised: In the ﬁrst state, we train the model using regular cross-entropy loss, deﬁned as,

Original: [Equation]
Revised: [Equation]

Original: 10) where y ˚ t is the word at the t -th position of the ground-truth output sequence and covloss t is the coverage loss deﬁned as ř i min p a t i , c t i q , with a t i being the i -th element of the attention vector over the input sequence at time step t .
Revised: where y ˚ t is the word at the t -th position of the ground-truth output sequence and covloss t is the coverage loss deﬁned as ř i min p a ti , c ti q , with a ti being the i -th element of the attention vector over the input sequence at time step t .

Original: Scheduled teacher forcing (Bengio et al., 2015) is adopted to alleviate the exposure bias problem.
Revised: Scheduled teacher forcing (Bengio et al., 2015) is adopted to alleviate the exposure bias problem.

Original: In the second stage, we ﬁne-tune the model by optimizing a mixed objective function combining both cross-entropy loss and RL loss, deﬁned as,
Revised: In the second stage, we ﬁne-tune the model by optimizing a mixed objective function combining both cross-entropy loss and RL loss, deﬁned as,

Original: [Equation]
Revised: [Equation]

Original: 11) where γ is a scaling factor controling the trade-off between cross-entropy loss and RL loss.
Revised: where γ is a scaling factor controling the trade-off between cross-entropy loss and RL loss.

Original: During the testing phase, we use beam search to generate ﬁnal predictions.
Revised: During the testing phase, we use beam search to generate ﬁnal predictions.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: We evaluate our proposed model against state-of-the-art methods on the SQuAD dataset (Rajpurkar et al., 2016).
Revised: We evaluate our proposed model against state-of-the-art methods on the SQuAD dataset (Rajpurkar et al., 2016).

Original: Our full models have two variants G2S sta +BERT+RL and G2S dyn +BERT+RL which adopts static graph construction or dynamic graph construction, respectively.
Revised: Our full models have two variants G2S sta +BERT+RL and G2S dyn +BERT+RL which adopts static graph construction or dynamic graph construction, respectively.

Original: For model settings and sensitivity analysis, please refer to Appendix B and C. 
Revised: For model settings and sensitivity analysis, please refer to Appendix B and C. The implementation of our model is publicly available at https://github.com/hugochan/RL-based-Graph2Seq-for-NQG .

Original: 3. B ASELINE M ETHODS
Revised: 3. B ASELINE M ETHODS

Original: We compare against the following baselines in our experiments: i)  SeqCopyNet
Revised: We compare against the following baselines in our experiments: i) Transformer (Vaswani et al., 2017), ii) SeqCopyNet

Original: (Zhou et al., 2018), ii) NQG++ (Zhou et al., 2017), iii) MPQG+R (Song et al., 2017), iv) AFPQA (Sun et al., 2018), v) s2sa-at-mp-gsa (Zhao et al., 2018), vi
Revised: (Zhou et al., 2018), iii) NQG++ (Zhou et al., 2017), iv) MPQG+R (Song et al., 2017), v) AFPQA (Sun et al., 2018), vi) s2sa-at-mp-gsa (Zhao et al., 2018), vii)

Original: ) ASs2s (Kim et al., 2018), and vii) CGC-QG (Liu et al., 2019).
Revised: ASs2s (Kim et al., 2018), and viii) CGC-QG (Liu et al., 2019).

Original: Detailed descriptions of the baselines are provided in Appendix D. Experiments on baselines followed by * are conducted using released source codes.
Revised: Detailed descriptions of the baselines are provided in Appendix D. Experiments on baselines followed by * are conducted using released code.

Original: Results of other baselines are taken from the corresponding papers, with unreported metrics marked as –.
Revised: Results of other baselines are taken from the corresponding papers, with unreported metrics marked as –.

Original: 3. D ATA AND M ETRICS
Revised: D ATA AND M ETRICS

Original: SQuAD contains more than 100K questions posed by crowd workers on 536 Wikipedia articles.
Revised: SQuAD contains more than 100K questions posed by crowd workers on 536 Wikipedia articles.

Original: Since the test set of the original SQuAD is not publicly available, the accessible parts ( « 90%) are used as the entire dataset in our experiments.
Revised: Since the test set of the original SQuAD is not publicly available, the accessible parts ( « 90%) are used as the entire dataset in our experiments.

Original: For fair comparison with previous methods, we evaluated our model on both data split-1 (Song et al., 2018a) 2 that contains 75,500/17,934/11,805 (train/development/test) examples and data split-2 (Zhou et al., 2017) 3 that contains 86,635/8,965/8,964 examples.
Revised: For fair comparison with previous methods, we evaluated our model on both data split-1 (Song et al., 2018a) 1 that contains 75,500/17,934/11,805 (train/development/test) examples and data split-2 (Zhou et al., 2017) 2 that contains 86,635/8,965/8,964 examples.

Original: Following previous works, we use BLEU-4 (Papineni et al., 2002), METEOR (Banerjee & Lavie, 2005), ROUGE-L (Lin, 2004) and Q-BLEU1 (Nema & Khapra, 2018) as our evaluation metrics.
Revised: Following previous works, we use BLEU-4 (Papineni et al., 2002), METEOR (Banerjee & Lavie, 2005), ROUGE-L (Lin, 2004) and Q-BLEU1 (Nema & Khapra, 2018) as our evaluation metrics.

Original: Initially, BLEU-4 and METEOR were designed for evaluating machine translation systems and
Revised: Initially, BLEU-4 and METEOR were designed for evaluating machine translation systems and

Original: ROUGE-L was designed for evaluating text summarization systems.
Revised: ROUGE-L was designed for evaluating text summarization systems.

Original: Recently, Q-BLEU1 was designed for better evaluating question generation systems, which was shown to correlate signiﬁcantly better with human judgments compared to existing metrics.
Revised: Recently, Q-BLEU1 was designed for better evaluating question generation systems, which was shown to correlate signiﬁcantly better with human judgments compared to existing metrics.

Original: Besides automatic evaluation metrics, we also conduct a human evaluation study on split-2.
Revised: Besides automatic evaluation, we also conduct a human evaluation study on split-2.

Original: We ask human evaluators to rate generated questions from a set of anonymized competing systems based on whether they are syntactically correct, semantically correct and relevant to the passage.
Revised: We ask human evaluators to rate generated questions from a set of anonymized competing systems based on whether they are syntactically correct, semantically correct and relevant to the passage.

Original: The rating scale is from 1 to 5, on each of the three categories.
Revised: The rating scale is from 1 to 5, on each of the three categories.

Original: Evaluation scores from all evaluators were collected and averaged as ﬁnal scores.
Revised: Evaluation scores from all evaluators are collected and averaged as ﬁnal scores.

Original: Further details on human evaluation can be found in Appendix E. 
Revised: Further details on human evaluation can be found in Appendix E. [Table]

Revised: [Table]

Original: 3. E XPERIMENTAL R ESULTS AND H UMAN E VALUATION
Revised: 3. E XPERIMENTAL R ESULTS AND H UMAN E VALUATION

Original: Table 1 shows the automatic evaluation results comparing our proposed models against other stateof-the-art baseline methods.
Revised: Table 1 shows the automatic evaluation results comparing our proposed models against other stateof-the-art baseline methods.

Original: First of all, we can see that both of our full models G2S sta +BERT+RL and G2S dyn +BERT+RL achieve the new state-of-the-art scores on both data splits and consistently outperform previous methods by a signiﬁcant margin.
Revised: First of all, we can see that both of our full models G2S sta +BERT+RL and G2S dyn +BERT+RL achieve the new state-of-the-art scores on both data splits and consistently outperform previous methods by a signiﬁcant margin.

Original: This highlights that our RL-based Graph2Seq model, together with the deep alignment network, successfully addresses the three issues we highlighted in Sec. 1.
Revised: This highlights that our RL-based Graph2Seq model, together with the deep alignment network, successfully addresses the three issues we highlighted in Sec. 1.

Original: Between these two variants, G2S sta +BERT+RL outperforms G2S dyn +BERT+RL[Table] [Table] on all the metrics.
Revised: Between these two variants, G2S sta +BERT+RL outperforms G2S dyn +BERT+RL on all the metrics.

Original: Also, unlike the baseline methods, our model does not rely on any hand-crafted rules or ad-hoc strategies, and is fully end-to-end trainable.
Revised: Also, unlike the baseline methods, our model does not rely on any hand-crafted rules or ad-hoc strategies, and is fully end-to-end trainable.

Original: As shown in Table [Table] we conducted a human evaluation study to assess the quality of the questions generated by our model, the baseline method MPQG+R, and the ground-truth data in terms of syntax, semantics and relevance metrics.
Revised: As shown in Table 2, we conducted a human evaluation study to assess the quality of the questions generated by our model, the baseline method MPQG+R, and the ground-truth data in terms of syntax, semantics and relevance metrics.

Original: We can see that our best performing model achieves good results even compared to the ground-truth, and outperforms the strong baseline method MPQG+R.
Revised: We can see that our best performing model achieves good results even compared to the ground-truth, and outperforms the strong baseline method MPQG+R.

Original: Our error analysis shows that main syntactic error occurs in repeated/unknown words in generated questions.
Revised: Our error analysis shows that main syntactic error occurs in repeated/unknown words in generated questions.

Original: Further, the slightly lower quality on semantics also impacts the relevance.
Revised: Further, the slightly lower quality on semantics also impacts the relevance.

Original: 3. A BLATION S TUDY
Revised: 3. A BLATION S TUDY

Original: [Table]
Revised: [Table]

Revised: BERT 17.

Original: As shown in Table
Revised: G2S sta w/o DAN 12. G2S sta +BERT 18. G2S sta w/o BiGGNN, w/ Seq2Seq 16.

Revised: G2S sta +BERT-ﬁxed 17.

Original: [Table]
Revised: G2S sta w/o BiGGNN, w/ GCN 14. G2S dyn +RL 17. G2S sta w/ GGNN-forward 16. G2S sta +RL 17.

Original:  we perform an ablation study to systematically assess the impact of different model components (e.g., BERT, RL, DAN, and BiGGNN) for two proposed full model variants (static vs dynamic) on the SQuAD split-2 test set.
Revised: G2S sta w/ GGNN-backward 16. 1 https https As shown in Table 3, we perform an ablation study to systematically assess the impact of different model components (e.g., BERT, RL, DAN, and BiGGNN) for two proposed full model variants (static vs dynamic) on the SQuAD split-2 test set.

Original: It conﬁrms our ﬁnding that syntax-based static graph construction (G2S sta +BERT+RL) performs better than semantics-aware dynamic graph construction (G2S dyn +BERT+RL) in almost every setting.
Revised: It conﬁrms our ﬁnding that syntax-based static graph construction (G2S sta +BERT+RL) performs better than semantics-aware dynamic graph construction (G2S dyn +BERT+RL) in almost every setting.

Original: However, it may be too early to conclude which one is the method of choice for QG.
Revised: However, it may be too early to conclude which one is the method of choice for QG.

Original: On the one hand, an advantage of static graph construction is that useful domain knowledge can be hard-coded into the graph, which can greatly beneﬁt the downstream task.
Revised: On the one hand, an advantage of static graph construction is that useful domain knowledge can be hard-coded into the graph, which can greatly beneﬁt the downstream task.

Original: However, it might suffer if there is a lack of prior knowledge for a speciﬁc domain knowledge.
Revised: However, it might suffer if there is a lack of prior knowledge for a speciﬁc domain knowledge.

Original: On the other hand, dynamic graph construction does not need any prior knowledge about the hidden structure of text, and only relies on the attention matrix to capture these structured information, which provides an easy way to achieve a decent performance.
Revised: On the other hand, dynamic graph construction does not need any prior knowledge about the hidden structure of text, and only relies on the attention matrix to capture these structured information, which provides an easy way to achieve a decent performance.

Original: One interesting direction is to explore effective ways of combining both static and dynamic graphs.
Revised: One interesting direction is to explore effective ways of combining both static and dynamic graphs.

Original: By turning off the Deep Alignment Network (DAN), the BLEU-4 score of G2S sta (similarly for
Revised: By turning off the Deep Alignment Network (DAN), the BLEU-4 score of G2S sta (similarly for

Original: G2S dyn ) dramatically drops from 16 .
Revised: G2S dyn ) dramatically drops from 16 .

Original: 96% to 12 .
Revised: 96% to 12 .

Original: 62% , which indicates the importance of answer information for QG and shows the effectiveness of DAN.
Revised: 62% , which indicates the importance of answer information for QG and shows the effectiveness of DAN.

Original: This can also be veriﬁed by comparing the performance between the DAN-enhanced Seq2Seq model (16.14 BLEU-4 score) and other carefully designed answer-aware Seq2Seq baselines such as NQG++ (13.29 BLEU-4 score), MPQG+R (14.
Revised: This can also be veriﬁed by comparing the performance between the DAN-enhanced Seq2Seq model (16.14 BLEU-4 score) and other carefully designed answer-aware Seq2Seq baselines such as NQG++ (13.29 BLEU-4 score), MPQG+R (14.

Original: BLEU-4 score) and AFPQA (15.82 BLEU-4 score).
Revised: BLEU-4 score) and AFPQA (15.82 BLEU-4 score).

Original: Further experiments demonstrate that both word-level (G2S sta w/ DAN-word only) and hidden-level (G2S sta w/ DAN-hidden only) answer alignments in DAN are helpful.
Revised: Further experiments demonstrate that both word-level (G2S sta w/ DAN-word only) and contextual-level (G2S sta w/ DAN-contextual only) answer alignments in DAN are helpful.

Original: We can see the advantages of Graph2Seq learning over Seq2Seq learning on this task by comparing the performance between G2S sta and Seq2Seq.
Revised: We can see the advantages of Graph2Seq learning over Seq2Seq learning on this task by comparing the performance between G2S sta and Seq2Seq.

Original: Compared to Seq2Seq based QG methods that completely ignore hidden structure information in the passage, our Graph2Seq based method is aware of more hidden structure information such as semantic similarity between any pair of words that are not directly connected or syntactic relationships between two words captured in a dependency parsing tree.
Revised: Compared to Seq2Seq based QG methods that completely ignore hidden structure information in the passage, our Graph2Seq based method is aware of more hidden structure information such as semantic similarity between any pair of words that are not directly connected or syntactic relationships between two words captured in a dependency parsing tree.

Original: In our experiments, we also observe that doing both forward and backward message passing in the GNN encoder is beneﬁcial.
Revised: In our experiments, we also observe that doing both forward and backward message passing in the GNN encoder is beneﬁcial.

Original: Surprisingly, using GCN (Kipf & Welling, 2016) as the graph encoder (and converting the input graph to an undirected graph) does not provide good performance.
Revised: Surprisingly, using GCN (Kipf & Welling, 2016) as the graph encoder (and converting the input graph to an undirected graph) does not provide good performance.

Original: In addition, ﬁne-tuning the model using REINFORCE can further improve the model performance in all settings (i.e., w/ and w/o BERT), which shows the beneﬁts of directly optimizing the evaluation metrics.
Revised: In addition, ﬁne-tuning the model using REINFORCE can further improve the model performance in all settings (i.e., w/ and w/o BERT), which shows the beneﬁts of directly optimizing the evaluation metrics.

Original: Besides, we ﬁnd that the pretrained BERT embedding has a considerable impact on the performance and ﬁne-tuning BERT embedding even further improves the performance, which demonstrates the 
Revised: Besides, we ﬁnd that the pretrained BERT embedding has a considerable impact on the performance and ﬁne-tuning BERT embedding even further improves the performance, which demonstrates the power of large-scale pretrained language models.

Original: . 3. C ASE S TUDY
Revised: 3. C ASE S TUDY

Original: Passage: for the successful execution of a project , effective planning is essential .
Revised: Passage: for the successful execution of a project , effective planning is essential .

Original: Gold: what is essential for the successful execution of a project ?
Revised: Gold: what is essential for the successful execution of a project ?

Original: G2S
Revised: G2S

Original: sta w/o BiGGNN (Seq2Seq): what type of planning is essential for the project ?
Revised: sta w/o BiGGNN (Seq2Seq): what type of planning is essential for the project ?

Original: G2S sta w/o DAN.
Revised: G2S sta w/o DAN.

Original: : what type of planning is essential for the successful execution of a project ?
Revised: : what type of planning is essential for the successful execution of a project ?

Original: G2S
Revised: G2S

Original: sta : what is essential for the successful execution of a project ?
Revised: sta : what is essential for the successful execution of a project ?

Original: G2S sta +BERT: what is essential for the successful execution of a project ?
Revised: G2S sta +BERT: what is essential for the successful execution of a project ?

Original: G2S
Revised: G2S

Original: sta +BERT+RL: what is essential for the successful execution of a project ?
Revised: sta +BERT+RL: what is essential for the successful execution of a project ?

Original: G2S dyn +BERT+RL: what is essential for the successful execution of a project ?
Revised: G2S dyn +BERT+RL: what is essential for the successful execution of a project ?

Original: Passage: the church operates three hundred sixty schools and institutions overseas .
Revised: Passage: the church operates three hundred sixty schools and institutions overseas .

Original: Gold: how many schools and institutions does the church operate overseas ?
Revised: Gold: how many schools and institutions does the church operate overseas ?

Original: G2S sta w/o BiGGNN (Seq2Seq): how many schools does the church have ?
Revised: G2S sta w/o BiGGNN (Seq2Seq): how many schools does the church have ?

Original: G2S sta w/o DAN.
Revised: G2S sta w/o DAN.

Original: : how many schools does the church have ?
Revised: : how many schools does the church have ?

Original: G2S sta : how many schools and institutions does the church have ?
Revised: G2S sta : how many schools and institutions does the church have ?

Original: G2S sta +BERT: how many schools and institutions does the church have ?
Revised: G2S sta +BERT: how many schools and institutions does the church have ?

Original: G2S
Revised: G2S

Original: sta +BERT+RL: how many schools and institutions does the church operate ?
Revised: sta +BERT+RL: how many schools and institutions does the church operate ?

Original: G2S dyn +BERT+RL: how many schools does the church operate ?
Revised: G2S dyn +BERT+RL: how many schools does the church operate ?

Original: In Table  we further show a few examples that illustrate the quality of generated text given a passage under different ablated systems.
Revised: In Table 4, we further show a few examples that illustrate the quality of generated text given a passage under different ablated systems.

Original: As we can see, incorporating answer information helps the model identify the answer type of the question to be generated and thus makes the generated questions more relevant and speciﬁc.
Revised: As we can see, incorporating answer information helps the model identify the answer type of the question to be generated, and thus makes the generated questions more relevant and speciﬁc.

Original: Also, we ﬁnd our Graph2Seq model can generate more complete and valid questions compared to the Seq2Seq baseline.
Revised: Also, we ﬁnd our Graph2Seq model can generate more complete and valid questions compared to the Seq2Seq baseline.

Original: We think it is because a Graph2Seq model is able to exploit the rich text structure information better than a Seq2Seq model.
Revised: We think it is because a Graph2Seq model is able to exploit the rich text structure information better than a Seq2Seq model.

Original: Lastly, it shows that ﬁne-tuning the model using REINFORCE can improve the quality of the generated questions.
Revised: Lastly, it shows that ﬁne-tuning the model using REINFORCE can improve the quality of the generated questions.

Original:  R ELATED W ORK 4. N ATURAL Q UESTION G ENERATION
Revised:  R ELATED W ORK 4. N ATURAL Q UESTION G ENERATION

Original: Early works (Mostow & Chen, 2009; Heilman & Smith, 2010; Heilman, 2011) for QG focused on rule-based approaches that rely on heuristic rules or hand-crafted templates, with low generalizability and scalability.
Revised: Early works (Mostow & Chen, 2009; Heilman & Smith, 2010) for QG focused on rule-based approaches that rely on heuristic rules or hand-crafted templates, with low generalizability and scalability.

Original: Recent attempts have focused on NN-based approaches that do not require manually-designed rules and are end-to-end trainable.
Revised: Recent attempts have focused on NN-based approaches that do not require manually-designed rules and are end-to-end trainable.

Original: Existing NN-based approaches (Du et al., 2017; Yao et al.
Revised: Existing NN-based approaches (Du et al., 2017; Yao et al.

Original: ; Zhou et al., 2018) rely on the Seq2Seq model with attention, copy or coverage mechanisms.
Revised: ; Zhou et al., 2018) rely on the Seq2Seq model with attention, copy or coverage mechanisms.

Original: In addition, various ways (Zhou et al., 2017; Song et al., 2017; Zhao et al., 2018; Sun et al., 2018; Kim et al., 2018; Liu et al., 2019) have been proposed to utilize the target answer so as to guide the generation of the question.
Revised: In addition, various ways (Zhou et al., 2017; Song et al., 2017; Zhao et al., 2018) have been proposed to utilize the target answer for guiding the question generation. Some recent approaches (Song et al., 2017;

Original: To address the limitations of cross-entropy based sequence learning, some approaches (Song et al., 2017; Kumar et al., 2018b) aim at directly optimizing evaluation metrics using REINFORCE. 
Revised: Kumar et al., 2018b) aim at directly optimizing evaluation metrics using REINFORCE. Concurrent works have explored tackling the QG task with various semantics-enhanced rewards (Zhang &

Revised: Bansal, 2019) or large-scale pretrained language models (Dong et al., 2019).

Original: However, the existing approaches for QG suffer from several limitations; they (i) ignore the rich structure information hidden in text, (ii) solely rely on cross-entropy loss that leads to issues like exposure bias and inconsistency between train/test measurement, and (iii) fail to fully exploit the answer information.
Revised: However, the existing approaches for QG suffer from several limitations; they (i) ignore the rich structure information hidden in text, (ii) solely rely on cross-entropy loss that leads to issues like exposure bias and inconsistency between train/test measurement, and (iii) fail to fully exploit the answer information.

Original: To address these limitations, we propose a reinforcement learning (RL) based graph-to-sequence (Graph2Seq) model for QG as well as deep alignment networks to effectively cope with the QG task.
Revised: To address these limitations, we propose a RL based Graph2Seq model augmented with a deep alignment network to effectively tackle the QG task.

Original: To the best of our knowledge, we are the ﬁrst to introduce the Graph2Seq architecture to solve the question generation task.
Revised: To the best of our knowledge, we are the ﬁrst to introduce the Graph2Seq architecture to solve the question generation task.

Original: 4. G RAPH N EURAL N ETWORKS
Revised: 4. G RAPH N EURAL N ETWORKS

Original: Over the past few years, graph neural networks (GNNs) (Kipf & Welling, 2016;
Revised: Over the past few years, graph neural networks (GNNs) (Kipf & Welling, 2016;

Original: Gilmer et al., 2017; Hamilton et al., 2017; Li et al., 2015) have attracted increasing attention.
Revised: Gilmer et al., 2017; Hamilton et al., 2017) have attracted increasing attention.

Original: Due to more recent advances in graph representation learning, a number of works have extended the widely used Seq2Seq architectures (Sutskever et al., 2014; Cho et al., 2014) to Graph2Seq architectures for machine translation, semantic parsing,  and AMR(SQL)-to-text tasks (Bastings et al., 2017; Beck et al., 2018;
Revised: Due to more recent advances in graph representation learning, a number of works have extended the widely used Seq2Seq architectures (Sutskever et al., 2014; Cho et al., 2014) to Graph2Seq architectures for machine translation, semantic parsing, AMR(SQL)-to-text, and online forums health stage prediction tasks (Bastings et al., 2017; Beck et al., 2018;

Original: Xu et al., 2018a;b;c; Song et al., 2018b).
Revised: Xu et al., 2018a;b;c; Song et al., 2018b; Gao et al., 2019).

Original: While the high-quality graph structure is crucial for the performance of GNN-based approaches, most existing works use syntax-based static graph structures when applied to textual data.
Revised: While the high-quality graph structure is crucial for the performance of GNN-based approaches, most existing works use syntax-based static graph structures when applied to textual data.

Original: Very recently, researchers have started exploring methods to automatically construct a graph of visual objects (Norcliffe-Brown et al., 2018) or words (Liu et al., 2018;
Revised: Very recently, researchers have started exploring methods to automatically construct a graph of visual objects (Norcliffe-Brown et al., 2018) or words (Liu et al., 2018;

Original: Chen et al., 2019b) when applying GNNs to non-graph structured data.
Revised: Chen et al., 2019c;b) when applying GNNs to non-graph structured data.

Original: To the best of our knowledge, we are the ﬁrst to investigate systematically the performance difference between syntactic-aware static graph construction and semantics-aware dynamic graph construction in the context of question generation.
Revised: To the best of our knowledge, we are the ﬁrst to investigate systematically the performance difference between syntactic-aware static graph construction and semantics-aware dynamic graph construction in the context of question generation.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We proposed a novel RL based Graph2Seq model for QG, where the answer information is utilized by an effective Deep Alignment Network and a novel bidirectional GNN is proposed to process the directed passage graph.
Revised: We proposed a novel RL based Graph2Seq model for QG, where the answer information is utilized by an effective Deep Alignment Network and a novel bidirectional GNN is proposed to process the directed passage graph.

Original: Our two-stage training strategy beneﬁts from both cross-entropy based and

Original: REINFORCE based sequence training.

Original: We also explore both static and dynamic graph construction from text, and systematically investigate and analyze the performance difference between the two.

Original: On thebenchmark SQuAD dataset, our proposed model outperforms previous state-of-the-art methods by a signiﬁcant margin and achieve new best results.
Revised: On the SQuAD dataset, our method outperforms existing methods by a signiﬁcant margin and achieves the new state-of-the-art results.

Original: One of the interesting future directions is to investigate more effective ways of automatically learning graph structures from any data source, including texts.
Revised: Future directions include investigating more effective ways of automatically learning graph structures from text and exploiting Graph2Seq models for question generation from structured data like knowledge graphs or tables.

Original: It would be also be interesting to study the unpaired problem setting for QG.
Revised: This work is supported by IBM Research AI through the IBM AI Horizons Network. We thank the human evaluators who evaluated our system. We also thank the anonymous reviewers for their constructive feedback.

Original: A D ETAILS ON THE RNN D ECODER
Revised: A D ETAILS ON THE RNN D ECODER

Original: At each decoding step t  an attention mechanism learns to attend to the most relevant words in the input sequence and computes a context vector h ˚ t based on the current decoding state s t , the current coverage vector c t and the attention memory.
Revised: At each decoding step t , an attention mechanism learns to attend to the most relevant words in the input sequence, and computes a context vector h ˚ t based on the current decoding state s t , the current coverage vector c t and the attention memory.

Original: In addition, the generation probability p gen P r 0 , 1 s is calculated from the context vector h ˚ t , the decoder state s t and the decoder input y t ´ 1 .
Revised: In addition, the generation probability p gen P r 0 , 1 s is calculated from the context vector h ˚ t , the decoder state s t and the decoder input y t ´ 1 .

Original: Next, p gen is used as a soft switch to choose between generating a word from the vocabulary, or copying a word from the input sequence.
Revised: Next, p gen is used as a soft switch to choose between generating a word from the vocabulary, or copying a word from the input sequence.

Original: We dynamically maintain an extended vocabulary which is the union of the usual vocabulary and all words appearing in a batch of source examples (i.e., passages and answers).
Revised: We dynamically maintain an extended vocabulary which is the union of the usual vocabulary and all words appearing in a batch of source examples (i.e., passages and answers).

Original: Finally, in order to encourage the decoder to utilize the diverse components of the input sequence, a coverage mechanism is applied.
Revised: Finally, in order to encourage the decoder to utilize the diverse components of the input sequence, a coverage mechanism is applied.

Original: At each step, we maintain a coverage vector c t , which is the sum of attention distributions over all previous decoder time steps.
Revised: At each step, we maintain a coverage vector c t , which is the sum of attention distributions over all previous decoder time steps.

Original: A coverage loss is also computed to penalize repeatedly attending to the same locations of the input sequence.
Revised: A coverage loss is also computed to penalize repeatedly attending to the same locations of the input sequence.

Original: B M ODEL S ETTINGS
Revised: B M ODEL S ETTINGS

Original: We keep and ﬁx the 300-dim GloVe vectors for the most frequent 70,000 words in the training set.
Revised: We keep and ﬁx the 300-dim GloVe vectors for the most frequent 70,000 words in the training set.

Original: We compute the 1024-dim BERT embeddings on the ﬂy for each word in text using a (trainable) weighted sum of all BERT layer outputs.
Revised: We compute the 1024-dim BERT embeddings on the ﬂy for each word in text using a (trainable) weighted sum of all BERT layer outputs.

Original: The embedding sizes of case, POS and NER tags are set to 3, 12 and 8, respectively.
Revised: The embedding sizes of case, POS and NER tags are set to 3, 12 and 8, respectively.

Original: We set the hidden state size of BiLSTM to 150 so that the concatenated state size for both directions is 300.
Revised: We set the hidden state size of BiLSTM to 150 so that the concatenated state size for both directions is 300.

Original: The size of all other hidden layers is set to 300.
Revised: The size of all other hidden layers is set to 300.

Original: We apply a variational dropout (Kingma et al., 2015) rate of 0.4 after word embedding layers and 0.3 after
Revised: We apply a variational dropout (Kingma et al., 2015) rate of 0.4 after word embedding layers and 0.3 after

Original: RNN layers.
Revised: RNN layers.

Original: We set the neighborhood size to 10 for dynamic graph construction.
Revised: We set the neighborhood size to 10 for dynamic graph construction.

Original: The number of
Revised: The number of

Original: GNN hops is set to 3.
Revised: GNN hops is set to 3.

Original: During training, in each epoch, we set the initial teacher forcing probability to 0.75 and exponentially increase it to 0 .
Revised: During training, in each epoch, we set the initial teacher forcing probability to 0.75 and exponentially increase it to 0 .

Original: 75 ˚ 0 .
Revised: 75 ˚ 0 .

Original: 9999 i where i is the training step.
Revised: 9999 i where i is the training step.

Original: We set α in the reward function to 0.1, γ in the mixed loss function to 0.99, and the coverage loss ratio λ to 0.4.
Revised: We set α in the reward function to 0.1, γ in the mixed loss function to 0.99, and the coverage loss ratio λ to 0.4.

Original: We use Adam (Kingma & Ba, 2014) as the optimizer, and the learning rate is set to 0.001 in the pretraining stage and 0.00001 in the ﬁne-tuning stage.
Revised: We use Adam (Kingma & Ba, 2014) as the optimizer, and the learning rate is set to 0.001 in the pretraining stage and 0.00001 in the ﬁne-tuning stage.

Original: We reduce the learning rate by a factor of 0.5 if the validation BLEU-4 score stops improving for three epochs.
Revised: We reduce the learning rate by a factor of 0.5 if the validation BLEU-4 score stops improving for three epochs.

Original: We stop the training when no improvement is seen for 10 epochs.
Revised: We stop the training when no improvement is seen for 10 epochs.

Original: We clip the gradient at length 10.
Revised: We clip the gradient at length 10.

Original: The batch size is set to 60 and 50 on data split-1 and split-2, respectively.
Revised: The batch size is set to 60 and 50 on data split-1 and split-2, respectively.

Original: The beam search width is set to 5.
Revised: The beam search width is set to 5.

Original: All hyperparameters are tuned on the development set.
Revised: All hyperparameters are tuned on the development set.

Original: C S ENSITIVITY A NALYSIS OF H YPERPARAMETERS
Revised: C S ENSITIVITY A NALYSIS OF H YPERPARAMETERS

Original: To study the effect of the number of GNN hops, we conduct experiments on the G2S sta model on the SQuAD split-2 data.
Revised: To study the effect of the number of GNN hops, we conduct experiments on the G2S sta model on the SQuAD split-2 data.

Original: Fig.
Revised: Fig.

Original: 3 shows that our model is not very sensitive to the number of GNN hops and can achieve reasonably good results with various number of hops. 
Revised: 3 shows that our model is not very sensitive to the number of GNN hops and can achieve reasonably good results with various number of hops. [Table]

Original: D D ETAILS ON B ASELINE M ETHODS
Revised: D D ETAILS ON B ASELINE M ETHODS

Original: SeqCopyNet (Zhou et al., 2018) proposed an extension to the copy mechanism which learns to copy not only single words but also sequences from the input sentence.
Revised: Transformer (Vaswani et al., 2017) We included a Transformer-based Seq2Seq model augmented with attention and copy mechanisms. We used the open source implementation 3 provided by the OpenNMT (Klein et al., 2017) library and trained the model from scratch.

Revised: Surprisingly, this baseline performed very poorly on the benchmarks even though we conducted moderate hyperparameter search and trained the model for a large amount of epochs.

Revised: We suspect this might be partially because this method is very sensitive to hyperparameters as reported by Klein et al.

Original:  NQG++ (Zhou et al., 2017) proposed an attention-based Seq2Seq model equipped with a copy mechanism and a feature-rich encoder to encode answer position, POS and NER tag information.
Revised: (2017) and probably data-hungry on this task. We conjecture that better performance might be expected by extensively searching the hyperparameters and using a pretrained transformer model. SeqCopyNet (Zhou et al., 2018) proposed an extension to the copy mechanism which learns to copy not only single words but also sequences from the input sentence. NQG++ (Zhou et al., 2017) proposed an attention-based Seq2Seq model equipped with a copy mechanism and a feature-rich encoder to encode answer position, POS and NER tag information.

Original: MPQG+R (Song et al., 2017) proposed an RL-based Seq2Seq model with a multi-perspective matching encoder to incorporate answer information.
Revised: MPQG+R (Song et al., 2017) proposed an RL-based Seq2Seq model with a multi-perspective matching encoder to incorporate answer information.

Original: Copy and coverage mechanisms are applied.
Revised: Copy and coverage mechanisms are applied.

Original: AFPQA (Sun et al., 2018) consists of an answer-focused component which generates an interrogative word matching the answer type, and a position-aware component which is aware of the position of the context words when generating a question by modeling the relative distance between the context words and the answer.
Revised: AFPQA (Sun et al., 2018) consists of an answer-focused component which generates an interrogative word matching the answer type, and a position-aware component which is aware of the position of the context words when generating a question by modeling the relative distance between the context words and the answer.

Original: s2sa-at-mp-gsa (Zhao et al., 2018) proposed a model which contains a gated attention encoder and a maxout pointer decoder to tackle the challenges of processing long input sequences.
Revised: s2sa-at-mp-gsa (Zhao et al., 2018) proposed a model which contains a gated attention encoder and a maxout pointer decoder to tackle the challenges of processing long input sequences.

Original: For fair comparison, we report the results of the sentence-level version of their model to match with our settings.
Revised: For fair comparison, we report the results of the sentence-level version of their model to match with our settings.

Original: ASs2s (Kim et al., 2018) proposed an answer-separated Seq2Seq model which treats the passage and the answer separately.
Revised: ASs2s (Kim et al., 2018) proposed an answer-separated Seq2Seq model which treats the passage and the answer separately.

Original: CGC-QG (Liu et al., 2019) proposed a multi-task learning framework to guide the model to learn the accurate boundaries between copying and generation.
Revised: CGC-QG (Liu et al., 2019) proposed a multi-task learning framework to guide the model to learn the accurate boundaries between copying and generation.

Original: E D ETAILS ON HUMAN EVALUATION
Revised: E D ETAILS ON HUMAN EVALUATION

Original: We conducted a small-scale (i.e., 50 random examples per system) human evaluation on the splitdata.
Revised: We conducted a small-scale (i.e., 50 random examples per system) human evaluation on the splitdata.

Original: We asked 5 human evaluators to give feedback on the quality of questions generated by a set of anonymized competing systems.
Revised: We asked 5 human evaluators to give feedback on the quality of questions generated by a set of anonymized competing systems.

Original: In each example, given a triple containing a source passage, a target answer and an anonymised system output, they were asked to rate the quality of the output by answering the following three questions: i) is this generated question syntactically correct? ii) is this generated question semantically correct?
Revised: In each example, given a triple containing a source passage, a target answer and an anonymised system output, they were asked to rate the quality of the output by answering the following three questions: i) is this generated question syntactically correct? ii) is this generated question semantically correct?

Original: and iii) is this generated question relevant to the passage?
Revised: and iii) is this generated question relevant to the passage?

Original: For each evaluation question, the rating scale is from 1 to 5 where a higher score means better quality (i.e., 1: Poor, 2: Marginal, 3: Acceptable, 4: Good, 5: Excellent).
Revised: For each evaluation question, the rating scale is from 1 to 5 where a higher score means better quality (i.e., 1: Poor, 2: Marginal, 3: Acceptable, 4: Good, 5: Excellent).

Original: Responses from all evaluators were collected and averaged.
Revised: Responses from all evaluators were collected and averaged.

Original: F M ORE RESULTS ON A BLATION S TUDY
Revised: F M ORE RESULTS ON A BLATION S TUDY

Original: We perform the comprehensive ablation study to systematically assess the impact of different model components (e.g., BERT, RL, DAN, BiGGNN, FEAT, DAN-word, and DAN-hidden) for two pro- [Table] posed full model variants (static vs dynamic) on the SQuAD split-2 test set.
Revised: We perform the comprehensive ablation study to systematically assess the impact of different model components (e.g., BERT, RL, DAN, BiGGNN, FEAT, DAN-word, and DAN-contextual) for two proposed full model variants (static vs dynamic) on the SQuAD split-2 test set.

Original: Our experimental results conﬁrmed that every component in our proposed model makes the contribution to the overall performance.
Revised: Our experimental results conﬁrmed that every component in our proposed model makes the contribution to the overall performance.