Integrating Learning and Reasoning with Deep Logic Models

TL;DR

This paper introduces Deep Logic Models, a novel end-to-end differentiable framework that combines deep learning with probabilistic logic reasoning to improve learning and inference in complex environments.

Contribution

It presents a new deep graphical model that integrates deep neural networks with logic reasoning, enabling joint learning and reasoning in a unified architecture.

Findings

Outperforms existing methods in integrating learning and reasoning.

Allows end-to-end training of deep and logical components.

Demonstrates improved decision robustness in complex tasks.

Abstract

Deep learning is very effective at jointly learning feature representations and classification models, especially when dealing with high dimensional input patterns. Probabilistic logic reasoning, on the other hand, is capable to take consistent and robust decisions in complex environments. The integration of deep learning and logic reasoning is still an open-research problem and it is considered to be the key for the development of real intelligent agents. This paper presents Deep Logic Models, which are deep graphical models integrating deep learning and logic reasoning both for learning and inference. Deep Logic Models create an end-to-end differentiable architecture, where deep learners are embedded into a network implementing a continuous relaxation of the logic knowledge. The learning process allows to jointly learn the weights of the deep learners and the meta-parameters controlling the high-level reasoning. The experimental results show that the proposed methodology overtakes the limitations of the other approaches that have been proposed to bridge deep learning and reasoning.

Figures

Tables

Table 1. Table 1: The Operations performed by the single units of an expression tree depending on the inputs a , b 𝑎 𝑏 a,b and the used t-norm.

	Product	Minimum	Łukasiewicz
$a\wedge b$	$a\cdot b$	$\min (a,b$)	$\max (0,a+b-1$)
$a\vee b$	$a+b-a\cdot b$	$\max (a,b)$	$\min (1,a+b)$
$\neg a$	$1-a$	$1-a$	$1-a$
$a\Rightarrow b$	$\min (1,\frac{b}{a})$	$a\le b?1:b$	$\min (1,1-a+b)$

Table 2. Table 2: Comparison of the accuracy metric on the PAIRS dataset using different models.

Model	NN	SBR	DLM-NN	DLM
Accuracy	0.62	0.64	0.65	0.76

Table 3. Table 3: Comparison of the accuracy provided by different methods on link prediction on the Countries dataset. Bold numbers are the best performers for each task.

Task	ComplEx	NTP	NTP$\lambda$	DLM
S1	$99.37$	$90.83$	100.00	100.00
S2	$87.95$	$87.40$	$93.04$	97.79
S3	$48.44$	$56.68$	$77.26$	91.93

Equations

$$p(\mathbf{\theta }|\mathbf{y},X)\propto p(\mathbf{y}|\mathbf{\theta },X)p(\mathbf{\theta }).$$

$$p(\mathbf{y}|\mathbf{\theta },X)={\int }_{\mathbf{f}}p(\mathbf{y}|\mathbf{f},\mathbf{\lambda })\cdot p(\mathbf{f}|\mathbf{w},X)d\mathbf{f}.$$

$$p(\mathbf{f}|\mathbf{w},X)=\frac{1}{Z(\mathbf{f})}\exp \left(-\frac{(\mathbf{f}-{\mathbf{f}}_{nn}{)}^2}{2{\sigma }^2}\right),$$

$$p(\mathbf{f}|\mathbf{w},X)\approx \delta (\mathbf{f}-{\mathbf{f}}_{nn}),$$

$$p(\mathbf{y}|\mathbf{\theta },X)\approx p(\mathbf{y}|{\mathbf{f}}_{nn},\mathbf{\lambda }).$$

$$p(\mathbf{y}|{\mathbf{f}}_{nn},\mathbf{\lambda })\triangleq \frac{1}{Z(\mathbf{y})}\exp \left({\Phi }_r(\mathbf{y},{\mathbf{f}}_{nn})+\sum _c{\lambda }_c{\Phi }_c(\mathbf{y})\right),$$

$$Z(\mathbf{y})={\int }_{\mathbf{y}}\exp \left({\Phi }_r(\mathbf{y},{\mathbf{f}}_{nn})+\sum _c{\lambda }_c{\Phi }_c(\mathbf{y})\right)d\mathbf{y}.$$

$${\mathbf{y}}_M=\text{arg}\underset{\mathbf{y}}{\max }\log p(\mathbf{y}|{\mathbf{f}}_{nn},\mathbf{\lambda })=\text{arg}\underset{\mathbf{y}}{\max }\left[{\Phi }_r(\mathbf{y},{\mathbf{f}}_{nn})+\sum _c{\lambda }_c{\Phi }_c(\mathbf{y})\right].$$

