A tensorized logic programming language for large-scale data

TL;DR

This paper introduces T-PRISM, a tensor-based logic programming language that combines symbolic reasoning with scalable numerical computation, enabling high-level modeling and processing of large-scale data using GPUs.

Contribution

It proposes a novel tensorized semantics for logic programming, integrating tensor embeddings into a probabilistic logic language with scalable GPU acceleration.

Findings

Successfully handled large-scale data in declarative modeling

Implemented a DistMult model for knowledge graphs

Demonstrated scalability with FB15k and WN18 datasets

Abstract

We introduce a new logic programming language T-PRISM based on tensor embeddings. Our embedding scheme is a modification of the distribution semantics in PRISM, one of the state-of-the-art probabilistic logic programming languages, by replacing distribution functions with multidimensional arrays, i.e., tensors. T-PRISM consists of two parts: logic programming part and numerical computation part. The former provides flexible and interpretable modeling at the level of first order logic, and the latter part provides scalable computation utilizing parallelization and hardware acceleration with GPUs. Combing these two parts provides a remarkably wide range of high-level declarative modeling from symbolic reasoning to deep learning. To embody this programming language, we also introduce a new semantics, termed tensorized semantics, which combines the traditional least model semantics in logic programming with the embeddings of tensors. In T-PRISM, we first derive a set of equations related to tensors from a given program using logical inference, i.e., Prolog execution in a symbolic space and then solve the derived equations in a continuous space by TensorFlow. Using our preliminary implementation of T-PRISM, we have successfully dealt with a wide range of modeling. We have succeeded in dealing with real large-scale data in the declarative modeling. This paper presents a DistMult model for knowledge graphs using the FB15k and WN18 datasets.

Tables

Table 1. Table 1: DistMult (Figure 2 ) performance using T-PRISM

	FB15K	WN18
MRR	54.16%	60.62%
HIT@10	75.88%	86.00%
HIT@1	42.22%	47.04%

Equations

$$H$$

$$W_{\ell }$$

$$q(A\vee B)\stackrel{\mathrm{def}}{=}q(A)+q(B).$$

$$q(H)$$

$$q(W_{\ell })$$

$$q(W_{\ell })=$$

$$\circ \text{mbox}{einsum}_{q,T}(B_{1\ell },B_{2\ell },...,B_{M_{\ell }\ell }).$$

$$f(s,r,o)=\sum _i{\mathbf{s}}_i{\mathbf{r}}_i{\mathbf{o}}_i.$$

$$Loss(rel(S,R,O))={\left[f(S,R,O)-f(S,R,O^{\prime })-\gamma \right]}_{+}$$

Full text

To embody this programming language, we also introduce a new semantics, termed tensorized semantics, which combines the traditional least model semantics in logic programming with the embeddings of tensors. In T-PRISM, we first derive a set of equations related to tensors from a given program using logical inference, i.e., Prolog execution in a symbolic space and then solve the derived equations in a continuous space by TensorFlow.

Using our preliminary implementation of T-PRISM, we have successfully dealt with a wide range of modeling. We have succeeded in dealing with real large-scale data in the declarative modeling. This paper presents a DistMult model for knowledge graphs using the FB15k and WN18 datasets.

1. Introduction

Logic programming provides concise expressions of knowledge and has been proposed as means for representing and modeling various types of data for real-world AI systems. For example, to deal with uncertain and noisy data, probabilistic logic programming (PLP) has been extensively studied (?; ?; ?). PLP systems allow users to flexibly and clearly describe stochastic dependencies and relations between entities using logic programming. Also in the different context, to handle a wide range of applications, the unification of neural networks and approximate reasoning by symbol embeddings into continuous spaces has recently been proposed (?; ?; ?).

In this paper, we tackle a task of combining symbolic reasoning and multi-dimensional continuous-space embeddings of logical constructs such as clauses, and explore a new approach to compile a program written in a declarative language into a procedure of numerical calculation suitable for large-scale data. Such languages are expected to be interpretable as a programming language while efficiently executable in the level of numerical calculation like vector computation. Aiming at this goal, we introduce tensorized semantics, a novel algebraic semantics interfacing a symbolic reasoning layer and the numeric computation layer, and propose a new modeling language “T-PRISM”. It is based on an existing probabilistic logic programming language PRISM (?) and implements the tensorized semantics for large-scale datasets.

