Original: N EURAL M ODULE N ETWORKS FOR R EASONING OVER T EXT
Revised: N EURAL M ODULE N ETWORKS FOR R EASONING OVER T EXT

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: Answering compositional questions that require multiple steps of reasoning against text is challenging, especially when they involve discrete, symbolic operations.
Revised: Answering compositional questions that require multiple steps of reasoning against text is challenging, especially when they involve discrete, symbolic operations.

Original: Neural module networks (NMNs) learn to parse such questions as executable programs composed of learnable modules, performing well on synthetic visual
Revised: Neural module networks (NMNs) learn to parse such questions as executable programs composed of learnable modules, performing well on synthetic visual

Original: QA domains.
Revised: QA domains.

Original: However, we ﬁnd that it is challenging to learn these models for non-synthetic questions on open-domain text, where a model needs to deal with the diversity of natural language and perform a broader range of reasoning.
Revised: However, we ﬁnd that it is challenging to learn these models for non-synthetic questions on open-domain text, where a model needs to deal with the diversity of natural language and perform a broader range of reasoning.

Original: We extend NMNs by: (a) introducing modules that reason over a paragraph of text, performing symbolic reasoning (such as arithmetic, sorting, counting) over numbers and dates in a probabilistic and differentiable manner; and (b) proposing an unsupervised auxiliary loss to help extract arguments associated with the events in text.
Revised: We extend NMNs by: (a) introducing modules that reason over a paragraph of text, performing symbolic reasoning (such as arithmetic, sorting, counting) over numbers and dates in a probabilistic and differentiable manner; and (b) proposing an unsupervised auxiliary loss to help extract arguments associated with the events in text.

Original: Additionally, we show that a limited amount of heuristically-obtained question program and intermediate module output supervision provides sufﬁcient inductive bias for accurate learning.
Revised: Additionally, we show that a limited amount of heuristically-obtained question program and intermediate module output supervision provides sufﬁcient inductive bias for accurate learning.

Original: Our proposed model signiﬁcantly outperforms state-of-the-art models on a subset of the DROP dataset that poses a variety of reasoning challenges that are covered by our modules.
Revised: Our proposed model signiﬁcantly outperforms state-of-the-art models on a subset of the DROP dataset that poses a variety of reasoning challenges that are covered by our modules

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Being formalism-free and close to an end-user task, QA is increasingly becoming a proxy for gauging a model’s natural language understanding capability (He et al., 2015; Talmor et al., 2018).
Revised: Being formalism-free and close to an end-user task, QA is increasingly becoming a proxy for gauging a model’s natural language understanding capability (He et al., 2015; Talmor et al., 2018).

Original: Recent models have performed well on certain QA datasets, sometimes rivaling humans (Zhang et al., 2019), but it has become increasingly clear that they primarily exploit surface level lexical cues (Jia &
Revised: Recent models have performed well on certain QA datasets, sometimes rivaling humans (Zhang et al., 2019), but it has become increasingly clear that they primarily exploit surface level lexical cues (Jia &

Original: Liang, 2017; Feng et al., 2018) and compositional QA still remains a challenge.
Revised: Liang, 2017; Feng et al., 2018) and compositional QA still remains a challenge.

Original: Answering complex compositional questions against text is challenging since it requires a comprehensive understanding of both the question semantics and the text against which the question needs to be answered.
Revised: Answering complex compositional questions against text is challenging since it requires a comprehensive understanding of both the question semantics and the text against which the question needs to be answered.

Original: Consider the question in Figure 1; a model needs to understand the compositional reasoning structure of the questions, perform accurate information extraction from the passage (eg. extract lengths , kickers , etc.
Revised: Consider the question in Figure 1; a model needs to understand the compositional reasoning structure of the questions, perform accurate information extraction from the passage (eg. extract lengths , kickers , etc.

Original: for the ﬁeld goals and touchdowns )
Revised: for the ﬁeld goals and touchdowns )

Original: and perform symbolic reasoning (eg. counting, sorting, etc.).
Revised: and perform symbolic reasoning (eg. counting, sorting, etc.).

Original: Semantic parsing techniques, which map natural language utterances to executable programs, have been used for compositional question understanding for a long time (Zelle & Mooney, 1996; Zettlemoyer & Collins, 2005; Liang et al., 2011), but have been limited to answering questions against structured and semi-structured knowledge sources.
Revised: Semantic parsing techniques, which map natural language utterances to executable programs, have been used for compositional question understanding for a long time (Zelle & Mooney, 1996; Zettlemoyer & Collins, 2005; Liang et al., 2011), but have been limited to answering questions against structured and semi-structured knowledge sources.

Original: Neural module networks (NMNs; Andreas et al., 2016) extend semantic parsers by making the program executor a learned function composed of neural network modules.
Revised: Neural module networks (NMNs; Andreas et al., 2016) extend semantic parsers by making the program executor a learned function composed of neural network modules.

Original: These modules are designed to perform basic reasoning tasks and can be composed to perform complex reasoning over unstructured knowledge.
Revised: These modules are designed to perform basic reasoning tasks and can be composed to perform complex reasoning over unstructured knowledge.

Original: NMNs perform well on synthetic visual question answering (VQA) domains such as CLEVR (Johnson et al., 2017) and it is appealing to apply them to answer questions over text due to their interpretable, modular, and inherently compositional nature.
Revised: NMNs perform well on synthetic visual question answering (VQA) domains such as CLEVR (Johnson et al., 2017) and it is appealing to apply them to answer questions over text due to their interpretable, modular, and inherently compositional nature.

Original: We ﬁnd, however, that it is non-trivial to extend NMNs for answering non-synthetic questions against open-domain text, where a model needs to deal with the ambiguity and variability of real-world text while performing a diverse range of reasoning.
Revised: We ﬁnd, however, that it is non-trivial to extend NMNs for answering non-synthetic questions against open-domain text, where a model needs to deal with the ambiguity and variability of real-world text while performing a diverse range of reasoning.

Original: Jointly learning the parser and executor using only QA supervision is also extremely challenging ( § 2.2).
Revised: Jointly learning the parser and executor using only QA supervision is also extremely challenging ( § 2.2).

Original: Our contributions are two-fold: Firstly, we extend NMNs to answer compositional questions against a paragraph of text as context.
Revised: Our contributions are two-fold: Firstly, we extend NMNs to answer compositional questions against a paragraph of text as context.

Original: We introduce neural modules to perform reasoning over text using distributed representations, and perform symbolic reasoning, such as arithmetic, sorting, comparisons, 
Revised: We introduce neural modules to perform reasoning over text using distributed representations, and perform symbolic reasoning, such as arithmetic, sorting, comparisons, and counting ( § 3).

Revised: The modules we deﬁne are probabilistic and differentiable, which lets us maintain uncertainty about intermediate decisions and train the entire model via end-to-end differentiability.

Original: Secondly, we show that the challenges arising in learning from end-task QA supervision can be alleviated with an auxiliary loss over the intermediate latent decisions of the model.
Revised: Secondly, we show that the challenges arising in learning from end-task QA supervision can be alleviated with an auxiliary loss over the intermediate latent decisions of the model.

Original: Speciﬁcally, we introduce an unsupervised objective that provides an inductive bias to perform accurate information extraction from the context ( § 4.1).
Revised: Speciﬁcally, we introduce an unsupervised objective that provides an inductive bias to perform accurate information extraction from the context ( § 4.1).

Original: Additionally, we show that providing heuristically-obtained supervision for question programs and outputs for intermediate modules in a program ( § 4.2) for a small subset of the training data (5–10%) is sufﬁcient for accurate learning.
Revised: Additionally, we show that providing heuristically-obtained supervision for question programs and outputs for intermediate modules in a program ( § 4.2) for a small subset of the training data (5–10%) is sufﬁcient for accurate learning.

Original: We experiment on 21,800 questions from the recently proposed DROP dataset (Dua et al., 2019) that are heuristically chosen based on their ﬁrst n-gram such that they are covered by our designed modules.
Revised: We experiment on 21,800 questions from the recently proposed DROP dataset (Dua et al., 2019) that are heuristically chosen based on their ﬁrst n-gram such that they are covered by our designed modules.

Original: This is a signiﬁcantly-sized subset that poses a wide variety of reasoning challenges and allows for controlled development and testing of models.
Revised: This is a signiﬁcantly-sized subset that poses a wide variety of reasoning challenges and allows for controlled development and testing of models.

Original: We show that our model, which has interpretable intermediate outputs by design, signiﬁcantly outperforms state-of-the-art black box models on this dataset.
Revised: We show that our model, which has interpretable intermediate outputs by design, signiﬁcantly outperforms state-of-the-art black box models on this dataset.

Original: We conclude with a discussion of the challenges of pushing NMNs to the entire DROP dataset, where some questions require reasoning that is hard to design modules for.
Revised: We conclude with a discussion of the challenges of pushing NMNs to the entire DROP dataset, where some questions require reasoning that is hard to design modules for.

Original:  N EURAL M ODULE N ETWORKS
Revised:  N EURAL M ODULE N ETWORKS

Original: Consider the question “Who kicked the longest ﬁeld goal in the second quarter?”
Revised: Consider the question “Who kicked the longest ﬁeld goal in the second quarter?”

Original: in Figure 1.
Revised: in Figure 1.

Original: Multiple reasoning steps are needed to answer such a question: ﬁnd all instances of “ﬁeld goal” in the paragraph, select the ones “in the second quarter”, ﬁnd their lengths, compute the “longest” of them, and then ﬁnd “who kicked” it.
Revised: Multiple reasoning steps are needed to answer such a question: ﬁnd all instances of “ﬁeld goal” in the paragraph, select the ones “in the second quarter”, ﬁnd their lengths, compute the “longest” of them, and then ﬁnd “who kicked” it.

Original: We would like to develop machine reading models that are capable of understanding the context and the compositional semantics of such complex questions in order to provide the correct answer, ideally while also explaining the reasoning that led to that answer.
Revised: We would like to develop machine reading models that are capable of understanding the context and the compositional semantics of such complex questions in order to provide the correct answer, ideally while also explaining the reasoning that led to that answer.

Original: Neural module networks (NMN) capture this intuition naturally, which makes them a good ﬁt to solve reasoning problems like these.
Revised: Neural module networks (NMN) capture this intuition naturally, which makes them a good ﬁt to solve reasoning problems like these.