$${\nabla }_{\mathbf{y}}\log p(\mathbf{y}|{\mathbf{f}}_{nn},\mathbf{\lambda })={\nabla }_{\mathbf{y}}{\Phi }_r(\mathbf{y},{\mathbf{f}}_{nn})+\sum _c{\lambda }_c{\nabla }_{\mathbf{y}}{\Phi }_c(\mathbf{y})$$

$$\text{arg}\underset{\mathbf{\theta }}{\max }\log p(\mathbf{\theta }|{\mathbf{y}}_t,X)=\log p({\mathbf{y}}_t|\mathbf{\theta },X)+\log p(\mathbf{w})+\log p(\mathbf{\lambda }).$$

$$\log p(\mathbf{\theta }|{\mathbf{y}}_t,X)=-\frac{\alpha }{2}||\mathbf{w}|{|}^2-\frac{\beta }{2}||\mathbf{\lambda }|{|}^2-{\Phi }_r({\mathbf{y}}_t,{\mathbf{f}}_{nn})+\sum _c{\lambda }_c{\Phi }_c({\mathbf{y}}_t)-\log Z(\mathbf{y})$$

$$\begin{array}[]{lcl}\frac{\partial\log p(\boldsymbol{\theta}|\boldsymbol{y}_{t},X)}{\partial\lambda_{c}}&=&-\beta\lambda_{c}+\Phi_{c}(\boldsymbol{y}_{t})-E_{p}\left[\Phi_{c}\right]\\ &&\\ \frac{\partial\log p(\boldsymbol{\theta}|\boldsymbol{y}_{t},X)}{\partial w_{i}}&=&-\alpha w_{i}+\frac{\partial\Phi_{r}(\boldsymbol{y}_{t},\boldsymbol{f}_{nn})}{\partial w_{i}}-E_{p}\left[\frac{\partial\Phi_{r}}{\partial w_{i}}\right]\end{array}$$

$$\log p({\mathbf{y}}_t|{\mathbf{f}}_{nn},X)\approx {\Phi }_r({\mathbf{y}}_t,{\mathbf{f}}_{nn})-{\Phi }_r({\mathbf{y}}_M,{\mathbf{f}}_{nn})+\sum _c{\lambda }_c\left({\Phi }_c({\mathbf{y}}_t)-{\Phi }_c({\mathbf{y}}_M)\right)$$

$$\begin{array}[]{c}\log p(\boldsymbol{w})+\log p(\boldsymbol{\lambda})+\Phi_{r}(\boldsymbol{y}_{t},\boldsymbol{f}_{nn})+\Phi_{r}(\boldsymbol{y}_{M},\boldsymbol{f}_{nn})+\displaystyle\sum_{c}\lambda_{c}\left[\Phi_{c}(\boldsymbol{y}_{t})-\Phi_{c}(\boldsymbol{y}_{M})\right]\end{array}$$

$$C_{\mathbf{\theta }}({\mathbf{y}}_t,{\mathbf{y}}_M,X)$$

$$\Phi (X,A,B)=\frac{1}{|X_{d_1}|\cdot |X_{d_2}|}\sum _{v_1\in X_{d_1}}\sum _{v_2\in X_{d_2}}[1-A(v_1,v_2)]\cdot B(v_1).$$

Full text

1 Introduction

Artificial Intelligence (AI) approaches can be generally divided into symbolic and sub-symbolic approaches. Sub-symbolic approaches like artificial neural networks have attracted most attention of the AI community in the last few years. Indeed, sub-symbolic approaches have got a large competitive advantage from the availability of a large amount of labeled data in some applications. In these contexts, sub-symbolic approaches and, in particular, deep learning ones are effective in processing low-level perception inputs [3, 18]. For instance, deep learning architectures have been achieved state-of-the-art results in a wide range of tasks, e.g. speech recognition, computer vision, natural language processing, where deep learning can effectively develop feature representations and classification models at the same time.

On the other hand, symbolic reasoning [7, 16, 23], which is typically based on logical and probabilistic inference, allows to perform high-level reasoning (possibly under uncertainty) without having to deal with thousands of learning hyper-parameters. Even if recent work has tried to gain insight on how a deep model works [21], sub-symbolic approaches are still mostly seen as black-boxes, whereas symbolic approaches are generally more easier to interpret, as the symbol manipulation or chain of reasoning can be unfolded to provide an understandable explanation to a human operator.

In spite of the incredible success of deep learning, many researchers have recently started to question the ability of deep learning to bring us real AI, because the amount and quality of training data would explode in order to jointly learn the high-level reasoning that is needed to perform complex tasks [2]. For example, forcing some structure to the output of a deep learner has been shown to bring benefits in image segmentation tasks, even when simple output correlations were added to the enforced contextual information [6].

