∎

11institutetext: Radha Kopparti 22institutetext: 22email:
<EMAIL_ADDRESS>33institutetext: Tillman Weyde 44institutetext:
44email<EMAIL_ADDRESS>
# Relational Weight Priors in Neural Networks for Abstract Pattern Learning
and Language Modelling

Radha Kopparti  Tillman Weyde

(Received: May 15, 2020)

###### Abstract

Deep neural networks have become the dominant approach in natural language
processing (NLP). However, in recent years, it has become apparent that there
are shortcomings in systematicity that limit the performance and data
efficiency of deep learning in NLP. These shortcomings can be clearly shown in
lower-level artificial tasks, mostly on synthetic data. Abstract patterns are
the best known examples of a hard problem for neural networks in terms of
generalisation to unseen data. They are defined by relations between items,
such as equality, rather than their values. It has been argued that these low-
level problems demonstrate the inability of neural networks to learn
systematically.

In this study, we propose Embedded Relation Based Patterns (ERBP) as a novel
way to create a relational inductive bias that encourages learning equality
and distance-based relations for abstract patterns. ERBP is based on Relation
Based Patterns (RBP), but modelled as a Bayesian prior on network weights and
implemented as a regularisation term in otherwise standard network learning.
ERBP is is easy to integrate into standard neural networks and does not affect
their learning capacity. In our experiments, ERBP priors lead to almost
perfect generalisation when learning abstract patterns from synthetic noise-
free sequences. ERBP also improves natural language models on the word and
character level and pitch prediction in melodies with RNN, GRU and LSTM
networks. We also find improvements in in the more complex tasks of learning
of graph edit distance and compositional sentence entailment. ERBP
consistently improves over RBP and over standard networks, showing that it
enables abstract pattern learning which contributes to performance in natural
language tasks.

###### Keywords:

Abstract Pattern Learning Inductive Bias Weight Priors Language Modelling

## Declaration

  * •

Funding : Radha Kopparti is supported by a PhD studentship from City,
University of London

  * •

Conflicts of interest/Competing interests : No conflicts of interest

  * •

Availability of data and material : All the datasets used in the experiments
are available online

  * •

Code availability : The code for the experiments will be made available online

  * •

Authors’ contributions : Included in Introduction

##  1 Introduction

Humans are very good at learning abstract patterns, i.e. patterns based on
relations rather than values, from sensory input and systematically applying
them to new stimuli, even after brief exposure. On the other hand, neural
networks fail to detect such patterns in unseen data (Marcus et al., 1999).
The lack of systematicity in neural network learning has already been
discussed over 30 years ago (Fodor and Pylyshyn, 1988), but that discussion
has still not led to a generally accepted consensus. Nevertheless, deep
learning has had impressive successes based on computational advances and
greatly increased amounts of data. Yet, it has become evident that there are
still relevant limitations to systematicity and compositionality of learning
and generalisation in current neural network architectures (e.g., Lake and
Baroni, 2018; Marcus, 2018; Hupkes et al., 2019; Baroni, 2019; Keresztury and
Bruni, 2020). Neural networks are effective at mapping numerical patterns
similar to the training data to corresponding outputs, but often do not
extrapolate this mapping successfully on unseen data (Liska et al., 2018a).
Specifically, standard neural networks do not seem to learn equality relations
(Mitchell et al., 2018; Weyde and Kopparti, 2018), which define simple
abstract patterns, such as those used in the well-known study by Marcus et al.
(1999).

In this study, we use Embedded RBP (ERBP) (Kopparti and Weyde, 2020), an
extension of Relation Based Patterns (Weyde and Kopparti, 2019), for effective
generalisation of equality and similarity relationships. ERBP is modeled as a
prior over the network weights in standard feed-forward and recurrent network
architectures. Thus, ERBP enables the use of existing standard architectures
with just one additional term in the loss function, as opposed to other
architectures addressing systematicity, and it uses no fixed weights, in
contrast to RBP. Our experimental results confirm that ERBP consistently leads
to almost perfect generalisation on abstract pattern learning.

Marcus et al. (1999) and Marcus (2018) see the failure to learn abstract
patterns as evidence for general limitations of neural network learning. To
our knowledge, this link has not been shown experimentally. Therefore we
evaluate our solution on language models for words and characters on real-life
data. We find consistent improvements in all experiments, providing evidence
for a link between the capacity for low-level abstraction and performance in
natural language modelling.

The main contributions of this study are:

  * •

The application of the novel ERBP method for weight priors that enable
abstract pattern learning

  * •

Extensive experimental evaluation on abstract pattern learning with perfect
accuracy on synthetic test data

  * •

Multiple experiments on natural language modelling and graph neural networks,
showing consistent improvements through ERBP

The remainder of the paper is organised as follows: Section 2 discusses the
related work. In Section 3, learning of abstract patterns with ERBP is
explained. Sections 4, 5, and 6 describe the experimental setup and results on
synthetic, real-world, and complex tasks, followed by the Discussion and
Conclusions in Sections 7 and 8, respectively.

##  2 Related Work

There has recently been an increased interest in inductive biases to improve
generalisation in machine learning and specifically neural networks with
potential benefits in various applications like relational reasoning
(Battaglia et al., 2018), spatial reasoning (Hamrick et al., 2018), learning
from few examples (Snell et al., 2017; Wang and Yao, 2019), cognitive
modelling (Griffiths et al., 2010), natural language processing (Mitchell et
al., 2018), machine translation (Sutskever et al., 2014; Lake and Baroni,
2018), and numeric reasoning (Trask et al., 2018).

Earlier work on systematicity of human language learning and connectionism
started with (Fodor and Pylyshyn, 1988). There have been wider debates on
systematicity of neural network learning with claims and counter-claims on
their abilities (Fodor and McLaughlin, 1990; Niklasson and van Gelder, 1994;
Christiansen and Chater, 1994; Frank, 2014). In the context of abstract
pattern learning, there was series of studies triggered by Marcus et al.
(1999) with different extended network architectures and evaluation methods
(Elman, 1999; Altmann and Dienes, 1999; Vilcu and Hadley, 2005; Shultz and
Bale, 2006; Alhama and Zuidema, 2016, 2019), but no general consensus has
emerged.

Traditional rule based approaches do not suffer from a lack of systematicity,
but they lack the flexibility of neural networks. Some approaches aim to
improve rule based learning with more flexibility, e.g. through probabilistic
logic (De Raedt and Thon, 2010; De Raedt et al., 2019a). Other studies aim at
combining symbolic rule based knowledge with neural networks (Garcez et al.,
2015; Besold et al., 2017; De Raedt et al., 2019b; Vankov and Bowers, 2020).
However, this approach has not yet been adopted in the mainstream of machine
learning research and applications.

There has been work on different ways of modelling inductive biases in neural
networks in recent years, like using matrix factorisation (Neyshabur et al.,
2014) and convolutional arithmetic circuits (Cohen and Shashua, 2016) for
computer vision tasks, relational inductive bias models and Bayesian inference
in the context of deep reinforcement learning (Zambaldi et al., 2019; Gershman
and Niv, 2015) and inductive bias for integrating tree structures in LSTMs by
ordering neurons (Shen et al., 2019).

It has been identified for a long time that weight initialisation can improve
the speed and quality of neural network learning (Sutskever et al., 2013; Le
et al., 2015; Nye and Saxe, 2018). Various regularisation methods have also
been proposed to improve generalisation (Sussillo, 2014; Zaremba et al., 2014;
Pachitariu and Sahani, 2013). Mikolov et al. (2015) use two weight matrices
with different learning dynamics to encourage short and long term memory.
Recently, spatial weight priors have been proposed for Bayesian convolutional
neural networks by Atanov et al. (2019). There is work by Demeester et al.
(2016) for injecting inductive bias in the form of implication first order
rules through an additional regularisation term for learning relations between
entities in WordNet.

Recent studies have confirmed that state of the art neural networks lack
systematic generalisation, specifically recurrent neural networks for a
sequence to sequence learning task (Lake and Baroni, 2018; Liska et al.,
2018b; Bastings et al., 2018) and have stressed the lack of compositionality
and generalisation in neural networks (Lake, 2019; Baroni, 2019; Nye et al.,
2020; Keresztury and Bruni, 2020; Vankov and Bowers, 2020, 2019; Hupkes et
al., 2019; Andreas, 2019).

Other works on incorporating symbolic prior knowledge into neural networks
include that by Xu et al. (2018), where a loss function based on constraints
on the output has been developed as a regularisation term and evaluated on
structured prediction and multi-label classification tasks. Minervini et al.
(2017b, a) proposed a method for regularising multi-layer graph based neural
networks using logic based prior knowledge on link prediction tasks. There are
other works like Neural Theorem Provers (NTPs) (Rocktäschel and Riedel, 2017)
which are proposed to solve large scale knowledge reasoning tasks (Minervini
et al., 2019) and systematic generalisation (Minervini et al., 2020). In the
context of relational reasoning and natural language understanding, works like
Sinha et al. (2019, 2020) evaluate systematic out-of-order logical
generalisation in graph neural networks.

Mitchell et al. (2018) studied among other problems the learning equality of
numbers in binary representation, which does not generalise from even to odd
numbers as pointed out already by Marcus (2001). They investigate several
potential solutions, with a preference for a convolutional approach. Trask et
al. (2018) studied the numerical extrapolation behaviour using logic gates
based on arithmetic logic units for fundamental numerical operations.