Original: A NMN would parse such a question into an executable program, such as relocate(find-max-num(filter(find()))) , whose execution against the given paragraph yields the correct answer.
Revised: A NMN would parse such a question into an executable program, such as relocate(find-max-num(filter(find()))) , whose execution against the given paragraph yields the correct answer.

Original: These programs capture the abstract compositional reasoning structure required to answer the question correctly and are composed of learnable modules designed to solve sufﬁciently independent reasoning tasks.
Revised: These programs capture the abstract compositional reasoning structure required to answer the question correctly and are composed of learnable modules designed to solve sufﬁciently independent reasoning tasks.

Original: For example, the find module should ground the question span “ﬁeld goal” to its various occurrences in the paragraph; the module find-max-num should output the span amongst its input that is associated with the largest length; and ﬁnally, the relocate module should ﬁnd “who kicked” the ﬁeld goal corresponding to its input span.
Revised: For example, the find module should ground the question span “ﬁeld goal” to its various occurrences in the paragraph; the module find-max-num should output the span amongst its input that is associated with the largest length; and ﬁnally, the relocate module should ﬁnd “who kicked” the ﬁeld goal corresponding to its input span.

Original: 2. C OMPONENTS OF A NMN FOR T EXT
Revised: 2. C OMPONENTS OF A NMN FOR T EXT

Original: Modules.
Revised: Modules.

Original: To perform natural language and symbolic reasoning over different types of information, such as text, numbers, and dates, we deﬁne a diverse set of differentiable modules to operate over these different data types.
Revised: To perform natural language and symbolic reasoning over different types of information, such as text, numbers, and dates, we deﬁne a diverse set of differentiable modules to operate over these different data types.

Original: We describe these modules and the data types in § 3.
Revised: We describe these modules and the data types in § 3.

Original: Contextual Token Representations.
Revised: Contextual Token Representations.

Original: Our model represents the question q as Q ∈ R n × d
Revised: Our model represents the question q as Q ∈ R n × d

Original: and the context paragraph p as P ∈ R m × d using contextualized token embeddings.
Revised: and the context paragraph p as P ∈ R m × d using contextualized token embeddings.

Original: These are outputs of either the same bidirectional-GRU or a pre-trained BERT (Devlin et al., 2019) model.
Revised: These are outputs of either the same bidirectional-GRU or a pre-trained BERT (Devlin et al., 2019) model.

Original: Here n and m are the number of tokens in the question and the paragraph, respectively.
Revised: Here n and m are the number of tokens in the question and the paragraph, respectively.

Original: Appendix § A.1 contains details about how these contextual embeddings are produced.
Revised: Appendix § A.1 contains details about how these contextual embeddings are produced.

Original: Question Parser.
Revised: Question Parser.

Original: We use an encoder-decoder model with attention to map the question into an executable program.
Revised: We use an encoder-decoder model with attention to map the question into an executable program.

Original: Similar to N2NMN (Hu et al., 2017), at each timestep of decoding, the attention that the parser puts on the question is available as a side argument to the module produced at that timestep during execution.
Revised: Similar to N2NMN (Hu et al., 2017), at each timestep of decoding, the attention that the parser puts on the question is available as a side argument to the module produced at that timestep during execution.

Original: This lets the modules have access to question information without making hard decisions about which question words to put into the program.
Revised: This lets the modules have access to question information without making hard decisions about which question words to put into the program.

Original: In our model, the data types of the inputs and output of modules automatically induce a typeconstrained grammar which lends itself to top-down grammar-constrained decoding as performed by
Revised: In our model, the data types of the inputs and output of modules automatically induce a typeconstrained grammar which lends itself to top-down grammar-constrained decoding as performed by

Original: Krishnamurthy et al.
Revised: Krishnamurthy et al.

Original: This ensures that the decoder always produces well-typed programs.
Revised: This ensures that the decoder always produces well-typed programs.

Original: For example, if a module f 1 inputs a number , and f 2 outputs a date , then f 1 ( f 2 ) is invalid and would not be explored while decoding.
Revised: For example, if a module f 1 inputs a number , and f 2 outputs a date , then f 1 ( f 2 ) is invalid and would not be explored while decoding.

Revised: For example, if a module f 1 inputs a number , and f 2 outputs a date , then f 1 ( f 2 ) is invalid and would not be explored while decoding.

Original: The output of the decoder is a linearized abstract syntax tree (in an in-order traversal).
Revised: The output of the decoder is a linearized abstract syntax tree (in an in-order traversal).

Original: See § A.2 for details.
Revised: See § A.2 for details.

Original: Learning.
Revised: Learning.

Original: We deﬁne our model probabilistically, i.e., for any given program z , we can compute the likelihood of the gold-answer p ( y ∗ | z ) .
Revised: We deﬁne our model probabilistically, i.e., for any given program z , we can compute the likelihood of the gold-answer p ( y ∗ | z ) .

Original: Combined with the likelihood of the program under the question-parser model p ( z | q ) , we can maximize the marginal likelihood of the answer by enumerating all possible programs; J = (cid:80) z p ( y ∗ | z ) p ( z | q ) .
Revised: Combined with the likelihood of the program under the question-parser model p ( z | q ) , we can maximize the marginal likelihood of the answer by enumerating all possible programs; J = (cid:80) z p ( y ∗ | z ) p ( z | q ) .

Original: Since the space of all programs is intractable, we run beam search to enumerate top-K programs and maximize the approximate marginal-likelihood.
Revised: Since the space of all programs is intractable, we run beam search to enumerate top-K programs and maximize the approximate marginal-likelihood.

Original: 2. L EARNING C HALLENGES IN NMN FOR T EXT
Revised: 2. L EARNING C HALLENGES IN NMN FOR T EXT

Original: As mentioned above, the question parser and the program executor both contain learnable parameters.
Revised: As mentioned above, the question parser and the program executor both contain learnable parameters.

Original: Each of them is challenging to learn in its own right and joint training further exacerbates the situation.
Revised: Each of them is challenging to learn in its own right and joint training further exacerbates the situation.

Original: Question Parser.
Revised: Question Parser.

Original: Our model needs to parse free-form real-world questions into the correct program structure and identify its arguments (e.g. ”who kicked”, ”ﬁeld goal”, etc.).
Revised: Our model needs to parse free-form real-world questions into the correct program structure and identify its arguments (e.g. ”who kicked”, ”ﬁeld goal”, etc.).

Original: This is challenging since the questions are not generated from a small ﬁxed grammar (unlike CLEVR), involve lexical variability, and have no program supervision.
Revised: This is challenging since the questions are not generated from a small ﬁxed grammar (unlike CLEVR), involve lexical variability, and have no program supervision.

Original: Additionally, many incorrect programs can yield the same correct answer thus training the question parser to highly score incorrect interpretations.
Revised: Additionally, many incorrect programs can yield the same correct answer thus training the question parser to highly score incorrect interpretations.

Original: Program Executor.
Revised: Program Executor.

Original: The output of each intermediate module in the program is a latent decision by the model since the only feedback available is for the ﬁnal output of the program.
Revised: The output of each intermediate module in the program is a latent decision by the model since the only feedback available is for the ﬁnal output of the program.

Original: The absence of any direct feedback to the intermediate modules complicates learning since the errors of one module would be passed on to the next.
Revised: The absence of any direct feedback to the intermediate modules complicates learning since the errors of one module would be passed on to the next.

Original: Differentiable modules that propagate uncertainties in intermediate decisions help here, such as attention on pixels in CLEVR, but do not fully solve the learning challenges.
Revised: Differentiable modules that propagate uncertainties in intermediate decisions help here, such as attention on pixels in CLEVR, but do not fully solve the learning challenges.

Original: Joint Learning.
Revised: Joint Learning.

Original: Jointly training the parser and executor increases the latent choices available to the model by many folds while the only supervision available is the gold answer.
Revised: Jointly training the parser and executor increases the latent choices available to the model by many folds while the only supervision available is the gold answer.

Original: Additionally, joint learning is challenging as prediction errors from one component lead to incorrect training of the other.
Revised: Additionally, joint learning is challenging as prediction errors from one component lead to incorrect training of the other.

Original: E.g., if the parser predicts the program relocate(find()) for the question in Fig.
Revised: E.g., if the parser predicts the program relocate(find()) for the question in Fig.

Original: 1, then the associated modules would be incorrectly trained to predict the gold answer.
Revised: 1, then the associated modules would be incorrectly trained to predict the gold answer.

Original: On the next iteration, incorrect program execution would provide the wrong feedback to the question parser and lead to its incorrect training, and learning fails.
Revised: On the next iteration, incorrect program execution would provide the wrong feedback to the question parser and lead to its incorrect training, and learning fails.

Original:  M ODULES FOR R EASONING OVER T EXT
Revised:  M ODULES FOR R EASONING OVER T EXT

Original: Modules are designed to perform basic independent reasoning tasks and form the basis of the compositional reasoning that the model is capable of.
Revised: Modules are designed to perform basic independent reasoning tasks and form the basis of the compositional reasoning that the model is capable of.

Original: We identify a set of tasks that need to be performed to support diverse enough reasoning capabilities over text, numbers, and dates, and deﬁne modules accordingly.
Revised: We identify a set of tasks that need to be performed to support diverse enough reasoning capabilities over text, numbers, and dates, and deﬁne modules accordingly.

Original: Since the module parameters will be learned jointly with the rest of the model, we would like the modules to maintain uncertainties about their decisions and propagate them through the decision making layers via end-to-end differentiability.
Revised: Since the module parameters will be learned jointly with the rest of the model, we would like the modules to maintain uncertainties about their decisions and propagate them through the decision making layers via end-to-end differentiability.

Original: One of the main contributions of our work is introducing differentiable modules that perform reasoning over text and symbols in a probabilistic manner.
Revised: One of the main contributions of our work is introducing differentiable modules that perform reasoning over text and symbols in a probabilistic manner.

Original: Table 1 gives an overview of representative modules and § 3.2 describes them in detail. 
Revised: Table 1 gives an overview of representative modules and § 3.2 describes them in detail. Module In Out

Revised: Task find

Original:  [Table]
Revised: Q P For [Table]

