Does Entity Abstraction Help Generative Transformers Reason?
Authors: Nicolas Gontier
Siva Reddy
Christopher Pal
Venue: ICLR 2022 Submitted (2022)
Keywords: Transformers
reasoning
compositional generalization
entity type
abstraction

Abstract: Pre-trained language models (LMs) often struggle to reason logically or generalize in a compositional fashion. Recent work suggests that incorporating external entity knowledge can improve language models' abilities to reason and generalize. However the effect of explicitly providing entity abstraction remains unclear, especially with recent studies suggesting that pre-trained models already encode some of that knowledge in their parameters. In this work, we study the utility of incorporating entity type abstractions into pre-trained Transformers and test these methods on three different NLP tasks requiring different forms of logical reasoning: (1) compositional language understanding with text-based relational reasoning (CLUTRR), (2) multi-hop question answering (HotpotQA), and (3) conversational question answering (CoQA). We propose and empirically explore three different ways to add such abstraction: (i) as additional input embeddings, (ii) as a separate sequence to encode, and (iii) as an auxiliary prediction task for the model. Overall our analysis demonstrate that models with abstract entity knowledge performs slightly better than without it. However, our experiments also show that the benefits strongly depend on the technique used and the task at hand. The best abstraction aware model achieved an overall accuracy of 88.8% compared to the baseline model achieving 62.3% on CLUTRR. In addition, abstraction-aware models showed improved compositional generalization in both interpolation and extrapolation settings. However, for HotpotQA and CoQA, we find that F1 scores improve by only 0.5% on average. Our results suggest that the benefits of explicit abstraction could be very significant in formally defined logical reasoning settings such as CLUTRR, but point to the notion that explicit abstraction is likely less beneficial for NLP tasks having less formal logical structure.

Under review as a conference paper at ICLR 2022
DOES ENTITY ABSTRACTION HELP GENERATIVE TRANSFORMERS REASON?
Anonymous authors Paper under double-blind review
ABSTRACT
Pre-trained language models (LMs) often struggle reason logically or general- ize in a compositional fashion. Recent work suggests that incorporating external entity knowledge can improve language models' abilities reason and general- ize. However the effect of explicitly providing entity abstraction remains unclear, especially with recent studies suggesting that pre-trained models already encode some of that knowledge in their parameters. In this work, we study the utility of incorporating entity type abstractions into pre-trained Transformers and test these methods four different NLP tasks requiring different forms of logical reasoning: (I) compositional language understanding with text-based relational reasoning (CLUTRR), (2) abductive reasoning (ProofWriter), (3) multi-hop ques- tion answering (HotpotQA), and (4) conversational question answering (CoQA). We propose and empirically explore three different ways add such abstraction: (i) as additional input embeddings, (ii) as a separate sequence to encode, and (iii) as an auxiliary prediction task for the model. Overall our analysis demonstrate that models with abstract entity knowledge performs better than without it. However, our experiments also show that the benefits strongly depend on the technique used and the task at hand. The best abstraction aware models achieved an overall accu- racy of 88.8% and 91.9 01.8% compared the baseline model achieving 62.3% and 89.8% on CLUTRR and ProofWriter respectively. In addition, abstraction-aware models showed improved compositional generalization in both interpolation and extrapolation settings. However, for HotpotQA and CoQA, find that F1 scores improve by only 0.5% on average. Our results suggest that the benefits of explicit abstraction is significant in formally defined logical reasoning settings such CLUTRR and Pritr, but point to the notion that explicit abstraction is less beneficial for NLP tasks having less formal logical structure.
INTRODUCTION
Transformer language models (TLMs; Vaswani al. (017)) have enabled rapid progress in natural language processing (NLP). When pre-trained on large corpora (such as the web) to predict the next of masked tokens from input sequence, TLMs
capture linguistic knowledge (Peters et al.) 2018 Goldberg 2019 Tenney et al. 2019b), and yield state-of-the-art performance on
tokens
many NLP tasks with little to no task supervision (Devlin et al. 2019 Radford et al. 2018 2019]]
Brown et al. 2020). However, it is not clear if these models can capture higher level knowledge such as reasoning skills that can be re-used in arbitrary contexts, and in ways that leverage the compositionality
of those skills (Lake & Baroni 2018 Liska et al. 2018), something logical reasoners can do relatively well on a smaller scale (De Raedt et al. Fieren et al. 2013). Simple compositional tasks such as SCAN (Lake & Baroni 2018), CLUTRR (Sinha et al. 2019). and ProofWritter (Clark et al. 2020) Tafjord al. 2020) can help diagnose the compositional generalization behavior of language models. Recent work on some of these datasets showed that TLMs still struggle to learn reasoning strategies that can be re-used in out-of training distribution settings (Lake Baroni 2018 Gontier et al. 2020).
If we look at how logical reasoners operate, we find that they have important abstraction component (going from grounded entities to higher level concepts) before logical reasoning can start (De Raedt al. 2007). Going from original text sequence its higher-order meaning important part of the NLP pipeline (part of it being entity type tagging). Similarly in mathematics, the introduction of generic variables allows to progress in logical reasoning process without keeping track of every

---