Blending symbolic and sub-symbolic approaches is one of the most challenging open problem in AI and, recently, a lot of works, often referred as neuro-symbolic approaches [10], have been proposed by several authors [6, 14, 22, 27].

In this paper, we present Deep Logic Models (DLMs), a unified framework to integrate logical reasoning and deep learning. DLMs bridge an input layer processing the sensorial input patterns, like images, video, text, from a higher level which enforces some structure to the model output. Unlike in Semantic-based Regularization [8] or Logic Tensor Networks [9], the sensorial and reasoning layers can be jointly trained, so that the high-level weights imposing the output structure are jointly learned together with the neural network weights, processing the low-level input. The bonding is very general as any (set of) deep learners can be integrated and any output structure can be expressed. This paper will mainly focus on expressing the high-level structure using logic formalism like first–order logic (FOL). In particular, a consistent and fully differentiable relaxation of FOL is used to map the knowledge into a set of potentials that can be used in training and inference.

The outline of the paper is the following. Section 2 presents the model and the integration of logic and learning. Section 3 compares and connects the presented work with previous work in the literature and Section 4 shows the experimental evaluation of the proposed ideas on various datasets. Finally, Section 5 draws some conclusions and highlights some planned future work.

2 Model

We indicate as $\boldsymbol{\theta}$ the model parameters, and $X$ the collection of input sensorial data. Deep Logic Models (DLMs) assume that the prediction of the system is constrained by the available prior knowledge. Therefore, unlike standard Neural networks which compute the output via a simple forward pass, the output computation in DLM can be decomposed into two stages: a low-level stage processing the input patterns, and a subsequent semantic stage, expressing constraints over the output and performing higher level reasoning. We indicate by $\boldsymbol{y}=\{y_{1},\ldots,y_{n}\}$ and by $\boldsymbol{f}=\{f_{1},\ldots,f_{n}\}$ the two multivariate random variables corresponding to the output of the model and to the output of the first stage respectively, where $n>0$ denotes the dimension of the model outcomes. Assuming that the input data is processed using neural networks, the model parameters can be split into two independent components $\boldsymbol{\theta}=\{\boldsymbol{w},\boldsymbol{\lambda}\}$, where $\boldsymbol{w}$ is the vector of weights of the networks $f_{nn}$ and $\boldsymbol{\lambda}$ is the vector of weights of the second stage, controlling the semantic layer and the constraint enforcement.

Figure 1 shows the graphical dependencies among the stochastic variables that are involved in our model. The first layer processes the inputs returning the values $\boldsymbol{f}$ using a model with parameters $\boldsymbol{w}$. The higher layer takes as input $\boldsymbol{f}$ and applies reasoning using a set of constraints, whose parameters are indicated as $\boldsymbol{\lambda}$, then it returns the set of output variables $\boldsymbol{y}$.

The Bayes rule allows to link the probability of the parameters to the posterior and prior distributions:

[TABLE]

Assuming the breakdown into a sensorial and a semantic level, the prior may be decomposed as $p(\boldsymbol{\theta})=p(\boldsymbol{\lambda})p(\boldsymbol{w})$, while the posterior can be computed by marginalizing over the assignments for $\boldsymbol{f}$:

[TABLE]

A typical choice is to link $p(\boldsymbol{f}|\boldsymbol{w},X)$ to the outputs of the neural architectures:

[TABLE]

where the actual (deterministic) output of the networks $f_{nn}$ over the inputs is indicated as $\boldsymbol{f}_{nn}$. Please note that there is a one-to-one correspondence among each element of $\boldsymbol{y},\boldsymbol{f}$ and $\boldsymbol{f}_{nn}$, such that $|\boldsymbol{y}|=|\boldsymbol{f}|=|\boldsymbol{f}_{nn}|$.

However, the integral in Equation (1) is too expensive to compute and, as commonly done in the deep learning community, only the actual output of the network is considered, namely:

[TABLE]

resulting in the following approximation of the posterior:

[TABLE]

A Deep Logic Model assumes that $p(\boldsymbol{y}|\boldsymbol{f}_{nn},\boldsymbol{\lambda})$ is modeled via an undirected probabilistic graphical model in the exponential family, such that:

[TABLE]

where the $\Phi_{c}$ are potential functions expressing some constraints on the output variables, $\boldsymbol{\lambda}=\{\lambda_{1},\lambda_{2},\ldots,\lambda_{C}\}$ are parameters controlling the confidence for the single constraints where a higher value corresponds to a stronger enforcement of the corresponding constraint, $\Phi_{r}$ is a potential favoring solutions where the output closely follows the predictions provided by the neural networks (for instance $\Phi_{r}(\boldsymbol{y},\boldsymbol{f}_{nn})=-\frac{1}{2}||\boldsymbol{y}-\boldsymbol{f}_{nn}||^{2}$) and $Z(\boldsymbol{y})$ is a normalization factor (i.e. the partition function):