Revised: spans

Revised: [Table]

Revised: , ﬁnd similar spans

Revised: [Table]

Revised: the passage filter

Revised: [Table]

Revised: , P

Revised: [Table]

Revised: relocate

Original:  3. D ATA T YPES
Revised: [Table] find [Table] 3. D ATA T YPES

Original: The modules operate over the following data types.
Revised: The modules operate over the following data types.

Original: Each data type represents its underlying value as a normalized distribution over the relevant support.
Revised: Each data type represents its underlying value as a normalized distribution over the relevant support.

Original: • Question ( Q ) and Paragraph ( P ) attentions: soft subsets of relevant tokens in the text.
Revised: • Question ( Q ) and Paragraph ( P ) attentions: soft subsets of relevant tokens in the text.

Original: • Number ( N ) and Date ( D ): soft subset of unique numbers and dates from the passage.• Count Number ( C ): count value as a distribution over the supported count values ( 0 − 9 ).
Revised: • Number ( N ) and Date ( D ): soft subset of unique numbers and dates from the passage.• Count Number ( C ): count value as a distribution over the supported count values ( 0 − 9 ).

Original: • Time Delta ( TD ): a value amongst all possible unique differences between dates in the paragraph.
Revised: • Time Delta ( TD ): a value amongst all possible unique differences between dates in the paragraph.

Original: In this work, we consider differences in terms of years.
Revised: In this work, we consider differences in terms of years.

Original: • Span ( S ): span-type answers as two probability values (start/end) for each paragraph token.
Revised: • Span ( S ): span-type answers as two probability values (start/end) for each paragraph token.

Original: 3. N EURAL M ODULES FOR Q UESTION A NSWERING
Revised: 3. N EURAL M ODULES FOR Q UESTION A NSWERING

Original: The question and paragraph contextualized embeddings ( Q and P ) are available as global variables to all modules in the program.
Revised: The question and paragraph contextualized embeddings ( Q and P ) are available as global variables to all modules in the program.

Original: The question attention computed by the decoder during the timestep the module was produced is also available to the module as a side argument, as described in § 2.1.
Revised: The question attention computed by the decoder during the timestep the module was produced is also available to the module as a side argument, as described in § 2.1.

Original: find(Q)
Revised: find(Q)

Original: → P This module is used to ground attended question tokens to similar tokens in the paragraph (e.g., “ﬁeld goal” in Figure 1).
Revised: → P This module is used to ground attended question tokens to similar tokens in the paragraph (e.g., “ﬁeld goal” in Figure 1).

Original: We use a question-to-paragraph attention matrix A ∈ R n × m whose i -th row is the distribution of similarity over the paragraph tokens for the i -th question token.
Revised: We use a question-to-paragraph attention matrix A ∈ R n × m whose i -th row is the distribution of similarity over the paragraph tokens for the i -th question token.

Original: The output is an expected paragraph attention; a weighted-sum of the rows of A , weighed by the input question attention, P = (cid:80) i Q i · A i :
Revised: The output is an expected paragraph attention; a weighted-sum of the rows of A , weighed by the input question attention, P = (cid:80) i Q i · A i :

Original: ∈ R m .
Revised: ∈ R m .

Original: A is computed by normalizing (using softmax) the rows of a question-to-paragraph similarity matrix S ∈ R n × m .
Revised: A is computed by normalizing (using softmax) the rows of a question-to-paragraph similarity matrix S ∈ R n × m .

Original: Here S ij is the similarity between the contextual embeddings of the i -th question token and the j -th paragraph token computed as,
Revised: Here S ij is the similarity between the contextual embeddings of the i -th question token and the j -th paragraph token computed as,

Original: S ij = w f T [ Q i : ; P j : ; Q i : ◦ P j : ] , where w f ∈ R 3 d is a learnable parameter vector of this module, [; ] denotes the concatenation operation, and ◦ is elementwise multiplication.
Revised: S ij = w f T [ Q i : ; P j : ; Q i : ◦ P j : ] , where w f ∈ R 3 d is a learnable parameter vector of this module, [; ] denotes the concatenation operation, and ◦ is elementwise multiplication.

