Humans have the ability to seamlessly combine low-level visual input with high-level symbolic reasoning often in the form of recognising objects, learning relations between them and applying rules. Neurosymbolic systems aim to bring a unifying approach to connectionist and logic-based principles for visual processing and abstract reasoning respectively. This paper presents a complete neuro-symbolic method for processing images into objects, learning relations and logical rules in an end-to-end fashion. The main contribution is a di erentiable layer in a deep learning architecture from which symbolic relations and rules can be extracted by pruning and thresholding. We evaluate our model using two datasets: subgraph isomorphism task for symbolic rule learning and an image classi cation domain with compound relations for learning objects, relations and rules. We demonstrate that our model scales beyond stateof-the-art symbolic learners and outperforms deep relational neural network architectures.
input such as images [
Hence, in this paper we focus on the question of whether an end-to-end neural network can
learn objects, relations and rule-based reasoning going from pixels in an image all the way to
logic-based rules. Inspired by the perceptron algorithm [
Our neuro-symbolic architecture makes use of a di erentiable feed-forward layer that behaves
like conjunction or disjunction. Given continuous inputs 1, 2, . . . , ∈ [⊥, ⊤] in which
⊥, ⊤ ∈ R denote some real-valued constants for false and true respectively, we would like
to model a layer that can act like conjunction = ⋀︀ or disjunction = ⋁︀ where
∈ [⊥, ⊤] is the output. If we take ⊥ = 0, ⊤ = 1 and utilise t-norms [30] to implement fuzzy
logic, as the number of inputs increases, the operation su ers from vanishing gradients and
becomes unviable for upstream layers such as convolutional neural networks (CNN) [
Based on the single-layer perceptron [
Although for symbolic inputs ∈ {⊥, ⊤} and = {1, − 1}, we achieve the proper behaviour, una
ry(X,0) una ry(X,0)
X X not nullary(1) binary(X,Y,1) not binary(X,Y,0) nullary(1) binary(X,Y,1) binary(Y,X,0)
Y Y t :- not nullary(1), unary(X,0),
not binary(X,Y,0), binary(X,Y,1).
unary(Y,1) t :- bniunlalarryy((X1,)Y,,u1n),abryin(aXr,y0()Y,,uXn,0a)r.y(Y,1),
1–43
(a) Sample target rules for the easy di culty of (b) Example images from the relations game dataset
the graph dataset. For each predicate, the last with the top and bottom rows showing correct
argument denotes the relation id. and incorrect cases respectively.
the output of the semi-symbolic layer does not align with existing many-valued logics such
as Kleene or Lukasiewicz logics [
Prune & Threshold In order to obtain symbolic formulas, we prune and then threshold the
weights after training. Similar to decision tree pruning methods [23], each weight is set to zero
= 0 and pruned if the performance has not dropped by a xed . Then a threshold value
is picked by sweeping over potential values [min ||, max ||] with a similar performance
check to pruning. Each weight is then set to ′ = 6 sign() which gives su cient saturation
tanh(6) ≈ 0.999. Finally, we repeat the pruning step to remove any wrongly ampli ed weights.
We opt for this simple post-training regime rather than regularisation such as l-norms [
Since low-level signals such as images can produce large noisy latent spaces, we need to understand whether our approach can robustly learn symbolic rules in a scalable fashion. Hence, we use two synthetic datasets: subgraph set isomorphism for testing the semi-symbolic layer over symbolic inputs and image classi cation for the full pipeline. For both datasets, the model is required to predict a true or false label. Samples from each dataset are shown in Fig. 1 with further details and examples in Appendix B. We opt to use synthetic datasets with known and controlled parameters to avoid any inherent biases that may arise in real-world datasets.
Subgraph set isomorphism requires a model to decide whether any subgraph of a given
graph is isomorphic to a set of other graphs. We choose graph isomorphism as it is combinatorial
in nature and known to be NP-complete [
Relations Game dataset consists of an input image with di erent shapes and colours exhibiting compound relations between them. It has been introduced to evaluate object-based relational learning in deep neural networks [65]. Existing methods fail to provide a coherent object, relation and symbolic rule learning in an end-to-end fashion. Along with the four tasks in Fig. 1b, we create an All multi-task setting and provide the task id as additional input. While the training set contains pentominoes, shapes with 5 uniformly coloured pixels, the test sets expand to hexominoes (shapes with 6 pixels) as well as striped shapes with unseen colours. To ascertain if neuro-symbolic approaches could be more data e cient, we take 100, 1k and 5k for training and 1k for validation and test splits. We also apply standard data augmentation during training with random horizontal or vertical ips with an added input noise drawn from (0, 0.01). For further details and more examples, please refer to Appendix B.2.
We evaluate our approach’s ability to learn symbolic rules in a di erentiable manner, scalability and performance in the presence of input noise. To learn full logic rules such as in Fig. 1a, we stack two semi-symbolic layers, one conjunctive and one disjunctive, for a disjunctive normal form (DNF) layer. While theoretically di erent combinations of SL layers can extend the space of possible logic programs to a larger language including constraints and predicates with arity greater than two, we focus on learning rst-order (recursive) normal logic programs without function symbols and excluding constraints. We also work with the nullary/1, unary/2 and binary/3 predicates since any logic program can be converted to a program using this signature. The DNF layer is constructed with a maximum number of variables | (ℋ)| and xed |H| to learn rst-order rules rather than just propositional formula. When viewed as a fully-connected graph with variable symbols as the nodes (similar to Fig. 1a), the maximum number of edges
CNN
Objects
Relations nullary(0). nullary(3). ... unary( ,0). … binary( ,
, |(ℋ)| corresponds to the maximum length (number of body atoms) of the learnable rules. We gather all combinations (︀ | ()| )︀ to e ectively curate every possible object to variable binding, | (ℋ)| shown as Permute step in Fig. 2. This grounding step converts rst-order normal rules in question into their propositional instantiations over which SL layers from Section 2 are used. Although this binding is combinatorial, the evaluation of the rule under every binding can be computed in parallel which bene ts from the increasing computing infrastructure available. In cases where the desired rules require speci c constants as literal arguments, the instantiations could be restricted at the permutation step to adjust the hypothesis space accordingly. After the conjunctive SL, we use the max operator over the instantiations of any existential variables that may occur in the rules. The DNF layer is used as a standalone model for the subgraph set isomorphism dataset or in tandem with upstream image processing layers for the relations game as in Fig. 2. We train all deep models using Adam [36] with a xed learning rate of 0.001 and the negative log-likelihood loss on an Intel Core i7 CPU and report the median results to avoid outliers. For all the hyper-parameters and further training details, please refer to Appendix A.6.
Can the DNF layer learn symbolic rules in a scalable, di erentiable manner? We
train a standalone DNF layer on the subgraph set isomorphism dataset for 10k batch updates with
a batch size of 128. The results with continuous weights (DNF) and with pruning, thresholding
(DNF+t) are compared against two state-of-the-art symbolic learners: ILASP [38] (2i as the
recommended version for non-noisy tasks) and the recent more scalable FastLAS [39]. We also
considered state-of-the-art rule mining system AMIE [37] but it does not support negated rules
and uses breath- rst search that does not scale well to long rules. We were only able to run the
symbolic learners for the easy size because they do not report progress or allow checkpointing
making them infeasible for distributed shared computing infrastructure. FastLAS on an isolated
machine did not terminate after 16 hours on the medium di culty. In Table 2, we observe that
DNF layer scales better than symbolic learners to larger rule sizes and since it is trained for xed
number of iterations maintains a steady training time. Since DNF+t is thresholded, we have
exact logic semantics which correspond to the symbolic rules learnt by the symbolic systems.
We can convert the thresholded weights into ASP rules and test them using clingo [
DNF DNF+t
Medium
subgraph set isomorphism dataset by randomly ipping the truth values of () in the training
set with a xed probability shown in Table 3. We observe that the DNF layer performs well up
to 0.3 where the median accuracy drops below 0.9. The pruning and thresholding steps seem
to improve the performance with lower levels of noise, likely because incorrect weights are
removed against a non-noisy validation set.
upstream convolutional neural networks (CNN) and object selection layers to construct the full
neuro-symbolic DNF model (DNF), Fig. 2. The image is processed in patches by the CNN to
obtain a set of 9 candidate objects. Since reasoning with 9 objects at the same time creates a
large grounding for the DNF layer, we use an attention based object selection layer. Attention
0.56
0.62
0.50
0.69
0.63
0.57
0.57
0.62
0.49
0.69
0.65
0.60
0.57
0.57
0.49
0.63
0.64
0.54
0.99
0.99
0.79
0.99
0.99
0.95
0.96
0.95
0.81
0.98
0.96
0.95
0.97
0.97
0.84
0.96
0.95
0.94
models [
Is the DNF model more data e cient? We compare our approach against PrediNet [65],
an explicitly relational neural network and the current state-of-the-art in the relations game
dataset. Note that PrediNet already outperforms MLP baselines and Relation Networks [
Can the DNF model generalise to unseen shapes and colours? After training on pentominoes, the models are tested on unseen hexominoes and striped shapes, Appendix B.2. The results for Hex. and Stripe in Table 4 are similar to that of pentominoes for all models. This lack of change might be because of the tasks’ requirement to determine whether the shapes match or not, which can encourage a simple subtraction based representation that would generalise to unseen shapes and colours. Indeed, PrediNet uses subtraction as the main relational operator while our model would need to learn that solely from examples.
Does image reconstruction improve DNF model performance? We try to reconstruct the image from the selected objects using deconvolutional layers as an auxiliary loss (DNF-hi), see Appendix A.5 for reconstruction details and Appendix D for examples. Comparing DNF-hi and DNF-h rows, we do not observe any improvement above 5% despite the extra computation required to reconstruct the images. Although the representations of objects would need to accommodate both the reasoning and the reconstruction, we believe the simplicity of the shapes might be why the auxiliary loss does not yield any advantage for the rule learning.
Can we extract symbolic rules in an image classi cation task? Finally, the goal is to obtain a coherent neuro-symbolic pipeline where objects, their relations and symbolic rules are learnt. We take the best variant DNF-h and threshold its weights DNF-h+t to get symbolic rules. Comparing DNF-h with DNF-h+t in Table 4, only if DNF-h achieves ≥ 0.99 accuracy does DNF-h+t consistently yield better than random performance. This highlights the di culty of learning both the meaning of the predicates as well as the rules in tandem. Yet, there are some successful outliers ignored by the median, please refer to Appendix D for the full results. Input 0 1 2 0 1 2 0 1 2 0 1 2 (a) Attention maps learnt during the object se- (b) Object arguments (top and bottom rows) that make lection phase. Gumbel-Softmax with low binary(X,Y,6) true or false exhibit no common temperature approximates hard attention. pattern of the principal concepts of the dataset.
To understand what the model has learnt and how it is behaving, we take a single successful run (≥ 0.95 accuracy) from the DNF model with image reconstruction on the between task with 1k training examples. We choose this task because it is smaller in size and the model achieves 0.99 and 0.97 test hexominoes accuracy prior to and after thresholding respectively. For further examples and analysis, please refer to Appendix D.
What are the selected objects? To ensure whether the relations and rules actually work with the desired objects, we plot the attention maps obtained from the object selection step. As shown in Fig. 3a, the model learns to assign higher scores to patches with objects and iteratively selects them. Due to the random sampling, the order of the selected objects may vary.
In a successful run, what are the rules learnt? Since the thresholded model has a oneto-one correspondence with the desired logic semantics, we extract out the rule used to solve the between task, e.g. input images shown in Fig. 3a: between :- unary(X,4), not unary(Y,6), binary(Y,Z,6), not binary(Y,Z,9),
not binary(Z,Y,3), binary(Z,Y,5), not binary(Z,Y,9), binary(Z,Y,14).
which achieves 0.97 accuracy on the test hexominoes set. This is the rst result we are aware of that presents di erentiable rule learning with learnt predicates on continuous representations of images in an end-to-end fashion. To further validate this rule, we threshold > 0 the interpretation, relations box in Fig. 2, and pass them, along with the rule to clingo. Over a sample test batch of 64 examples, clingo solves 91% of them verifying the correctness of the learnt rules by the DNF layer. This seamless integration of symbolic relations and rules with distributed representations of objects re ect on how the human brain might be using symbolic and sub-symbolic representations in tandem [35].
What do the learnt predicates mean? We iteratively remove one atom from the body and check the drop in accuracy over the same sample test batch. Removing binary(X,Y,6) yields the highest drop of 18%. Hence, we plot cases of binary(X,Y,6) in Fig. 3b but fail to notice any alignment between the primary concepts of the dataset such as shape, colour or position. Although at rst this may seem odd, since there is no regularisation for any sort of disentanglement, we would not expect or assume any correlation between the concepts and the learnt relations. This is in contrast with explainable AI [2] and the promise of interpretability using neuro-symbolic methods which is fundamentally limited by our ability to decode learnt representations. On the other hand, this phenomenon does not arise when the input predicates are known and xed such as in the graph isomorphism dataset where the learnt rules have interpretable meanings in the form of graphs, see Fig. 1a.
Neuro-symbolic [
Going one step closer to symbolic, architectural biases are often added to constrain and
re ne the behaviour of neural networks. For example, Relation Networks [
Methods described so far do not consider logical formalisms or logic programs. DeepLogic [
Going further away from deep neural networks, logic based architectures become more
prominent. For example, Lifted Relational Neural Networks [
One could also use distributed representations for constants or predicates. For example
similarity between vectors could provide basis for a logical calculus [
Closer to the symbolic end of the spectrum, one could also attempt to decompose or parse
continuous input completely into symbolic entities or concepts and then perform symbolic
reasoning. Neural scene parsing as done in Neuro-Symbolic VQA [
Moving away from neural networks but attempting to harness gradient descent, we have
approaches such as -ILP [
We presented a uni ed neuro-symbolic framework for learning objects, their relations and symbolic rules in an end-to-end fashion using semi-symbolic layers. Evaluation on two datasets portray competitive if not better results of our approach against symbolic learners and deep neural networks. Since symbolic rules can be extracted and examined, we plan to apply this technique to more decision making critical domains such as reinforcement learning.
We would like to thank Murray Shanahan for his helpful comments. We would also like to thank Mark Law for his support in running ILASP and FastLAS symbolic learners.
Martin Abadi et al. “TensorFlow: A system for large-scale machine learning”. In: 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI 16). 2016, pp. 265–283. url: https : / / www. usenix . org / system / les / conference / osdi16 / osdi16 abadi.pdf.
Masataro Asai and Alex Fukunaga. “Classical Planning in Deep Latent Space: Bridging the Subsymbolic-Symbolic Boundary”. In: (Apr. 29, 2017). arXiv: 1705.00154 [cs.AI]. [7] Yaniv Aspis et al. “Stable and Supported Semantics in Continuous Vector Spaces”. In: Proceedings of the Seventeenth International Conference on Principles of Knowledge Representation and Reasoning. International Joint Conferences on Arti cial Intelligence Organization, 2020. doi: 10.24963/kr.2020/7. [8] Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. “Neural Machine Translation by Jointly Learning to Align and Translate”. In: ICLR (Sept. 1, 2014). arXiv: 1409.0473 [cs.CL]. [9] Peter W. Battaglia et al. “Relational inductive biases, deep learning, and graph networks”.
In: (June 4, 2018). arXiv: 1806.01261 [cs.LG]. [10] Daniel M. Bear et al. “Learning Physical Graph Representations from Visual Scenes”. In:
NeurIPS (June 2020). arXiv: 2006.12373 [cs.CV]. [11] Yoshua Bengio et al. “Curriculum learning”. In: Proceedings of the 26th Annual International Conference on Machine Learning - ICML ’09. ACM. ACM Press, 2009, pp. 41–48. doi: 10.1145/1553374.1553380. [12] Tarek R. Besold et al. “Neural-Symbolic Learning and Reasoning: A Survey and Interpretation”. In: (Nov. 10, 2017). arXiv: 1711.03902 [cs.AI]. [23] F. Esposito et al. “A comparative analysis of methods for pruning decision trees”. In: IEEE Transactions on Pattern Analysis and Machine Intelligence 19.5 (1997), pp. 476–493. doi: 10.1109/34.589207. [29] [30] [31]
Alex Graves et al. “Hybrid computing using a neural network with dynamic external memory”. In: Nature 538.7626 (Oct. 2016), pp. 471–476. doi: 10.1038/nature20101. M.M. Gupta and J. Qi. “Theory of T-norms and fuzzy inference methods”. In: Fuzzy Sets and Systems 40.3 (Apr. 1991), pp. 431–450. doi: 10.1016/0165-0114(91)90171-l. Marco A. P. Idiart et al. “How the Brain Represents Language and Answers Questions? Using an AI System to Understand the Underlying Neurobiological Mechanisms”. In: Frontiers in Computational Neuroscience 13 (Mar. 2019). doi: 10.3389/fncom.2019.00012. [32] Peter Jackson. Introduction to expert systems. Harlow, England Reading, Massachusetts:
Addison-Wesley, 1999. isbn: 9780201876864. [33] Eric Jang, Shixiang Gu, and Ben Poole. “Categorical Reparameterization with Gumbel
Softmax”. In: ICLR (Nov. 3, 2016). arXiv: 1611.01144 [stat.ML]. [34] Armand Joulin and Tomas Mikolov. “Inferring Algorithmic Patterns with Stack-Augmented Recurrent Nets”. In: NIPS (Mar. 3, 2015), pp. 190–198. arXiv: http://arxiv.org/abs/1503. 01007v4 [cs.NE]. [35] Troy D. Kelley. “Symbolic and Sub-Symbolic Representations in Computational Models of Human Cognition”. In: Theory & Psychology 13.6 (2003), pp. 847–860. doi: 10.1177/ 0959354303136005. [36]
Diederik P. Kingma and Jimmy Ba. “Adam: A Method for Stochastic Optimization”. In: ICLR (Dec. 22, 2014). arXiv: 1412.6980 [cs.LG]. [37] Jonathan Lajus, Luis Galárraga, and Fabian Suchanek. “Fast and Exact Rule Mining with AMIE 3”. In: The Semantic Web. Springer International Publishing, 2020, pp. 36–52. doi: 10.1007/978-3-030-49461-2_3. [38] [39]
Mark Law, Alessandra Russo, and Krysia Broda. “The ILASP system for Inductive Learning of Answer Set Programs”. In: (May 2020). arXiv: 2005.00904 [cs.AI].
Mark Law et al. “FastLAS: Scalable Inductive Logic Programming Incorporating DomainSpeci c Optimisation Criteria”. In: Proceedings of the AAAI Conference on Arti cial Intelligence 34.03 (Apr. 2020), pp. 2877–2885. doi: 10.1609/aaai.v34i03.5678. [40] Richard L. Lewis. “Cognitive modeling, symbolic”. In: The MIT encyclopedia of the cognitive sciences (1999), pp. 525–527. url: http://www-personal.umich.edu/~rickl/pubs/lewis1999-mitecs.pdf. [41] Yujia Li et al. “Graph Matching Networks for Learning the Similarity of Graph Structured
Objects”. In: (Apr. 2019). arXiv: 1904.12787 [cs.LG]. [42] Chen Liang et al. “Neural Symbolic Machines: Learning Semantic Parsers on Freebase with Weak Supervision”. In: ACL (Oct. 31, 2016). arXiv: http://arxiv.org/abs/1611.00020v4 [cs.CL]. [43] Vladimir Lifschitz. What is Answer Set Programming? AAAI’08. Menlo Park, Calif: AAAI Press, 2008, pp. 1594–1597. isbn: 9781577353683. [74] Wojciech Zaremba et al. “Learning Simple Algorithms from Examples”. In: ICML. Nov. 23, 2015, pp. 421–429. arXiv: http://arxiv.org/abs/1511.07275v2 [cs.AI]. We use two models in our experiments that share the common DNF layer described in Section 2 and Section 4. In this section, we provide details on the semi-symbolic layer as well as the larger model used for the image classi cation task.
The semi-symbolic layer builds on the semantics of how a regular single-layer perceptron [
Now, suppose we are interested in obtaining AND gate semantics with a pre-activation value if all inputs are true and − if one of the inputs are false. To simplify the derivation, suppose the magnitudes of the weights are equal ∀ = :
A. Model Details
where a true input means = 1.0 if the weight is positive or = − 1.0 otherwise. We use the absolute value of the weights since the sum of the weights multiplied by matching inputs would yield the sum of the absolute value of the weights. Solving the above system of equations for , we obtain: ∑︁ + = ∑︁ || + =
= max || − ∑︁ || Since the weights would not be equal during training, we replace the rst term to obtain the nal equation Eq. (2) presented in Section 2: which preserves the desired AND gate semantics. The derivation for the disjunctive case is identical and leads to the bias terms ipped, i.e. sum - max. A fully functional implementation of the semi-symbolic layer in TensorFlow can be found in Listing 1. 1–43 (3) (4) (5) (6) (7) (8) To process the input images in the relations game dataset, Section 3, we use a single layer convolutional neural network (CNN) with a kernel size of 4x4, stride 4, relu activation and 32 lters. We use these options to keep the image processing layer simple and less computationally intensive. The input to the layer is a single relations game image, 12x12x3 and the output is 3x3x32. Note that, with this con guration the CNN is aligned to the grid cells of the image in which the objects are contained.
For each output of the CNN, 3x3x32, we also append the location information yielding a nal result of 3x3x36. The coordinates are computed on a linear scale from 0 to 1 based on the location of the patch in the 3x3 grid. The representations are attened into 9x36 and passed onto the selection layer. Example representations learnt by this layer are shown in Table 5.
Given a set of objects with continuous representations in the form of a matrix ∈ R× where
is the number of objects and is the number of dimensions, the object selection layer selects
many relevant objects. The number of objects is xed and determined by the task. We use
2 for Same, 3 for Between and 4 for the rest of the tasks including All. The relevance, or score,
is learnt using single feed-forward layer. Concretely, the 9x36 object matrix obtained from the
CNN layer, is mapped to a vector ∈ R9. Then these unnormalised scores are used as logits for
a Gumbel-Softmax [33] or Concrete [
+1 = ( − ) + (1 − ) where = 100 is the inversion constant. We iterate for times selecting one object at each iteration and by inverting its score, the layer learns to select distinct objects.
Similar to previous work that use Gumbel-Softmax as a means of di erentiable categorical distribution [5], we anneal the temperature of the distribution starting from 0.5, down to 0.01 with an exponential rate of 0.9 every step after 20 epochs. That allows the model to gradually learn and then sharpen the object selection process. At a temperature of 0.01, the attention maps become one-hot vectors allowing a clear correspondence between the selected objects and the applied rules. This is in contrast with soft attention [8] mechanisms such as the dot-product attention used in PrediNet which allow continuous selection of image patches as a single object.
Once the objects are selected, we compute all unary and binary relations between them using their continuous representations. We use a single feed-forward layer for unary and another for binary relations:
unary(, ) = tanh( + )
binary(, , ) = tanh( [, , − ] + )
where [] is the concatenation operator and , are di erent weights for each equation. The
result can be considered a fully connected graph with the selected objects as nodes, and the
computed unary and binary relations as edges. We opt for this single-layer formulation to
keep it computationally less intensive and focus on rule learning. We leave more complex and
expressive relational layers that compute interactions between dense entity vectors such as
Neural Tensor Networks [
To test the hypothesis whether image reconstruction can help with di erentiable rule learning, we provide an auxiliary loss by reconstructing the full input image from the selected objects. Starting from a matrix of selected objects ∈ R× , we spatially broadcast them into a 3x3 grid. In the speci c case of relations game dataset, the selected objects are broadcast into a tensor of shape mx3x3x36. We then use 2 deconvolution layers, also known as transposed convolution, with 32 lters, kernel size 5, relu activation and stride 2 to expand the tensor to shape mx12x12x32. For the nal layer, we apply another deconvolution with 4 lters, kernel size 5 and a stride of 1 yielding mx12x12x4. The rst three colour channels are combined with the last masking channel to obtain the nal output. The reconstructed image is trained using mean squared error and example reconstructions can be seen in Fig. 19 and in Fig. 22. 1–43
(9) (10) (11)
Key # batch updates Rels. Game
# batch updates Graph # batch updates per eval
learning rate batch size Rels. Game batch size Graph # of repeated runs
There are three main categories of hyperparameters used in this work: model, dataset and training. We cover all of them in Table 6 and Table 7. The magnitude of the semantic gate selector | | presented in Section 2 is gradually adjusted during training according to a xed exponential schedule. For the image classi er model, we start with 0.01 and increase to 1.0 with an exponential rate of 1.1 while for the subgraph set isomorphism dataset we start higher 0.1 and use the same rate of 1.1. We start the gate at a higher value for the graph isomorphism dataset since the input is already symbolic, i.e. ∀ ∈ {− 1, 1}. The sign of is pre-determined by the layer type, conjunctive or disjunctive within a DNF layer, see Sections 2 and 4.
We use two synthetic datasets to create a controlled environment in which we can evaluate
our approach. The rst dataset is based on the subgraph isomorphism problem and is used
as the basis for an unbiased Inductive Logic Programming (ILP) [
The subgraph set isomorphism task is designed to create an unbiased combinatorial search
space for rule learning. To generate data points, we uniformly sample unique graphs for H
and then sample of which subgraphs are isomorphic. The resulting examples are checked
using the answer set solver clingo [
ically, 2 nullary, 4 unary and 8 binary predicates.
be absent in the rule, the upper bound on the search space for possible rules is 3|(ℋ)|. This ensures there is no bias in the rules or heuristics that can be used to prune the search space. As a result, any atom can appear in the rule equally likely.
An example set of rules H from the medium dataset size is shown in Table 8. The head of
the rules corresponds to the desired target label for a given set of context facts, i.e. whether
the given graph is subgraph isomorphic to the set of graphs represented by the rules. The
symbolic learners timeout on this size due to the long rules. Rules of this length are uncommon
in many standard ILP datasets [
The relations game dataset consists of an input image with a desired binary label. There are 3 sets: pentominoes, hexominoes and stripes, examples of which are shown in Fig. 4. The original dataset presented in PrediNet [65] comes with 250k examples per set and with a higher resolution of 36x36x3. At the high resolution, each block of a shape consists of 3x3 pixels and since this is redundant, we convert each block to a single pixel reducing the image without any loss of information to 12x12x3. This conversion reduces the computational power required to run the experiments without changing the tasks.
During training we apply standard data augmentation: (i) random horizontal or vertical ips, (ii) random 90 degrees counter-clockwise rotation and (iii) added input noise drawn from a normal distribution with 0.01 as the standard deviation. This augmentation is applied to every batch and the randomness is drawn from a random number generator with a xed seed of 42.
We train all deep models using the Adam [36] optimiser with a learning rate of 0.001. The models are trained for a xed number of batch updates and evaluated every 200 batch updates. We use the negative log-likelihood as the loss function for the binary predictions. For all the hyperparameters used in training, please refer to Table 6. The models are trained on a shared pool of computers all having Intel Core i7 CPUs. Note that the run times of the deep models may vary depending on the shared workload on the worker machine. Once the training is complete for the DNF models, we prune and threshold the weights to obtain DNF+t variants, as described in Section 2.
The training curves for every deep model trained on every dataset and hyperparameter con guration, can be found in Fig. 5, Fig. 6, Fig. 7, Fig. 8, Fig. 9, Fig. 10, Fig. 11 and Fig. 12. For relations game training curves, the slight dip in accuracy around epoch 70 when trained with only 100 examples corresponds to the point at which the semantic gate | | becomes close to 1. This indicates that if the model is over tting, it almost has to relearn the task with the desired semantics since this phenomenon is less pronounced with more training examples and almost absent in the graph dataset. We also observe mode collapses in the recursive con guration of the DNF model (DNF-r) in which the accuracy suddenly drops when the semantic gate | | becomes closer to 1 around epoch 70. We believe this is due to the recursion in the model making a recovery to the desired disjunctive normal form semantics more di cult. The DNF-r either performs well with some runs surviving the saturation | | = 1.0 and some collapsing.
This section includes further tables and gures to complement and extend the main content presented in the paper. The description for each gure is provided in the caption. Same
Between
Occurs
XOccurs Same
Between
Occurs
XOccurs (c) Example striped shapes where each object has 9 pixels with a striped colour pattern.
1.0 0.9 e0.8 vu l a 0.7 0.6 0.5 1.0 variable train_acc validation_acc test_acc 20 epoch 30 20 epoch 30 0 10 40 20 epoch 30 60 epoc8h0 variable train_acc test_hexos_acc test_pentos_acc validation_acc test_stripes_acc task = xoccurs | train_size = 100 task = xoccurs | train_size = 1000 task = xoccurs | train_size = 5000 60 epoc8h0 task = same | train_size = 100 task = al | train_size = 100 variable train_acc test_hexos_acc test_pentos_acc validation_acc test_stripes_acc task = occurs | train_size = 100 task = occurs | train_size = 1000 task = occurs | train_size = 5000 60 epoc8h0 task = al | train_size = 100 task = occurs | train_size = 100 task = occurs | train_size = 1000 task = occurs | train_size = 5000 task = same | train_size = 100 task = same | train_size = 1000 task = same | train_size = 5000 variable train_acc test_hexos_acc test_pentos_acc validation_acc test_stripes_acc 20 40 100 120 140 0 20 40 100 120 140 0 20 40 100 120
140 1.1 1.0 0.9 le0.8 vau0.7 0.6 0.5 task = al | train_size = 100 task = xoccurs | train_size = 100 task = xoccurs | train_size = 1000
task = xoccurs | train_size = 5000 task = occurs | train_size = 100 task = occurs | train_size = 1000 task = occurs | train_size = 5000 variable train_acc test_hexos_acc test_pentos_acc validation_acc test_stripes_acc 20 40 100 120 140 0 20 40 100 120 140 0 20 40 100 120
140 task = xoccurs | train_size = 100 task = xoccurs | train_size = 1000 task = xoccurs | train_size = 5000 task = occurs | train_size = 100 task = occurs | train_size = 1000 task = occurs | train_size = 5000 task = al | train_size = 100 task = al | train_size = 1000 task = al | train_size = 5000 variable train_acc test_hexos_acc test_pentos_acc validation_acc test_stripes_acc 60 epoc8h0 task = same | train_size = 100 task = same | train_size = 1000 task = same | train_size = 5000 task = al | train_size = 100 task = al | train_size = 1000 task = al | train_size = 5000 task = occurs | train_size = 100 task = occurs | train_size = 1000
task = occurs | train_size = 5000 20 40 100 120 140 0 20 40 100 120 140 0 20 40 100 120
140 1.0 0.9 0.6 0.5 1.0 0.9 0.6 0.5 1.0 0.9 0.5 noise = 0.15 | difficulty = hard noise = 0.15 | difficulty = medium noise = 0.15 | difficulty = easy noise = 0.3 | difficulty = hard noise = 0.3 | difficulty = medium noise = 0.3 | difficulty = easy DNF
DNF+t model
DNF
DNF+t model
DNF
DNF+t model 1.00 0.95 0.90 cc0.85 t_sae t0.80 0.75 0.70 1.00 0.95 0.90 cc0.85 t_sae t0.80 0.75 0.70 1.00 0.95 0.90 cc0.85 t_sae t0.80 0.75 0.70 noise = 0.0 | difficulty = easy noise = 0.0 | difficulty = hard noise = 0.0 | difficulty = medium noise = 0.15 | difficulty = easy noise = 0.15 | difficulty = hard noise = 0.15 | difficulty = medium noise = 0.3 | difficulty = easy noise = 0.3 | difficulty = hard noise = 0.3 | difficulty = medium DNF
DNF+t
DNF
DNF+t
DNF
DNF+t difficulty = easy difficulty = hard difficulty = medium fastlas ilasp
DNF
DNF+t fastlas ilasp
DNF
DNF+t fastlas ilasp
DNF
DNF+t model model model train_size = 5000 | task = xoccurs train_size = 5000 | task = same train_size = 5000 | task = between train_size = 5000 | task = al train_size = 5000 | task = occurs variable train_acc test_hexos_acc test_pentos_acc validation_acc test_stripes_acc
DNF-hDNF-hiDNF DNF-iDNF-riDNF-PmrreoddiNeDelNtF-hD+NtF-r+DtNF+DtNF-hDi+NtF-ri+DNtF-i+t DNF-hDNF-hiDNF DNF-iDNF-riDNF-PmrreoddiNeDelNtF-hD+NtF-r+DtNF+DtNF-hDi+NtF-ri+DNtF-i+t DNF-hDNF-hiDNF DNF-iDNF-riDNF-PmrreoddiNeDelNtF-hD+NtF-r+DtNF+DtNF-hDi+NtF-ri+DNtF-i+t DNF-hDNF-hiDNF DNF-iDNF-riDNF-PmrreoddiNeDelNtF-hD+NtF-r+DtNF+DtNF-hDi+NtF-ri+DNtF-i+t DNF-hDNF-hiDNF DNF-iDNF-riDNF-PmrreoddiNeDelNtF-hD+NtF-r+DtNF+DtNF-hDi+NtF-ri+DNtF-i+t xoccurs 100 0.01 0.17 0.01 0.11 0.00 0.04 0.01 0.17 0.03 0.13 0.00 0.00 0.00 0.02 0.16 0.02 0.10 0.00 0.05 0.01 0.18 0.04 0.13 0.01 0.00 0.00 0.01 0.17 0.01 0.12 0.02 0.03 0.02 0.17 0.03 0.14 0.01 0.00 0.03
Hex. loss along with median absolute deviation. Only for XOccurs task do we see an improvement. all between occurs same xoccurs 100 1000 5000 100 1000 5000 100 1000 5000 100 1000 5000 100 1000 5000
False
True 0.94± 0.06 2 2 2 2 0 1 1 1 Input 0 1 0.996 0.991 0.942 0.938 Input Object 1 1 1 1 1 1 0 1 1 1 Input 2 1 binary(X,Y,23) - 1.0 unary(V0,10) :c3unary(V0,10) :unary(V0,11) :c1unary(V0,11) :binary(V0,V1,23) :binary(V0,V1,23) :c3binary(V0,V1,23) :Input