Under review as a conference paper at ICLR 2022
(grounded) atomic entity. Overall, this idea that call abstraction, seems to be important part of logical reasoning. Recent work suggests that incorporating external knowledge about grounded entities could improve language models' abilities to reason and generalize (Ji et al. 2017 Zhang et al., 2019 Moosavi et al., 2020, Rosset et al.] (020). However the empirical effect of incorporating generic entity types remains unclear, especially with recent studies suggesting that pre-trained models already encode some of that linguistic knowledge in their parameters (Hewitt & Manning 2019 Liu ct al. 2019a; Clark et al., 2019; Tenney et al., 2019a). In this work, we study the effect of explicitly providing entity type abstraction in addition to the original input to pre-trained Transformers.
We explore and evaluate different ways to incorporate entity type abstraction and observe that some methods are more efficient than others. To constructs the abstract representation incorporated into TLMs, we leverage symbolic NI.P representations such as entity type information given by popular NLP libraries. This allows for automatic and reproducible data processing. In general, our approach the following: given an input sequence, we build simplified version of by replacing entity names by their corresponding entity types. This simplified sequence can then be used extra input (Sections 3.1 & 3.2 or as extra training signal to the model (Sections 3.3 In particular, we explore three different ways to augment pre-traine pre-trained Transformers with this abstract knowledge:
1. by combining token embeddings from both the original and the abstract sequence before encoding (Section 3.1 (Figure a & [[p..
2. by encoding both the original and the abstract sequence and combining them before decoding the target output (Section 3.2 (Figure D & [.)..
3. by adding second language model head on top of the Transformer decoder to predict the abstract sequence (Section 3.3 (Figure [+).
A series of controlled experiments on two synthetic datasets show that models having access to abstract knowledge about entity types yield better performance at inference time both when interpolating and extrapolating to unseen lengths of reasoning chains. Synthetic data is used in order to control for the degree of compositional generalization required. Furthermore, in order understand if the benefits observed in the synthetic cases are applicable in more realistic settings, we ran a series of experiments on two question answering datasets requiring various degrees of multi-hop reasoning. Unfortunately, results on these more natural language datasets show that abstraction aware models are not significantly better than baseline models.
Overall our work contributions are the following:
we introduce and compare empirically different ways to incorporate abstraction into pre-trained TLMs.
2. we show that incorporating abstract knowledge can significantly improve reasoning and composi- tional generalization in both interpolation and extrapolation when the environment is formally defined in a logical reasoning setting.
3. show that abstraction aware models may not benefit much when language is more natural and less procedural.
We hope that our work will inspire future research in the field look for simple inductive biases that can complement pre-trained models in their quest to achieve logical reasoning at scale.
RELATED WORK
Augmenting neural language models with knowledge about entities has been a popular method to improve their functionality. Ji et al. (2017) trained an entity neural language model to predict sequences of entities with an LSTM (Hochreiter & Schmidhuber, 1997). At each sampling step, they predict the next word alongside a categorical variable indicating the current token's 's entity ID. They obtained lower perplexity and better results on co-reference resolution and entity prediction tasks than a variety of baselines. Similarly, |oosett et al. (2020) trained a GPT2 model (Radford et al.) 2019) by giving it access to entity knowledge at the input level and as additional pre-training loss. Their model achieved better factual correctness on benchmarks such as LAMA (Petroni et al. 2019). and performed better than baseline GPT2 model in various question answering tasks. Inspired by this work and motivated by the goal of building better reasoning language models, we instead focus on the prediction of entity types rather than entity identifiers taken from fixed list of entities. This
2

---

Under review as a conference paper at ICLR 2022
allows our solution to be robust to new entities. In addition, explore and compare different ways to incorporate the entity knowledge in an encoder-decoder architecture.
Besides entity knowledge, other types of explicit information has also been given to Transformer models. Levine et al. (2019) trained a BERT-like model to learn word senses. They gave their model access to WordNet supersenses at the input level and an additional training loss. They achieve better performance than other baselines on the SemEval Word Sense Disambiguation task (Raganato al. 2017). In addition, Moosavi et al. (2200) propose improve robustness data biases by structures. They train a BERT-base model (Devlin et al., 2019) with PropBank-style semantic role labeling (Shi & Lin 2019) on MultiNLI (Williams et al.) (017)) and SWAG (Zellers et al. (018)) datasets. Their results show that incorporating predicate- arggumet structure in the input sequence (only during training) makes the model more robust to adversarial examples in MultiNLI. Furthermore, |Sachan et al. (2020) ask if syntax trees can help Transformers to better extract information. They augmented a pre-trained BERT model with syntax graph neural network in order to encode syntaxt trees and measure the performance of their model against a BERT model on various tasks. Their results showed that the quality of the trees highly tied to the performance boost observed. More recently, Porada et al. (2021) extended RoBERTa model (Liu et al., 2019b) with hypernym abstraction based on Word et to evaluate the plausibility of events. Their model is able to better predict human plausibility judgement than other RoBERTa baselines. Although different in application, all these prior works leverage the general idea of explicitly giving more abstract knowledge to Transformer models, hence showing how flexible and generic this strategy can be. We take a similar approach with entity types, but in the hope of improving the reasoning skills of our baseline model.
augmenting the training data with predicate-argumenn
A flurry of recent work has also examined ways to augment TLMs with entities from external knowledge bases (Zhang et al., 2019; Peters et al. 2019 Févry al., 2020) Verga et al., 2020). However, most of the time, these solutions rely on external components such as knowledge graphs with pre-trained entity embeddings, and/or an additional memory. While they often use entity linking as way to perform co-reference resolution, they do not incorporate higher level of abstractions such as entity types like we do here.
3 INTRODUCING ABSTRACTION INDUCTIVE BIASES
In this section we describe five different ways to incorporate abstraction into a pre-trained encoder- decoder model. Given an input sequence X, we use existing NLP tools such spacy named entity tagger to make a simplified copy X, of the input. This is a more generic copy of X.
We run the spacy recognizer on X to extract entity tags such as PERSON, ORG, GPE, etc... For each entity type, we create n additional vocabulary entries (with randomly initialized embeddings) such as [PERSON_1, ... PERSON_n, ORG_1, ORG_n. Every token in X is then replaced by their (randomly numbered) entity tag to make the simplified sequence Xg. If the same entity is present multiple times in X, each occurrence will be replaced by the same entity tag in X,. If no entity is found for a token in X, the original token's 's text is kept in X, (e.g. "Bob Smith has a cat that he loves. Bob also loves Alexandra." " would be transformed into "PERSON 11 has a cat that he loves. PERSON_I also loves PERSON DE."".
The hyper-parameter n is set such that each distinct entity within the same sequence gets a different ID. If the same entity appears more than once in a single example, it will get the same ID every time within that sequence. However, we re-use the same set of entity tags across different examples. The value of n depends on each dataset, details can be seen in Appendix A Although this may look similar to attributing different entity IDs to each entity regardless of their type, we believe that after seeing many examples, all IDs of the same type will have a similar embedding since we randomly select such ID across examples and across epochs. The number of overlapping entity tags across the entire dataset during many epochs will be large, resulting in pushing the embedding of same-type entity tokens closer together.
To test the effect of having multiple tags for the same entity type, we also ran experiments in which we set n = thus forcing overlapping entity tags within each example. However we didn't 't notice any concluding difference, so the rest of this work will focus on the n > 1 setting described above.
hutp:///pacciioomoodeeeee
3

---

Under review as a conference paper at ICLR 2022
RWC
2BC
Y
X,
DBC
(a) emb sum architecture
(b)
cat architecture
X
ENG
77
ENC
DRC
H,
DBC
ENC
H,
X
(c) enc sum architecture
(d) enc cat architecture
W
y
ENC
D5C
Wab
(c) dec loss architecture
Table Different architectures different abstraction strategies. (blue) is original sequence embedding. X, (green) is the embedding of the simplified sequence with entities replaced by their entity type tags, "ENC" the T5 encoder, H (blue) is the contextualized representation of sequence X, H, (green) is the contextualized representation of sequence X., "DEC" is the T5 decoder, and Y is the target sequence predict.
In the following subsections, we describe different strategies to incorporate X, into an encoder- decoder Transformer model.
3.1 ABSTRACTION AS ADDITIONAL EMBEDDING
Our first strategy is to combine X, with X at the embedding level. To do that, we construct X, to be of the same length of X. If a spacy entity spans over multiple tokens (e.g. ["Alex", "anddra, "Smith" "is", "the", "wife", "of", "Bob"I), we copy its entity tag each sub-token positions (e.g. ["PERSON 23", "PERSON "PERSON 23", "is", "the", "wife", "of", "PERSON.II"D, For each token within both sequences either sum (emb- sum experiments) concatenate (emb-cat experiments) their respective token embeddings.
sum. In emb sum experiments (Figure Th). if tokens do not have entity tags associated with them, we ignore their embedding to avoid summing the same embedding twice for non-entity tokens. We only sum embeddings of tokens that do have abstract tag associated with them. This is to ensure that we only modify pre-trained embeddings that correspond to entity tokens. This is done by masking out the tokens in X, that the same in X. The input given the model's encoder is then emb(X) + mask x emb(Xx)) + positional with emb() being the embedding matrix, mask defined as the X * X, binary tensor, and positional being the regular Transformer positional embedding. This resembles the setting used by Rosset et al. (2020), however their knowledge-ane comes from sequence of entities from dictionary lookup, rather than sequence of entity types from pre-trained tagger. The advantage of our method is that it is robust to unseen entities of the same type.
embedding
concat. In emb-cat experiments (Figure[)), if tokens do not have entity tag associated with them, we replace their embedding with generic (learnable) "<grounded>" token embedding. This ensures that all non-entity token embeddings gets modified in the same way compared to entity tokens. We eventually resize the concatenated embeddings with a learnable matrix W1 e Rlexe with being the model's embedding size. The input given the model's encoder is then (emb(X), X); emb( concatenation operator, and positional being the regular Transformer positional embedding. this setup the model has 2e + e more parameters.
W, + positional with emb() being the embedding matrix,
[:] defined as the
3.2 ABSTRACTION AS AN ADDITIONAL SEQUENCE TO ENCODE
Our second strategy is to combine X. with at the encoding level. To do that, we again construct X, to be of the same length of X. Similarly as above, if a spacy entity spans over multiple tokens, we copy its entity tag at each sub-token positions. We then encode both X and X, with the same encoder weights to have two contextualized encodings: H and H, respectively. For each token within both sequences we either sum senc-sum experiments) or concatenate (enc-cat experiments) their respective contextualized encodings.
4

---

Under review as a conference paper at ICLR 2022
sum. For enc-sum experiments (Figure [t], the input given to the model's decoder becomes H Hg Unlike in Section 3.I in these experiments we do not mask any position because the encodings contextualized over the entire sequence. All token representations were influenced by all other tokens because of the Transformer encoder attention mask. Thus even non-entity token representations were influenced by entity tokens.
concat. For enc-cat experiments (Figure I we introduce a learnable matrix W2 E R2dxd with d being the model's encoding size in order to resize the concatenated encodings, similarly to Section 3.1 The input given to the model's 's decoder is then [H; H.] W2 with [; defined as the concatenation operator. In this setup the model has 2d more parameters.
3.3 ABSTRACTION AS AN AUXILIARY TASK
Our third strategy is to incorporate X, into the model with an additional cross entropy loss (dec-loss experiments). The model will now be tasked to predict both the target output Y as well as the abstracted input X,. To do that, we introduce a second language model head W E 12dx (with d' being the model's 's decoder size) on top of the model's decoder, initialized to have the same weights than the original language model head Wim, and fine-tuned during training. We then apply a softmax on the predicted logits before measuring the cross entropy loss between the predicted probability distribution and X,. The final model's loss is then the average between the cross entropy losses:
0.5 CE(X,; softmax(HHee Wans)) + 0.5 * CE(Y, softmax WWim),;
with CE() being the cross entropy loss and Hdee being the output tensor of the model's decoder. By sharing the decoder weights (except for the additional language model head), we make sure that most of the network parameters are influenced by the additional cross-entropy loss. This acts as regularizer and forces the model to "know" about entity types within its original parameters. this setup, the model has d vocab more parameters. Figure le illustrates this strategy.
4 EXPERIMENTS
In this section we describe the experiments we ran on various datasets. We start with the CLUTRR benchmark (Sinha al., 2019) in Section 4.1 as controlled experiments in which we know how much compositional generalisation is required. We then test our models on the ProofWriter (Clark et al. 2020: Taijord al., 2020) dataset in Section 4.2 This allows to verify entity type abstraction beneficial in formally defined logical reasoning environments with simple language. We next report experiments on the multi-hop question answering task HotpotQA (Yang et al., 2018) Section 4.3 This allows to test if entity type abstraction is beneficial in two-hop question answering settings with more natural language which is by nature more noisy. Eventually, we also report results on the conversational question answering task CoQA (Reddy et al. 2019) in Section 4.4 This allows to test entity type abstraction is beneficial conversational settings in which the entity being discussed may be originally introduced much earlier in the conversation, thus requiring some entity linking before answering.
For all experiments we trained one model for each of the 5 different strategies presented in Section in addition to a baseline model fine-tuned without any abstraction knowledge. We used the A1 enNLP library (Gardner et al. 2017) with the HuggingFace rran formers library (Wolf et al. 2019) Py Torch implementation of T5- small 1 with 16-bit floating point precision. Each experiment was run on tesla V100 32gb GPUs with early stopping and a patience of 10 epochs on the validation set (defined as a 10% split of the training set). We report all parammeerseeeess and library versions in Appendix A for reproducibility purposes.
4.1 COMPOSITIONAL GENERALIZATION WITH CLUTRR
Although synthetic, CLUTRR is used because it allows for controlled experiments in which we can clearly measure both interpolation and extrapolation performance our model. We generated 390, 000 examples that were roughly split 70/30 between training and testing. Each example consists of a unique (non-cyclic) family graph. The goal of this task is to infer the type of edge (family relation) between two nodes (two entities) that are the further apart in the input graph. The bigger the
5

---

Under review as a conference paper at ICLR 2022
CLUTRR
2
3
6
7
8
10
avg.
no abstraction
100%
84.4%
64.8%
61.5%
54.2%
56.6%
45.5%
42.6%
56.8%
62.9%
emb-sum
100%
85.3%
74.6%
59.3%
64.3%
67.7%
65.1%
58.9%
68. 68.4%
71.5%
emb-cat
94.6%
60.0%
35.6%
42.0%
40.2%
74.3%
78.2%
77.9%
80.6
64.8%
enc-sum
100
94.8%
86.9%
89.9%
85.6%
87.2%
85.1 %
84.3%
85.5%
88.8%
enc-cat
100%
86.1%
72.6%
70.2%
66.7% 66.7%
69.1%
63.8%
61.9%
74.0%
73.8%
dec-loss
100%
74.7%
64.9%
59.3%
56.2%
61.3%
52.8%
47.8%
61.3%
64.2%
Table 2: Prediction accuracy on CLUTRR test set for all difficulty levels. Models have been trained on levels 2. 4, 6 with only 9.58% of all the (el,rel, e2) triples present in the test set. Per-level performance is colored in shades of green for better visualisation.
graph, the more hops are required to infer the missing edge. We express each family graph, along with its question and answer in text using a simple "/e_!] is the [rel] of [e_2|" template. Some examples of input/output sequence pairs can be seen in Appendix B
We evaluate the generated answer accuracy. The answer defined as the first sentence in the generated sequence. Since all answers during training were expressed using simple template, we inverse this template extract the rél, ē2) triple from the generated answer. If the extraction fails, we consider the generated answer wrong. We then compare the extracted triple to the ground truth provided by the CLUTRR dataset. If the reference solution is (el, rel, e2), we accept both rel, e2) and (e2, inv_rel, el) as valid solutions, with inv_rel being the inverse relation of rel. For instance, the inverse relation "father" can be "son" or "daughter", we accept both.
4.1.1 TESTING COMPOSITIONAL GENERALIZATION
We carefully divided train and test sets to force the model to generalize to both unseen graph sizes (Le.: unseen reasoning depth) and unseen (el, rel, e2) triples. Specifically, the training set is made of graphs with 2, 4 and 6 relations between 3, 5 and entities respectively, while the test set is made of graphs with up 10 relations between 11 entities. In addition, all possible entities and relations are seen during training but only 9.58% of (e1, rel, c2) triples from the test set are also in the training set. This small overlap makes the test set harder than originally designed and allows to analyse the compositional generalization capacity of our model.
We fine-tuned T5-ama 1 model 300, 000 training examples of levels 2, 4 and 6 and evaluate the model on a test set of 10, 000 examples for all levels from 2 to 10. The level is defined as the number of edges (relations) in the graph. The higher the level is, the bigger the graph is, the further apart the two entities to link are, and the greater the number of hops required to answer the query is. Specifically, we test levels 2, 4 and for compositional generalization, levels and 5 for interpolation, and levels 7, 8, 9 and 10 for extrapolation.
4.1.2 RESULTS
Table 2 shows answer accuracy on each test set level for models trained with n 20 tokens per entity type. As mentioned in Section 3 this helps keeping track of "who's who" in the abstracted sequence, which is important for solving task such as CLUTRR. We see that the best model (enc um) strongly outperforms all other models with an average score of 88.8% compared to 62.9% for the baseline.
sum -vs- concatenation. We can see that for both the embedding strategies (emb-cat & sub and the encoding strategies (enc-cat & enc-sum), summing representations together yields better performance than feeding their concatenation through a linear layer. One hypothesis that modified by either entity type token
in the emb cat model, all pre-trained embeddings embedding or the "<grounded>" embedding, whereas the emb- sum model keeps most of its pre- trained embeddings unchanged. This result also suggests that sometimes, simpler methods are more effective.
embedding encoding. From Table 2 we also that, average, processing the abstract sequence through the encoder yields better performance than only processing it through the token embedder. This is expected more layers of the Transformer can process the abstracted sequence.

---

Under review as a conference paper at ICLR 2022
RoBEkTaalarge Clark al. 2020
ProolWriter
no abstraction OWA
emb-sum OWA
emb-cat OWA
enc-sum OWA
ene-cat OWA
dec-loss
OWA
CWA
Overall
83.9%
89.8%
90.9%
90.9%
88.4%
90.1%
91.8%
DO
100.0%
99.5%
99.2%
99.5%
98.9%
99.2
99.4 4%
D1
98.8%
95.6%
93.5%
95.3%
89.5%
91.8%
95.1%
98.8%
87.9%
81.0%
87.1%
75.3%
83.5%
86.6%
D3
71.1%
83.7%
84.6%
85.9%
81.7%
85.2%
87.4% %
D4
43.4%
77.3%
87.4%
82,
84.7%
84.1%
85 85.0%
D5
37.2%
70.0%
85.3%
74.8%
84.0%
79.6%
80.6%
Table 3: Prediction accuracy on different slices of the ProofWriter D5 set for all our models and the originally reported numbers by CClrk et al. (2020). Models have been trained on depth DO, DI, D2. Models are trained the "open-world" assumption (OWA), except for the original Clark ct al. (2020) model which was trained in the "closed-world" assumption (CWA). Per-depth performance colored in shades of green for better visualisation. The red boxed indicates problems at depths unseen during training.
learning the abstraction. In the last line of Table 2 the abstraction is given output to the model. This experiment tests if learning how abstract along- the original task helps the model. We can see that learning to predict the abstract sequence can indeed help generalize as the average score increases from 62.9% for the baseline to 64.2% for the dec-l loss model. However is not the most effective method in this case.
Overall, we can see that abstraction- models can all extrapolate better than the baseline model, suggesting that entity abstraction does help pre-trained Transformers to compositionally generalize. To verify that this is not just a feature of the CLUTRR dataset, we perform the same analysis on another synthetic dataset in the next section.
4.2 ABDUCTIVE REASONING WITH PROOFWRITER
Similarly to CLUTRR, the ProofWriter dataset TTfjordd et al. 2020) is collection of synthetic facts and rules with derived conclusions. The goal this task is to infer the truth value of an unknown statement given series of known facts and 1 1-hop inference rules. Each example is made of different set of facts, rules, and an unknown statement. The model then has to predict the unknown statement "True", "False", "Unknown" according to the input knowledge. Each fact and rule is expressed in simple templated language given by a grammar. Some examples of input/output pairs can be seen in Appendix B
The dataset also provides the required chain of inference required to arrive at the final answer. The number of such 1-hop inference steps is considered the "depth" of the example. For instance depth-0 (DO) example simply requires to see if the unknown statement is present in the input list of fact or not; a depth-1 (D1) example requires apply one inference rule one fact arrive at the answer, etc... The dataset contains examples of up to depth-5 (D5) inference chains. We test for compositional generalisation by training on examples of up depth 2 reasoning chains (DO, D1, D2) and testing on examples for each depth from DO to D5.
We fine-tuned T5-smal1 models on the official training and development set from the depth <= data folder and tested it on the test set from the depth <= 5 data folder; consisting of 70,076 training examples and 20,030 testing examples. We trained one model for each of the different strategies presented in Section in addition to bascline model fine-tuned without any abstraction knowledge. Unlike in all other experiments, for ProofWriter examples, we did not use the generie spacy named entity tagger because it did not support the entity types covered by ProofWriter examples. Instead, used the real abstraction labels provided by the grammar files and defined the following abstraction tokens: "PERSON". "ATTRIBUTE", "ANIMAL". "RELATION".
Table shows the prediction accuracy on different slices of the D5 test set for all our models. older version of the dataset ("closed-world" assumption CWA), also report the original performance by Clark et al. (020).. While not directly comparable because of the different version of the dataset, we can still see that our 7m5lmmall experiments all extrapolate
Although trained
(D3-D5) better than the original RoBERTa large model. However RoBERTa- aaaERTa--arge performs
hwtp://ggmiikooomiiiiaitiiiiiiie and config/grammars
7

---

Under review as a conference paper at ICLR 2022
HOTPOTQA
CoQA
EM
FI
Prec
Rec
EM
FT
no abstraction
53.2%
67.4%
70.9%
67.6%
66.0%
74.4%
emb-sum
52.9%
67.2%
70.7%
67.4%
65.7%
74.1% %
emb-cat 50.9%
64.9%
68.2%
65.3%
63.9%
72.4%
enc-sum 53.1%
67.3%
70.8%
67.5%
65.8%
73.9%
enc-cat
51.5%
65.8%
69.6%
65.8%
65.1%
73.7%
dec-loss
53.7%
68.1%
71.7% %
68.2%
66.4%
74.8%
Table 4: Test results for all models. (left) Exact Match, F1, Precision and Recall on HotpotQA. (right) Exact Match and Fl CoQA.
better at depths seen during training, which may be due to the model size being bigger, hence having greater capacity to model questions of previously
depths.
Most importantly, if we compare with our "no abstraction" baseline model, Table shows that our abstraction methods help extrapolate to unseen reasoning depths. While our baseline model performs 83.7%, 77.3%, and 70% on examples from D3, D4, DS respectively; all other abstraction-aware models extrapolate better, with the best overall model (dec-loss) performing 87.4%, 85%, and 80.6% respectively on D3, D4, DS examples.
Overall, we achieve new state-of-the-arr results on the ProofWriter dataset when trained only on examples from DO-D2. This is suggesting that entity abstraction does help pre-trained Transformers to compositionally generalize to unseen reasoning chains. One important thing to note however is that both CLUTRR and ProofWriter sentences 94% CLUTRR entities were correctly labeled as PERSON by spacy entity tagger, and 100% of ProofWriter entities correctly abstracted since used the golden grammar). In the next sections we will analyse what happens on more realistic data.
relatively simple abstract (we found that
4.3 MULTI-HOP QUESTION ANSWERING WITH HOTPOTQA
In this section we report experiments on the multi-hop question answering (HotpotQA) dataset (Yang al.] 2018). HotpotQA contains natural language, making more diverse and harder to get abstraction labels than CLUTRR. In addition, HotpotQA has 2-hop inference chains both in its training and testing data splits. While not as "reasoning intensive" as CLUTRRR or ProofWriter, still good compromise between natural language and multi-hop reasoning.
Used in the distractor setting, each example consists of a list of 10 Wikipedia paragraphs, a ques- tion that requires the model to combine information from two paragraphs, and the answer. Since concatenating all of the 10 paragraphs would result in a context size much larger than what regular Transformer models allowed (512 1024 tokens), instead only took the golden paragraphs as context, plus the question. While this beats the original purpose of retrieving the useful paragraphs, interested in achieving state-of-the it to compare the usefulness of our approach on a more natural multi-hop question-answering answering setup. An example of input/output sequence pair can be seen in Appendix B
this benchmark. We rather interested in using
Because the official test set is not public, we used the official validation set as our test set to compare our models and fine-tuned 75-small model on 90% of the training while keeping the remaining 10% as our custom validation set for early stopping. We trained one model for each of the 5 different strategies presented in Section in addition baseline model fine-tuned without any abstraction knowledge.
Table 4 (left) shows exact match (EM), scores, Precision and Recall on our test set. We can see from these results that the best model is the abstraction- aware dec-loss model (trained to predict both the answer and the input in its abstract form) with an Fl score of 68.1% 1% against 67.4% for the baseline model. However, the baseline model is strong candidate and the abstraction does not always benefit the model depending on how it is incorporated. This may be due to the fact that entity abstraction labels harder predict and that entity type abstraction may not be required for some examples. Eventually, we find that emb - cat is the least performing model and enc- sum one of the better performing abstraction-aue model (after dec-1 1 oss in this case).
8

---

Under review as a conference paper at ICLR 2022
4.4 CONVERSATIONAL QUESTION ANSWERING WITH COQA
Eventually, motivated by the use of generative model, test the same abstraction strategy in conversational setting. For that, we leveraged the conversational question answering dataset CoQA (Reddy et al., 2019). The task presented by this dataset is to understand text passage and answer series of inter-connected questions in a conversation. The conversation aspect introduces follow-up questions that forces the model to keep track of what entity is currently being referred to and to look back at previous interactions. Examples of input/output sequence pairs can be found in Appendix B The dataset does not always explicitly forces multi-hop reasoning steps, but it could still happen (i.e. see the last CoQA example of Appendix [Bin which the model must perform a substraction between all subjects and the ones already mentioned). In addition, the conversational nature of this dataset often introduces co-reference step to be made before fetching the information from the paragraph in context. In this setting we will thus test if abstraction can help in this multi-step information retrieval procedure.
Similarly to HotpoiQA, because the official test set is not public, we used the official validation set as our test set to compare models and fine-tuned mm5small model on 90% of the training set while keeping the remaining 10% as our custom validation set for early stopping. We trained one model for each of the 5 different strategies presented in Section 3 in addition to a baseline model fine-tuned without any abstraction knowledge.
Table 4 (right) shows the exact match (EM) and F1 score we can see that the best model is again the abstraction aware dec- loss model (trained to predict both the answer and the input in its abstract form) with an Fl score of 74.8% against 74.4% for the baseline. The baseline model is quite strong already and the benefit of abstraction is questionable in this case. As in previous experiments, the worst performing model is emb cmb- cat and one of the best is the enc- s um model (after dec-loss in this case).
test Although by a small margin,
DISCUSSION AND FUTURE WORK
We presented various ways to incorporate abstract knowledge into Transformer Language Models. Focusing entity types, this work evaluated model performance reasoning tasks requiring compositional generalization and multi-hop reasoning.
Overall our results demonstrate three things: (i) incorporating abstract knowledge can significantly improve reasoning and compositional generalization in both interpolation and extrapolation when the environment is formally defined in logical reasoning setting: (ii) different ways incorporate abstraction can yield different performance boosts: enc-sum and dec- loss are generally per- forming better than others; (iii) abstraction aware models may not benefit much when language is more natural and less procedural. This last result suggest that the amount of information provided by off-the-shed entity recognizers are already captured by pre-trained weights of Transformers. However, the fact that abstraction labels greatly improve generalization in CLUTRR and ProofWriter experiments show that in order for pre-trained models to benefit from abstraction, the sequences must be easy to abstract and the task must have formal logical structure.
Limitations. Along with the fact that abstraction may not help in more realistic data, another limitation of our work is that the method we present requires more annotated data, which is not always available. Furthermore, this additional data processing can take time and may not scale well to larger datasets if implemented naively.
Future Explorations. One hypothesis that results from our work is the following question: could pre-training Transformer models with additional abstraction data result in stronger performance when fine-tumed with abstraction data like we do in this work? Although we could not train from-scratch a T5 model on its original C4 dataset (Raffel al. 2020), we believe that augmenting C4 with abstract annotations like we do on a smaller scale and training T5 from scratch on this augmented dataset could potentially yield a stronger language model.

---

Under review as a conference paper at ICLR 2022
ETHICAL CONCERNS
Previous work showed that pre-trained language models can have some undesired societal biases (Henderson et al. 2018 Shwartz et al. 2020 Bender et al., (021). Although not explored in this work, we believe that giving abstract entity types like we do in this work could have a positive societal impact on language models, potentially alleviating some of these biases. For instance, through abstraction, model can be exposed to both female and male names both being "PERSON"S and that a "PERSON" can equally be a "manager" or an "assistant" regardless its gender. Similar exposure could be achieved with other abstraction types such as "RELIGION", "JOB", "COUNTRY", "NATIONALITY"" etc... One potential future direction for this work could be to measure the impact explicit abstraction can have benchmarks such as StereoSet (Nadeem al. 2020
REFERENCES
Emily M Bender, Timnit Gebru, Angelina McMillan-Major and Shmargaret Shmitchell, On the dangers of stochastic parrots: Can language models be too big? In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, pp. 610-623, 2021.
Tom B Brown, Benjamin Mann, Nick Ryder, Melanic Subbiah, Jared Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005. 14165, 2020.
Kevin Clark, Urvashi Khandelwal, Omer Levy, and Christopher D Manning. What does bert look at? 2019.
an analysis of bert's attention. arXiv preprint
Peter Clark, Oyvind Tafjord, and Kyle Richardson. Transformers as soft reasoners over language. In Christian Bessiere (ed.), Proceedings of the Twenty-Ninth International Joint Conference Artificial Intelligence, IJCAI-20, pp. 3882-3890. International Joint Conferences on Artificial Intelligence Organization, 7 2020. doi: 10. 10.24963/jjca.222200
URL https::/dooi org/
10. N8.224963/2 2t.24493//1caii1220/33333
Main track.
Lue De Raedt, Angelika Kimmig, and Hannu Toivonen. Problog: probabilistic prolog and its application in link discovery. In Proceedings of the Twentieth International Joint Conference on Artificial Intelligence, IJCAI-07, pp. 1462-2467. International Joint Conferences on Artificial Intelligence Organization, 2007.
Jacob Devlin, Ming- Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics, pp. 4171- 4186, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10. 10.18653/v1/N199 1423. URL htLhhttss:// www. a wtt.eb..rg///o www.ww...../.ttooooeee..oo http//annhooooggyllll1la
Thibault Févry, Livio Baldini Soares, Nicholas FitzGerald, Eunsol Choi, and Tom Kwiatkowski. En tities as experts: Sparse memory access with entity supervision. arXiv preprint arXiv:2004.07202, 2020.
Daan Fierens, Guy Van den Broeck, Joris Renkens, Dimitar Shterionov, Bernd Gutmann, Ingo Thon, Gerda Janssens, and Luc De Raedt. Inference and learning in probabilistic logic programs using weighted boolean formulas. Theory and Practice of Logic Programming, 15(3):358 401, 2015.
Matt Gardner, Joel Grus, Mark Neumann, Oyvind Tafjord, Pradeep Dasigi, Nelson F. Liu, Matthew Peters, Michael Schmitz, and Luke S. Zettlemoyer. Allennlp: deep semantic natural language processing platform. 2017.
Yoav Goldberg. Assessing bert's syntactic abilities. arXiv preprint arXiv: 2019.
Nicolas Gontier, Koustuy Sinha, Siva Reddy, and Christopher Pal. Measuring systematic generaliza- tion in neural proof generation with transformers. In Advances in Neural Information Processing Systems 33, Curran Associates, Inc., 2020. URL http:/tp//axxv..oo/p/pp///////// http:///awa.a...//////////... fddf
10

---

Under review as a conference paper at ICLR 2022
Peter Henderson, Koustuv Sinha, Nicolas Angelard-Gontin Nan Rosemary Ke, Genevieve Fried, Ryan Lowe, and Joelle Pineau. Ethical challenges in data-driven dialogue systems. In Proceedings of the 2018 AAAI/ACM Conference AI, Ethics, and Society, pp. 123-129, 2018.
John Hewitt and Christopher D. Manning. A structural probe for finding syntax in word representa- tions. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume I (Long and Short Papers), pp. 4129 4138, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10118633/1/N199
URL httpt:tts////caaatttt http::://aaaaaahlloolseo wrt.l//yy..///111//1/09 1419
Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9()): 1735-17880 1997.
Yangfeng Ji, Chenhao Tan, Sebastian Martschat, Yejin Choi, and Noah A Smith. Dynamic entity 2017.
representations in neural language models. arXiv preprint
Brenden M. Lake and Marco Baroni. Generalization without systematicity: On the compositional skills of sequence-to-seqqeenee recurrent networks. ICML, pp. 2879-2888, 2018. URL h
//proceedings..o www.ssssm...ppr....mmm......... /v00ssss/vv/llll 8a. html
Yoav Levine, Barak Lenz, Or Dagan, Ori Ram, Dan Padnos, Or Sharir, Shai Shalev-Shwartz, Amnon Shashua, and Yoav Shoham. Sensebert: Driving some sense into bert. arXiv preprint 19Xiv:/908.00644: 2019.
Adam Liška, Germán Kruszewski, and Marco Baroni. Memorize or generalize? searching for compositional mnn in a haystack. arXiv preprint arXiv:1802.06467, 2018.
Nelson Liu, Matt Gardner, Yonatan Belinkov, Matthew E Peters, and Noah A Smith. Linguistic knowledge and transferability of contextual representations. arXiv preprint arXiv: arXiv:1903.08855 2019a.
Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach. arXiv preprint arXiv: 1907.1 1 16692, 2019b.
Nafise Sadat Moosavi, Marcel de Boer, Prasetya Ajie Utama, and Iryna Gurevych. Improving robustness by augmenting training sentences with predicate-argument structures. arXiv preprint wrXiv:2010.12510, 2020.
Moin Nadeem, Anna Bethke, and Siva Reddy. StereoSet: Measuring stereotypical bias in pretrained language models. ArXiv, abs/2004.09456, 2020.
Matthew Peters, Mark Neumann, Luke Zettlemoyer, and Wen-tau Yih. Dissecting contextual word embeddings: Architecture and repressentatin. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 1499-1509, Brussels, Belgium, October- November 2018 Association for Computational Linguistics. doi: 1/D8 URI.
https: www ac www.wwwwwwb...................ww wwt.c/ew.........eeeeeeoeo www.oorg//aata wttp://annoogg/gggee-e-ea-- ogt
Matthew E Peters. Mark Neumann, Robert L Logan IV, Roy Schwartz, Vidur Joshi, Sameer Singh, and Noah A Smith. Knowledge enhanced contextual word representations. arXiv preprint 1rXiv:1909.04164 2019.
Fabio Petroni, Tim Rocktäschel, Sebastian Riedel, Patrick Lewis, Anton Bakhtin, Yuxiang Wu, and Alexander Miller. Language models as knowledge bases? In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP), pp. 2463-2473, Hong Kong, China, November 2019, Association for Computational Linguisties. doi: 10.186533v1/D19-12250
URL wtwpthtts///c.... www a c greb.org www.ww/.w.....ooooooooooooooo/e. antho 9-100/999111110000000
Ian Porada, Kaheer Suleman, Adam Trischler, and Jackie Chi Kit Cheung. Modeling event plausibility with consistent conceptual abstraction. arXiv e-prints, pp. arXiy-2104, 2021.
11

---

Under review as a conference paper at ICLR 2022
Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us us-st--22. amazonaws. com/openai- aater//rcerrbboovss//uuggueeeeer
understanding paper. pdf. 2018.
Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and llya Sutskever. Language models are unsupervised multitask learners. OpenAl Blog, 1(8), 2019.
Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research, 21(1), 2020.
Alessandro Raganato, Jose Camacho-Collados, and Roberto Navigli. Word sense disambiguation: unified evaluation framework and empirical comparison. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pp. 99- 10, 2017.
Siva Reddy, Danqi Chen, and Christopher D) Manning. Coqa: A conversational question answering challenge. Transactions of the Association for Computational Linguistics, 7:249-266, 2019.
Corby Rosset, Chenyan Xiong, Minh Phan, Xia Song, Paul Bennett, and Saurabh Tiwary. Knowledge- aware language model pretraining. arXiv preprint arXiv:2007.00655, 2020.
Devendra Singh Sachan, Yuhao Zhang, Peng Qi. and William Hamilton. Do syntax trees help pre-trained transformers extract information? arXiv preprint arXiv:2008. 09084, 2020.
Peng Shi and Jimmy Lin. Simple bert models for relation extraction and semantic role labeling. arXiv preprint arXiv:1904.05255, 2019.
Vered Shwartz, Rachel Rudinger, and Oyvind Tafjord. you are grounded!":: Latent name artifacts in pre-trained language models. arXiv preprint arXiv:2004. 03012, 2020.
Koustuv Sinha, Shagun Sodhani, Jin Dong, Joelle Pineau, and William L.. Hamilton. CLUTRR: A diagnostic benchmark for inductive reasoning from text. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLL) pp. 4506-4515, Hong Kong, China, November
2019, Association for Computational Linguistics.. doi: 10.19653/v/DD19-145 1458. URL https
Oyvind Tafjord, Bhavana Dalvi Mishra, and Peter Clark. Proofwriter: Generating implications, proofs, and abductive statements over natural language. arXiv preprint arXiv:2012.13048 2020.
Ian Tenney, Dipanjan Das, and Ellie Pavlick. Bert rediscovers the classical nlp pipeline. arXiv preprint
005500 2019a
Ian Tenney, Patrick Xia, Berlin Chen, Alex Wang, Adam Poliak, R Thomas McCoy, Najoung Kim, Benjamin Van Durme, Sam Bowman, Dipanjan Das, and Ellie Pavlick. What do you learn from context? probing for sentence structure in contextualized word representations. In Proceedings of the 2019 International Conference on Learning Representations, 2019b. URL net. httpeeeeeeeeefuueeeeeeeeeee wtw.:/ooomddddssammmaaa
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, ukasz Kaiser, and Illia Polosukhin. Attention is all you need. Advances in Neural Information Processing Systems 30, pp. 5998-6008, Curran Associates, Inc., 2017. URL http:/ Btttht/pp///prr. papers mips.cc/ppae htaps.cc/paper///e/ wwtp:ccccpppe11.... attention is all you peed.pdd
Pat Verga, Haitian Sun, Livio Baldini Soares, and William W Cohen. Facts as experts: Adaptable and interpretable neural memory over symbolic knowledge. arXiv preprini arXiv:2007.00844) 2020.
Adina Williams, Nikita Nangia, and Samuel R Bowman. A broad-coverage challenge corpus for sentence understanding through inference. arXiv preprint arXiv: 170..0/7044.552000 2017
12

---

Under review as a conference paper at ICLR 2022
Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger. Mariama Drame, Quentin Lhoest, and Alexander M. Rush. Huggingface's 's transformers: State-of-the-art
natural language processing. ArXiv, abs/1910.03371, 2019.
Zhilin Yang. Peng Qi. Saizheng Zhang, Yoshua Bengio. William W Cohen, Ruslan Salakhutdinov, and Christopher D Manning. Hotpoiqa: A dataset for diverse, explainable multi-hop question answering. arXiv preprint arXiv: 809.09600, 2018.
Rowan Zellers, Yonatan Bisk, Roy Schwartz, and Yejin Choi. Swag: A large-scale adversarial dataset for grounded commonsense inference. arXiv preprint arXiv:1808.05326 2018.
Zhengyan Zhang, Xu Han, Zhiyuan Liu, Xin Jiang, Maosong Sun, and Qun Liu. Ernie: Enhanced language representation with informative entities, arXiv preprint
2019.
13

---

Under review as a conference paper at ICLR 2022
A HYPERPARAMETERS
We used the default T5- 1. hyperparameters from the Huggi agca library (Wolf et al. 2019). We present in Table bellow the library version used and the model hyperparameters used for all experiments.
The only difference between each dataset is the number of same-type entity tags allowed in each input sequence n. For CLUTRR the maximum number of same-type entities was 20, for ProofWriter it was 10, and for HotpotQA and CoQA it 100. This is due the larger context size and the diversity of natural language texts.
for CLUTRR n for ProofWriter
20
10
for HotpotQA n for CoQA
100
100
AllenNLP
version 2.2.0
Transformers
version 4.4.2
Spacy batch size
version 2.3.5
256
16-bit floating point
True
dim embedding
512
dim feedforward
2048
dim key-value dropout
64
0.1
max length #of heads #of layers
512
8
optimizer learning rate betas
Adam W
1500-05
[0.9, 0.999]
epsilon
1.00F-08
gradient norm
1.0
sampler
top-p
p
0.9
temperature
1.0
Table 5: Library version and model hyper-parameters.
14

---

Under review as a conference paper at ICLR 2022
B INPUT OUTPUT EXAMPLES
CLUTRR.
"question How is Anne related to Gary context
lv1.2 input:
Brett is Anne Father Gary is sen Brett .'
output:
Vaaswor : Anne has a brother named Gary .'
"question: What the family connection between Patricia and Timothy ? context May is the aunt of Doris Patricia has a daughter called Doris Timothy is Charles 's brother May has called Charles
lvl.4 input:
output:
'answer : Timothy is the nephew of Patricia .'
ProofWriter.
"context The cow is round. The cow needs the lion. The cow needs the rabbit. The The lion is round. The rabbit t is kind. The rabbit visits the tiger. the rabbit.
the lion. The cow visits the rabbit.
The tiger is big. The tiger is kind. The tiger The tiger visits the rabbit. If something is kind and it visits the rabbit then
young. If something sees the tiger and visits the 1ien then it sees the rabbit. If something is big and young then sees the lien. needs the lion. If something is big then it visits the rabbit. If something sees the tiger then it is rough. If something visits the rabbit and it is kind then the rabbit needs the lion. If something is rough and kind then it visits the lion. If something needs the lion then it is big. question The tiger visits the rabbit.''
Depth-0 input:
something visits the rabbit then the rabbit
Depth-0
aanswer True!
output:
ccontext: Anne is nice. Charlie is blue. Charlie is furry. Charlie green. Charlie kind. Charlic is nice. Charlie is red. Ficna is furry. Fiona is green. Harry is furry. Harry is kind. Harry is nice. All nice people are rough. red and furry then they are blue. Rough, kind people are furry. Charlie is furry then Charlie is nice. All furry people are nice. If soreone is rough then they are kind. If someone is red and nice then they are blue. All furry people are red. question Harry is not blue.''
Depth-2
someone
input:
Depth-2
Vanswer False!
output:
HotpotQA.
"question Which magazine was started first Arthur's Magazine or First for Women ? context : Arthur's s Magazine (1844-1846) was an American literary periodical published in Philadelphia in the 19th century. Eaited by I.S. Arthur, it featured work by Edgar A. Poe, J.E. Ingraham, Sarah Josepha Hale, and others. In May 1846 it merged into GGddy's s Lady's s Book"', First for Women is woman's s magazine published by Bauer Media Group in the USA. The magazine was started in 1989. It is based in Englewood Cliffs, New Jersey. 2011 the circulation of the magazine was 310, 696 copies.''
input:
output:
*annwwe Arthur's Magazine'
CoQA.
15

---

Under review as a conference paper at ICLR 2022
"context : The Vatican Apostolic Library, more commonly called the Vatican Library or simply the Vat, is the library of the Holy See, located in Vatican City. Formally established although it is much older, it is the world and contains one of the most significant collections of historical texts. It has 75, 000 codices from throughout
1475,
of the oldest libraries in
context:
history, as well as 1.1 million printed books, which include some 5,500 incunabula. The Vatican Library is research library for history, law, philosophy, science and theology. The Vatican Library is open anyone who document their qualifications and research needs.' [...] "Only handful of volumes survive from this period, though some are very significant.''
input:
context above + 'question : when was the Vat formally opened?'
output:
'aaswwrr : It was formally cstablished in 1475.''
context above "question when the Vat formally opened? answer was formally established in 1475. question what is the library for? answer research. question for what subjects?" 'answer history, and lax.''
input:
output:
context above + "question When the Vat formally opened? answer It was formally established in 1475. question what is the library for?
input:
: research. question : for what subjects? history, and law. question what else ?!/ ophilosophy, science and theology.''
output:
16


Reviews:
[{"review_id": "zd_ZGO6RFby", "reviewer": "Reviewer_r8rD", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "Strengths:\n1. The paper is generally well written and easy to follow. The idea of using entity abstraction is simple to implement and can be widely applied if works.\n2. The experimental results on CLUTRR is promising and show improved performance on compositional generalization, which is interesting.\n\nWeaknesses:\n1. The idea of using entity abstraction is straightforward and not very novel as doing POS tagging for input is widely used in many NLP models, especially in traditional NLP pipelines.\n2. While the performance on synthetic datasets is promising, on realistic datasets the proposed method fails to improve the performance. Therefore the effectiveness of the method is not fully supported by the experiments.", "summary_of_the_paper": "This paper investigate incorporating entity abstraction to transformer language models for text reasoning tasks. The paper proposes different methods to inject entity abstraction information into transformer LMs and experiments on a synthetic dataset show that the proposed method helps compositional generalization. However, experiments on two realistic datasets show that the proposed method fail to effectively improve performance.", "summary_of_the_review": "This paper proposed a simple method which incorporating entity abstraction to transformer language models. The method is simple while somewhat trivial, and the novelty/technical contribution is not very significant. The experimental results on synthetic dataset is good but not as well on realistic datasets. Therefore I believe this paper is below the bar.", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "2: Several of the paper’s claims are incorrect or not well-supported.", "technical_novelty_and_significance": "2: The contributions are only marginally significant or novel.", "empirical_novelty_and_significance": "1: The contributions are neither significant nor novel."}, "extra_text": {}}, {"review_id": "oCh_0x9jrm9", "reviewer": "Reviewer_sWnL", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "strengths:\n\n1. This paper is in a good shape for reading, easy following. \n\n2. The experiment part gives convincing numbers on performance boosting on three NLP tasks, CLUTRR, HotpotQA, and CoQA.\n\nweaknesses:\n\n1. The experiment part lacks analysis on the model which could provide more intuitions on how the model works. More analytic experiments will bring more interesting findings of the proposed model. For instance, we could dive deep into why the model variants perform differently between CLUTRR and HotpotQA & CoQA.\n\n", "summary_of_the_paper": "This paper empirically explored three different ways to add abstraction, additional input embeddings, a separate sequence to encode, and an auxiliary prediction task. Experiments on CLUTRR, HotpotQA, and CoQA show that the models with abstract entity knowledge perform slightly better than without it.", "summary_of_the_review": "Overall, this is a solid empirical paper with convincing experimental results. It will be of great help for revealing the intuition of the model if introducing more analytic experiments.", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "2: The contributions are only marginally significant or novel.", "empirical_novelty_and_significance": "2: The contributions are only marginally significant or novel."}, "extra_text": {}}, {"review_id": "mGIT1Cavqzh", "reviewer": "Reviewer_pDcD", "summary": "", "questions": "", "limitations": "", "rating": 3, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "Strengths\n- The paper is clearly written and easy to understand.\n- The improvement on the synthetic logical reasoning setting (CLUTRR) is significant.\n- The conclusion of the paper provides some insights on the capacity of T5-small model to understand entity abstraction.\n\nWeakness\n- The paper only shows end-to-end performance on the three tasks without deeper analysis on why entity abstraction does not always improve the performance. Like the authors pointed out, the current conclusion could be due to the noisy entity type predictions or the fact that the tasks do not require entity abstraction. Without the deeper analysis, readers cannot generalize the conclusion beyond the three datasets mentioned in this paper to other unexplored downstream tasks.\n- Only one pretrained transformer model t5-small is tested, therefore the empirical findings of this paper cannot be applied to other models, which usually contain much more parameters and perform better on various downstream tasks.", "summary_of_the_paper": "The paper studied the utility of incorporating entity type abstractions into pre-trained Transformers and its effectiveness on three tasks which require logical reasoning: 1) compositional language understanding with text-based relational\nreasoning 2) multi-hop question answering 3) conversational question answering. Empirical result shows that the proposed method significantly improves the synthetic compositional language understanding task while only marginally improves the other two tasks in natural languages.", "summary_of_the_review": "Technically, the paper presents novel approaches to incorporate entity type abstraction with transformer language model. As the related work section discussed, there are a lot of other related works also incorporating knowledge from named entities. To me, using only the entity type is marginally novel. Also, the empirical findings lack deeper analysis and were merely conducted on a single and toy-sized pretrained language model. For empirical results, the only significant improvement is on a synthetic dataset while the gain on real-world datasets is also marginal. Therefore, the significance of the paper's contribution is limited.", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "3: Some of the paper’s claims have minor issues. A few statements are not well-supported, or require small changes to be made correct.", "technical_novelty_and_significance": "2: The contributions are only marginally significant or novel.", "empirical_novelty_and_significance": "2: The contributions are only marginally significant or novel."}, "extra_text": {}}, {"review_id": "Yt2EwXrswPI", "reviewer": "Reviewer_oWCK", "summary": "", "questions": "", "limitations": "", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "main_review": "**Strengths**:\n\\\nOverall a good paper. It is well presented, and the experimental results are solid.\n\n**Weaknesses**:\n\\\nMy major concern is about the experiments. Specifically,\n1. There is very minor boost in performance on QA datasets. The goal of the proposed model should be improving real-world data, instead of synthetic data (CLUTTR in this paper). Because improving numbers on synthetic data could be hacky, and not scalable to practical applications.\n2. The performance of baselines are far below the current top performers. I understand that the paper is not interested in achieving new state-of-the-art, and the test set used might be different. However, in that case you can not prove that the proposed methods are still beneficial on a model that achieves way better baseline results. An analogy here is that something working under low-resource setting is not necessarily effective when there is adequate access to data.\n3. The method of incorporating abstraction is not universal. We’ve seen different methods work for different datasets. If there is a new reasoning dataset, which architecture in Table 1 should people use? Testing all five is very inefficient.\n\n**Style, Typos etc.**\n1. In Section 4,1, it is mentioned that “the inverse relation of “father” can be “son” or “daughter”, we accept both”. What does “accept both” mean here? “Ann is the daughter of Brett” and “Ann is the son of Brett” can not be both correct. Right?\n2. Also in Section 4.1, “We generated 390,000 examples that were roughly split 70/30 between training and testing”. But in Section 4.1.1, the size of test set becomes 10,000. Which one is correct?\n3. The lvl.2 output of CLUTTR in Appendix B does not use the answer template specified in Section 4.\n4. TACRED has been mentioned multiple times in the Appendix. How is TACRED used in this work?", "summary_of_the_paper": "The paper investigates the effect of incorporating entity type abstraction into pre-trained Transformers. To achieve that, the authors have tried five different architectures to build the abstraction aware model. The proposed model is tested on three NLP datasets for reasoning. Empirical results show that entity type abstraction is beneficial in formally defined logical reasoning environments with simple language. While for QA datasets with more natural language, the baseline is already very strong and the improvement of incorporating abstraction is minor.", "summary_of_the_review": "This paper tries to address an important problem, but the experiments conducted show that the proposed methods are not scalable to more real-world datasets. I do not recommend acceptance of the paper in its current form.", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "extra_scores": {"correctness": "4: All of the claims and statements are well-supported and correct.", "technical_novelty_and_significance": "3: The contributions are significant and somewhat new. Aspects of the contributions exist in prior work.", "empirical_novelty_and_significance": "2: The contributions are only marginally significant or novel."}, "extra_text": {}}]

Author rebuttal:

Meta-review: This is a clearly written paper about integration of entity abstraction to the transformer based language modeling methods for language processing tasks that require reasoning (this is clarified by the authors later as tasks that require linger chains of reasoning) and have shown results on CLUTTR, HotpotQA, and CoQA. The reviewers seem to agree on two issues: First, it is not clear why the proposed idea does not result in a lot of improvement, except the synthetic CLUTTR. Authors provided additional experimental results on yet another dataset. Second, the paper would benefit from a detailed analysis of the experimental results, for example, why don't abstractions help on all datasets.
Decision: Reject