Original: filter(Q, 
Revised: filter(Q, P) → P

Original: P → P

Original: This module masks the input paragraph attention conditioned on the question, selecting a subset of the attended paragraph (e.g., selecting ﬁelds goals “in the second quarter” in Fig. 1).
Revised: This module masks the input paragraph attention conditioned on the question, selecting a subset of the attended paragraph (e.g., selecting ﬁelds goals “in the second quarter” in Fig. 1).

Original: We compute a locally-normalized paragraph-token mask M ∈ R m where M j is the masking score for the j -th paragraph token computed as M j = σ ( w ﬁlter T [ q ; P j : ; q ◦ P j : ]) .
Revised: We compute a locally-normalized paragraph-token mask M ∈ R m where M j is the masking score for the j -th paragraph token computed as M j = σ ( w ﬁlter T [ q ; P j : ; q ◦ P j : ]) .

Original: Here q = (cid:80) i Q i · Q i : ∈ R d , is a weighted sum of question-token embeddings, w ﬁlter T ∈ R 3 d is a learnable parameter vector, and σ is the sigmoid non-linearity function.
Revised: Here q = (cid:80) i Q i · Q i : ∈ R d , is a weighted sum of question-token embeddings, w ﬁlter T ∈ R 3 d is a learnable parameter vector, and σ is the sigmoid non-linearity function.

Original: The output is a normalized masked input paragraph attention, P ﬁltered = normalize ( M ◦ P ) .
Revised: The output is a normalized masked input paragraph attention, P ﬁltered = normalize ( M ◦ P ) .

Original: relocate(Q, P) → P This module re-attends to the paragraph based on the question and is used to ﬁnd the arguments for paragraph spans (e.g., shifting the attention from “ﬁeld goals” to “who kicked” them).
Revised: relocate(Q, P) → P This module re-attends to the paragraph based on the question and is used to ﬁnd the arguments for paragraph spans (e.g., shifting the attention from “ﬁeld goals” to “who kicked” them).

Original: We ﬁrst compute a paragraph-to-paragraph attention matrix R ∈ R m × m based on the question, as R ij = w relocate T [( q + P i : ) ; P j : ; ( q + P i : ) ◦ P j : ] , where q = (cid:80) i Q i · Q i : ∈ R d , and w relocate ∈ R 3 d is a learnable parameter vector.
Revised: We ﬁrst compute a paragraph-to-paragraph attention matrix R ∈ R m × m based on the question, as R ij = w relocate T [( q + P i : ) ; P j : ; ( q + P i : ) ◦ P j : ] , where q = (cid:80) i Q i · Q i : ∈ R d , and w relocate ∈ R 3 d is a learnable parameter vector.

Original: Each row of R is also normalized using the softmax operation.
Revised: Each row of R is also normalized using the softmax operation.

Original: The output attention is a weighted sum of the rows R weighted by the input paragraph attention, P relocated =
Revised: The output attention is a weighted sum of the rows R weighted by the input paragraph attention, P relocated =

Original: (cid:80) i P i · R i : find-num(P)
Revised: (cid:80) i P i · R i : find-num(P)

Original: → N This module ﬁnds a number distribution associated with the input paragraph attention.
Revised: → N This module ﬁnds a number distribution associated with the input paragraph attention.

Original: We use a paragraph token-to-number-token attention map A num ∈ R m × N tokens whose i -th row is probability distribution over number-containing tokens for the i -th paragraph token.
Revised: We use a paragraph token-to-number-token attention map A num ∈ R m × N tokens whose i -th row is probability distribution over number-containing tokens for the i -th paragraph token.

Original: We ﬁrst compute a token-to-number similarity matrix S num ∈ R m × N tokens as, S num i,j = P Ti : W num P n j : , where n j is the index of the j -th number token and W
Revised: We ﬁrst compute a token-to-number similarity matrix S num ∈ R m × N tokens as, S num i,j = P T i : W num P n j : , where n j is the index of the j -th number token and W

Original: num ∈ R d × d is a learnable parameter.
Revised: num ∈ R d × d is a learnable parameter.

Original: A num i : =
Revised: A num i : =

Original: softmax ( S num i : ) .
Revised: softmax ( S num i : ) .

Original: We compute an expected distribution over the number tokens
Revised: We compute an expected distribution over the number tokens

Original: T = (cid:80) i P i · A num i : and aggregate the probabilities for number-tokens with the same value to compute the output distribution N .
Revised: T = (cid:80) i P i · A num i : and aggregate the probabilities for number-tokens with the same value to compute the output distribution N .

Original: For example, if the values of the number-tokens are [ 2 , 2 , 3 , 4 ] and T = [0 . 1 , 0 . 4 , 0 . 3 , 0 . 2] , the output will be a distribution over { 2 , 3 , 4 } with N = [0 . 5 , 0 . 3 , 0 . 2] .
Revised: For example, if the values of the number-tokens are [ 2 , 2 , 3 , 4 ] and T = [0 . 1 , 0 . 4 , 0 . 3 , 0 . 2] , the output will be a distribution over { 2 , 3 , 4 } with N = [0 . 5 , 0 . 3 , 0 . 2] .

Original: find-date(P)
Revised: find-date(P)

Original: → D follows the same process as above to compute a distribution over dates for the input paragraph attention.
Revised: → D follows the same process as above to compute a distribution over dates for the input paragraph attention.

Original: The corresponding learnable parameter matrix is W date ∈
Revised: The corresponding learnable parameter matrix is W date ∈

Original: R d × d . count(P)
Revised: R d × d . count(P)

Original: → C This module is used to count the number of attended paragraph spans.
Revised: → C This module is used to count the number of attended paragraph spans.

Original: The idea is to learn a module that detects contiguous spans of attention values and counts each as one.
Revised: The idea is to learn a module that detects contiguous spans of attention values and counts each as one.

Original: For example, if an attention vector is [0 , 0 , 0 . 3 , 0 . 3 , 0 , 0 . 4] , the count module should produce an output of 2 .
Revised: For example, if an attention vector is [0 , 0 , 0 . 3 , 0 . 3 , 0 , 0 . 4] , the count module should produce an output of 2 .

Original: The module ﬁrst scales the attention using the values [1 , 2 , 5 , 10] to convert it into a matrix P scaled ∈
Revised: The module ﬁrst scales the attention using the values [1 , 2 , 5 , 10] to convert it into a matrix P scaled ∈

Original: R m × 4 .
Revised: R m × 4 .

Original: A bidirectional-GRU then represents each token attention as a hidden vector h t .
Revised: A bidirectional-GRU then represents each token attention as a hidden vector h t .

Original: A single-layer feed-forward network maps this representation to a soft 0 / 1 score to indicate the presence of a span surrounding it.
Revised: A single-layer feed-forward network maps this representation to a soft 0 / 1 score to indicate the presence of a span surrounding it.

Original: These scores are summed to compute a count value, c v = (cid:80) σ ( FF ( countGRU ( P scaled )))
Revised: These scores are summed to compute a count value, c v = (cid:80) σ ( FF ( countGRU ( P scaled )))

Original: ∈ R .
Revised: ∈ R .

Original: We hypothesize that the output count value is normally distributed with c v as mean, and a constant variance v = 0 .
Revised: We hypothesize that the output count value is normally distributed with c v as mean, and a constant variance v = 0 .

Original: 5 , and compute a categorical distribution over the supported count values, as p ( c ) ∝ exp( − ( c − c v ) 2 / 2 v 2 ) ∀ c ∈ [0 , 9] .
Revised: 5 , and compute a categorical distribution over the supported count values, as p ( c ) ∝ exp( − ( c − c v ) 2 / 2 v 2 ) ∀ c ∈ [0 , 9] .

Original: Pretraining this module by generating synthetic data of attention and count values helps (see § A.4).
Revised: Pretraining this module by generating synthetic data of attention and count values helps (see § A.4).

Original: compare-num-lt(P1, P2)
Revised: compare-num-lt(P1, P2)

Original: → P This module performs a soft less-than operation between two passage distributions.
Revised: → P This module performs a soft less-than operation between two passage distributions.

Original: For example, to ﬁnd the city with fewer people, cityA or cityB , the module would output a linear combination of the two input attentions weighted by which city was associated with a lower number.
Revised: For example, to ﬁnd the city with fewer people, cityA or cityB , the module would output a linear combination of the two input attentions weighted by which city was associated with a lower number.

Original: This module internally calls the find-num module to get a number distribution for each of the input paragraph attentions, N 1 and N 2 .
Revised: This module internally calls the find-num module to get a number distribution for each of the input paragraph attentions, N 1 and N 2 .

Original: It then computes two soft boolean values, p ( N 1 < N 2 ) and p ( N 2 < N 1 ) , and outputs a weighted sum of the input paragraph attentions.
Revised: It then computes two soft boolean values, p ( N 1 < N 2 ) and p ( N 2 < N 1 ) , and outputs a weighted sum of the input paragraph attentions.

Original: The boolean values are computed by marginalizing the relevant joint probabilities:
Revised: The boolean values are computed by marginalizing the relevant joint probabilities:

Original: [Equation]
Revised: [Equation]

Original: The ﬁnal output is, P out = p ( N 1 < N 2 ) ∗ P 1 + p ( N 2 < N 1 ) ∗ P 2 .
Revised: The ﬁnal output is, P out = p ( N 1 < N 2 ) ∗ P 1 + p ( N 2 < N 1 ) ∗ P 2 .

Original: When the the predicted number distributions are peaky, p ( N 1 < N 2 ) or p ( N 2 < N 1 ) is close to 1 , and the output is either P 1 or P 2 .
Revised: When the the predicted number distributions are peaky, p ( N 1 < N 2 ) or p ( N 2 < N 1 ) is close to 1 , and the output is either P 1 or P 2 .

Original: We similarly include the comparison modules compare-num-gt , compare-date-lt , and compare-date-gt , deﬁned in an essentially identical manner, but for greater-than and for dates.
Revised: We similarly include the comparison modules compare-num-gt , compare-date-lt , and compare-date-gt , deﬁned in an essentially identical manner, but for greater-than and for dates.

Original: time-diff(P1, P2) → TD The module outputs the difference between the dates associated with the two paragraph attentions as a distribution over all possible difference values.
Revised: time-diff(P1, P2) → TD The module outputs the difference between the dates associated with the two paragraph attentions as a distribution over all possible difference values.

Original: The module internally calls the find-date module to get a date distribution for the two paragraph attentions,
Revised: The module internally calls the find-date module to get a date distribution for the two paragraph attentions,

Original: D 1 and D 2 .
Revised: D 1 and D 2 .

Original: The probability of the difference being t d is computed by marginalizing over the joint probability for the dates that yield this value, as p ( t d ) = (cid:80)
Revised: The probability of the difference being t d is computed by marginalizing over the joint probability for the dates that yield this value, as p ( t d ) = (cid:80)

Original: i,j 1 ( d i − d j = t d ) D i 1 D j 2 .
Revised: i,j 1 ( d i − d j = t d ) D i 1 D j 2 .

Original: find-max-num(P)
Revised: find-max-num(P)

Original: → P , find-min-num(P)
Revised: → P , find-min-num(P)

Original: → P Given a passage attention attending to multiple spans, this module outputs an attention for the span associated with the largest (or smallest) number.
Revised: → P Given a passage attention attending to multiple spans, this module outputs an attention for the span associated with the largest (or smallest) number.

Original: We ﬁrst compute an expected number token distribution T using find-num , then use this to compute the expected probability that each number token is the one with the maximum value,
Revised: We ﬁrst compute an expected number token distribution T using find-num , then use this to compute the expected probability that each number token is the one with the maximum value,

Original: T max ∈ R N tokens (explained below).
Revised: T max ∈ R N tokens (explained below).

Original: We then re-distribute this distribution back to the original passage tokens associated with those numbers.
Revised: We then re-distribute this distribution back to the original passage tokens associated with those numbers.

Original: The contribution from the i -th paragraph token to the j -th number token, T j , was P i · A num ij .
Revised: The contribution from the i -th paragraph token to the j -th number token, T j , was P i · A num ij .

Original: To compute the new attention value for token i , we re-weight this contribution based on the ratio T max j / T j and marginalize across the number tokens to get the new token attention value: ¯ P i =
Revised: To compute the new attention value for token i , we re-weight this contribution based on the ratio T max j / T j and marginalize across the number tokens to get the new token attention value: ¯ P i =

Original: (cid:80) j T max j / T j · P
Revised: (cid:80) j T max j / T j · P

Original: i · A num ij .
Revised: i · A num ij .

Original: Computing T max : Consider a distribution over numbers N , sorted in an increasing order.
Revised: Computing T max : Consider a distribution over numbers N , sorted in an increasing order.

Original: Say we sample a set S (size n ) of numbers from this distribution.
Revised: Say we sample a set S (size n ) of numbers from this distribution.

Original: The probability that N j is the largest number in this set is p ( x ≤ N j ) n − p ( x ≤ N j − 1 ) n i.e. all numbers in S are less than or equal to N j , and at least one number is N j .
Revised: The probability that N j is the largest number in this set is p ( x ≤ N j ) n − p ( x ≤ N j − 1 ) n i.e. all numbers in S are less than or equal to N j , and at least one number is N j .

Original: By picking the set size n = 3 as a hyperparameter, we can analytically (and differentiably) convert the expected distribution over number tokens, T , into a distribution over the maximum value T max . span(P)
Revised: By picking the set size n = 3 as a hyperparameter, we can analytically (and differentiably) convert the expected distribution over number tokens, T , into a distribution over the maximum value T max . span(P)

Original: → S This module is used to convert a paragraph attention into a contiguous answer span and only appears as the outermost module in a program.
Revised: → S This module is used to convert a paragraph attention into a contiguous answer span and only appears as the outermost module in a program.

Original: The module outputs two probability distributions, P s and P e ∈ R m , denoting the probability of a token being the start and end of a span, respectively.
Revised: The module outputs two probability distributions, P s and P e ∈ R m , denoting the probability of a token being the start and end of a span, respectively.

Original: This module is implemented similar to the count module (see § A.5).
Revised: This module is implemented similar to the count module (see § A.5).

Original:  A UXILIARY S UPERVISION
Revised:  A UXILIARY S UPERVISION

Original: As mentioned in § 2.2, jointly learning the parameters of the parser and the modules using only endtask QA supervision is extremely challenging.
Revised: As mentioned in § 2.2, jointly learning the parameters of the parser and the modules using only endtask QA supervision is extremely challenging.

Original: To overcome issues in learning, (a) we introduce an unsupervised auxiliary loss to provide an inductive bias to the execution of find-num , find-date , and relocate modules ( § 4.1); and (b) provide heuristically-obtained supervision for question program and intermediate module output ( § 4.2) for a subset of questions (5–10%).
Revised: To overcome issues in learning, (a) we introduce an unsupervised auxiliary loss to provide an inductive bias to the execution of find-num , find-date , and relocate modules ( § 4.1); and (b) provide heuristically-obtained supervision for question program and intermediate module output ( § 4.2) for a subset of questions (5–10%).

Original: 4. U NSUPERVISED A UXILIARY L OSS FOR IE
Revised: 4. U NSUPERVISED A UXILIARY L OSS FOR IE

Original: The find-num , find-date , and relocate modules perform information extraction by ﬁnding relevant arguments for entities and events mentioned in the context.
Revised: The find-num , find-date , and relocate modules perform information extraction by ﬁnding relevant arguments for entities and events mentioned in the context.

Original: In our initial experiments we found that these modules would often spuriously predict a high attention score for output tokens that appear far away from their corresponding inputs.
Revised: In our initial experiments we found that these modules would often spuriously predict a high attention score for output tokens that appear far away from their corresponding inputs.

Original: We introduce an auxiliary objective to induce the idea that the arguments of a mention should appear near it.
Revised: We introduce an auxiliary objective to induce the idea that the arguments of a mention should appear near it.

Original: For any token, the objective increases the sum of the attention probabilities for output tokens that appear within a window W = 10 , letting the model distribute the mass within that window however it likes.
Revised: For any token, the objective increases the sum of the attention probabilities for output tokens that appear within a window W = 10 , letting the model distribute the mass within that window however it likes.

Original: The objective for the find-num is
Revised: The objective for the find-num is

Original: [Equation]
Revised: [Equation]

Original: We compute a similar loss for the date-attention map A date ( H dloss ) and the relocate-map R ( H rloss ).
Revised: We compute a similar loss for the date-attention map A date ( H dloss ) and the relocate-map R ( H rloss ).

Original: The ﬁnal auxiliary loss is H loss =
Revised: The ﬁnal auxiliary loss is H loss =

Original: H nloss + H dloss + H rloss .
Revised: H nloss + H dloss + H rloss .

Original: 4. Q UESTION P ARSE AND I NTERMEDIATE M ODULE O UTPUT S UPERVISION
Revised: 4. Q UESTION P ARSE AND I NTERMEDIATE M ODULE O UTPUT S UPERVISION

Original: Question Parse Supervision.
Revised: Question Parse Supervision.

Original: Learning to parse questions in a noisy feedback environment is very challenging.
Revised: Learning to parse questions in a noisy feedback environment is very challenging.

Original: For example, even though the questions in CLEVR are programmatically generated,
Revised: For example, even though the questions in CLEVR are programmatically generated,

Original: Hu et al.
Revised: Hu et al.

Original: (2017) needed to pre-train their parser using external supervision for all questions.
Revised: (2017) needed to pre-train their parser using external supervision for all questions.

Original: For
Revised: For

Original: DROP, we have no such external supervision.
Revised: DROP, we have no such external supervision.

Original: In order to bootstrap the parser, we analyze some questions manually and come up with a few heuristic patterns to get program and corresponding question attention supervision (for modules that require it) for a subset of the training data (10% of the questions; see § A.6).
Revised: In order to bootstrap the parser, we analyze some questions manually and come up with a few heuristic patterns to get program and corresponding question attention supervision (for modules that require it) for a subset of the training data (10% of the questions; see § A.6).

Original: For example, for program find-num(find-max-num(find())) , we provide supervision for question tokens to attend to when predicting the find module.
Revised: For example, for program find-num(find-max-num(find())) , we provide supervision for question tokens to attend to when predicting the find module.

Original: Intermediate Module Output Supervision.
Revised: Intermediate Module Output Supervision.

Original: Consider the question, “how many yards was the shortest goal?”.
Revised: Consider the question, “how many yards was the shortest goal?”.

Original: The model only gets feedback for how long the shortest goal is, but not for other goals .
Revised: The model only gets feedback for how long the shortest goal is, but not for other goals .

Original: Such feedback biases the model in predicting incorrect values for intermediate modules (only the shortest goal instead of all in find-num ) which in turn hurts model generalization.
Revised: Such feedback biases the model in predicting incorrect values for intermediate modules (only the shortest goal instead of all in find-num ) which in turn hurts model generalization.

Original: We provide heuristically-obtained noisy supervision for the output of the find-num and find-date modules for a subset of the questions (5%) for which we also provide question program supervision.
Revised: We provide heuristically-obtained noisy supervision for the output of the find-num and find-date modules for a subset of the questions (5%) for which we also provide question program supervision.

Original: For questions like “how many yards was the longest/shortest touchdown?”, we identify all instances of the token “touchdown” in the paragraph and assume the closest number to it should be an output of the find-num module.
Revised: For questions like “how many yards was the longest/shortest touchdown?”, we identify all instances of the token “touchdown” in the paragraph and assume the closest number to it should be an output of the find-num module.

Original: We supervise this as a multi-hot vector N ∗ and use an auxiliary loss, similar to question-attention loss, against the output distribution N of find-num .
Revised: We supervise this as a multi-hot vector N ∗ and use an auxiliary loss, similar to question-attention loss, against the output distribution N of find-num .

Original: We follow the same procedure for a few other question types involving dates and numbers; see § A.7 for details.[Table]
Revised: We follow the same procedure for a few other question types involving dates and numbers; see § A.7 for details.

Original:  E XPERIMENTS 5. D ATASET
Revised:  E XPERIMENTS 5. D ATASET

Original: We perform experiments on a portion of the recently released DROP dataset (Dua et al., 2019), which to the best of our knowledge is the only dataset that requires the kind of compositional and symbolic reasoning that our model aims to solve.
Revised: We perform experiments on a portion of the recently released DROP dataset (Dua et al., 2019), which to the best of our knowledge is the only dataset that requires the kind of compositional and symbolic reasoning that our model aims to solve.

Original: Our model possesses diverse but limited reasoning capability; hence, we try to automatically extract questions in the scope of our model based on their ﬁrst n-gram.
Revised: Our model possesses diverse but limited reasoning capability; hence, we try to automatically extract questions in the scope of our model based on their ﬁrst n-gram.

Original: These n-grams were selected by performing manual analysis on a small set of questions.
Revised: These n-grams were selected by performing manual analysis on a small set of questions.

Original: The dataset we construct contains 20 , 000 questions for training/validation [Table] and 1800 questions for testing ( 25% of DROP).
Revised: The dataset we construct contains 20 , 000 questions for training/validation, and 1800 questions for testing ( 25% of DROP).

Original: Since the DROP test set is hidden, this test set is extracted from the validation data.
Revised: Since the DROP test set is hidden, this test set is extracted from the validation data.

Original: Though this is a subset of the full DROP dataset it is still a signiﬁcantly-sized dataset that allows drawing meaningful conclusions.
Revised: Though this is a subset of the full DROP dataset it is still a signiﬁcantly-sized dataset that allows drawing meaningful conclusions.

Original: Wewill make the subset and splits available publicly.
Revised: We make our subset and splits available publicly with the code.

Original: Based on the manual analysis we classify these questions into different categories, which are:
Revised: Based on the manual analysis we classify these questions into different categories, which are:

Original: Date-Compare e.g. What happened last, commission being granted to Robert or death of his cousin?
Revised: Date-Compare e.g. What happened last, commission being granted to Robert or death of his cousin?

Original: Date-Difference
Revised: Date-Difference

Original: e.g. How many years after his attempted assassination was James II coronated?
Revised: e.g. How many years after his attempted assassination was James II coronated?

Original: Number-Compare e.g. Were there more of cultivators or main agricultural labourers in Sweden?
Revised: Number-Compare e.g. Were there more of cultivators or main agricultural labourers in Sweden?

Original: Extract-Number e.g. How many yards was Kasay’s shortest ﬁeld goal during the second half?
Revised: Extract-Number e.g. How many yards was Kasay’s shortest ﬁeld goal during the second half?

Original: Count e.g. How many touchdowns did the Vikings score in the ﬁrst half?
Revised: Count e.g. How many touchdowns did the Vikings score in the ﬁrst half?

Original: Extract-Argument e.g. Who threw the longest touchdown pass in the ﬁrst quarter?
Revised: Extract-Argument e.g. Who threw the longest touchdown pass in the ﬁrst quarter?

Original: Auxiliary Supervision Out of the 20 , 000 training questions, we provide question program supervision for 10% ( 2000 ), and intermediate module output supervision for 5% ( 1000 ) of training questions.
Revised: Auxiliary Supervision Out of the 20 , 000 training questions, we provide question program supervision for 10% ( 2000 ), and intermediate module output supervision for 5% ( 1000 ) of training questions.

Original: We use curriculum learning (Bengio et al., 2009) where the model is trained only on heuristically-supervised non-count questions for the ﬁrst 5 epochs.
Revised: We use curriculum learning (Bengio et al., 2009) where the model is trained only on heuristically-supervised non-count questions for the ﬁrst 5 epochs.

Original: 5. R ESULTS
Revised: 5. R ESULTS

Original: We compare to publicly available best performing models:
Revised: We compare to publicly available best performing models:

Original: NAQANet (Dua et al., 2019),
Revised: NAQANet (Dua et al., 2019),

Original: NABERT+ (Kinley & Lin, 2019), TAG-NABERT + (Avia Efrat & Shoham, 2019), and MTMSN (Hu et al., 2019), all trained on the same data as our model.
Revised: NABERT+ (Kinley & Lin, 2019), TAG-NABERT + (Avia Efrat & Shoham, 2019), and MTMSN (Hu et al., 2019), all trained on the same data as our model.

Original: We implement our model using AllenNLP (Gardner et al., 2018)
Revised: We implement our model using AllenNLP (Gardner et al., 2018).

Original: (code available at https://anon.ymo.us).

Original: The hyperparameters used for our model are described in the appendix.
Revised: The hyperparameters used for our model are described in the appendix.

Original: All results are reported as an average of 4 model runs.
Revised: All results are reported as an average of 4 model runs.

Original: Overall.
Revised: Overall.

Original: Table 2a compares our model’s performance to state-of-the-art models on our full test set.
Revised: Table 2a compares our model’s performance to state-of-the-art models on our full test set.

Original: Our model achieves an F1 score of 73 .
Revised: Our model achieves an F1 score of 73 .

Original: 1 (w/ GRU) and signiﬁcantly outperforms NAQANet ( 62 .
Revised: 1 (w/ GRU) and signiﬁcantly outperforms NAQANet ( 62 .

Original: F1).
Revised: F1).

Original: Using BERT representations, our model’s performance increases to 77 .
Revised: Using BERT representations, our model’s performance increases to 77 .

Original: 4 F1 and outperforms
Revised: 4 F1 and outperforms

Original: SoTA models that use BERT representations, such as MTMSN (76.5 F1).
Revised: SoTA models that use BERT representations, such as MTMSN (76.5 F1).

Original: This shows the efﬁcacy of our proposed model in understanding complex compositional questions and performing multi-step  reasoning over natural language text.
Revised: This shows the efﬁcacy of our proposed model in understanding complex compositional questions and performing multi-step [Table] reasoning over natural language text.

Original: Additionally, this shows that structured models still beneﬁt when used over representations from large pretrained-LMs, such as BERT.
Revised: Additionally, this shows that structured models still beneﬁt when used over representations from large pretrained-LMs, such as BERT.

Original: Performance by Question Type.
Revised: Performance by Question Type.

Original: Table 2b shows the performance for different question types as identiﬁed by our heuristic labeling.
Revised: Table 2b shows the performance for different question types as identiﬁed by our heuristic labeling.

Original: Our model outperforms MTMSN on majority of question types but struggles with counting questions; it outperforms MTMSN on only some of the runs.
Revised: Our model outperforms MTMSN on majority of question types but struggles with counting questions; it outperforms MTMSN on only some of the runs.

Original: Even after[Figure] pre-training the count module using synthetic data, training it is particularly unstable.
Revised: Even after pre-training the count module using synthetic data, training it is particularly unstable.

Original: We believe this is because feedback from count questions is weak, i.e., the model only gets feedback about the count value and not what the underlying set is; and because it was challenging to deﬁne a categorical count distribution given a passage attention distribution— ﬁnding a better way to parameterize this function is an interesting problem for future work.
Revised: We believe this is because feedback from count questions is weak, i [Table] e., the model only gets feedback about the count value and not what the underlying set is; and because it was challenging to deﬁne a categorical count distribution given a passage attention distribution— ﬁnding a better way to parameterize this function is an interesting problem for future work.

Original: Effect of Additional Supervision.
Revised: Effect of Additional Supervision.

Original: Figure 2a shows that the unsupervised auxiliary objective significantly improves model performance (from 57 .
Revised: Figure 2a shows that the unsupervised auxiliary objective significantly improves model performance (from 57 .

Original: 3 to 73 .
Revised: 3 to 73 .

Original: 1 F1).
Revised: 1 F1).

Original: The model using BERT diverges while training without the auxiliary objective.
Revised: The model using BERT diverges while training without the auxiliary objective.

Original: Additionally, the intermediate module output supervision has slight positive effect on the model performance.
Revised: Additionally, the intermediate module output supervision has slight positive effect on the model performance.

Original: Effect of Training Data Size.
Revised: Effect of Training Data Size.

Original: Figure 2b shows that our model signiﬁcantly outperforms MTMSN when training using less data, especially using 10 - 25% of the available supervision.
Revised: Figure 2b shows that our model signiﬁcantly outperforms MTMSN when training using less data, especially using 10 - 25% of the available supervision.

Original: This shows that by explicitly modeling compositionality, our model is able to use additional auxiliary supervision effectively and achieves improved model generalization.
Revised: This shows that by explicitly modeling compositionality, our model is able to use additional auxiliary supervision effectively and achieves improved model generalization.

Original: Incorrect Program Predictions.
Revised: Incorrect Program Predictions.

Original: Mistakes by our model can be classiﬁed into two types; incorrect program prediction and incorrect execution.
Revised: Mistakes by our model can be classiﬁed into two types; incorrect program prediction and incorrect execution.

Original: Here we show few mistakes of the ﬁrst type that highlight the need to parse the question in a context conditional manner:
Revised: Here we show few mistakes of the ﬁrst type that highlight the need to parse the question in a context conditional manner:

Original: How many touchdown passes did Tom Brady throw in the season? - count(find) is incorrect since the correct answer requires a simple lookup from the paragraph.
Revised: How many touchdown passes did Tom Brady throw in the season? - count(find) is incorrect since the correct answer requires a simple lookup from the paragraph.

Original: Which happened last, failed assassination attempt on Lenin, or the Red Terror? - date-compare-gt(find, find)) is incorrect since the correct answer requires natural language inference about the order of events and not symbolic comparison between dates.
Revised: Which happened last, failed assassination attempt on Lenin, or the Red Terror? - date-compare-gt(find, find)) is incorrect since the correct answer requires natural language inference about the order of events and not symbolic comparison between dates.