In our previous work (Weyde and Kopparti, 2018, 2019; Kopparti and Weyde,
2019), we have shown that equality relations and abstract patterns based on
such relations are not generalised by standard feed-forward and recurrent
neural network architectures. This failure is independent of various
parameters like the vector dimension, amount of training data, train/test
split, type of activation function, data representation, vector coverage, and
aspects of the network architecture. The proposed RBP model, creates a bias
that leads to almost perfect generalisation on a number of tasks that relate
to equality detection and learning abstract patterns. Tanneberg et al. (2020)
use the differential rectifier units proposed as part of RBP (Weyde and
Kopparti, 2018) to develop an architecture for learning efficient strategies
that solve abstract algorithmic problems. In this work, we extend the RBP
framework in the form of a Bayesian prior on the network weights to enable
abstract relation learning.

##  3 An Inductive Bias for Learning Abstract Patterns

To the best of our knowledge, a solution based on weight priors has not been
proposed for the abstract pattern learning task. We therefore re-model the RBP
approach by proposing a weight prior which makes it a more effective inductive
bias and simpler to integrate into standard neural networks.

###  3.1 Motivation

Neural networks are effective in recognising and mapping numerical patterns
seen in the training data to corresponding outputs, but very often do not
extrapolate this mapping outside the range of the training data (Liska et al.,
2018a). Specifically, standard neural networks do not seem to learn equality
based abstract relations (Mitchell et al., 2018), which are fundamental for
many higher level tasks. Learning equality or identity based relations is not
only a very useful numerical relationship but also an important characteristic
that defines abstract relations in data e.g., the grammar-like rules ABA or
ABB as used in the well-known study by Marcus et al. (1999).

It is not clearly understood why the standard neural network models in their
current form are not able to learn abstract grammar-like rules based on
equality. To this end, we have proposed solutions based on Relation Based
Patterns (RBP) (Weyde and Kopparti, 2018, 2019), and Embedded Relation Based
Patterns (ERBP) in Kopparti and Weyde (2020) as re-modelling RBP as a weight
prior with a regularisation term in otherwise standard neural network
learning.

Here, we take this approach forward, and apply ERBP firstly to a wide range of
synthetic tasks of learning abstract, mixed and concrete patterns, thereby
modelling lower-level abstract patterns in data. We then aim to evaluate
whether modelling the lower-level abstractions in data can improve higher
level tasks like language modelling. To this end, we experiment with ERBP on
real-word tasks of character and word prediction, music pitch prediction,
graph distance modelling, and sentence entailment. The aim behind this work is
not to improve the state-of-the-art performance on these tasks but rather to
focus on highlighting the problem of lower-level abstract pattern learning
with neural networks and show that creating an inductive bias as a weight
prior leads to improvements in several tasks.

###  3.2 Relation Based Patterns (RBP)

The RBP model introduced in Weyde and Kopparti (2018, 2019) is based on the
comparison of input neurons that are in some relation to each other. For the
comparison, Differentiator-Rectifier (DR) units are used that calculate the
absolute difference of two inputs: $f(x,y)=|x-y|$. DR units realise this with
fixed weights from the two neurons that are to be compared, with values $+1$
and $-1$, and the absolute value as activation function.

For abstract pattern learning, there are multiple vector comparisons that
correspond to the different possible relations within the patterns, e.g.
equality of pairs of vectors representing tokens in positions (1,2), (1,3),
(2,3), to recognise abstract patterns within three elements. For each
dimension of the input vectors and each comparison there is a $DR_{n}$ unit.
$DR_{n}$ units are applied to every pair of corresponding input neurons
representing the same dimension within a token representation. There are also
$DRp$ units, which we do not model in ERBP, that can be used to aggregate the
activations for all dimensions in a vector comparison by summing the
activations of the $DR_{n}$ values. Weyde and Kopparti (2019) has a detailed
description of $DR_{n}$ and $DR_{p}$ units.

Figure 1: Structure of RBP Early Fusion. The DR units are concatenated with
the input neurons. The fixed connections from the Inputs to the DR units are
not shown for simplicity. Figure 2: Structure of the RBP Mid Fusion. The DR
units are concatenated with the first hidden layer. The weights of incoming
connections of the DR units are fixed in RBP (see the main text for details).
In ERBP, we use the same structure but with trainable weights. Then the only
difference to a standard Feed Forward Neural Network is the prior on the
weights between input and hidden units as described in the text. This
structure can be applied to Recurrent Neural Networks, as long as we have $n$
items represented in the input.

There are different ways of integrating DR units into neural networks in RBP:
Early, Mid and _Late Fusion_.

In _Early Fusion_ , DR units are concatenated to input units as shown in
Figure 1. In _Mid Fusion_ , they are concatenated to the hidden layer as shown
in Figure 2. In both cases, the existing input and hidden units are unchanged.
The _Late Fusion_ design predicts abstract relations and is more complex. Late
Fusion are not used in this study, but a detailed description can be found in
Weyde and Kopparti (2019).

###  3.3 Embedded Relation Based Patterns

RBP adds units with hard-wired connections and non-standard activation
function, which limits the flexibility of that part of the network and makes
practical use more complex. By contrast, ERBP introduces a modified Mid Fusion
RBP structure and remodels it as a Bayesian prior on a standard weight matrix,
thus avoiding hard-coded weights and non-standard network structures and
activation functions. The approach of using a prior has been introduced in our
previous work Kopparti and Weyde (2020) for equality learning and here we are
extending it to abstract patterns and language modelling.

We model each DR unit of RBP with two standard neurons using ReLU activation
and model the fixed weights with a default weight matrix $D$, that is applied
at initialisation and through a loss function to the weights between input
neurons and a hidden layer. ERBP therefore has two nodes of comparison per
pair of input neurons, unlike RBP which has one, and we need therefore a
higher minimal number of hidden units in the first layer.

The matrix is initialised between the input and the first hidden layer as
follows. The incoming connections from two corresponding inputs to a neuron in
the hidden layer to be compared have values of $+1$ and $-1$. For the same
pair we use another hidden neuron with inverted signs of the weights, as in
rows 1 and 2. All other incoming weights to the hidden layer are set to 0,
including the bias. This ensures that in all cases where corresponding inputs
are not equal, there will be a positive activation in one of the hidden
neurons.

More formally, we can define the matrix $D$ as follows. Consider an
architecture with input consisting of $n$ tokens represented as vectors of
dimensionality $m$, concatenated to a $n\cdot m$ dimensional input vector.
Then each token vector $i$ starts at position $i\cdot m$ (assuming $i$ starts
at $0$). In the first hidden layer, we represent each of the $n(n-1)/2$ pairs
of input tokens with $2m$ neurons, so that the representation of pair $j$
starts at position $p_{j}=j\cdot 2m$ (assuming 0-indexing again). The hidden
layer has to have at least $n(n-1)/2\cdot 2m=n(n-1)m$ neurons. We can then
describe the creation of the matrix D with algorithm 1.

Algorithm 1 ERBP creation of weight matrix $D$

$D_{q,r}\leftarrow 0\,\forall q,r$ // initialise the matrix to 0

$p\leftarrow n(n-1)/2$ // number of token pairs

$k\leftarrow 0$ // will be used as row index

for $i_{1}$ from $0$ to $p-1$ do // first token in pair

for $i_{2}$ from $i_{1}+1$ to $p$ do // second token in pair

for $j$ from 0 to $m$ do // dimensions in token vectors

$D_{k,i_{1}\cdot m+j}=+1$ // first comparison neuron

$D_{k,i_{2}\cdot m+j}=-1$

$k\leftarrow k+1$

$D_{k,i_{1}\cdot m+j}=-1$ // second comparison neuron

$D_{k,i_{2}\cdot m+j}=+1$

$k\leftarrow k+1$

end for

end for

end for

An example of this default matrix $D$ for three tokens of length $m=2$ is
shown in Figure 3.

$\displaystyle D={\text{\boldmath$\begin{pmatrix}+1&0&-1&0&0&0\\\
-1&0&+1&0&0&0\\\ 0&+1&0&-1&0&0\\\ 0&-1&0&+1&0&0\\\ +1&0&0&0&-1&0\\\
-1&0&0&0&+1&0\\\ 0&+1&0&0&0&-1\\\ 0&-1&0&0&0&+1\\\ 0&0&+1&0&-1&0\\\
0&0&-1&0&+1&0\\\ 0&0&0&+1&0&-1\\\ 0&0&0&-1&0&+1\\\ \end{pmatrix}$}}$

Figure 3: Default weight matrix $D$ for 3 input token vectors of dimension
m=2. Each row corresponds to the incoming weights of a hidden neuron and each
column the outgoing weights of an input neuron. If there are more hidden
neurons than pairs of input neurons times token vector dimension ($p\cdot m$),
the additional rows contain only zeros.

As stated, Matrix $D$ is used for the loss function and also for
initialisation. It is sufficient to use $D$ only in the loss function, but
using $D$ also for initialisation speeds up convergence, as we found in
initial tests, and is therefore applied in most of our experiments. In the
initialisation, we first initialise weight matrix $W$ between the input and
hidden layer as normal, e.g. with low-energy noise, and then copy the non-zero
values of $D$ to $W$.

Further, we define an ERBP loss based on the difference between $D$ and the
actual weights in $W$. We compute the $L2$ or $L1$ norm of the difference
$D-W$. This loss term corresponds to a Bayesian prior on the weights with the
mean defined by the values of $D$. The $L2$ loss corresponds to a Gaussian
prior and $L1$ loss to a Laplacian prior, such that back propagation maximises
the posterior likelihood of the weights given the data (Williams, 1995). The
overall training loss $l_{t}$ is defined as

$l_{t}=l_{c}+\lambda\,l_{ERBP}$ (1)