[TABLE]

2.1 MAP Inference

MAP inference assumes that the model parameters are known and it aims at finding the assignment maximizing $p(\boldsymbol{y}|\boldsymbol{f}_{nn},\boldsymbol{\lambda})$. MAP inference does not require to compute the partition function $Z$ which acts as a constant when the weights are fixed. Therefore:

[TABLE]

The above maximization problem can be optimized via gradient descent by computing:

[TABLE]

2.2 Learning

Training can be carried out by maximizing the likelihood of the training data:

[TABLE]

In particular, assuming that $p(\boldsymbol{y}_{t}|\boldsymbol{\theta},X)$ follows the model defined in equation (2) and the parameter priors follow Gaussian distributions, we get:

[TABLE]

where $\alpha,\beta$ are meta-parameters determined by the variance of the selected Gaussian distributions. Also in this case the likelihood may be maximized by gradient descent using the following derivatives with respect to the model parameters:

[TABLE]

Unfortunately, the direct computation of the expected values in the above derivatives is not feasible. A possible approximation [12, 13] relies on replacing the expected values with the corresponding value at the MAP solution, assuming that most of the probability mass of the distribution is centered around it. This can be done directly on the above expressions for the derivatives or in the log likelihood:

[TABLE]

From the above approximation, it emerges that the likelihood tends to be maximized when the MAP solution is close to the training data, namely if $\Phi_{r}(\boldsymbol{y}_{t},\boldsymbol{f}_{nn})\simeq\Phi_{r}(\boldsymbol{y}_{M},\boldsymbol{f}_{nn})$ and $\Phi_{c}(\boldsymbol{y}_{t})\simeq\Phi_{c}(\boldsymbol{y}_{M})\leavevmode\nobreak\ \forall c$. Furthermore, the probability distribution is more centered around the MAP solution when $\Phi_{r}(\boldsymbol{y}_{M},\boldsymbol{f}_{nn})$ is close to its maximum value. We assume that $\Phi_{r}$ is negative and have zero as upper bound: $\Phi_{r}(\boldsymbol{y},\boldsymbol{f}_{nn})\leq 0\leavevmode\nobreak\ \forall\boldsymbol{y},\boldsymbol{f}_{nn}$, like it holds for example for the already mentioned negative quadratic potential $\Phi_{r}(\boldsymbol{y},\boldsymbol{f}_{nn})=-\frac{1}{2}||\boldsymbol{y}-\boldsymbol{f}_{nn}||^{2}$. Therefore, the constraint $\Phi_{r}(\boldsymbol{y}_{t},\boldsymbol{f}_{nn})\simeq\Phi_{r}(\boldsymbol{y}_{M},\boldsymbol{f}_{nn})$ is transformed into the two separate constraints $\Phi_{r}(\boldsymbol{y}_{t},\boldsymbol{f}_{nn})\simeq 0$ and $\Phi_{r}(\boldsymbol{y}_{M},\boldsymbol{f}_{nn})\simeq 0$.

This means that, given the current MAP solution, it is possible to increase the log likelihood by computing the gradient and weight updates using the following cost function:

[TABLE]

In this paper, a quadratic form for the priors and the potentials is selected, but other choices are possible. For example, $\Phi_{r}(\cdot)$ could instead be implemented as a negative cross entropy loss. Therefore, replacing the selected forms for the potentials and changing the sign to transform a maximization into a minimization problem, yields the following cost function, given the current MAP solution:

[TABLE]

Minimizing the cost function $C_{\boldsymbol{\theta}}(\boldsymbol{y}_{t},\boldsymbol{y}_{M},X)$ is just a local approximation of the full likelihood maximization for the current MAP solution. Therefore, the training process alternates the computation of the MAP solution, the computation of the gradient for $C_{\boldsymbol{\theta}}(\boldsymbol{y}_{t},\boldsymbol{y}_{M},X)$ and one weight update step.

Algorithm 1 summarizes this iterative training algorithm. Please note that, for any constraint $c$, the parameter $\lambda_{c}$ admits also a negative value. This is in case the $c$-th constraint turns out to be too satisfied by the actual MAP solution with respect to the satisfaction degree on the training data.

2.3 Mapping Constraints into a Continuous Logic

The DLM model is absolutely general in terms of the constraints that can be expressed on the outputs. However, this paper mainly focuses on constraints expressed in the output space $\boldsymbol{y}$ by means of first–order logic formulas. Therefore, this section focuses on defining a methodology to integrate prior knowledge expressed via FOL into a continuous optimization process.