Original: Who caught the most touchdown passes? - relocate(find-max-num(find))) .
Revised: Who caught the most touchdown passes? - relocate(find-max-num(find))) .

Original: Such questions, that require nested counting, are out of scope of our deﬁned modules because the model would  need to to count the passes caught by each player, and then ﬁnd the maximum amongst them.
Revised: Such questions, that require nested counting, are out of scope of our deﬁned modules because the model would ﬁrst need to to count the passes caught by each player.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: Semantic parsing techniques have been used for a long time for compositional question understanding.
Revised: Semantic parsing techniques have been used for a long time for compositional question understanding.

Original: Approaches have used labeled logical-forms (Zelle & Mooney, 1996; Zettlemoyer & Collins, 2005), or weak QA supervision (Clarke et al., 2010;
Revised: Approaches have used labeled logical-forms (Zelle & Mooney, 1996; Zettlemoyer & Collins, 2005), or weak QA supervision (Clarke et al., 2010;

Original: Berant et al., 2013; Reddy et al., 2014) to learn parsers to answer questions against structured knowledge bases.
Revised: Berant et al., 2013; Reddy et al., 2014) to learn parsers to answer questions against structured knowledge bases.

Original: These have also been extended for QA using symbolic reasoning against semi-structured tables (Pasupat & Liang, 2015; Krishnamurthy et al., 2017; Neelakantan et al., 2016).
Revised: These have also been extended for QA using symbolic reasoning against semi-structured tables (Pasupat & Liang, 2015; Krishnamurthy et al., 2017; Neelakantan et al., 2016).