Thus the first contribution of this paper is the introduction of a new semantics, tensorized semantics. The current PRISM has the distribution semantics (?) that probabilistically generalizes the least model semantics in logic programming to coherently assign probabilities to the logical constructs. Likewise tensorized semantics assigns tensors111 In this paper, the term “tensor” is used as a multi-dimensional array interchangeably. to the logical constructs based on the least model semantics. Both of PRISM and T-PRISM programs are characterized by a set of equations for the assigned quantities.

One may be able to view T-PRISM as one approach to an equation-level interface to connect logic programming and continuous-space embeddings. Another approach is possible, predicate-level interface, such as DeepProblog (?). Their approach is to provide special predicates connecting neural networks and probabilistic logic programming by ProbLog. It implementationally separates neural networks from probabilistic models but syntactically integrates, for example, image recognition and logical reasoning using estimated labels. This approach, unlike our approach, does not allow constants and predicates to have corresponding vectors (tensors) representations in neural networks.

The second contribution of this paper is an implementation methodology of the T-PRISM’s tensorized semantics. T-PRISM’s new semantics guides an internal data structure to connect symbolic inference by Prolog execution and numerical calculation by TensorFlow (?). This internal data structure represents tensor equations for tensorized semantics and is an expanded PRISM’s explanation graph, explanation graphs with Einstein’s notation, a set of logical equations (bi-implications) that allows repeated sum-product operations for a specified number of times, called Einstein’s notation. This expansion is intended for parallelization and enhance the applicability of T-PRISM to large-scale data.

2. Tensorized semantics

T-PRISM’s semantics, “tensorized least model semantics” or “tensorized semantics” for short, is a tensorized version of existing PRISM semantics. In PRISM, the semantics assigns probability masses to ground atoms in the Herbrand base of a program whereas in T-PRISM, multi-dimensional arrays are assigned to them.

Formally, a T-PRISM program is a five-tuple $\left\langle F,C,q_{F},T_{F},R\right\rangle$. A primary part of the program $\mathit{DB}=F\cup C$ is a Prolog (definite clause) program where $F$ is a set of tensor atoms (see below), and $C$ is a set of definite clauses whose head contains no tensor atom. Theoretically, we always equate a set of clauses with the set of all ground instances and allow $\mathit{DB}$ to be countably infinite.

In addition to this setting, we introduce a specific type of atoms called tensor atoms represented by tensor/2 which declare multi-dimensional arrays called embedded tensors. A tensor atom has an index as a list of Prolog constants in the second argument to access the entries of the declared multi-dimensional array. For example, ${\tt tensor(x,[i,j])}$ represents a tensor atom having a ground atom x and an index [i,j]. It declares a second-order tensor (matrix) $\mathbf{X}$ specified by x whose index $(i,j)$ is expressed by [i,j]. To make this correspondence mathematically rigorous, we define a function $q_{F}(\cdot)$ from tensor atoms to embedded tensors such that $q_{F}({\tt tensor(x,[i,j])})=\mathbf{X}_{i,j}$. In general, an index of an $n$-order tensor is represented as an $n$-length list of Prolog constants. Note that the domain of $q_{F}(.)$ can be extended to programs without tensor atoms. In such case, $q_{F}({\tt x})$ is defined as one (a scalar value) when a ground atom ${\tt x}$ is logically true in Prolog. This treatment is consistent with PRISM in a part of vanilla Prolog.

In this paper, as already shown, we use italic fonts for indices appearing in mathematical expressions to distinguish them from the corresponding ones appearing in a program. So for a matrix $\mathbf{X}$ specified by x, we write an entry $\mathbf{X}_{i,j}$ for the index [i,j]. Also to extract indices, we define $T_{F}$ such that, for instance, $T_{F}({\tt tensor(x,[i,j])})=(i,j)$.

In the concrete numerical calculation, we have to give the range of indices, i.e., the size of embedded tensors. A T-PRISM program contains a function $R({\tt i})$ that determines the range of an index [i] as ${1,2,...,R({\tt i})}$. Thus, in the above example, the size of a matrix $\mathbf{X}_{i,j}$ is determined as $R({\tt i})\times R({\tt j})$.

Once a T-PRISM program is given, a set of tensor equations are determined from the program. Consider a clause having a head $H$. Let $H\leftarrow W_{\ell}(\ell=1,\ldots,L)$ be an enumeration of clauses about $H$ in the program. For each $H$, logical equations222 Logical equivalence seems a more appropriate term, but we use equation for intuitiveness. of the following form, which holds in the least model of the program, are derived.

[TABLE]

where $B_{*\ell}$ is a ground atom in the body $W_{\ell}$.