In this framework we only deal with closed FOL formulas, namely formulas where any variable occurring in predicates is quantified. In the following, given an $m$-ary predicate $p$ and a tuple $(a_{1},\ldots,a_{m})\in Dom(p)$, we say that $p(a_{1},\ldots,a_{m})\in[0,1]$ is a grounding of $p$. Given a grounding of the variables occurring in a FOL formula (namely a grounding for all the predicates involved in the formula), the truth degree of the formula for that grounding is computed using the t-norm fuzzy logic theory as proposed in [24]. The overall degree of satisfaction of a FOL formula is obtained by grounding all the variables in such formula and aggregating the values with different operators depending on the occurring quantifiers. The details of this process are explained in the following of the section.

Grounded Expressions.

Any fully grounded FOL rule corresponds to an expression in propositional logic and we start showing how a propositional logic expression may be converted into a differentiable form. In particular, one expression tree is built for each considered grounded FOL rule, where any occurrence of the basic logic connectives ($\lnot,\land,\lor,\Rightarrow$) is replaced by a unit computing its corresponding fuzzy logic operation according to a certain logic semantics. In this regard, some recent work shows how to get convex (or even linear) functional constraints exploiting the convex Łukasiewicz fragment [11]. The expression tree can take as input the output values of the grounded predicates and then recursively compute the output values of all the nodes in the expression tree. The value obtained on the root node is the result of the evaluation of the expression given the input grounded predicates.

Table 1 shows the algebraic operations corresponding to the logic operators for different selections of the t-norms. Please note that the logic operators are always monotonic with respect of any single variable, but they are not always differentiable (nor even continuous). However, the sub-space where the operators are non-differentiable has null-Lebesgue measure, therefore they do not pose any practical issue, when used as part of a gradient descent optimization schema as detailed in the following.

We assume that the input data $X$ can be divided into a set of sub-domains $X=\{X_{1},X_{2},\ldots\}$, such that each variable $v_{i}$ of a FOL formula ranges over the data of one input domain, namely $v_{i}\in X_{d_{i}}$, where $d_{i}$ is the index of the domain for the variable $v_{i}$.

For example, let us consider the rule $\forall v_{1}\forall v_{2}\leavevmode\nobreak\ \lnot A(v_{1},v_{2})\land B(v_{1})$. For any assignment to $v_{1}$ and $v_{2}$, the expression tree returns the output value $[1-A(v_{1},v_{2})]\cdot B(v_{1})$, assuming to exploit the product t-norm to convert the connectives.

Quantifiers.

The truth degree of a formula containing an expression with a universally quantified variable $v_{i}$ is computed as the average of the t-norm truth degree of the expression, when grounding $v_{i}$ over its domain. The truth degree of the existential quantifier is the maximum of the t-norm expression grounded over the domain of the quantified variable. When multiple quantified variables are present, the conversion is performed from the outer to the inner variable. When only universal quantifiers are present the aggregation is equivalent to the overall average over each grounding.

In the previous example, this yields the following expression:

[TABLE]

2.4 Potentials expressing the logic knowledge

It is now possible to explain how to build the potentials from the prior knowledge. In any learning task, each unknown grounded predicate corresponds to one variable in the vector $\boldsymbol{y}$. In the above example, the number of groundings is $|X_{d_{1}}|\times|X_{d_{2}}|$ (i.e. the size of the cartesian product of the domains of $A$) and $|X_{d_{1}}|$ (i.e. the size of the domain of $B$). Therefore, assuming that both predicates $A,B$ are unknown, $|\boldsymbol{y}|=|\boldsymbol{f}|=|X_{d_{1}}|\times|X_{d_{2}}|+|X_{d_{1}}$|. The vector $\boldsymbol{f}_{nn}$ is built similarly by replacing a generic predicate with its neural implementation and then emplacing the function values for the groundings in the vector. Again for the considered example: $\boldsymbol{f}_{nn}=\{f_{A}(v_{11},v_{21}),\ldots,f_{A}(v_{1|X_{d_{1}}|},v_{2|X_{d_{2}}|}),f_{B}(v_{11}),\ldots,f_{B}(v_{1|d_{2}|})\}$, where $v_{ij}$ is the $j$-th grounding for the $i$-th variable and $f_{A},f_{B}$ are the learned neural approximations of $A$ and $B$, respectively. Finally, the differentiable potential for the example formula is obtained by replacing in Equation (4) each grounded predicate with the corresponding stochastic variable in $\boldsymbol{y}$.