Original: Recently, BERT-based models for DROP have been been  proposed (Hu et al., 2019; Andor et al., 2019; Kinley & Lin, 2019), but all these models essentially perform a multiclass classiﬁcation over pre-deﬁned programs.
Revised: Recently, BERT-based models for DROP have been been [Figure] proposed (Hu et al., 2019; Andor et al., 2019; Kinley & Lin, 2019), but all these models essentially perform a multiclass classiﬁcation over pre-deﬁned programs.

Original: Our model on the other hand provides an interpretable, compositional parse of the question and exposes its intermediate reasoning steps.
Revised: Our model on the other hand provides an interpretable, compositional parse of the question and exposes its intermediate reasoning steps.

Original: For combining learned execution modules with semantic parsing, many variations to NMNs have been proposed; NMN (Andreas et al., 2016) use a PCFG parser to parse the question and only learn module parameters.
Revised: For combining learned execution modules with semantic parsing, many variations to NMNs have been proposed; NMN (Andreas et al., 2016) use a PCFG parser to parse the question and only learn module parameters.

Original: N2NMNs (Hu et al., 2017) simultaneously learn to parse and execute but require pre-training the parser.
Revised: N2NMNs (Hu et al., 2017) simultaneously learn to parse and execute but require pre-training the parser.

Original: Gupta & Lewis (2018) propose a NMN model for QA against knowledge graphs and learn execution for semantic operators from QA supervision alone.
Revised: Gupta & Lewis (2018) propose a NMN model for QA against knowledge graphs and learn execution for semantic operators from QA supervision alone.

Original: Recent works (Gupta & Lewis, 2018; Mao et al., 2019) also use domain-knowledge to alleviate issues in learning by using curriculum learning to train the executor ﬁrst on simple questions for which parsing is not an issue.
Revised: Recent works (Gupta & Lewis, 2018; Mao et al., 2019) also use domain-knowledge to alleviate issues in learning by using curriculum learning to train the executor ﬁrst on simple questions for which parsing is not an issue.

Original: All these approaches perform reasoning on synthetic domains, while our model is applied to natural language.
Revised: All these approaches perform reasoning on synthetic domains, while our model is applied to natural language.

Original: Concurrently, Jiang & Bansal (2019) apply NMN to HotpotQA
Revised: Concurrently, Jiang & Bansal (2019) apply NMN to HotpotQA

Original: (Yang et al., 2018)
Revised: (Yang et al., 2018)

Original: but their model comprises of only 3 modules and is not capable of performing symbolic reasoning.
Revised: but their model comprises of only 3 modules and is not capable of performing symbolic reasoning.

Original:  F UTURE D IRECTIONS
Revised:  F UTURE D IRECTIONS

Original: We try a trivial extension to our model by adding a module that allows for addition & subtraction between two paragraph numbers.
Revised: We try a trivial extension to our model by adding a module that allows for addition & subtraction between two paragraph numbers.

Original: The resulting model achieves a score of 65 . 4 F1 on the complete validation data of DROP, as compared to MTMSN that achieves 72 . 8 F1.
Revised: The resulting model achieves a score of 65 . 4 F1 on the complete validation data of DROP, as compared to MTMSN that achieves 72 . 8 F1.

Original: Manual analysis of predictions reveals that a signiﬁcant majority of mistakes are due to insufﬁcient reasoning capability in our model and would require designing additional modules.
Revised: Manual analysis of predictions reveals that a signiﬁcant majority of mistakes are due to insufﬁcient reasoning capability in our model and would require designing additional modules.

Original: For example, questions such as (a) How many languages each had less than 115 , 000 speakers in the population?
Revised: For example, questions such as (a) How many languages each had less than 115 , 000 speakers in the population?

Original: and Which racial groups are smaller than 2% ?
Revised: and Which racial groups are smaller than 2% ?

Original: would require pruning passage spans based on the numerical comparison mentioned in the question; (b) Which quarterback threw the most touchdown passes?
Revised: would require pruning passage spans based on the numerical comparison mentioned in the question; (b) Which quarterback threw the most touchdown passes?

Original: and In which quarter did the teams both score the same number of points? would require designing modules that considers some key-value representation of the paragraph; (c) How many points did the packers fall behind during the game? would require IE for implicit argument (points scored by the other team).
Revised: and In which quarter did the teams both score the same number of points? would require designing modules that considers some key-value representation of the paragraph; (c) How many points did the packers fall behind during the game? would require IE for implicit argument (points scored by the other team).

Original: It is not always clear how to design interpretable modules for certain operations; for example, for the last two cases above.
Revised: It is not always clear how to design interpretable modules for certain operations; for example, for the last two cases above.

Original: It is worth emphasizing here what happens when we try to train our model on these questions for which our modules can’t express the correct reasoning.
Revised: It is worth emphasizing here what happens when we try to train our model on these questions for which our modules can’t express the correct reasoning.

Original: The modules in the predicted program get updated to try to perform the reasoning anyway, which harms their ability to execute their intended operations (cf. § 2.2).
Revised: The modules in the predicted program get updated to try to perform the reasoning anyway, which harms their ability to execute their intended operations (cf. § 2.2).

Original: This is why we focus on only a subset of the data when training our model.
Revised: This is why we focus on only a subset of the data when training our model.

Original: In part due to this training problem, some other mistakes of our model relative to MTMSN on the full dataset are due to incorrect execution of the intermediate modules.
Revised: In part due to this training problem, some other mistakes of our model relative to MTMSN on the full dataset are due to incorrect execution of the intermediate modules.