The tensorized semantics is obtained by expanding the mappings $q_{F}(\cdot)$ and $T_{F}(\cdot)$ over $F$ respectively to $q(\cdot)$ and $T(\cdot)$ for the entire Herbrand base. It assigns various orders of tensors to atoms as their denotation. They are inductively defined, starting from tensor atoms, by applying two rules below to Equation (1).

• •

Disjunction rule

Given a disjunction of tensor atoms, its embeddings is defined as the summation of the tensor atoms, $A$ and $B$:

[TABLE]

• •

Conjunction rule

Given a conjunction of tensor atoms with associated multi-dimensional arrays for embedding, embeddings of the conjunction is defined by the Einstein’s notation rule333 Although a general formulation of Einstein’s notation distinguishes between covariance and contravariance, indicated by subscript and superscript indices respectively, their distinction is irrelevant to our semantics, and hence ignored in this paper. . In the case where subscripts overlap in the same term, the rule is to take a sum for that subscript. Note the non-overlap indices are not eliminated by this operation. We call the overlapping index a dummy index whereas a non-overlapping index as a free index. A set of free indices is assigned to $T(A\wedge B)$. For example, put $T(A)=(i,j)$ and $T(B)=(j,k)$. $T(A\wedge B)=(i,k)$ is computed by this rule, and a matrix is embedded to $q(A\wedge B)$. As a result, its $i,k$-th element $q(A\wedge B)_{ik}$ is computed as $\sum_{j}q(A)_{ij}\cdot q(B)_{jk}$, i.e., this computation coincides with matrix multiplication. When the index is empty, the resulting value is a scalar (number) and the value of a conjunction of scalar embedding atoms is the product of their values.

By applying the disjunction and conjunction rules to Equation (1) recursively, we can derive the following tensor equations:

[TABLE]

where $\mbox{einsum}_{q,T}$ is a sum-product operation indicated by the Einstein’s notation in the conjunction rule. The derived set of tensor equations has a least solution (as all coefficients are non-negative and all derived equations have upper bounds)(?) and we consider it as the denotation of the given T-PRISM program in the tensorized semantics. In this paper, we assume Equation (2) is well-defined, i.e., there is no mismatch of tensor dimensions.

Non-linear operations are prerequisites for a wider range of applications including deep neural networks. To make them available, T-PRISM provides operator/1 indicating a non-linear operation. This built-in predicate occurs in an explanation graph similarly to tensor/2. The second equation in Equation (2) is modified as follows:

[TABLE]

where $op_{1},op_{2},...,op_{O_{k}}$ are non-linear operations, $B_{*\ell}$ is a ground atom in the body $W_{\ell}$ except for non-linear operations, and $\circ$ represents their function synthesis. Note that nonlinear operations and function synthesis are non-commutative. For example, let $A$ and $B$ be tensor atoms. $B\Leftrightarrow{\tt operator}(f)\wedge{\tt operator}(g)\wedge A$ is interpreted as $q(B)=f\circ g\circ q(A)$. While ${\tt operator}(f)\wedge{\tt operator}(g)\wedge A$ and ${\tt operator}(g)\wedge{\tt operator}(f)\wedge A$ are logically equivalent, they are interpreted as different equations: $f(g(q(A)))$ and $g(f(q(B)))$, respectively.

3. T-PRISM

Theoretically T-PRISM is an implementation of the tensorized semantics with a specific execution mechanism. The main idea of T-PRISM program execution is that the symbolic part of program execution including recursion is processed by Prolog search and the numerical and parallel part such as loop for sum-product computation is carried out by TensorFlow. More concretely in T-PRISM, a program is first compiled to an explanation graph with Einstein’s notation, a set of logical equations like Equation (1), translated to a set of tensor equations like Equation (2) and Equation (3). By removing redundant repetitions, Einstein’s notation enables sum-product computation much faster than that in PRISM which uses sum and product operations naively. Hereafter, we simply call it explanation graph. This explanation graph is obtained by using tabled search in the exhaustive search for all proofs for the top-goal $G$ and by applying dynamic programming to them (?).

To train parameters in embedded tensors, T-PRISM supports (stochastic) gradient decent algorithms using an auto-differential mechanism in TensorFlow. We compute the loss of a dataset $D$ represented as a set of goals to learn parameters. T-PRISM assumes the total loss is defined to be the sum of individual goal loss as follows:$Loss(D)=\sum_{G\in D}Loss(G)$. Usually, $Loss(G)$ is a function of $q(G)$. For example, when parameter training uses a negative log likelihood loss function, the goal loss function is defined as $Loss(G)=-\log q(G)$ where $q(G)$ stands for the likelihood of $G$. For the convenience of modeling, the T-PRISM system offers related built-ins for parameter training and custom loss functions written by Python programs with TensorFlow. Utilizing this T-PRISM system based on tensorized semantics with non-linear operators, various models including matrix computation, deep neural networks, and the models written by recursive programs can be designed.