Figure 2 shows the undirected graphical model corresponding to the DLM for the running example rule used in this section, assuming that $v_{1}$ can assume values over the constants $\{Mary,John\}$ and $v_{2}$ over $\{Munich,London\}$. Each stochastic node $y_{i}$ approximates one grounded predicate, while the $f_{i}$ nodes are the actual output of a neural network getting as input the pattern representations of the corresponding grounding. The vertical connections between two $y_{i}$ and $f_{i}$ nodes correspond to the cliques over the groundings for which the $\Phi_{r}$ potential can be decomposed. The links between the $y_{i}$ nodes corresponds to the cliques over the groundings of the rule for which the corresponding $\Phi_{c}$ potential can be decomposed. The structure of these latter cliques follows a template determined by the rule, that is repeated for the single groundings. The graphical model is similar to the ones built by Probabilistic Soft Logic [1] or Markov Logic Networks [26], but enriched with the nodes corresponding to the output of the neural networks.

3 Related Works

DLMs have also their roots in Probabilistic Soft Logic (PSL) [1], a probabilistic logic using an undirected graphical model to represent a grounded FOL knowledge base, and employing a similar differentiable and convex approximation of FOL. PSL, similar to a DLM, allows to learn the weight of each formula in the KB by maximizing the log likelihood of the training data. However in PSL, rule weights are restricted to only positive values denoting how far the rule is from being satisfied. On the other hand, in DLMs the rule weights denote the needed constraint reactions to match the degree satisfaction of the training data. In addition, unlike DLMs, PSL focuses on logic reasoning without any integration with deep learners, beside a simple stacking with no joint training.

The integration of learning from data and symbolic reasoning [10] has recently attracted a lot of attention. Hu at al. [15], Semantic-based regularization (SBR) [8] for kernel machines and Logic Tensor Networks (LTN) [9] for neural networks share the same basic idea of integrating logic reasoning and learning using a similar continuous relaxation of logic to the one presented in this paper. However, this class of approaches considers the reasoning layer as frozen, without allowing to jointly train its parameters. This is a big limitation, as these methods work better only with hard constraints, while they are less suitable in presence of reasoning under uncertainty.

The integration of deep learning with Conditional Random Fields (CRFs) [20] is also an alternative approach to enforce some structure on the network output. This approach has been proved to be quite successful on sequence labeling for natural language processing tasks. This methodology can be seen as a special case of the more general methodology presented in this paper, when the potential functions are used to represent the correlations among consecutive outputs of a recurrent deep network.

DeepProbLog [22] extends the popular ProbLog [7] probabilistic programming framework with the integration of deep learners. DeepProbLog requires the output from the neural networks to be probabilities and an independence assumption among atoms in the logic is required to make inference tractable. This is a strong restriction, since the sub-symbolic layer often consists of several neural layers sharing weights.

A Neural Theorem Prover (NTP) [27, 28] is an end-to-end differentiable prover based on the Prolog’s backward chaining algorithm. An NTP constructs an end-to-end differentiable architecture capable of proving queries to a KB using sub-symbolic vector representations. NTPs have been proven to be effective in tasks like entity linking and knowledge base completion. However, an NTP encodes relations as vectors using a frozen pre-selected function (like cosine similarity). This can be ineffective in modeling relations with a complex and multifaceted nature (for example a relation friend(A,B) can be triggered by different relationships of the representations in the embedding space). On the other hand, DLMs allow a relation to be encoded by any selected function (e.g. any deep neural networks), which is co-trained during learning. Therefore, DLMs are capable of a more powerful and flexible exploitation of the representation space. On the other end, DLMs require to fully ground a KB (like SBR, LTN, PSL and most of other methods discussed here), while NTPs expands only the groundings on the explored frontier, which can be more efficient in some cases.

Deep Structured Models [6, 19] use a similar graphical model to bridge the sensorial and semantic levels. However, they have mainly focused on imposing correlations on the output layer, without any focus on logic reasoning. Furthermore, DLMs transform the training process into an iterative constrained optimization problem, which is very different from the approximation of the partition function used in Deep Structured Models.

DLMs also open up the possibility to iteratively integrate rule induction mechanisms like the ones proposed by the Inductive Logic Programming community [17, 25].

4 Experimental Results

4.1 The PAIRS artificial dataset

Consider the following artificial task. We are provided with 1000 pairs of handwritten digits images sampled from the MNIST dataset. The pairs are not constructed randomly but they are compilied according to the following structure:

pairs with mixed even-odd digits are not allowed; 2. 2.

the first image of a pair represents a digit randomly selected from a uniform distribution; 3. 3.

if the first image is an even (resp. odd) digit, the second image of a pair represents one of the five even (resp. odd) digits with probabilities $p_{1}\geq p_{2}\geq p_{3}\geq p_{4}\geq p_{5}$, with $p_{1}$ the probability of being an image of the same digit, $p_{2}$ the probability of being an image of the next even/odd digit, and so on.