where $l_{c}$ is the classification loss and $l_{ERBP}$ is

$l_{ERBP}=wl_{1}\sum_{i=1}^{k}(w_{i}-d_{i})^{2}+wl_{2}\sum_{i=1}^{k}|(w_{i}-d_{i})|.$
(2)

$\lambda$ is the regularisation parameter, corresponding to the inverse of the
variance of the prior, effectively regulating the strength of the ERBP
regularisation. $(wl_{1},wl_{2})$ are the weights for L1 and L2, respectively.
In principle, any combination of weights is possible, but here we only use
$(1,0)$ or $(0,1)$ for $(wl_{1},wl_{2})$. We call these methods ERBP L1 and
ERBP L2 respectively.

For $l_{c}$ we have used cross entropy loss in the experiments, although it
can be replaced with any other loss function suitable for the task. The ERBP
approach can be applied to feed froward and to recurrent networks. The only
additional condition for recurrent networks is that we need to use a sliding
window of size $n$. ERBP requires $n(n-1)m$ neurons in the first hidden layer
which leads to $n(n-1)m^{2}$ weight parameters. If this number of neurons is
present in the first hidden layer, no additional parameters are needed in the
network.

Although the $L1$ loss encourages sparsity, that is not the specific goal of
ERBP L1. Rather it is to enable learning of pairwise token equality by
encouraging suitable features that compare token vectors in each dimension.
Since equality learning is needed for abstract pattern recognition, but
equality learning is a hard problem for neural networks, we hope that abstract
pattern learning will benefit from ERBP similarly to RBP. We further apply
this prior on a wide number of synthetic tasks which benefit from the equality
based prior in different settings and experiments in the following sections.

##  4 Experiments: Abstract Pattern Recognition

In this section, we evaluate the ERBP method on generalising abstract
patterns, based on equality relations, from training data. We compare ERBP to
standard neural networks and Early and Mid-Fusion RBP, and we evaluate the
effect on mixed abstract and concrete patterns.

###  4.1 Dataset

For performing the rule learning experiments, we artificially generate data in
the form of triples for each of the experiments. We generate triples in all
five abstract patterns of length 3: AAA, AAB, ABA, ABB, and ABC for the
experiments. We use as sample vocabulary $a...l$ (12 letters) for both
prediction and classification tasks. The sequences are divided differently for
the different cases of classification. For all the experiments we used
separate train, validation, and test sets with 50%, 25%, and 25% of the data,
respectively. All sampling (train/test/validation split, downsampling) is done
per simulation. We used half of the vocabulary for training and the other half
for testing and validation (randomly sampled). Using disjoint parts of the
vocabulary means that the validation and test sets contain out of distribution
patterns, in particular non-zero activations of input neurons that are always
zero in the training set.

###  4.2 Setup

For all abstract pattern learning tasks, we used a standard feed-forward
neural network. We used a grid search over hyperparameters: the number of
epochs with values $[10,20,30]$, and the number of neurons in the hidden layer
with values $[10,20,30]$, except for ERBP where we use the minimal number
necessary for the ERBP matrix. We varied the regularisation parameter
$\lambda$ with values $[0.01,0.03,0.1,0.3,1,3,10,30]$ for the ERBP approaches.
For larger values of regularisation beyond 30, the performance did not improve
and showed a downward trend. We ran a total of 10 runs for each experiment. We
used the Adam optimiser (Kingma and Ba, 2014) by default and also Stochastic
Gradient Descent for comparison. We used a single hidden layer and a mini-
batch size of 1 unless indicated otherwise. The networks have been implemented
using the PyTorch library111http://pytorch.org.

###  4.3 Abstract Patterns

In this experiment, we aim to learn classification by abstract patterns based
on equality as in the experiments by Marcus et al. (1999), using the
terminology and tasks from Weyde and Kopparti (2019). Triples of items
$(\alpha,\beta,\gamma)$ following the abstract patterns AAA, AAB, ABA ABB and
ABC are presented to the network. These abstract patterns can be described in
logic using a binary equality predicate $eq(\cdot,\cdot)$. E.g., the abstract
patterns $ABA$ and $ABB$ can be represented by the following predicates:

$\displaystyle ABA$ $\displaystyle:\neg eq(\alpha,\beta)\land
eq(\alpha,\gamma)$ (3) $\displaystyle ABB$ $\displaystyle:\neg
eq(\alpha,\beta)\land eq(\beta,\gamma).$ (4)

These predicates only depend on the equality relations and not the values of
$\alpha,\beta,\text{and}\;\gamma$. They are also called algebraic patterns or
abstract rules (Marcus, 2001; Dehaene et al., 2015). We represent the input
tokens to the network as one-hot encoded vectors and perform 5 different
experiments as follows.

  1. 1.

ABA vs other: In this task, one class contains only patterns of ABA and the
other class contains all the other possible patterns (AAA, AAB, ABB, ABC),
downsampled for class balance. Expressed in logic, the task is to detect
whether $eq(\alpha,\gamma)\land\neg eq(\alpha,\beta)$ is true or false.

  2. 2.

ABB vs other: In this task, one class contains only patterns of the form ABB
and the other class contains all the other possible patterns (AAA, AAB, ABA,
ABC), downsampled for class balance. The logical task is to detect
$eq(\beta,\gamma)\land\neg eq(\alpha,\beta)$.

  3. 3.

ABA-BAB vs other: In this task, class one contains patterns of type ABA as in
1. For ABA sequences in the training set, the corresponding BAB sequences
appear in the test set. The other class contains all other possible patterns
(AAA, AAB, ABB, ABC) downsampled per pattern for class balance as before.

  4. 4.

ABA vs ABB: This task is like task 1 above, but only pattern ABB occurs in the
other class, so that this task has less variance in the second class. We
expected this task to be easier to learn because two equality predicates
$eq(\alpha,\gamma),eq(\beta,\gamma)$ change their values between the classes
and are each sufficient to indicate the class.

  5. 5.

ABC vs other: In this case, class one (ABC) has no pair of equal tokens, while
the $other$ class has at least one of
$eq(\alpha,\beta),eq(\alpha,\gamma),eq(\beta,\gamma)$ as $true$, i.e.
detecting equalities without localising them is sufficient for correct
classification.

Type | 1) | 2) | 3) | 4) | 5)
---|---|---|---|---|---
Standard | 50 (1.86) | 50 (1.83) | 50 (1.73) | 50 (1.81) | 50 (1.68)
Early Fusion | 65 (1.26) | 65 (1.29) | 75 (1.22) | 55 (1.18) | 65 (1.04)
Mid Fusion | 100 (0.00) | 100 (0.00) | 100 (0.05) | 100 (0.00) | 100 (0.00)
ERBP L1 | 100 (0.00) | 100 (0.00) | 100 (0.02) | 100 (0.00) | 100 (0.00)
ERBP L2 | 100 (0.00) | 100 (0.00) | 100 (0.00) | 100 (0.00) | 100 (0.00)

Table 1:  Abstract Pattern Learning. Test accuracy (in %) with different
models: (1) ABA vs other, 2) ABB vs other, 3) ABA-BAB vs other, 4) ABA vs ABB,
5) ABC vs other). The table shows average and standard deviation (in brackets)
over 10 simulations.

In Table 1 (abstract patterns) we present test set accuracy, the training set
accuracy was 100% in all cases. We find that abstract patterns are almost
perfectly generalised with ERBP L1 and ERBP L2, like with Mid Fusion RBP. We
compared the differences between network performances across 10 simulations
using the Wilcoxon Signed Ranked Test. The differences between ERBP L1/L2 and
Standard as well as between ERBP L1/L2 and Early Fusion are statistically
significant in all abstract pattern experiments at a threshold of $p<0.05$.
The differences between Mid Fusion, ERBP L1 and ERBP L2 are not significant.
However, while the Mid Fusion RBP achieves rounded 100% test accuracy, the
non-zero standard deviation indicates that some results are not fully
accurate, while ERBP L2 has zero standard deviation in all tasks and ERBP L1
in all but one tasks.

###  4.4 Parameter Variations

We study the effect of several parameters: number of hidden layers, choice of
optimiser, regularisation factor and weight initialisation on the abstract
pattern learning tasks.

No of Hidden | Standard | Early | Mid | ERBP L1 | ERBP L2
---|---|---|---|---|---
Layers | Network | Fusion | Fusion |  |
h=2 | 50 (1.56) | 65 (1.23) | 100 (0.05) | 100 (0.00) | 100 (0.00)
h=3 | 52 (1.59) | 66 (1.08) | 100 (0.03) | 100 (0.00) | 100 (0.00)
h=4 | 55 (1.63) | 68 (1.12) | 100 (0.02) | 100 (0.00) | 100 (0.00)
h=5 | 56 (1.55) | 70 (0.89) | 100 (0.02) | 100 (0.00) | 100 (0.00)
Table 2: Network Depth. Test accuracy (in %) for abstract pattern learning (ABA vs other) with h= 2,3,4,5 hidden layers. Averages and standard deviations over 10 simmulations. Type | ERBP L1 | ERBP L2
---|---|---
Adam | 100 (0.00) | 100 (0.00)
SGD | 98 (0.06) | 96 (0.04)
Table 3: Optimiser Choice. Test accuracy (in %) and standard deviation of
Abstract Pattern Learning (ABA vs other) using Adam and SGD for ERBP L1 and
L2. Averages and standard deviations (in brackets) over 10 simulations. SGD
can also lead to 100% accuracy on the test set, but needs higher $\lambda$
values.