Original: For example, incorrect grounding by the ﬁnd module, or incorrect argument extraction by the ﬁnd-num module.
Revised: For example, incorrect grounding by the ﬁnd module, or incorrect argument extraction by the ﬁnd-num module.

Original: For mistakes such as these, our NMN based approach allows for identifying the cause of mistakes and supervising these modules using additional auxiliary supervision that is not possible in black-box models.
Revised: For mistakes such as these, our NMN based approach allows for identifying the cause of mistakes and supervising these modules using additional auxiliary supervision that is not possible in black-box models.

Original: This additionally opens up avenues for transfer learning where modules can be independently trained using indirect or distant supervision from different tasks.
Revised: This additionally opens up avenues for transfer learning where modules can be independently trained using indirect or distant supervision from different tasks.

Original: Direct transfer of reasoning capability in black-box models is not so straight-forward.
Revised: Direct transfer of reasoning capability in black-box models is not so straight-forward.

Original: To solve both of these classes of errors, one could use black-box models, which gain performance on some questions at the expense of limited interpretability.
Revised: To solve both of these classes of errors, one could use black-box models, which gain performance on some questions at the expense of limited interpretability.

Original: It is not trivial to combine the two approaches, however.
Revised: It is not trivial to combine the two approaches, however.

Original: Allowing black-box operations inside of a neural module network signiﬁcantly harms the interpretability—e.g., an operation that directly answers a question after an encoder, mimicking BERT-QA-style models, encourages the encoder to perform complex reasoning in a non-interpretable way.
Revised: Allowing black-box operations inside of a neural module network signiﬁcantly harms the interpretability—e.g., an operation that directly answers a question after an encoder, mimicking BERT-QA-style models, encourages the encoder to perform complex reasoning in a non-interpretable way.

Original: This also harms the ability of the model to use the interpretable modules even when they would be sufﬁcient to answer the question.
Revised: This also harms the ability of the model to use the interpretable modules even when they would be sufﬁcient to answer the question.

Original: Additionally, due to our lack of supervised programs, training the network to use the interpretable modules instead of a black-box shortcut module is challenging, further compounding the issue.
Revised: Additionally, due to our lack of supervised programs, training the network to use the interpretable modules instead of a black-box shortcut module is challenging, further compounding the issue.

Original: Combining these black-box operations with the interpretable modules that we have presented is an interesting and important challenge for future work.
Revised: Combining these black-box operations with the interpretable modules that we have presented is an interesting and important challenge for future work.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: We show how to use neural module networks to answer compositional questions requiring symbolic reasoning against natural language text.
Revised: We show how to use neural module networks to answer compositional questions requiring symbolic reasoning against natural language text.

Original: We deﬁne probabilistic modules that propagate uncertainty about symbolic reasoning operations in a way that is end-to-end differentiable.
Revised: We deﬁne probabilistic modules that propagate uncertainty about symbolic reasoning operations in a way that is end-to-end differentiable.

Original: Additionally, we show that injecting inductive bias using unsupervised auxiliary losses signiﬁcantly helps learning.
Revised: Additionally, we show that injecting inductive bias using unsupervised auxiliary losses signiﬁcantly helps learning.

Original: While we have demonstrated marked success in broadening the scope of neural modules and applying them to open-domain text, it remains a signiﬁcant challenge to extend these models to the full range of reasoning required even just for the DROP dataset.
Revised: While we have demonstrated marked success in broadening the scope of neural modules and applying them to open-domain text, it remains a signiﬁcant challenge to extend these models to the full range of reasoning required even just for the DROP dataset.

Original: NMNs provide interpretability, compositionality, and improved generalizability, but at the cost of restricted expressivity as compared to more black box models.
Revised: NMNs provide interpretability, compositionality, and improved generalizability, but at the cost of restricted expressivity as compared to more black box models.

Original: Future research is necessary to continue bridging these reasoning gaps.
Revised: Future research is necessary to continue bridging these reasoning gaps.

Revised: A CKNOWLEDGMENTS

Revised: We would like to thank Daniel Deutsch and the anonymous reviewers for their helpful comments.

Revised: This material is based upon work sponsored in part by the DARPA MCS program under Contract

Revised: No. N660011924033 with the United States Ofﬁce Of Naval Research, an ONR award, the LwLL

Revised: DARPA program, and a grant from AI2.

Original: A A PPENDIX A. Q UESTION AND P ARAGRAPH E NCODER
Revised: A A PPENDIX A. Q UESTION AND P ARAGRAPH E NCODER

Original: Our model represents the question q as Q ∈ R n × d and paragraph p as P ∈ R m × d using contextualized token embeddings.
Revised: Our model represents the question q as Q ∈ R n × d and paragraph p as P ∈ R m × d using contextualized token embeddings.

Original: These embeddings are either produced using a multi-layer GRU network that is trained from scratch, or a pr-trained BERT model that is ﬁne-tuned during training.
Revised: These embeddings are either produced using a multi-layer GRU network that is trained from scratch, or a pr-trained BERT model that is ﬁne-tuned during training.

Original: GRU : We use a 2 -layer, 64 -dimensional ( d = 128 , effectively), bi-directional GRU.
Revised: GRU : We use a 2 -layer, 64 -dimensional ( d = 128 , effectively), bi-directional GRU.

Original: The same GRU is used for both, the question and the paragraph.
Revised: The same GRU is used for both, the question and the paragraph.

Original: The token embeddings input to the contextual encoder are a concatenation of 100 -d pre-trained GloVe embeddings, and 200 -d embeddings output from a CNN over the token’s characters.
Revised: The token embeddings input to the contextual encoder are a concatenation of 100 -d pre-trained GloVe embeddings, and 200 -d embeddings output from a CNN over the token’s characters.

Original: The CNN uses ﬁlters of size= 5 and character embeddings of 64 -d.
Revised: The CNN uses ﬁlters of size= 5 and character embeddings of 64 -d.

Original: The pre-trained glove embeddings are ﬁxed but the character embeddings and the parameters for the CNN are jointly learned with the rest of the model.
Revised: The pre-trained glove embeddings are ﬁxed, but the character embeddings and the parameters for the CNN are jointly learned with the rest of the model.

Original: BERT : The input to the BERT model is the concatenation of the question and paragraph in the following format: [CLS] Question [SEP] Context [SEP] .
Revised: BERT : The input to the BERT model is the concatenation of the question and paragraph in the following format: [CLS] Question [SEP] Context [SEP] .

Original: The question and context tokens input to the BERT model are sub-words extracted by using BERT’s tokenizer.
Revised: The question and context tokens input to the BERT model are sub-words extracted by using BERT’s tokenizer.

Original: We separate the question and context representation from the output of BERT as Q and P , respectively.
Revised: We separate the question and context representation from the output of BERT as Q and P , respectively.

Original: We use ‘bert-base-uncased‘ model for all out experiments.
Revised: We use ‘bert-base-uncased‘ model for all out experiments.

Original: A. Q UESTION P ARSER D ECODER
Revised: A. Q UESTION P ARSER D ECODER

Original: The decoder for question parsing is a single-layer, 100 -dimensional, LSTM.
Revised: The decoder for question parsing is a single-layer, 100 -dimensional, LSTM.

Original: For each module, we use a 100 -dimensional embedding to present it as an action in the decoder’s input/output vocabulary.
Revised: For each module, we use a 100 -dimensional embedding to present it as an action in the decoder’s input/output vocabulary.

Original: The attention is computed as a dot-product between the decoder hidden-state and the encoders hidden states which is normalized using the softmax operation.
Revised: The attention is computed as a dot-product between the decoder hidden-state and the encoders hidden states which is normalized using the softmax operation.

Original: As the memory-state for the zero-eth time-step in the decoder, we use the last hidden-state of the question encoder GRU, or the [CLS] embedding for the BERT-based model.
Revised: As the memory-state for the zero-eth time-step in the decoder, we use the last hidden-state of the question encoder GRU, or the [CLS] embedding for the BERT-based model.

Original: We use a beam-size of 4 for the approximate maximum marginal likelihood objective.
Revised: We use a beam-size of 4 for the approximate maximum marginal likelihood objective.

Original: Optmization is performed using the Adam algorithm with a learning rate of 0 .
Revised: Optmization is performed using the Adam algorithm with a learning rate of 0 .

Original: 001 or using BERT’s optimizer with a learning rate of 1 e − 5 .
Revised: 001 or using BERT’s optimizer with a learning rate of 1 e − 5 .

Original: A. N UMBER AND D ATE P ARSING
Revised: A. N UMBER AND D ATE P ARSING

Original: We pre-process the paragraphs to extract the numbers and dates in them.
Revised: We pre-process the paragraphs to extract the numbers and dates in them.

Original: For numbers, we use a simple strategy where all tokens in the paragraph that can be parsed as a number are extracted.
Revised: For numbers, we use a simple strategy where all tokens in the paragraph that can be parsed as a number are extracted.

Original: For example, 200 in “ 200 women”.
Revised: For example, 200 in “ 200 women”.

Original: The total number of number-tokens in the paragraph is denoted by
Revised: The total number of number-tokens in the paragraph is denoted by

Original: N tokens .
Revised: N tokens .

Original: We do not normalize numbers based on their units and leave it for future work.
Revised: We do not normalize numbers based on their units and leave it for future work.

Original: To extract dates from the paragraph, we run the spaCy-NER 2 and collect all “DATE” mentions.
Revised: To extract dates from the paragraph, we run the spaCy-NER 3 and collect all “DATE” mentions.

Original: To normalize the date mentions we use an off-the-shelf date-parser 3 .
Revised: To normalize the date mentions we use an off-the-shelf date-parser 4 .

Original: For example, a date mention “19th
Revised: For example, a date mention “19th

Original: November, 1961” would be normalized to (19 , 11 , 1961) (day, month, year).
Revised: November, 1961” would be normalized to (19 , 11 , 1961) (day, month, year).

Original: The total number of date-tokens is denoted by D tokens
Revised: The total number of date-tokens is denoted by D tokens

Original: A. P RE - TRAINING C OUNT M ODULE
Revised: A. P RE - TRAINING C OUNT M ODULE

Original: As mentioned in the paper, training the count module is challenging and found that pre-training the parameters of the count module helps.
Revised: As mentioned in the paper, training the count module is challenging and found that pre-training the parameters of the count module helps.

