Combining deep learning with symbolic logic reasoning aims to capitalize on the success of both fields and is drawing increasing attention. Inspired by DeepLogic, an end-to-end model trained to perform inference on logic programs, we introduce IMA-GloVe-GA, an iterative neural inference network for multi-step reasoning expressed in natural language. In our model, reasoning is performed using an iterative memory neural network based on RNN with a gate attention mechanism. We evaluate IMA-GloVe-GA on three datasets: PARARULES, CONCEPTRULES V1 and CONCEPTRULES V2. Experimental results show DeepLogic with gate attention can achieve higher test accuracy than DeepLogic and other RNN baseline models. Our model achieves better out-of-distribution generalisation than RoBERTa-Large when the rules have been shufled. Furthermore, to address the issue of unbalanced distribution of reasoning depths in the current multi-step reasoning datasets, we develop PARARULE-Plus, a large dataset with more examples that require deeper reasoning steps. Experimental results show that the addition of PARARULEPlus can increase the model's performance on examples requiring deeper reasoning depths. The source code and data are available at https://github.com/Strong-AI-Lab/Multi-Step-Deductive-Reasoning-Over-
Natural-Language.
Symbolic reasoning and deep learning remain two cornerstones in AI with profound yet divergent consequences. Indeed, symbolic approaches, equipped with various logic languages for knowledge representation and inference, have been the dominant paradigm in problem solving and reasoning. Deep learning approaches, through superior ability to capture rich semantic features from complex signals, triumph in tasks that usually require more intuitive and automatic judgements. A growing interest in AI amounts to harnessing the power from both schools, while mitigating each other’s weaknesses. First, symbolic reasoning were suitable only when the task at hand, along with all contextual knowledge, can be encoded by rigorous and structured logic expressions, which is itself a formidable obstacle. Then, deep learning relies on neural networks which have not demonstrated the ability to perform iterative, multi-step reasoning, which has a gap in making them suitable tools for reasoning. Towards a trainable reasoner that is able to perform complex real-world reasoning tasks, it is important to (1) facilitate end-to-end reasoning by enabling multi-step reasoning and (2) bypass logic-based knowledge representation and make inferences directly from natural language inputs. The goal of this paper is to explore possibilities around these two objectives. We now present the research background in detail.
Logic programs: Reasoning with logic programs is one of the key questions in AI. Here a
knowledge base consists of a number of rules, i.e., (universally quantified) implications where
the antecedent is a conjunction of literals and the consequent is an atom, and observed facts,
i.e., ground atoms. The task would specify a question which is another ground atom and asks if
the question logically follows from the knowledge base. Table 1 illustrates several archetypal
examples of reasoning tasks in logic programs (as in [
DeepLogic: The ability to conduct iterated inference for multi-step reasoning tasks such
as the ones above is viewed as an unchallenged strength of rule-based inference algorithms.
Yet recent advancements in deep learning techniques have challenged this view. DeepLogic,
introduced in [
Reasoning in natural language: The abilities demonstrated by DeepLogic has given hope
for similar neural networks to perform more general reasoning tasks. In particular, neural
network’s key strengths involve the ability to extract rich syntactical and semantic feature from
free-flowing texts, expressed in natural language. Indeed, PARARULES, introduced in [
(1) Existing models, including DeepLogic and other RNN-based baseline models, have room for
improvement in terms of their reasoning abilities over natural language. The vanilla GRU/LSTM
model might not handle well the multi-step reasoning tasks over logic programs from [
(2) Out-of-distribution (OOD) generalisation means the test set has a distribution that is
unknown or diferent from the distribution of the training set. In multi-step reasoning tasks,
OOD generalisation means that (1) the model is able to reason for cases that have a depth
greater than the depths of the instances it was trained on, and (2) the model is able to handle
samples with shufled rules from the training instances. Shufling here means permuting the
rules in the knowledge base. Being able to handle OOD is a crucial indicator of a model’s
reasoning capabilities. In [
(3) CONCEPTRULES V1 and V2 [
Systems that integrate deep learning techniques with symbolic reasoning are called
neurosymbolic systems [
Several reasoning datasets have been introduced for natural language-based reasoning tasks
which can be used to evaluate and compare neural models’ reasoning capabilities. Roughly
speaking, the datasets can be categorised as “shallow reasoning” and “deep reasoning” tasks.
The first category includes Task 15 in the bAbI dataset v1.0 [
The second category contains instances where the reasoning depth may go beyond 2. These
datasets are PARARULES [
Other work uses Transformer-based pretrained language models to perform tasks that require
multi-step reasoning over natural language. One such work is [
We consider multi-step deductive reasoning over natural language. Each sample is a triple
(, , ) where contains natural language implications (rules) and
observations (facts) resembling a knowledge base in logic programs, is a natural
language sentence expressing an atomic fact, and ∈ { true, false} tells whether
naturally follows from . In this regard, (, , ) is a natural-language
counterpart to a logic program. Figure 2 illustrates several examples in the PARARULES dataset
[
Multi-step reasoning requires multiple reasoning steps to answer a question. We define the reasoning depths (or steps) as the number of rules required to answer a question. For example, from “Bob is smart.”, it takes only one rule “All smart people are talented.” to answer “Bob is talented?”. This example is therefore considered as depth-1 reasoning. PARARULES has seven sub-datasets, each is named by the greatest depth of reasoning required to deduce which related facts support its question: depths = 1 , = 2 , = 3 , ≤ 3 , ≤ 3 + NatLang, ≤ 5 , ≤ 5 + NatLang, respectively. Here, NatLang means the extra out-of-distribution examples, containing about 2,000 examples. These examples include questions of diferent depths. They were created by paraphrasing examples using crowdsourcing. Crowdworkers rewrite part of the synthetic dataset using phrases such as “often”, “rather resembles”, and “a bit”. For instance, sentences like “Charlie is green, but often kind” and “Harry seems to be round” are more natural to a human reader.
(Input Facts:) Anne is rough. Anne is blue. (Input Rules:) Rule 1: Cold people are rough.
Rule 2: Rough people are young.
Rule 3: If Anne is green then Anne is blue.
Rule 4: If someone is rough and nice then they are green.
Rule 5: If someone is rough and furry then they are blue.
Rule 6: All young people are cold.
Q1: Anne is cold. True/False? [Answer: T] Q2: Anne is not young. True/False? [Answer: F]
Q3: Anne is not green. True/False? [Answer: T]
While PARARULES separates fact and rule explicitly, CONCEPTRULES V1 and V2 [
This section describes a word-level RNN-based iterative neural network. The general idea of
the model is borrowed from DeepLogic. DeepLogic is an end-to-end iterative memory attention
network trained on symbolic logic programs. For details about DeepLogic, we refer the reader
to the original paper [
Word-level embedding. The input representation layer of the network takes a sequence
of words concatenated from two sentences 0 , … , and 0 , … , for context and question
ℎ = GRU (GloVe [I∶∶ + I∶∶ ] , ℎ−1 )
The context I and the question I at time step are embedded by GloVe[I∶∶ + I∶∶ ], the GloVe
[
Iteration. Each iteration step computes the new state based on the current state and rules. In our model, gate attention is trained to decide how much of the state information will be reserved from the current state and the previous state. The process is iterated for steps ( is pre-determined). The initial state is denoted as 0 = , where is the question vector and ∈ ℝ . The -th rule is denoted as . and are the learnable weight matrices. is the bias vector. (1) (2) (3) = [ ; ; ; ( − ) 2
; ⊙ ] = (
( + ) + )
At time step , we compute a feature vector using the current state ∈ ℝ , question vector and a rule . In (2), [; ]is a concatenation operator. We use a feed-forward network to compute the attention vector , instead of the sigmoid function.
ℎ = GRU (C , ℎ
(−1) ) +1 = ∑ ℎ (4) (5) as word embeddings, and then attentions are computed to pick up related rules. Gate attention is used to compute the weighted sum of the Unifier GRU outputs. Then the weighted sum updates the state for the next iteration. the final attention vector
(3), where is a sigmoid function. For experimental comparison, softmax is used for our IMA-GloVe-GA and another baseline model IMASM-GloVe to compute We use another recurrent neural network to process the context embedding C . The initial hidden state ℎ
0 = , where is the current state. For each rule, the new hidden state ℎ is computed by (4). In the end, the new state +1 is computed as a weighted sum of the final hidden states in (5). The Unifier GRU learns the unification between pronouns (variables) and nouns (constants).
Gate attention.
Dynamic memory network+ [
exp ( ( + ) + ) ∑ =1 exp ( ( + ) + ) ℎ = ∘ ℎ̃ + (1 − ) ∘ ℎ−1 (6) (7)
To investigate whether end-to-end neural networks designed for symbolic logic reasoning can
be adapted to do multi-step deductive reasoning in natural language, we evaluated the models
on PARARULES [
We experiment with three variants of DeepLogic. The iterative memory attention (IMA) model
is adopted from DeepLogic. IMASM is similar to IMA, except that IMASM uses softmax rather
than sigmoid when computing attention scores. We also test three baseline models from the
bAbI leaderboard: Long short-term memory (LSTM) [
We train the models on PARARULES, incorporating all reasoning depths (Depth=0, Depth=1,
Depth= 2, Depth=3, Depth=5) and the examples paraphrased by humans (NatLang). We set the
random seed to 0. We train the models using the Adam [
Experimental Results: Table 4 shows the results of the RNN-based models on test sets
that require diferent reasoning steps. Unless otherwise stated models are trained on the entire
training set with all reasoning depths. The first horizontal row denotes test sets with specific
reasoning depth(s), and the second horizontal row denotes the number of test samples. We find
that our IMA-GloVe-GA and RoBERTa-Large achieve the 2nd and 1st best results. These two
models also achieve the 2nd and 1st best results in the test set with additional human-rewritten
examples (+NatLang), showing a better generalisation performance and robustness. We find that
by adding gate attention the test accuracy improved over IMA-GloVe in all cases. The results
support that gate attention can be more efective than dot-product attention on examples that
require multi-step reasoning. IMA-GloVe and IMASM-GloVe obtained better performance than
the other RNN-based baseline models. We speculate that the dot-product attention enhances
the learning and representation between context and question. In addition, the vanilla LSTM
fails to converge in all those cases. We get similar results as reported in DeepLogic [
The results shown in Table 4 compare the performances of the IMA models based on the GloVe word embeddings and the pretrained RoBERTa model on the same test sets of diferent reasoning depths. We find that by adding gate attention the test accuracy improved over IMA-GloVe in all cases. The results support that gate attention can be more efective than dot-product attention on examples that require multi-step reasoning. We also find that the pretrained RoBERTa model achieves better results in all of the cases. A possible reason is that our model is trained from scratch without any large-scale pretraining. However, our model can perform better than the other baselines without any pretraining.
Table 5 shows the results on CONCEPTRULES V1 (simplified) and CONCEPTRULES V1 (full). The second column is the training set CONCEPTRULES V1 (simplified or full). The last two columns show test accuracy on CONCEPTRULES V1 (simplified or full) test set. For example, in the first row, we train IMA-GloVe on the simplified version of the training sets, and then test on diferent test sets. We find that IMA-GloVe-GA (with gate attention) performs better than IMA-GloVe in all cases. In contrast, the pretrained RoBERTa model only achieves high performance in the simplified test set when it is trained on the simplified training set. It indicates that the pretrained RoBERTa overfits CONCEPTRULES V1 (simplified) since the rules are not shufled. Most likely it learns spurious relations in the training data and fails to generalise on test examples with shufled rules.
Table 6 shows results on CONCEPTRULES V2. We select the four models used in Table 5, and 3FAIRSEQ, https://github.com/pytorch/fairseq respectively select data of diferent depths in CONCEPTRULES V2 (full) as the training data. For example, Mod3 represents a model trained on examples with depth of 3. Mod0123 represents a model trained on examples with depth of 3 and less. Each row of the table represents a test set of a specific reasoning depth. We find that the IMA-based model achieves better results in almost all cases. The pretrained RoBERTa model does not outperform the IMA-based models in all cases. We find that when the model is only trained on examples with reasoning step of 1, the test accuracy dropped as we increase the reasoning steps in the test set. However, the drop in performance is not as great as we expected for the IMA-based models. This shows that the IMA-based models generalise better on out-of-distribution test examples. A possible reason why models achieve higher test accuracies on CONCEPTRULES V2 (full) is that CONCEPTRULES V2 has much more training data compared to PARARULES, from Table 2.
Table 7 shows the results of fine-tuning RoBERTa-Large on datasets with diferent reasoning depths and testing on test sets of various reasoning depths. Depth≤2 means the model is trained on the dataset with depths no larger than 2. Depth≤3+NatLang represents the model that is trained on the dataset with depths no larger than 3 and extra examples paraphrase by humans. The models trained on the datasets with shallow depths have lower test accuracies on test sets that require deeper reasoning depths. We find that adding training examples that require deeper reasoning steps for Mod0123 improves the results on the test sets with deeper reasoning steps (e.g. Mod0123Nat vs. Mod0123, and Mod012345 vs. Mod0123). Additionally, we find that adding the examples paraphrased by humans improves the performance on test examples with deep reasoning steps and human-paraphrased test examples.
Table 8 shows the results of fine-tuning RoBERTa-Large on the datasets found in Table 7 and our PARARULE-Plus. The addition of PARARULE-Plus during the fine-tuning improves the performance on the examples that require more reasoning steps. The yellow background shows the improvement over the test accuracy reported in Table 7, and the bracket contains the magnitude of the improvement. The bold numbers indicate the highest test accuracy on corresponding test sets. The results support that our PARARULE-Plus addresses the depth imbalance issue of the current datasets and the addition of it during training improves the model’s generalisation on the examples that require deeper reasoning steps.
We provide insights into an RNN-based iterative memory model that incorporates gate attention on multi-step reasoning over natural language. Instead of using the original GRU and dotproduct attention, we integrate gate attention to update hidden states. The experiment results show the model with gate attention achieves generally better performance than the original RNNbased iterative-memory model with dot-product attention and other RNN-based models. The performance of our model is comparable or better than the much larger and pretrained RoBERTaLarge in some scenarios. Furthermore, our model shows better out-of-distribution generalisation performance than the pretained RoBERTa. To address the issue of depth-imbalance in the existing datasets on multi-step reasoning over natural language, we develop a large-scale multi-step reasoning dataset called PARARULE-Plus, with more examples of deep reasoning depths than previous datasets. We find that the performance of the models in our experiments improves when we add PARARULE-Plus in the training, especially on examples that require deeper reasoning depths and extra out-of-distribution examples.
Following the closed-world assumption, we use the entities from the PARARULES which includes mainly PEOPLE and ANIMALS. We also consider negation, so there are 4 diferent scenarios in each depth for each category: PEOPLE with negation in the rules, PEOPLE without negation in the rules, ANIMALS with negation in the rules and ANIMALS without negation in the rules. All of the questions can be derived from the contexts and rules. If a question cannot be matched directly from the context, then it can be derived using rules. For the ANIMALS, we consider 14 diferent animal entities (“the bald eagle”, “the tiger”, “the bear”, “the lion”, “the wolf”, “the crocodile”, “the dinosaur”, “the snake”, “the leopard”, “the cat”, “the dog”, “the mouse”, “the rabbit”, “the squirrel”), 7 diferent animals relationships (“is”, “likes”, “chases”, “needs”, “visits”, “attacks”, “sees”), and 28 diferent animals attributes (“big”, “strong”, “awful”, “fierce”, “heavy”, “horrible”, “powerful”, “angry”, “furry”, “small”, “cute”, “lovely”, “beautiful”, “funny”, “dull”, “rough”, “lazy”, “slow”, “sleepy”, “boring”, “tired”, “reckless”, “kind”, “quiet”, “round”, “nice”, “smart”, “clever”). For the PEOPLE, we consider 9 diferent entities (“Anne”, “Alan”, “Bob”, “Charlie”, “Dave”, “Erin”, “Harry”, “Gary”, “Fiona”), 1 relationship (“is”) and 20 people attributes (“wealthy”, “smart”, “nice”, “quiet”, “kind”, “poor”, “dull”, “rough”, “bad”, “sad”, “short”, “thin”, “small”, “little”, “big”, “strong”, “high”, “old”, “young”, and “huge”).
Require: Type of dataset: animal/people, add negation rule or not: Yes/No,
reasoning depth ∈ 2, 3, 4, 5 , animal name list = [’the bald eagle’, ’the tiger’, ’the bear’,
’the lion’, ’the wolf’, ’the crocodile’, ’the dinosaur’, ’the snake’, ’the leopard’, ’the cat’,
’the dog’, ’the mouse’, ’the rabbit’, ’the squirrel’],
people name list = [’Anne’, ’Alan’, ’Bob’, ’Charlie’, ’Dave’, ’Erin’, ’Harry’, ’Gary’, ’Fiona’],
animal relation list = [’is’, ’is not’, ’likes’, ’chases’, ’needs’, ’visits’, ’attacks’, ’sees’],
people relation list = [’is’, ’is not’], animal attribute list = [’kind’, ’quiet’, ’round’, ’nice’,
’smart’, ’dull’, ’rough’, ’lazy’, ’slow’, ’sleepy’, ’furry’, ’small’, ’cute’, ’lovely’, ’beautiful’,
’big’, ’strong’, ’awful’, ’fierce’, ’heavy’], people attribute list = [’big’, ’strong’, ’high’,
’huge’, ’short’, ’thin’, ’small’, ’little’, ’wealthy’, ’smart’, ’nice’, ’quiet’, ’kind’, ’poor’, ’dull’,
’rough’, ’bad’, ’sad’, ’old’, ’young’] total_list = []
for reasoning depth in 2,3,4,5 do
item_list = randomly select 4 animals/people name from animal/people name list
for index in (0, ( _)) do
item, item_1, item_2, item_3 = item_list[0], item_list[1, item_list[
Algorithm 1: PARARULE-Plus data generation 0.901 0.847 0.873 0.862 0.852 0.888 (+0.032) 0.593 (+0.014) 0.963 (+0.010) 0.881 0.839 0.826 0.832 0.934 (+0.001) 0.649 (+0.055)