Network Depth: We test identity learning with deeper neural network models,
using $h={2,3,4,5}$ hidden layers. The results are listed in Table 2, showing
only minor improvements in the network performance for deeper networks.
However, ERBP L1 and L2 generalisation is consistent and independent of the
network depth.

Optimiser Choice: We test Stochastic Gradient Descent (SGD) and compare to the
Adam optimiser (Kingma and Ba, 2014) for training the ERBP. We observe faster
convergence and greater improvement in the overall accuracy with Adam compared
to SGD. We observe similar results for both ERBP L1 and L2. Table 3 summarises
the results of abstract pattern learning for both optimisers with the
regularisation parameter $\lambda$ set to 1. We observe that the SGD does not
reach full generalisation in this setting, however it does so at higher values
of $\lambda$.

Figure 4: Regularisation Factor. Test accuracy of the network with ERBP L1 and
L2 when varying the regularisation factor $\lambda$ (in logarithmic scale) for
abstract pattern learning (ABA vs other).

Regularisation Factor: We vary the regularisation factor $\lambda$ in the loss
function of the ERBP model and observe that a large factor reliably leads to
perfect generalisation in abstract pattern learning task. We vary the
regularisation parameter $\lambda$ with values [0.01,0.03,0.1,0.3,1,3,10,30].
Figure 4 shows how the effect depends on the size the regularisation factor
$\lambda$ using L1 and L2 loss functions for abstract pattern learning task.
We test for larger values of $\lambda$, but the performance is worse beyond
$\lambda$ value 30, hence, we do not consider values beyond that.

Weight Initialisation: We evaluate the effect of different weight
initialisation schemes without the ERBP weight prior, to test whether ERBP
initialisation or other schemes might be sufficient on their own to learn
abstract patterns. We test random, zero, Xavier (Glorot and Bengio, 2010) and
ERBP initialisation. For random initialisation, weight and bias are
initialised from a uniform distribution over$(-1/\sqrt{n},1/\sqrt{n})$ where
$n$ is the size of the weight matrix. The results of the experiment are shown
in Table 4. Although ERBP initialisation shows the best generalisation in this
comparison, it falls far short of the performance with the ERBP weight loss,
which consistently achieves 100% test accuracy (see Table 1).

Initialisation: | Random | Zero | Xavier | ERBP (init only)
---|---|---|---|---
Task 1 | 53 (1.82) | 51 (1.67) | 54 (1.53) |  61 (1.12)
Task 2 | 53 (1.76) | 52 (1.72) | 54 (1.57) |  61 (1.09)
Task 3 | 55 (1.73) | 54 (1.59) | 56 (1.49) |  65 (1.04)
Task 4 | 52 (1.89) | 54 (1.62) | 55 (1.62) |  60 (1.23)
Task 5 | 52 (1.54) | 53 (1.58) | 54 (1.67) |  62 (1.20)
Table 4: Weight Initialisation. Test accuracy (in %) with different weight
initialisation methods on standard neural networks for various tasks ie. Task
1-5 Abstract Pattern Learning (ABA vs other, ABB vs other, ABA-BAB vs other,
ABA vs ABB, ABC vs other). Averages and standard deviations (in brackets) over
10 simulations.

We also evaluate the performance with the ERBP loss without the ERBP
initialisation, using standard random weight initialisation instead. The ERBP
loss on its own is sufficient for the model to produce 100% accuracy when
tested on Task 1 (ABA vs other). However, the training takes longer than with
ERBP initialisation, doubling the number of epochs roughly from 30 to 60.

###  4.5 Combined Abstract and Concrete Patterns

An important question about any inductive bias for abstract patterns is
whether it has negative effects on other tasks. Here we test the effect of
ERBP on concrete patterns. We will answer this question for real-world tasks
in the following section.

Abstract pattern rules are independent of the actual values of
$\alpha,\beta,\text{and}\;\gamma$. Concrete patterns, on the other hand, are
defined in terms of values from a vocabulary a,b,c, … . E.g., sequences a**,
i.e. beginning with ‘a’, or *bc, ending with ‘bc’, can be formulated in logic
as follows:

a** $\displaystyle:eq(\alpha,\text{`a'})$ (5) *bc
$\displaystyle:eq(\beta,\text{`b'})\land eq(\gamma,\text{`c'}).$ (6)

We conduct an experiment where the classes were defined by combinations of
abstract and concrete patterns. Specifically we define four combined patterns
based on combinations of the abstract pattern $ABA$ and $ABB$ with the
concrete patterns $a**$ and $b**$. E.g., the pattern $(ABA,a**)$ can be
expressed logically as