4. T-PRISM programs for knowledge graphs

This section explains sample programs of T-PRISM through knowledge graph modeling using DistMult (?), After that, we present learning experiments with real datasets: the FB15k and WN18 datasets (?; ?).

The T-PRISM system provides a special predicate tensor/2 to define $T_{F}$ and $q_{F}$. Also it provides set_index_range/2 to define $R$. Using these built-in predicates, T-PRISM programs are written just like Prolog programs.

In addition to these special predicates, our preliminary implementation requires to declare all tensor atoms used in a program using a built-in predicates index_list/2. The first argument specifies a tensor atom, and the second one specifies a list of the second arguments of tensor/2s that occur during program execution, i.e., its possible use of indices for computing a cost function.

We first look at a simple T-PRISM program used for link prediction in knowledge graphs. A knowledge graph consists of triples (subject, relation, object), represented by a ground atom rel(subject, relation, object) using the rel/3 predicate. So logically speaking, a knowledge graph is nothing but a set of ground atoms.

For link prediction in knowledge graphs, we choose DistMult model (?), one of the standard knowledge graph models, for its simplicity. In DistMult, entities $s$, $o$, $r$ ($s$ for subject, $o$ for object, $r$ for relation) are encoded as N-dimensional real vectors, $\mathbf{s}$, $\mathbf{o}$, and $\mathbf{r}$ respectively, and the prediction is made based on the score of $(s,r,o)$ computed by:

[TABLE]

In T-PRISM, a DistMult model is written like Figure 1. The lines 1 and 2 introduce v() and r(). They are embedded vectors with an index i. The lines 3 says the range of index i is $0\leq$i$<20$. The lines 5-8 represent an equation for sum-product computation for the three embedded vectors required for computing the scores in Equation (4).

Next, we apply T-PRISM to link prediction in large size datasets. For more efficient computation, we rewrite a DistMult program as in Figure 2. This program outputs the $o$-dimensional vector, and computes scores for all entities at once (the number of entities in FB15k is 14951). Furthermore, we use a mini-batch method, an essential method in deep learning and other optimization problems from the viewpoint of learning speed and performance (?). Note that O is a singleton variable, i.e., not used in the Prolog search and construction of tensor equations; however, it is instantiated as labels and required to compute a loss function described as below.

For our link prediction experiment, we employ a loss function for the knowledge graph as follows:

[TABLE]

where $[\cdot]_{+}$ means a hinge loss $\max(0,\cdot)$ and a negative sample $O^{\prime}$ is uniformly sampled from all entities. We use this hinge loss function with $L2$ regularization and its learning parameters set to $\lambda=1.0e-5$ and $\gamma=1$.

In this experiment, we use two standard datasets: WN18 from WordNet and FB15k from the Freebase. The purpose here is not to outperform known models for knowledge graphs but rather to demonstrate that T-PRISM can implement them very compactly with a declarative program.

For FB15K, we use the following settings: the batch size $M=512$, the number of negative sampling for one positive sample $N_{neg}=100$ and select as a learning rate optimization method Adam (?), with the initial learning rate $0.001$. For WN18, we set $M$ to $256$ and other setting is the same as the case of FB15K.

This experiment shows that while the DistMult model written in PRISM (?) is incapable of dealing with these datasets due to their sheer data size, the T-PRISM implementation of a DistMult model can handle them and achieves reasonable prediction performance as listed in Table 1. Thanks to a GPU, this experiment is finished in 5 hours444 NVIDIA Tesla P40 GPU was used. .

Conclusion

We proposed an innovative tensorized logic language T-PRISM together with its tensorized semantics, enabling declarative tensor modeling for a large-scale data. We explained how programs are compiled into tensor equations by way of explanation graphs with Einstein’s notation using Prolog’s tabled search, and executed on TensorFlow efficiently. T-PRISM supports a rich array of non-linear operations and custom cost functions for parameter training. Using our preliminary T-PRISM system, we also demonstrated the modeling of knowledge graphs. Future work includes applying T-PRISM to real world problems and showing the effectiveness of logic-based declarative modeling.