Original: To re-iterate, the module gets as input a paragraph attention P ∈ R m .
Revised: To re-iterate, the module gets as input a paragraph attention P ∈ R m .

Original: The module ﬁrst scales the attention using the values [1 , 2 , 5 , 10] to convert it into a matrix P scaled ∈
Revised: The module ﬁrst scales the attention using the values [1 , 2 , 5 , 10] to convert it into a matrix P scaled ∈

Original: R m × 4 .
Revised: R m × 4 .

Original: A bidirectional-GRU then represents each token attention as a hidden vector h t .
Revised: A bidirectional-GRU then represents each token attention as a hidden vector h t .

Original: A single-layer feed-forward network maps this representation to a soft 0 / 1 score to indicate the presence of a span surrounding it.
Revised: A single-layer feed-forward network maps this representation to a soft 0 / 1 score to indicate the presence of a span surrounding it.

Original: These scores are summed to compute a count value, c v .
Revised: These scores are summed to compute a count value, c v .

Original: [Equation]
Revised: [Equation]

Original: We generate synthetic data to pre-train this module; each instance is a normalized-attention vector x = R m and a count value y ∈ [0 , 9] .
Revised: We generate synthetic data to pre-train this module; each instance is a normalized-attention vector x = R m and a count value y ∈ [0 , 9] .

Original: This is generated by sampling m uniformly between 200 − 600 , then sampling a count value y uniformly in [0 , 9] .
Revised: This is generated by sampling m uniformly between 200 − 600 , then sampling a count value y uniformly in [0 , 9] .

Original: We then sample y span-lengths between 5 −and also sample y non-overlapping span-positions in the attention vector x .
Revised: We then sample y span-lengths between 5 −and also sample y non-overlapping span-positions in the attention vector x .

Original: For all these y spans in x , we put a value of 1 . 0 and zeros everywhere else.
Revised: For all these y spans in x , we put a value of 1 . 0 and zeros everywhere else.

Original: We then add 0 -mean, 0 .
Revised: We then add 0 -mean, 0 .

Original: 01 -variance gaussian noise to all elements in x and normalize to make the normalized attention vector that can be input to the count module.
Revised: 01 -variance gaussian noise to all elements in x and normalize to make the normalized attention vector that can be input to the count module.

Original: We train the parameters of the count module using these generated instances using L 2 -loss between the true count value and the predicted c v .
Revised: We train the parameters of the count module using these generated instances using L 2 -loss between the true count value and the predicted c v .

Original: The countGRU in the count module (spanGRU – span module) is a 2 -layer, bi-directional GRU with input-dim = 4 and output-dim = 20 .
Revised: The countGRU in the count module (spanGRU – span module) is a 2 -layer, bi-directional GRU with input-dim = 4 and output-dim = 20 .

Original: The ﬁnal feed-forward comprises of a single-layer to map the output of the countGRU into a scalar score.
Revised: The ﬁnal feed-forward comprises of a single-layer to map the output of the countGRU into a scalar score.

Original: A. S PAN M ODULE
Revised: A. S PAN M ODULE

Original: The span module is implemented similar to the count module.
Revised: The span module is implemented similar to the count module.

Original: The input paragraph attention is ﬁrst scaled using [1 , 2 , 5 , 10] , then a bidirectional-GRU represents each attention as a hidden vector, and a single-layer feed-forward network maps this to 2 scores, for span start and end.
Revised: The input paragraph attention is ﬁrst scaled using [1 , 2 , 5 , 10] , then a bidirectional-GRU represents each attention as a hidden vector, and a single-layer feed-forward network maps this to 2 scores, for span start and end.

Original: A softmax operation on these scores gives the output probabilities.
Revised: A softmax operation on these scores gives the output probabilities.

Original: A. A UXILIARY Q UESTION P ARSE S UPERVISION
Revised: A. A UXILIARY Q UESTION P ARSE S UPERVISION

Original: For questions with parse supervision z ∗ , we decouple the marginal likelihood into two maximum likelihood objectives, p ( z ∗ | q ) and p ( y ∗ | z ∗ ) .
Revised: For questions with parse supervision z ∗ , we decouple the marginal likelihood into two maximum likelihood objectives, p ( z ∗ | q ) and p ( y ∗ | z ∗ ) .

Original: We also add a loss for the decoder to attend to the tokens in the question attention supervision when predicting the relevant modules.
Revised: We also add a loss for the decoder to attend to the tokens in the question attention supervision when predicting the relevant modules.

Original: The question attention supervision is provided as a mutli-hot vector α ∗ ∈ { 0 , 1 } n .
Revised: The question attention supervision is provided as a mutli-hot vector α ∗ ∈ { 0 , 1 } n .

Original: The loss against the predicted attention vector α is, Q loss = − (cid:80) ni
Revised: The loss against the predicted attention vector α is, Q loss = − (cid:80) ni

Original: =1 α ∗ i log α i .
Revised: =1 α ∗ i log α i .

Original: Since the predicted attention is a normalized distribution, the objective increases the sum of log-probabilities of the tokens in the supervision.
Revised: Since the predicted attention is a normalized distribution, the objective increases the sum of log-probabilities of the tokens in the supervision.

Original: The following patterns are used to extract the question parse supervision for the training data:
Revised: The following patterns are used to extract the question parse supervision for the training data:

Original: what happened ﬁrst SPAN1 or SPAN2? span(compare-date-lt(find(), find())) : with find attentions on SPAN1 and SPAN2, respectively.
Revised: what happened ﬁrst SPAN1 or SPAN2? span(compare-date-lt(find(), find())) : with find attentions on SPAN1 and SPAN2, respectively.

Original: Use compare-date-gt , if second instead of ﬁrst . 2.
Revised: Use compare-date-gt , if second instead of ﬁrst . 2.

Original: were there fewer SPAN1 or SPAN2?
Revised: were there fewer SPAN1 or SPAN2?

Original: span(compare-num-lt(find(), find())) : with find attentions on SPAN1 and SPAN2, respectively.
Revised: span(compare-num-lt(find(), find())) : with find attentions on SPAN1 and SPAN2, respectively.

Original: Use compare-num-gt , if more instead of fewer . 3.
Revised: Use compare-num-gt , if more instead of fewer . 3.

Original: how many yards was the longest { touchdown / ﬁeld goal } ?
Revised: how many yards was the longest { touchdown / ﬁeld goal } ?

Original: find-num(find-max-num(find())) : with find attention on touchdown / ﬁeld goal .
Revised: find-num(find-max-num(find())) : with find attention on touchdown / ﬁeld goal .

Original: For shortest , the find-min-num module is used.
Revised: For shortest , the find-min-num module is used.

Original: how many yards was the longest { touchdown / ﬁeld goal } SPAN ?
Revised: how many yards was the longest { touchdown / ﬁeld goal } SPAN ?

Original: find-num(find-max-num(filter(find()))) : with find attention on touchdown / ﬁeld goal and ﬁlter attention on all SPAN tokens.
Revised: find-num(find-max-num(filter(find()))) : with find attention on touchdown / ﬁeld goal and ﬁlter attention on all SPAN tokens.

Original: how many { ﬁeld goals, touchdowns, passes } were scored SPAN?
Revised: how many { ﬁeld goals, touchdowns, passes } were scored SPAN?

Original: count(filter(find
Revised: count(filter(find

Original: ())) : with find attention on { ﬁeld goals, touchdowns, passes } and filter attention on SPAN.
Revised: ())) : with find attention on { ﬁeld goals, touchdowns, passes } and filter attention on SPAN.

Original: who { kicked, caught, threw, scored } SPAN?
Revised: who { kicked, caught, threw, scored } SPAN?

Original: span(relocate(filter(find())))
Revised: span(relocate(filter(find())))

Original: : with relocate attention on { kicked, caught, threw, scored } , find attention on { touchdown / ﬁeld goal } , and filter attention on all other tokens in the SPAN.
Revised: : with relocate attention on { kicked, caught, threw, scored } , find attention on { touchdown / ﬁeld goal } , and filter attention on all other tokens in the SPAN.

Original: A. H EURISTIC I NTERMEDIATE M ODULE O UTPUT S UPERVISION
Revised: A. H EURISTIC I NTERMEDIATE M ODULE O UTPUT S UPERVISION

Original: As mentioned in Section 4.3, we heuristically ﬁnd supervision for the output of the find-num and find-date module for a subset of questions that already contain question program supervision.
Revised: As mentioned in Section 4.3, we heuristically ﬁnd supervision for the output of the find-num and find-date module for a subset of questions that already contain question program supervision.

Original: These are as follows:
Revised: These are as follows:

Original: how many yards was the longest/shortest { touchdown, ﬁeld goal } ?
Revised: how many yards was the longest/shortest { touchdown, ﬁeld goal } ?

Original: We ﬁnd all instances of touchdown/ﬁeld goal in the passage and assume that the number appearing closest should be an output of the find-num module.
Revised: We ﬁnd all instances of touchdown/ﬁeld goal in the passage and assume that the number appearing closest should be an output of the find-num module.

Original: what happened ﬁrst EVENT1 or EVENT2?
Revised: what happened ﬁrst EVENT1 or EVENT2?

Original: Similar to above, we perform fuzzy matching to ﬁnd the instance of EVENT1 and EVENT2 in the paragraph and assume that the closest dates should be the output of the two find 
Revised: Similar to above, we perform fuzzy matching to ﬁnd the instance of EVENT1 and EVENT2 in the paragraph and assume that the closest dates should be the output of the two find date module

Original: -date module

Original: calls made by the compare-date-lt module in the gold program.
Revised: calls made by the compare-date-lt module in the gold program.

Original: 3. were there fewer SPAN1 or SPAN2?
Revised: 3. were there fewer SPAN1 or SPAN2?

Original: This is exactly the same as previous for find-num module calls by compare-num-lt . 
Revised: This is exactly the same as previous for find-num module calls by compare-num-lt . A

Revised: [Figure]

Original: A.  E XAMPLE P REDICTIONS
Revised:  E XAMPLE P REDICTIONS

Original: In Figures 3, 4, 5, 6, 7 we show predictions by our model that shows the learned execution of various modules deﬁned in the paper.
Revised: In Figures 3, 4, 5, 6, 7 we show predictions by our model that shows the learned execution of various modules deﬁned in the paper.