$(ABA,\textit{a**})=eq(\alpha,\gamma)\land\neg eq(\alpha,\beta)\land
eq(\alpha,\text{`a'}).$ (7)

We define four classes based on two abstract and two concrete patterns, where
each class is a combination of one abstract and one concrete pattern. The
classes are defined as follows:

$\displaystyle 1:(\textit{ABA,a**})\qquad 2$
$\displaystyle:(\textit{ABB,a**})$ (8) $\displaystyle
3:(\textit{ABA,b**})\qquad 4$ $\displaystyle:(\textit{ABB,b**}).$ (9)

We create the dataset with each class equally frequent and with items not
prescribed by the patterns drawn at random, so that the abstract patterns (1,3
vs 2,4) and concrete patterns (1,2 vs 3,4) are statistically independent. We
use a vocabulary of 18 characters, out of which 12 are used for training and 6
are used for validation/testing in addition to ‘a’ and ‘b’, which need to
appear in all sets because of the definition of the concrete patterns. In our
experiment we perform a four-way classification using train, validation and
test split of 50%, 25% and 25% respectively. The results of the experiment are
listed in Table 5

Type | Accuracy
---|---
Standard Network | 39 (1.53)
Early Fusion | 66 (1.22)
Mid Fusion | 100 (0.00)
ERBP L1 | 100 (0.00)
ERBP L2 | 100 (0.00)
Table 5: Combined Patterns. Test accuracy (in %) for learning combined
abstract and concrete patterns using different models. Averages and standard
deviations (in brackets) over 10 simulations. Both Mid Fusion and ERBP
approaches result in 100% accuracy in all cases.

The results show that the mixed patterns are perfectly generalised by Mid
Fusion RBP and ERBP. We also test with only concrete patterns with two classes
starting with $a**$ and $b**$ respectively, and observe that ERBP leads to
100% accuracy unlike a standard network without ERBP which gives an accuracy
of 94%. This shows that the (E)RBP does not impede neural network learning of
concrete patterns. We try a range of values for $\lambda$ and found that a
minimum was necessary for learning but higher values did not impede the
learning of the concrete patterns.

The models with ERBP lead to 100% accuracy on a wide range of synthetic
classification tasks. Several authors, like Seidenberg and Elman (1999); Vilcu
and Hadley (2005); Shultz and Bale (2006); Frank (2014); Alhama and Zuidema
(2016, 2019) claimed success and showed improvements for the abstract pattern
learning task. However, the evaluation has mostly been conducted by testing
whether the output of the network shows a statistically significant difference
between the output for inputs that conform to a trained abstract pattern and
those that do not. From a machine learning perspective, this criterion is not
satisfactory. Instead, we would expect that an identity/equality rule should
always be applied correctly once if it has been learned from examples, at
least in cases of noise-free synthetic data, which we have achieved in with
the ERBP loss.

##  5 Experiments: Language and Music Modelling

In order to evaluate the effect of ERBP on language models, we perform
experiments with real world data on character and word prediction in natural
language and also on pitches in melodies. We use RNN, GRU and LSTM models for
character, word, and musical pitch prediction.

The input vectors represent items in a context window of length n. Therefore
there are $n\cdot(n-1)/2$ pairs of vectors to compare. The ERBP is applied in
the same way as before in the first hidden layer after the input. In these
tasks, the encoding of the information is not binary, as in the synthetic
tasks, but integer-based or continuous. Thus, the differences in DR units and
the ERBP hidden neurons represent not just equality but a form of distance of
the input values, which we expect to be useful for prediction.

###  5.1 Character and Word Prediction

We use Wikitext-2 (Merity et al., 2016) for character and word prediction. For
word prediction, the entire dataset with 2 million words was used with
train/validation/test split as in the original dataset with pretrained Glove
embeddings (Pennington et al., 2014) with 50 dimensional vectors. For
character prediction, a truncated version with $60\,000$ words was used with a
train/validation/test split of 50/25/25 and with integer encoding of the
characters.

Type | n=10 | n=20 | n=30 | n=40
---|---|---|---|---
RNN | 21.99 | 21.73 | 21.42 | 21.47
Early Fusion | 21.90 | 21.64 | 21.35 | 21.24
Mid Fusion | 21.89 | 21.60 | 21.33 | 21.20
ERBP L1 | 20.66 | 20.50 | 20.04 | 20.32
ERBP L2 | 20.60 | 20.53 | 20.03 | 20.27
Table 6: Character prediction. Perplexity per character for various context
lengths n = 10,20,30,40 with RNNs on the Wikitext-2 dataset truncated to 60k
words with integer encoding tested on standard RNN, Early, Mid Fusion, ERBP L1
and L2. The best results (in bold) occur for the ERBP approaches with
$\lambda=0.3$.

We use networks with 2 hidden layers with 50 neurons each. Both the hidden
layers have recurrent connections and we have used this network structure
throughout for all the experiments. We train the networks for up to 30 epochs
for characters and up to 40 for words. The learning rate was set to 0.01.
Training typically converges after less than 30 epochs and we select the best
model according to the validation loss. We test with regularisation parameter
$\lambda$ values [0.01,0.03,0.1,0.3,1,3] for ERBP. We test only for the above
set of $\lambda$ values, as the performance when $\lambda>3$ was worse for
both character and word predictions tasks. Hence, we did not consider larger
values of $\lambda$. We use a context length $n$ of [10,20,30,40] and evaluate
again ERBP L1 and L2, RBP Early and Mid Fusion, and standard networks.

Type | n=10 | n=20 | n=30 | n=40
---|---|---|---|---
GRU | 21.97 | 21.72 | 21.39 | 21.45
Early Fusion | 21.89 | 21.63 | 21.33 | 21.20
Mid Fusion | 21.87 | 21.59 | 21.30 | 21.19
ERBP L1 | 20.61 | 20.43 | 20.02 | 20.25
ERBP L2 | 20.53 | 20.46 | 19.96 | 20.23
Table 7: Character prediction. Perplexity per character for various context lengths n = 10,20,30,40 with GRUs on the Wikitext-2 dataset truncated to 60k words with integer encoding tested on standard GRU, Early, Mid Fusion, ERBP L1 and L2. The best results (in bold) occur for the ERBP approaches with $\lambda=0.3$.  Type | n=10 | n=20 | n=30 | n=40
---|---|---|---|---
LSTM | 21.88 | 21.64 | 21.34 | 21.33
Early Fusion | 21.84 | 21.63 | 21.27 | 21.14
Mid Fusion | 21.81 | 21.57 | 21.24 | 21.16
ERBP L1 | 20.54 | 20.32 | 19.89 | 20.18
ERBP L2 | 20.45 | 20.33 | 19.87 | 20.19
Table 8: Character prediction. Perplexity per character for various context
lengths n = 10,20,30,40 with LSTMs on the Wikitext-2 dataset truncated to 60k
words with integer encoding tested on standard LSTM, Early, Mid Fusion, ERBP
L1 and L2. The best results (in bold) occur for the ERBP approaches with
$\lambda=0.3$.

The results for character prediction and word prediction are summarised in
Tables 6, 7, 8 and 9, 10 11 for RNN, GRU and LSTM models respectively. The
performance was best for LSTMs with ERBP and the choice of $\lambda$ value
didn’t have a major effect in the case of word prediction, unlike character
prediction where $\lambda=0.3$ gave best performance. We test for larger
values of the regularisation factor but the performance did not improve.

Type | n=10 | n=20 | n=30 | n=40
---|---|---|---|---
RNN | 186.97 | 164.56 | 114.26 | 101.95
Early Fusion | 186.80 | 164.52 | 114.21 | 101.89
Mid Fusion | 186.52 | 164.41 | 114.19 | 101.69
ERBP L1 | 185.83 | 163.98 | 113.96 | 100.25
ERBP L2 | 185.54 | 163.90 | 113.99 | 100.23
Table 9: Word Prediction. Perplexity per word for various context lengths n = 10,20,30,40 with RNNs on the Wikitext-2 dataset consisting of 2 million words with integer encoding tested on standard RNN, Early, Mid Fusion, ERBP L1 and L2. The best results (in bold) occur for the ERBP approaches.  Type | n=10 | n=20 | n=30 | n=40
---|---|---|---|---
GRU | 174.62 | 160.31 | 114.05 | 97.62
Early Fusion | 174.35 | 160.26 | 113.86 | 96.39
Mid Fusion | 174.42 | 160.27 | 113.55 | 96.35
ERBP L1 | 173.33 | 159.36 | 113.42 | 96.21
ERBP L2 | 173.21 | 159.32 | 113.32 | 96.32
Table 10: Word Prediction. Perplexity per word for various context lengths n = 10,20,30,40 with GRUs on the Wikitext-2 dataset consisting of 2 million words with integer encoding tested on standard GRU, Early, Mid Fusion, ERBP L1 and L2. The best results (in bold) occur for the ERBP approaches.  Type | n=10 | n=20 | n=30 | n=40
---|---|---|---|---
LSTM | 160.44 | 153.61 | 113.40 | 93.28
Early Fusion | 160.32 | 153.42 | 113.26 | 93.23
Mid Fusion | 160.38 | 153.30 | 113.23 | 93.15
ERBP L1 | 159.29 | 152.78 | 113.02 | 92.96
ERBP L2 | 159.22 | 152.89 | 112.99 | 92.82
Table 11: Word Prediction. Perplexity per word for various context lengths n =
10,20,30,40 with LSTMs on the Wikitext-2 dataset consisting of 2 million words
with integer encoding tested on standard LSTM, Early, Mid Fusion, ERBP L1 and
L2.The best results (in bold) occur for the ERBP approaches.

We use the Wilcoxon Signed Rank test with threshold $p=0.05$ as above to
compare the standard models with ERBP L1 and L2 for both character and word
prediction across 60000 words for context length $n=10$. For character
prediction, RNN, GRU and LSTM with ERBP L1 and L2 are significantly better
than the standard RNN, GRU and LSTM models. For word prediction, all ERBP
models except LSTM ERBP L1 are significantly better than the corresponding
standard models.

In the case of language modelling for both character and word level, our
results are not comparable to the SOTA models on the Wikitext-2 dataset, which
have about 395M parameters in perplexity of 34.1 without pre-training Wang et
al. (2019). Even with state-of-the-art LSTM models our experiment are not
comparable as we used a subset of Wikitext-2.

###  5.2 Melody Prediction

In another experiment, we test ERBP for predicting the pitch of the next note
in melodies with a selection of the Essen Folk Song Collection (Schaffrath,
1995), which comprises of 8 sets of songs in different styles. Pitches are
integer-encoded. With RNN, GRU and LSTM we use two hidden layers of size 20.

In Figure 5 we indicated the sliding window at the initial position as a blue
rectangle which is the given context. We also highlighted repeated notes,
where we hypothesise that the repetition has a bearing on the prediction of
the next note, if the network learns to detect the repetition. The notes in
the pink circle correspond to the repetitions within a given context, and the
notes in the green circle are an example of repetition between a given context
and a corresponding note.

Figure 5: Examples from the Essen Folk Song Collection : Repetition of notes
in a given context length ‘n‘’ = 6 here represented in a blue rectangle. Pink
circles correspond to repeating notes in the context length ‘n’=6. Green
circles correspond to repetition of notes within a given context and the next
note being predicted.

We use Adam and tested values [0.01, 0.03, 0.1, 0.3, 1, 3] for the
regularisation factor $\lambda$. Similar to the character and word prediction
experiments, we evaluate for smaller $\lambda$ values, as the performance
degraded for values of $\lambda>3$. We tested context lengths of 5 and 10 and
the train/validation/test split was set to 50/25/25%.

Type | RNN | GRU | LSTM
---|---|---|---
Standard | 2.8012 | 2.7968 | 2.7928
Early Fusion | 2.7365 | 2.7328 | 2.7314
Mid Fusion | 2.7356 | 2.7302 | 2.7219
ERBP L1 | 2.7264 | 2.7252 | 2.7132
ERBP L2 | 2.7240 | 2.7260 | 2.7144
Table 12: Pitch Prediction. Average cross entropy per note for pitch prediction using context length $n=5$ on the Essen Folk Song dataset using standard models, Early, Mid fusion and ERBP approaches. The best results (in bold) are achieved with the ERBP approaches at $\lambda$ = 0.3.  Type | RNN | GRU | LSTM
---|---|---|---
Standard | 2.7502 | 2.7457 | 2.7432
Early Fusion | 2.6735 | 2.6723 | 2.6712
Mid Fusion | 2.6653 | 2.6650 | 2.6648
ERBP L1 | 2.6642 | 2.6641 | 2.6639
ERBP L2 | 2.6649 | 2.6645 | 2.6632
Table 13: Pitch Prediction. Average cross entropy per note for pitch
prediction using context length $n=10$ on the Essen Folk Song dataset using
standard models, Early, Mid fusion and ERBP approaches. The best results (in
bold) are achieved with the ERBP approach at $\lambda$ = 0.3.

Tables 12 and 13 summarise the results of the neural networks without and with
RBP in early, mid fusion and using ERBP L1 and L2. We observe the best results
for $\lambda$ values of 0.3. Larger values of $\lambda$ did not result in
improved results. We have tested for statistical significance over the results
for the 8 subsets, using the Wilcoxon signed rank test with threshold $p=0.05$
as above. We find that all model types (Standard/Early/Mid/ERBP L1/L2) are
different with statistical significance, so that ERBP L1 and L2 outperform
standard networks and RBP models for this task.

In the case of music modelling, SOTA model on monophonic pitch prediction task
is the work by (Langhabel, 2017) in which a feature discovery PULSE learning
framework has been proposed. The cross entropy was $2.395$ and the best
performance with ERBP using LSTMs in our experiments was $2.663$. However, the
models cannot be directly compared here as well, as the approach, number of
features, model architecture, parameters, context length are not directly
comparable. ERBP model has also not been evaluated on longer context lengths,
which we believe might result in improved or closer SOTA model performance
when fine-tuned effectively.

##  6 Experiments: Complex Learning Tasks

In this section, we evaluate the use of ERBP for more complex tasks.
Specifically, we experiment with graph distance learning as an example of
distance and relation learning and with compositional sentence entailment as a
compositional natural language task.

###  6.1 ERBP for learning Graph Edit Distance

In this experiment, we extend the scope from equality based patterns and
sequential prediction to a situation of end-to-end learning of a distance
function. Our goal is to learn a distance function between graphs. Given two
graphs $G_{1},G_{2}$, a graph distance model is a function $f(G_{1},G_{2})$
that computes a scalar distance value. This experiment uses Graph Neural
Networks (GNN), which are popularly used in relational learning tasks. In a
GNN, a graph structure with nodes and edges is used as input. A standard GNN
model comprises of two encoders to learn node and edge representations using
iterative message passing. For more details about the GNN model refer Zhou et
al. (2018).

Our model is based on embedding each graph into a vector with a GNN and then
classify pairs of graphs based on their distance. We use the graph edit
distance, which counts the number of operations needed for transforming one
graph into another. For more details refer to (Li et al., 2019). A graph
distance model that aligns with the GED is trained by giving graphs with small
edit distance a low distance and otherwise high distance as learning targets.

For our dataset, random pairs of graphs are generated from the Graph
Similarity data generator (Li et al., 2019). The generator yields pairs of
graphs $(G_{1},G_{2})$ and labels $t\in\\{-1,1\\}$ for this pair where ‘-1’
and and ‘+1’ signify that GED is above or below a threshold, respectively. The
loss function we optimise is

$L_{\mathrm{pair}}=\mathbb{E}_{(G_{1},G_{2},t)}[\max\\{0,\gamma-t(1-d(GNN(G_{1}),GNN(G_{2})))\\}].$
(10)

This loss encourages similar graphs to have distance smaller than $1-\gamma$,
and dissimilar graphs to have distance greater than $1+\gamma$, where $\gamma$
is a margin parameter, the NN is applied twice with shared weights, and $d$ is
a distance function to compare the graph. The dimensionality of node vectors
is 32 and that of graph embedding vectors is 128. We evaluate the model here
with several distance functions d: The standard Euclidean distance and
trainable NNs, specifically a Siamese Network and an MLP with and without ERBP
. The MLP has a single hidden layer with 256 neurons. The whole network is
trained end to end with a total of 1000 graph pairs in a split of 60/20/20%
for training, validation and test set, respectively. The results are shown in
Table 14.

Distance Function | Accuracy
---|---
Standard MLP | 95.61%
Siamese network | 96.09%
Euclidean distance | 97.54%
MLP with ERBP | 97.72%
Table 14: Graph Edit Distance. Accuracy of GNNs with different distance
functions for the graph edit distance (GED) task.

As can be seen from Table 14, the GNN outperforms a Siamese network in the GED
task. GNN with MLP+ERBP results in further improvements when compared to a
standard GNN, even though the difference is small. Table 14 shows that
standard GNN reaches accuracy of 97.54% and GNN with ERBP produces 97.72% on
1000 pairs generated from the Graph Similarity data generator (Li et al.,
2019). There is no directly comparable state of the art for this experiment
and the standard Euclidean distance produces already good results. However,
the MLP with ERBP reduces the number errors by over 9% compared to Euclidean
distance (2.28 vs 2.46%), while the other two trainable models perform worse
than Euclidean.

###  6.2 Compositional Sentence Entailment

In another experiment, the effect of ERBP is tested on an entailment task in
natural language data. In this task, we extend the notion of abstract rules to
the semantics of sentences, albeit in a very restricted syntactic context. The
notion of compositionality here is in the sense of understanding of how words
combine to form a sentence in a way that generalises to words and sentences
that have not previously been encountered.

The dataset used in the task is the Compositional Comparison Dataset
introduced by Dasgupta et al. (2018). The task is to classify a pair of
sentences into neutral, contradiction or entailment originally motivated from
the popular Stanford Natural Language Inference (SNLI) dataset Bowman et al.
(2015) natural language inference classification task. In this abstract
compositionality task, pairs of sentences (A,B) are generated which differ by
permutation of words, such that each of the pairs represent different
relations. This dataset is called as the Compositional Comparison dataset as
all the pairs of sentences are compositionally generated by changing the word
ordering in the sentences. There are three categories ‘Same’,‘More-less’ and
‘Not’. The structure of the sentences used is shown in Table 15, where the
type assignment holds true for any X, Y and Z. It is tested if the neural
network models to generalise to X, Y and Z that have never been encountered
before.

Type | Entailment | Contradiction | No of Pairs
---|---|---|---
Same | X is more Y than Z | Z is more Y than X | 14670
More-Less | Z is less Y than X | X is less Y than Z | 14670
Table 15: Sentence Entailment. Comparisons dataset summary. The premise to
compare to is: X is more Y than Z

In this experiment, we excluded the ’not’ category and the ’neutral’ class
from the original dataset, to focus on challenging tasks that are suitable for
testing compositionality based on comparisons. The values for X, Y and Z can
be arbitrary nouns for X and Z and adjectives for Y.

For example, in the Same Type Contradiction case, the sentence pairs differ
only in the order of the words.
A : The woman is more cheerful than the man
B : The man is more cheerful than the woman
And in the Entailment case, the sentences are identical:
A : The woman is more cheerful than the man
B : The woman is more cheerful than the man (Entailment)

In the More-Less Type, the Contradiction pairs differ by whether they contain
the word ‘more’ or the word ‘less’:
A : The woman is more cheerful than the man
B : The woman is less cheerful than the man
There the Entailment also differs additionally by word order:
A : The woman is more cheerful than the man
B : The man is less cheerful than the woman

We encode the sentences pairwise by word in A and B, i.e. one pair of words at
same position in A and B per time step. We apply the ERBP prior to the pair of
words rather than using a time window as in Section 5. We use Glove embeddings
(Pennington et al., 2014) and a network with a single LSTM layer and a sigmoid
layer for classification as the output. The dataset consists of approximately
5k sentences with equal split between the categories. As a baseline, we use a
Bag of Words (BOW) encoding that averages the Glove embeddings with a Multi-
Layer Perception (MLP). The state of art model for this type of task is the
InferSent model Conneau et al. (2017).

Model | Same type | More-Less type
---|---|---
BOW-MLP | 50% | 30.24%
InferSent model Conneau et al. (2017) | 50.37% | 50.35%
LSTM with ERBP | 51.32% | 50.64%
Table 16: Sentence Entailment. Accuracy of various models for abstract
compositionality task.

The results are listed in Table 16. The BOW/MLP model results are exactly at
chance level and the InferSent model perform only slightly above at 50.37% for
the ‘Same’ type class. LSTM with ERBP results improves by just under 1pp with
51.32%. For the ‘More-Less’ type, the Bag of Words MLP model gives only about
30% accuracy where as the InferSent and the LSTM model with ERBP give slightly
above 50% accuracy.

We can say that the model did benefit from the ERBP and the improvements were
consistent for the both the ‘Same’ and ‘More-Less’ types but the improvement
size is small.

##  7 Discussion

We have introduced ERBP as a re-modelling of RBP in the form of a Bayesian
prior on the weights as a solution for abstract pattern learning that is
simple to integrate into standard recurrent and feed-forward network
structures as a regularisation term and that retains the full flexibility of
the network learning without hard coded weights.

The experiments in Section 4 show that the ERBP L1 and L2 models are effective
in learning classification of abstract patterns on artificial sequence data,
and they improve performance slightly over the original RBP. The learning of
abstract patterns with ERBP is robust over a wide range of parameter settings
(Section 4.4) and does not limit the network’s learning of concrete pattern in
combination with abstract patterns or on its own (Section 4.5).

The second point of this study is whether the enabling of the abstract pattern
learning can improve neural network learning on real-world data. This was
addressed in the second set of experiments on language and music modelling as
well as a sentence entailment task and graph comparison. The language and
music modelling results show that the prediction performance benefits from
ERBP in all tested tasks of character and word prediction in natural language,
and pitch prediction in melodies. We observe that ERBP with recurrent models
(RNN, GRU, LSTM) leads to consistent improvements across different context
lengths and in tasks when compared to RBP and standard RNN model types. The
gain in perplexity obtained with ERBP is small but in most cases statistically
significant compared to RBP and standard NNs.

We performed two additional experiments on more complex tasks, compositional
sentence entailment with LSTMs and graph comparison with graph neural
networks, where we achieved small improvements with ERBP. For the
compositional entailment task, and LSTM network with ERBP outperforms the
baseline Bag of Words model and the state-of-the-art InferSent encoder-decoder
model (Conneau et al., 2017) slightly. In the Graphs Edit Distance task, the
GNN with MLP/ERBP as a trainable distance function outperforms both a Siamese
network and a GNN with Euclidean distance, but the difference between the two
GNN variants is small. While we believe that modelling of equality and
distance is a necessary component to better modelling, these tasks seem to
require more comprehensive approaches where the comparisons are more
strategically applied. There is clearly room for improvement, particularly in
the entailment task.

Overall, our results show that ERBP as a weight prior is an easy method to
integrate into the standard networks, wherever there are multiple input
vectors to compare. We demonstrated the use of ERBP with several neural
networks models, including feed-forward, RNNs and their gated variants, and
Graph Neural Networks. All networks did benefit from ERBP, with dramatic
improvements in abstract pattern recognition on synthetic sequence data. The
prediction improvements are relatively smaller real-life applications,
pointing to the fact that learning equality is not the only aspect that is
missing for improved language learning. This was even more pronounced in the
complex tasks of entailment and graph distance. Overall, we see the results
provides evidence that addressing systematicity in the form of equality and
distance learning in neural networks is not just a theoretical issue, but that
it has a positive impact on real-life tasks.

From a practical perspective, ERBP is straightforward to implement and
integrate into all standard network architectures, so that is still worth
exploring, even if the gains are not always substantial. We have observed no
negative effects of ERBP compared to standard networks and the method proved
to be robust to parameter values and the choice of L1 and L2 in all the
experiments.

##  8 Conclusions

In this study we focused on abstract pattern learning with neural network
architectures based on equality and distance relations. We introduce Embedded
Relation Based Patterns (ERBP), a prior on the weights of feed-forward and
recurrent neural network architectures that leads to learning of abstract
patterns, where standard neural networks fail. ERBP has been proven in our
experiment as a way of creating an inductive bias that encourages learning of
abstract patterns in synthetic as well as real word data. The ERBP weight
prior acts as a regularisation term which is easy to integrate into standard
back-propagation.

We observed in experiments that with ERBP L1 and L2 weight priors, neural
network models learn generalisable solutions to classification tasks based on
abstract pattern learning. While most approaches to learning abstractions
focus on the structure of the network and non-standard operators, this is to
our knowledge the first approach that addresses abstract pattern recognition
with a prior on the network weights.

In general, we see ERBP-like mechanisms as a way of modelling inductive bias
in neural network architectures that helps improve data efficiency by
systematic learning. We believe that this approach of creating an inductive
bias with weight priors can be extended easily to other forms of relations and
will be beneficial for many other learning tasks.

The effect of ERBP will be studied further to assess its effectiveness on
different tasks and datasets. Beyond its current form, ERBP can be adapted to
other forms of abstract relations and improving generalisation on more complex
tasks such as question answering or perception-based reasoning by extending
ERBP and combining it with memory models. We also see promise in extending
this approach towards learning higher-level abstractions by combining ERBP
with explicit memory and thus approaching a more comprehensive learning model.

## References

  * Alhama and Zuidema (2016) Alhama RG, Zuidema W (2016) Pre-wiring and pre-training: What does a neural network need to learn truly general identity rules. CoCo at NIPS
  * Alhama and Zuidema (2019) Alhama RG, Zuidema W (2019) A review of computational models of basic rule learning: The neural-symbolic debate and beyond. Psychonomic Bulletin & Review 26(4):1174–1194, DOI 10.3758/s13423-019-01602-z, URL https://doi.org/10.3758/s13423-019-01602-z
  * Altmann and Dienes (1999) Altmann G, Dienes Z (1999) Technical comment on rule learning by seven-month-old infants and neural networks. In Science 284(5416):875–875
  * Andreas (2019) Andreas J (2019) Measuring compositionality in representation learning. ArXiv abs/1902.07181
  * Atanov et al. (2019) Atanov A, Ashukha A, Struminsky K, Vetrov D, Welling M (2019) The deep weight prior. In: International Conference on Learning Representations, URL https://openreview.net/forum?id=ByGuynAct7
  * Baroni (2019) Baroni M (2019) Linguistic generalization and compositionality in modern artificial neural networks. CoRR abs/1904.00157, URL http://arxiv.org/abs/1904.00157, 1904.00157
  * Bastings et al. (2018) Bastings J, Baroni M, Weston J, Cho K, Kiela D (2018) Jump to better conclusions: SCAN both left and right. CoRR abs/1809.04640, URL http://arxiv.org/abs/1809.04640, 1809.04640
  * Battaglia et al. (2018) Battaglia PW, Hamrick JB, Bapst V, Sanchez-Gonzalez A, Zambaldi V, Malinowski M, Tacchetti A, Raposo D, Santoro A, Faulkner R, et al. (2018) Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:180601261
  * Besold et al. (2017) Besold TR, d’Avila Garcez AS, Bader S, Bowman H, Domingos PM, Hitzler P, Kühnberger K, Lamb LC, Lowd D, Lima PMV, de Penning L, Pinkas G, Poon H, Zaverucha G (2017) Neural-symbolic learning and reasoning: A survey and interpretation. CoRR abs/1711.03902, URL http://arxiv.org/abs/1711.03902, 1711.03902
  * Bowman et al. (2015) Bowman SR, Angeli CM Gabor Potts, D C (2015) A large annotated corpus for learning natural language inference. In: Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing (EMNLP), Association for Computational Linguistics
  * Christiansen and Chater (1994) Christiansen MH, Chater N (1994) Generalization and connectionist language learning. Mind & Language 9(3):273–287
  * Cohen and Shashua (2016) Cohen N, Shashua A (2016) Inductive bias of deep convolutional networks through pooling geometry. CoRR abs/1605.06743, URL http://arxiv.org/abs/1605.06743, 1605.06743
  * Conneau et al. (2017) Conneau A, Kiela D, Schwenk H, Barrault L, Bordes A (2017) Supervised learning of universal sentence representations from natural language inference data. CoRR abs/1705.02364, URL http://arxiv.org/abs/1705.02364, 1705.02364
  * Dasgupta et al. (2018) Dasgupta I, Guo D, Stuhlmüller A, Gershman S, Goodman N (2018) Evaluating compositionality in sentence embeddings
  * De Raedt and Thon (2010) De Raedt L, Thon I (2010) Probabilistic rule learning. vol 6489, pp 47–58, DOI 10.1007/978-3-642-21295-6˙9
  * De Raedt et al. (2019a) De Raedt L, Manhaeve R, Dumancic S, Demeester T, Kimmig A (2019a) Neuro-symbolic = neural + logical + probabilistic. In: Proceedings of the 2019 International Workshop on Neural- Symbolic Learning and Reasoning, p 4, URL https://sites.google.com/view/nesy2019/home
  * De Raedt et al. (2019b) De Raedt L, Manhaeve R, Dumancic S, Demeester T, Kimmig A (2019b) Neuro-symbolic = neural + logical + probabilistic. In: Proceedings of the 2019 International Workshop on Neural- Symbolic Learning and Reasoning, p 4, URL https://sites.google.com/view/nesy2019/home
  * Dehaene et al. (2015) Dehaene S, Meyniel F, Wacongne C, Wang L, Pallier C (2015) The neural representation of sequences: from transition probabilities to algebraic patterns and linguistic trees. Neuron 88(1):2–19
  * Demeester et al. (2016) Demeester T, Rocktäschel T, Riedel S (2016) Lifted rule injection for relation embeddings. 1606.08359
  * Elman (1999) Elman J (1999) Generalization, rules, and neural networks: A simulation of marcus et. al. https://crlucsdedu/~elman/Papers/MVRVsimulationhtml
  * Fodor and McLaughlin (1990) Fodor J, McLaughlin BP (1990) Connectionism and the problem of systematicity: Why smolensky’s solution doesn’t work. Cognition 35(2):183–204
  * Fodor and Pylyshyn (1988) Fodor JA, Pylyshyn ZW (1988) Connectionism and cognitive architecture: A critical analysis. Cognition 28(1-2):3–71
  * Frank (2014) Frank SL (2014) Getting real about systematicity. In: Calvo P, Symons J (eds) The architecture of cognition: Rethinking Fodor and Pylyshyn’s systematicity challenge, MIT Press, pp 147–164
  * Garcez et al. (2015) Garcez A, Besold TR, Raedt L, Foldiak P, Hitzler P, Icard T, Kuhnberger KU, Lamb LC, Miikkulainen R, Silver DL (2015) Neural-symbolic learning and reasoning: Contributions and challenges, URL https://openaccess.city.ac.uk/id/eprint/11838/
  * Gershman and Niv (2015) Gershman SJ, Niv Y (2015) Novelty and inductive generalization in human reinforcement learning. Topics in cognitive science 7 3:391–415
  * Glorot and Bengio (2010) Glorot X, Bengio Y (2010) Understanding the difficulty of training deep feedforward neural networks. Journal of Machine Learning Research - Proceedings Track 9:249–256
  * Griffiths et al. (2010) Griffiths TL, Chater N, Kemp C, Perfors A, Tenenbaum JB (2010) Probabilistic models of cognition: Exploring representations and inductive biases. Trends in cognitive sciences 14:357–64, DOI 10.1016/j.tics.2010.05.004
  * Hamrick et al. (2018) Hamrick JB, Allen KR, Bapst V, Zhu T, McKee KR, Tenenbaum JB, Battaglia PW (2018) Relational inductive bias for physical construction in humans and machines. arXiv preprint arXiv:180601203
  * Hupkes et al. (2019) Hupkes D, Dankers V, Mul M, Bruni E (2019) Compositionality decomposed: how do neural networks generalise? 1908.08351
  * Keresztury and Bruni (2020) Keresztury B, Bruni E (2020) Compositional properties of emergent languages in deep learning. 2001.08618
  * Kingma and Ba (2014) Kingma DP, Ba JL (2014) Adam : A method for stochastic optimization URL https://arxiv.org/abs/1412.6980
  * Kopparti and Weyde (2019) Kopparti R, Weyde T (2019) Factors for the generalisation of identity relations by neural networks. In: ICML 2019 Workshop on Understanding and Improving Generalization in Deep Learning
  * Kopparti and Weyde (2020) Kopparti R, Weyde T (2020) Weight priors for learning identity relations. URL https://arxiv.org/abs/2003.03125, 2003.03125
  * Lake and Baroni (2018) Lake B, Baroni M (2018) Generalization without systematicity: On the compositional skills of sequence-to-sequence recurrent networks. In: International Conference on Machine Learning, pp 2879–2888
  * Lake (2019) Lake BM (2019) Compositional generalization through meta sequence-to-sequence learning. CoRR abs/1906.05381, URL http://arxiv.org/abs/1906.05381, 1906.05381
  * Langhabel (2017) Langhabel J (2017) Learning a predictive model for music using PULSE. CoRR abs/1709.08842, URL http://arxiv.org/abs/1709.08842, 1709.08842
  * Le et al. (2015) Le QV, Jaitly N, Hinton GE (2015) A simple way to initialize recurrent networks of rectified linear units. CoRR abs/1504.00941, URL http://arxiv.org/abs/1504.00941, 1504.00941
  * Li et al. (2019) Li Y, Gu C, Dullien T, Vinyals O, Kohli P (2019) Graph matching networks for learning the similarity of graph structured objects. CoRR abs/1904.12787, URL http://arxiv.org/abs/1904.12787, 1904.12787
  * Liska et al. (2018a) Liska A, Kruszewski G, Baroni M (2018a) Memorize or generalize? searching for a compositional RNN in a haystack. CoRR abs/1802.06467, URL http://arxiv.org/abs/1802.06467, 1802.06467
  * Liska et al. (2018b) Liska A, Kruszewski G, Baroni M (2018b) Memorize or generalize? searching for a compositional RNN in a haystack. CoRR abs/1802.06467, URL http://arxiv.org/abs/1802.06467, 1802.06467
  * Marcus (2001) Marcus GF (2001) The algebraic mind: Integrating connectionism and cognitive science. Cambridge MIT Press
  * Marcus (2018) Marcus GF (2018) Deep learning : a critical appraisal. arXiv:180100631
  * Marcus et al. (1999) Marcus GF, Vijayan S, Rao S, Vishton P (1999) Rule learning by seven-month-old infants. Science, 283 5398:77–80
  * Merity et al. (2016) Merity S, Xiong C, Bradbury J, Socher R (2016) Pointer sentinel mixture models. CoRR abs/1609.07843, URL http://arxiv.org/abs/1609.07843, 1609.07843
  * Mikolov et al. (2015) Mikolov T, Joulin A, Chopra S, Mathieu M, Ranzato M (2015) Learning longer memory in recurrent neural networks URL https://arxiv.org/abs/1412.7753
  * Minervini et al. (2017a) Minervini P, Costabello L, Muñoz E, Novácek V, Vandenbussche PY (2017a) Regularizing Knowledge Graph Embeddings via Equivalence and Inversion Axioms, pp 668–683. DOI 10.1007/978-3-319-71249-9˙40
  * Minervini et al. (2017b) Minervini P, Demeester T, Rocktäschel T, Riedel S (2017b) Adversarial sets for regularising neural link predictors. CoRR abs/1707.07596, URL http://arxiv.org/abs/1707.07596, 1707.07596
  * Minervini et al. (2019) Minervini P, Bošnjak M, Rocktäschel T, Riedel S, Grefenstette E (2019) Differentiable reasoning on large knowledge bases and natural language. 1912.10824
  * Minervini et al. (2020) Minervini P, Riedel S, Stenetorp P, Grefenstette E, Rocktäschel T (2020) Learning reasoning strategies in end-to-end differentiable proving. 2007.06477
  * Mitchell et al. (2018) Mitchell J, Minervini P, Stenetorp P, Riedel S (2018) Extrapolation in nlp. arXiv preprint arXiv:180506648
  * Neyshabur et al. (2014) Neyshabur B, Tomioka R, Srebro N (2014) In search of the real inductive bias: On the role of implicit regularization in deep learning. CoRR abs/1412.6614, URL http://arxiv.org/abs/1412.6614, 1412.6614
  * Niklasson and van Gelder (1994) Niklasson L, van Gelder T (1994) Systematicity and connectionist language learning. Mind and Language 9(3):28–302
  * Nye and Saxe (2018) Nye M, Saxe A (2018) Are efficient deep representations learnable? In: 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Workshop Track Proceedings, OpenReview.net, URL https://openreview.net/forum?id=B1HI4FyvM
  * Nye et al. (2020) Nye MI, Solar-Lezama A, Tenenbaum JB, Lake BM (2020) Learning compositional rules via neural program synthesis. 2003.05562
  * Pachitariu and Sahani (2013) Pachitariu M, Sahani M (2013) Regularization and nonlinearities for neural language models: when are they needed? CoRR abs/1301.5650
  * Pennington et al. (2014) Pennington J, Socher R, Manning CD (2014) Glove: Global vectors for word representation. In: Empirical Methods in Natural Language Processing (EMNLP), pp 1532–1543, URL http://www.aclweb.org/anthology/D14-1162
  * Rocktäschel and Riedel (2017) Rocktäschel T, Riedel S (2017) End-to-end differentiable proving. CoRR abs/1705.11040, URL http://arxiv.org/abs/1705.11040, 1705.11040
  * Schaffrath (1995) Schaffrath H (1995) The essen folksong collection in the humdrum kern format. Database edited by David Huron, CCAHR, Menlo Park, CA URL http://kern.ccarh.org/cgi-bin/ksbrow
  * Seidenberg and Elman (1999) Seidenberg M, Elman J (1999) Do infants learn grammar with algebra or statistics? Science 284(5413):433–433
  * Shen et al. (2019) Shen Y, Tan S, Sordoni A, Courville A (2019) Ordered neurons: Integrating tree structures into recurrent neural networks. In: International Conference on Learning Representations, URL https://openreview.net/forum?id=B1l6qiR5F7
  * Shultz and Bale (2006) Shultz TR, Bale AC (2006) Neural networks discover a near-identity relation to distinguish simple syntactic forms. Minds and Machines 16(2):107–139
  * Sinha et al. (2019) Sinha K, Sodhani S, Dong J, Pineau J, Hamilton WL (2019) Clutrr: A diagnostic benchmark for inductive reasoning from text. 1908.06177
  * Sinha et al. (2020) Sinha K, Sodhani S, Pineau J, Hamilton WL (2020) Evaluating logical generalization in graph neural networks. 2003.06560
  * Snell et al. (2017) Snell J, Swersky K, Zemel R (2017) Prototypical networks for few-shot learning. In: Advances in Neural Information Processing Systems, pp 4077–4087
  * Sussillo (2014) Sussillo D (2014) Random walks: Training very deep nonlinear feed-forward networks with smart initialization. CoRR abs/1412.6558, URL http://arxiv.org/abs/1412.6558, 1412.6558
  * Sutskever et al. (2013) Sutskever I, Martens J, Dahl GE, Hinton GE (2013) On the importance of initialization and momentum in deep learning. In: ICML
  * Sutskever et al. (2014) Sutskever I, Vinyals O, Le QV (2014) Sequence to sequence learning with neural networks. In: Advances in neural information processing systems, pp 3104–3112
  * Tanneberg et al. (2020) Tanneberg D, Rueckert E, Peters J (2020) Learning algorithmic solutions to symbolic planning tasks with a neural computer. URL https://openreview.net/forum?id=S1gNc3NtvB
  * Trask et al. (2018) Trask A, Hill F, Reed SE, Rae J, Dyer C, Blunsom P (2018) Neural arithmetic logic units. In: Advances in Neural Information Processing Systems, pp 8046–8055
  * Vankov and Bowers (2019) Vankov I, Bowers JS (2019) Out-of-the box neural networks can support combinatorial generalization. CoRR abs/1903.12354, URL http://arxiv.org/abs/1903.12354, 1903.12354
  * Vankov and Bowers (2020) Vankov II, Bowers JS (2020) Training neural networks to encode symbols enables combinatorial generalization. Philosophical Transactions of the Royal Society B: Biological Sciences 375(1791):20190309, DOI 10.1098/rstb.2019.0309, URL https://royalsocietypublishing.org/doi/abs/10.1098/rstb.2019.0309, https://royalsocietypublishing.org/doi/pdf/10.1098/rstb.2019.0309
  * Vilcu and Hadley (2005) Vilcu M, Hadley RF (2005) Two apparent ‘counterexamples’ to marcus: A closer look. Minds and Machines 15(3-4):359–382
  * Wang et al. (2019) Wang C, Li M, Smola AJ (2019) Language models with transformers. arXiv preprint arXiv:190409408
  * Wang and Yao (2019) Wang Y, Yao Q (2019) Few-shot learning: A survey. CoRR abs/1904.05046, URL http://arxiv.org/abs/1904.05046, 1904.05046
  * Weyde and Kopparti (2018) Weyde T, Kopparti R (2018) Feed-forward neural networks need inductive bias to learn equality relations. In: Workshop Relational Representation Learning (R2L), 32nd Conference on Neural Information Processing Systems (NeurIPS), pp 2–8
  * Weyde and Kopparti (2019) Weyde T, Kopparti R (2019) Modelling identity rules with neural networks. Journal of Applied Logics 6(4):745–769, URL http://www.collegepublications.co.uk/downloads/ifcolog00033.pdf#page=146
  * Williams (1995) Williams PM (1995) Bayesian regularization and pruning using a laplace prior. Neural computation 7(1):117–143
  * Xu et al. (2018) Xu J, Zhang Z, Friedman T, Liang Y, den Broeck GV (2018) A semantic loss function for deep learning with symbolic knowledge. 1711.11157
  * Zambaldi et al. (2019) Zambaldi V, Raposo D, Santoro A, Bapst V, Li Y, Babuschkin I, Tuyls K, Reichert D, Lillicrap T, Lockhart E, Shanahan M, Langston V, Pascanu R, Botvinick M, Vinyals O, Battaglia P (2019) Deep reinforcement learning with relational inductive biases. In: International Conference on Learning Representations, URL https://openreview.net/forum?id=HkxaFoC9KQ
  * Zaremba et al. (2014) Zaremba W, Sutskever I, Vinyals O (2014) Recurrent neural network regularization. CoRR abs/1409.2329, URL http://arxiv.org/abs/1409.2329, 1409.2329
  * Zhou et al. (2018) Zhou J, Cui G, Zhang Z, Yang C, Liu Z, Sun M (2018) Graph neural networks: A review of methods and applications. CoRR abs/1812.08434, URL http://arxiv.org/abs/1812.08434, 1812.08434