For example, if the first image of a pair is selected to be a two, the second image will be a two with probability $p_{1}$, it will be a four with probability $p_{2}$, a six with probability $p_{3}$ and so on, in a circular fashion. An example is shown in Figure 3.

A correct classification happens when both digit in a pair are correctly predicted.

To model a task using DLMs there are some common design choices regarding these two features that one needs to take. We use the current example to show them. The first choice is to individuate the constants of the problem and their sensorial representation in the perceptual space. Depending on the problem, the constants can live in a single or multiple separate domains. In the pairs example, the images are constants and each one is represented as a vector of pixel brightnesses like commonly done in deep learning.

The second choice is the selection of the predicates that should predict some characteristic over the constants and their implementation. In the pairs experiment, the predicates are the membership functions for single digits (e.g. one(x), two(x), etc.). A single neural network with 1 hidden layer, 10 hidden neurons and $10$ outputs, each one mapped to a predicate, was used in this toy experiment. The choice of a small neural network is due to the fact that the goal is not to get the best possible results, but to show how the prior knowledge can help a classifier to improve its decision. In more complex experiments, different networks can be used for different sets of predicates, or each use a separate network for each predicate.

Finally, the prior knowledge is selected. In the pairs dataset, where the constants are grouped in pairs, it is natural to express the correlations among two images in a pair via the prior knowledge. Therefore, the knowledge consists of $100$ rules in the form $\forall(x,y)\leavevmode\nobreak\ D_{1}(x)\rightarrow D_{2}(y)$, where $(x,y)$ is a generic pair of images and $(D_{1},D_{2})$ range over all the possible pairs of digit classes.

We performed the experiments with $p_{1}=0.9,p_{2}=0.07,p_{3}=p_{4}=p_{5}=0.01$. All the images are rotated with a random degree between [math] and $90$ anti-clockwise to increase the complexity of the task. There is a strong regularity in having two images representing the same digit in a pair, even some rare deviations from this rule are possible. Moreover, there are some inadmissible pairs, i.e. those containing mixed even-odd digits. The train and test sets are built by sampling $90\%$ and $10\%$ image pairs.

The results provided using a DLM have been compared against the following baselines:

• •

the neural network (NN) with no knowledge of the structure of the problem;

• •

the Semantic Based Regularization [8] (SBR) framework, which also employs logical rules to improve the learner. However, the rule weights are treated as fixed parameters, which are not jointly trained during learning. Since searching in the space of these parameters via cross-validation is not feasible, a strong prior was provided to make SBR prefers pairs with the same image using 10 rules of the form $\forall(x,y)\leavevmode\nobreak\ D(x)\rightarrow D(y)$, for each digit class $D$. These rules hold true in most cases and improve the baseline performance of the network.

Table 2 shows how the neural network output of a DLM (DLM-NN) already beats both the same neural model trained without prior knowledge and SBR. This happens because the neural network in DLM is indirectly adjusted to respect the prior knowledge in the overall optimization problem. When reading the DLM output from the MAP solution (DLM), the results are significantly improved.

4.2 Link Prediction in Knowledge Graphs

Neural-symbolic approaches have been proved to be very powerful to perform approximated logical reasoning [29]. A common approach is to assign to each logical constant and relation a learned vectorial representation [4]. Approximate reasoning is then carried out in this embedded space. Link Prediction in Knowledge Graphs is a generic reasoning task where it is requested to establish the links of the graph between semantic entities acting as constants. Rocktaschel et al. [28] shows state-of-the-art performances on some link prediction benchmarks by combining Prolog backward chain with a soft unification scheme.

This section shows how to model a link prediction task on the Countries dataset using a Deep Logic Models, and compare this proposed solution to the other state-of-the-art approaches.

Dataset.

The Countries dataset [5] consists of $244$ countries (e.g. germany), $5$ regions (e.g. europe), $23$ sub-regions (e.g. western europe, northern america, etc.), which act as the constants of the KB. Two types of binary relations among the constant are present in the dataset: $\texttt{locatedIn}(c_{1},c_{2})$, expressing that $c_{1}$ is part of $c_{2}$ and $\texttt{neighborOf}(c_{1},c_{2})$, expressing that $c_{1}$ neighbors with $c_{2}$. The knowledge base consists of $1158$ facts about the countries, regions and sub-regions, expressed in the form of Prolog facts (e.g. locatedIn(italy,europe)). The training, validation and test sets are composed by $204,20$ and $20$ countries, respectively, such that each country in the validation and test sets has at least one neighbor in the training set. Three different tasks have been proposed for this dataset with an increasing level of difficulty. For all tasks, the goal is to predict the relation $\texttt{locatedIn}(c,r)$ for every test country $c$ and all five regions $r$, but the access to training atoms in the KB varies, as explained in the following:

• •

Task S1: all ground atoms $\texttt{locatedIn}(c,r)$ where $c$ is a test country and $r$ is a region are removed from the KB. Since information about the sub-region of test countries is still contained in the KB, this task can be solved exactly by learning the transitivity of the locatedIn relation.

• •

Task S2: like S1 but all grounded atoms $\texttt{locatedIn}(c,s)$, where $c$ is a test country and $s$ is a sub-region, are removed. The location of test countries needs to be inferred from the location of its neighbors. This task is more difficult than S1, as neighboring countries might not be in the same region.

• •

Task S3: like S2, but all ground atoms $\texttt{locatedIn}(c,r)$, where $r$ is a region and $c$ is a training country with either a test or validation country as a neighbor, are removed. This task requires multiple reasoning steps to determine an unknown link, and it strongly exploits the sub-symbolic reasoning capability of the model to be effectively solved.

Model.

Each country, region and sub-region corresponds to a constant. Since the constants are just symbols, each one is assigned to an embedding, which is learned together with the other parameters of the model. The predicates are the binary relations locatedIn and neighborOf, which connect constants in the KB. Each relation is learned via a separate neural network with a $50$ neuron hidden layer taking as input the concatenation of the embeddings of the constants. In particular, similarly to [4], the constants are encoded into a one-hot vector, which is processed by the first layer of the network, outputting an embedding composed by $50$ real number values. As commonly done in link prediction tasks, the learning process is performed in a transductive mode. In particular, the input $X$ consists of all possible constants for the task, while the train examples $\boldsymbol{y}_{t}$ will cover only a subset of all the possible grounded predicates, leaving to the joint train and inference process the generalization of the prediction to the other unknown grounded relations. Indeed, the output of the train process in this case is both the set of model parameters and the MAP solution predicting the unknown grounded relations that hold true.

Multi-step dependencies among the constants are very important to predict the existence of a link in this task. For example in task S1, the prediction of a link among a country and a region can be established via the path passing by a sub-region, once the model learns a rule stating the transitivity of the locatedIn relation (i.e. $\texttt{locatedIn}(x,y)\land\texttt{locatedIn}(y,z)\rightarrow\texttt{locatedIn}(x,z)$). Exploiting instead the rule $\texttt{neighborOf}(x,y)\land\texttt{locatedIn}(y,z)\rightarrow\texttt{locatedIn}(x,z)$, the model should be capable of approximately solving task S2.

All $8$ rules $\forall x\leavevmode\nobreak\ \forall y\leavevmode\nobreak\ \forall z\leavevmode\nobreak\ \texttt{A}(x,y)\land\texttt{B(y,z)}\rightarrow\texttt{C}(y,z)$, where A, B and C are either neighborOf or locatedIn are added to the knowledge base for this experiment. These rules represent all the 2-steps paths reasoning that can be encoded, and the strength of each rule needs to be estimated as part of the learning process for each task. The training process will iteratively minimize Equation 3 by jointly determining the embeddings and the network weights such that network outputs and the MAP solution will correctly predict the training data, while respecting the constraints on the MAP solution at the same level as on the train data.

Results.

Table 3 compares DLM against the state-of-the-art methods used by Rocktaschel et al. [28], namely ComplEx, NTP and NTP$\lambda$. Task S1 is the only one that can be solved exactly when the transitive property of the locatedIn relation has been learned to always hold true. Indeed, most methods are able to perfectly solve this task, except for the plain NTP model. DLM is capable perfectly solving this task by joining the logical reasoning capabilities with the discriminative power of neural networks. DLMs perform better than the competitors on tasks S2 and S3, thanks to additional flexibility obtained by jointly training the relation functions using neural networks, unlike the simple vectorial operations like the cosine similarity employed by the competitors.

5 Conclusions and future work

This paper presents Deep Logic Models that integrate (deep) learning and logic reasoning into a single fully differentiable architecture. The logic can be expressed with unrestricted FOL formalism, where each FOL rule is converted into a differentiable potential function, which can be integrated into the learning process. The main advantage of the presented framework is the ability to fully integrate learning from low-level representations and semantic high-level reasoning over the network outputs. Allowing to jointly learn the weights of the deep learners and the parameters controlling the reasoning enables a positive feedback loop, which is shown to improve the accuracy of both layers. Future work will try to bridge the gap between fully grounded methodologies like current Deep Logic Models and Theorem Provers which expand only the groundings needed to expand the frontier of the search space.