Differentiable Representations For Multihop Inference Rules

TL;DR

This paper introduces differentiable methods for second-order multi-hop reasoning over large symbolic knowledge bases, enabling scalable, efficient neural models that perform well on complex reasoning tasks.

Contribution

It presents a new operation for compositional multi-hop reasoning and evaluates various implementations for scalability and performance.

Findings

Techniques scale to KBs with millions of entities and triples

Models achieve competitive performance on multi-hop reasoning tasks

New operation improves compositional reasoning capabilities

Abstract

We present efficient differentiable implementations of second-order multi-hop reasoning using a large symbolic knowledge base (KB). We introduce a new operation which can be used to compositionally construct second-order multi-hop templates in a neural model, and evaluate a number of alternative implementations, with different time and memory trade offs. These techniques scale to KBs with millions of entities and tens of millions of triples, and lead to simple models with competitive performance on several learning tasks requiring multi-hop reasoning.

Tables

Table 1. Table 1: Summary of implementations of relation-set following, where N T subscript 𝑁 𝑇 N_{T} is the number of KB triples, N E subscript 𝑁 𝐸 N_{E} the number of entities, N R subscript 𝑁 𝑅 N_{R} the number of relations.

Strategy	Batch?	Space complexity	# Operations
			sp-dense	dense	sparse
			matmul	+ or $\odot$	+
naive	no	$O\left(N_T+N_E+N_R\right)$	1	0	$N_R$
late mixing	yes	$O\left(N_T+b{N}_E+b{N}_R\right)$	$N_R$	$N_R$	0
reified KB	yes	$O\left(b{N}_T+b{N}_E\right)$	3	1	0

Table 2. Table 2: Left: Hits@1 for the WebQuestionsSP and MetaQA datasets. Results for KV-Mem and VRN on MetaQA are from [ 29 ] ; results for GRAFT-Net and KV-Mem on WebQSP are from [ 19 ] . Systems marked with a star ∗ * construct question-specific autographs, based on the KB, at inference time. Right: Hits@1 and hits@10 for two KB completion tasks. Starred KB completion methods are transductive, and do not generalize to entities not seen in training.

	WebQSP	MetaQA
	1-2 hops	1-hop	2-hop	3-hop
KV-Mem*	46.7	95.8	25.1	10.1
VRN*	—	97.5	89.9	62.5
GRAFT-Net*	67.8	97.0	94.8	77.7
RSF (ours)	52.7	96.2	81.1	72.3

Table 3. Table 3: Time to run 10K examples for knowledge bases of different size.

	NELL-995	MetaQA	WebQuestionsSP
# Facts	154,213	196,453	43,724,175
# Entities	75,492	43,230	12,942,798
# Relations	200	9	616
Time (seconds)	44.3	72.6	1820

Equations

$$\{x^{\prime }:\exists x,z,x^{\prime },s,R_1,R_2\text{ so that }\text{subspan}(q,s)\wedge \text{referent}(s,x)\wedge R_1(x,z)\wedge R_2(z,x^{\prime })\}$$

$$\text{R-neighbors(X)}\equiv \{x^{\prime }:\exists r\in R,x\in X\text{mbox}sothat(x,x^{\prime })\in r\}$$

$$\text{follow}({\text{v}}_X,{\text{v}}_R)\equiv {\text{v}}_X{\text{M}}_R={\text{v}}_X(\sum _{k=1}^{N_{\tau }}{\text{v}}_R[k]\cdot {\text{M}}_k)$$

$$\text{follow}(\text{X},\text{R})=\sum _{k=1}^{N_{\tau }}(\text{R}[:,k]\cdot \text{X}{\text{M}}_k)$$

$${\text{M}}_{subj}[\ell ,m]\equiv \delta |[m=i_{\ell }]|;{\text{M}}_{obj}[\ell ,m]\equiv \delta |[m=j_{\ell }]|;{\text{M}}_{rel}[\ell ,m]\equiv w_{\ell }\cdot \delta |[m=k_{\ell }]|$$

$$\text{follow}(\text{X},\text{R})=(\text{X}{\text{M}}_{subj}^T\odot \text{R}{\text{M}}_{rel}^T){\text{M}}_{obj}$$

$$\textbf{X}\textbf{M}=\left[\textbf{X}_{1};\textbf{X}_{2};\ldots;\textbf{X}_{m}\right]\left[\begin{array}[]{cccc}\textbf{M}_{1,1}&\textbf{M}_{1,2}&\ldots&\textbf{M}_{1,m}\\ \vdots&\vdots&&\vdots\\ \textbf{M}_{m,1}&\textbf{M}_{m,2}&\ldots&\textbf{M}_{m,m}\\ \end{array}\right]=\left[(\sum_{i=1}^{m}\textbf{X}_{1}\textbf{M}_{i,1});\ldots;(\sum_{i=1}^{m}\textbf{X}_{m}\textbf{M}_{i,m})\right]$$

$$\begin{array}{c}{\text{r}}_{\text{E}\to \text{E}}=f_{\text{E}\to \text{E}}(q);{\text{r}}_{\text{E}\to \text{CVT}}=f_{\text{E}\to \text{CVT}}(q);{\text{r}}_{\text{CVT}\to \text{E}}=f_{\text{CVT}\to \text{E}}(q)\\ \hat{\text{a}}=\text{softmax}(\text{follow}(\text{follow}(\text{x},{\text{r}}_{\text{E}\to \text{CVT}}),{\text{r}}_{\text{CVT}\to \text{E}})+\text{follow}(\text{x},{\text{r}}_{\text{E}\to \text{E}}))\end{array}$$

$$\text{for t=1,2,3:}{\text{r}}^t=f^t(q);{\text{x}}^t=\text{follow}({\text{x}}^{t-1},{\text{r}}^t)$$

$$\begin{array}{c}{\text{h}}^0=\text{LSTM}(q);{\text{x}}^0=f_0({\text{h}}^0);{\text{r}}^0=\text{0};p^0=1\\ \text{for t=1,…,T:}{p}^t=f_p({\text{h}}^{t-1});{\text{r}}^t=f_r({\text{h}}^{t-1});{\text{h}}^t=f_h({\text{h}}^{t-1},{\text{r}}^{t-1})\end{array}$$

$$\begin{array}{c}\text{for i=1,…,N and t=1,…,T:}{\text{r}}_i^t=f_i^t(q);{\text{x}}_i^{t+1}=\text{follow}({\text{x}}_i^t,{\text{r}}_i^t)+{\text{x}}_i^t\end{array}$$

Full text

1 Introduction

Templates for multi-hop reasoning. For certain applications it is useful for a neural model to be able to encode multi-step accesses to a symbolic KB. For example, for the task of learning to answer natural-language questions with a KB, a question like $q$ = “who has directed a movie written by Christopher Nolan?” might be answered with the set $\{x^{\prime}:\exists x,z\mbox{~{}so that~{}}\textit{referent}(\textit{``Christopher Nolan''},x)\wedge\textit{writer\_of}(x,z)\wedge\textit{director\_of}(x^{\prime},z)\}$. Computing this set requires multi-hop reasoning, i.e., multiple steps of KB access: in this case, finding the referent of the name “Christopher Nolan”, then finding the movies written by that person, and then finding the directors of those movies. Constructing a logical interpretation like this from text is called semantic parsing.

Since the chains of reasoning in parses are usually short, semantic parsing often can be reduced to finding an appropriate template and instantiating it. For instance, queries like $q$ above could be modeled with the template

[TABLE]

where $s$ is a variable ranging over subspans of $q$; $x$, $x^{\prime}$, and $z$ range over entities, and $R_{1}$ and $R_{2}$ range over relations. Logical expressions with variables ranging over relations are usually called second-order expressions or templates.

Differentiable multi-hop templates. Learning a template-based semantic parser requires learning to select and instantiate the template, and instantiation requires learning a function for each variable in the template—e.g., a system might let $s=f_{s}(q)$, $R_{1}=f_{R_{1}}(q)$, and $R_{2}=f_{R_{2}}(q)$, where $f_{s}$, $f_{R_{1}}$ and $f_{R_{2}}$ might be, for instance, a softmax functions applied to linear transformations of a biLSTM-based encoding of $q$. Training these extractors requires data in which each $q$ is labeled with the value of each template variable—e.g., here labels for $q$ would specify that $f_{R_{1}}(q)$ should be the relation writer_of, etc. It would be preferable to be able to train extractors end-to-end, using as training examples pairs $(q,A)$, where $q$ is a document and $A$ is the result of evaluating the desired template—e.g., here $A$ would be all KB entities representing people that directed Nolan’s movies. However, while there is a literature on training semantic parsers end-to-end (e.g., [4, 26]) learning in this setting with modern gradient approaches requires evaluating the second-order template with only differentiable operations. Further, these evaluations must be done very efficiently over large KBs, since they are performed at training time; hence, to our knowledge, this approach has been used only when question-related knowledge is limited [30, 12, 19].

This paper describes a framework for efficiently evaluating multi-hop templates differentiably, enabling, for the first time, deep learning in end-to-end settings that require reasoning over large symbolic KBs. This is based on a primitive operation called relation-set following, which finds all KBs entities related to any member of an input set $X$ via any relation in a set $R$. By nesting this operation, multi-step reasoning templates can be formed. We present results for semantic parsing using second-order templates and KB completion, which can also be formulated as a multi-hop second-order reasoning task.

2 Differentiable Templates for Multi-Hop Reasoning

Preliminaries: KBs, entities, and relations. A KB consists of entities and relations. We use $x$ to denote an entity and $r$ to denote a relation. A relation is a set of entity pairs, and represents a relationship between entities: for instance, if $x$ represents “Christopher Nolan” and $x^{\prime}$ represents “Inception” then $(x,x^{\prime})$ would be an member of the relation writer_of. If $(x,x^{\prime})\in r$ we say that $r(x,x^{\prime})$* is an assertion (in the KB)*.

We assume each entity $x$ has a type, written $\textit{type}(x)$, and let $N_{\tau}$ denote the number of entities of type $\tau$. Each entity $x$ in type $\tau$ also has a unique index $index_{\tau}(x)$, which is an integer between $1$ and $N_{\tau}$. We write $x_{\tau,i}$ for the entity that has index $i$ in type $\tau$, or $x_{i}$ if the type is clear from context.

Every relation $r$ has a subject type $\tau_{\it subj}$ and an object type $\tau_{\it obj}$, which constrain the types of $x$ and $x^{\prime}$ for any pair $(x,x^{\prime})\in r$. Hence $r$ can be encoded as a subset of $\{1,\ldots,N_{\tau_{\it subj}}\}\times\{1,\ldots,N_{\tau_{\it obj}}\}$. Relations with the same subject and object types are called type-compatible. Finally a KB consists of a set of types, a set of typed relations, and a set of typed entities.

Weighted sets and their encodings. Our differentiable operations are based on weighted sets, where each element $x$ of weighted set $X$ is associated with a non-negative real number, written $\omega|\![{x}\in{X}]\!|$. It is convenient to define $\omega|\![{x}\in{X}]\!|\equiv{}0$ for all $x\not\in X$. Conceptually, a weight less than 1 for element $x$ is a confidence that the set contains $x$, and weights more than 1 make $X$ a multiset. If all elements of $X$ have weights 1, we say $x$ is a hard set. Weighted sets $X$ are also typed, and if $\textit{type}(X)=\tau$ then $X$ is constrained to contain only entities of type $\tau$; hence $X$ can be encoded as a subset of $\{1,\ldots,N_{\textit{type}(X)}\}$.

Weighted sets will be used as potential assignments to the variables in second-order templates. To support second-order reasoning, every relation $r$ in a KB is also associated with an entity $x_{r}$, and hence, an index and a type, and sets of relations $R$ are allowed if all members are type-compatible.111To avoid complexity in notation we do not distinguish between sets of relations and sets of entities that are associated relations. For example $R=\{\textit{writer\_of},\textit{director\_of}\}$ might be a set of type-compatible relations. For notational convenience, we also treat the relations in a KB as weighted sets of entity pairs, although in the experiments of this paper, all KB relations are hard sets.

A weighted set $X$ of type $\tau$ can be encoded as an entity-set vector $\textbf{v}_{X}\in\mathbb{R}^{N_{\tau}}$, where the $i$-th component of $\textbf{v}_{X}$ is the weight of the $i$-th entity of that type in the set $X$: e.g., $\textbf{v}_{X}[index_{\tau}(x)]=\omega|\![{x}\in{X}]\!|$. Notice that if $X$ is a hard entity set, then this will be a $k$-hot vector for $k=|X|$. The set of indices of v with non-zero values is written $\textit{support}(\textbf{v})$, and we also use $\textit{type}(\textbf{v})$ to denote the type $\tau$ of the set encoded by v. A relation $r$ with subject type $\tau_{1}$ and object type $\tau_{2}$ can be encoded as a relation matrix $\textbf{M}_{r}\in\mathbb{R}^{N_{\tau_{1}}\times N_{\tau_{2}}}$, where the value for $\textbf{M}_{r}[i,j]$ is the weight of the assertion $r(x_{i},x_{j})$ in the KB, i.e., $\textbf{M}_{r}[index_{\tau_{1}}(x),index_{\tau_{2}}(x^{\prime})]=\omega|\![{(x,x^{\prime})}\in{r}]\!|$.

Sparse relation matrices. For all but the smallest KBs, a relation matrix must be implemented using a sparse matrix data structure, as explicitly storing the $N_{\tau_{1}}\times N_{\tau_{2}}$ values will be very wasteful. For instance, if a KB contains 10,000 movie entities and 100,000 person entities, then a relationship like writer_of would require storing 1 billion values, while, since most movies have only a few writers, only a few tens of thousands of writer_of facts will be in the KB. One possible sparse matrix data structure for a relation matrix is a sparse coordinate pair (COO) structure, which consists of a $N_{r}\times 2$ matrix $\textbf{Ind}_{r}$ containing pairs of entity indices, and a parallel vector $\textbf{w}_{r}\in\mathbb{R}^{N_{r}}$ containing the weights of each entity pair in $M_{r}$. In this encoding, if $(i,j)$ is row $k$ of Ind, then $\textbf{M}_{r}[i,j]=\textbf{w}_{r}[k]$, and if $(i,j)$ does not appear in $\textbf{Ind}_{r}$, then $\textbf{M}[i,j]$ is zero. Hence with a COO encoding, the size needed to encode the relations in the KB is linear in the number of facts.

Our experiments are performed with Tensorflow [1], which offers limited support for sparse matrices. In particular, Tensorflow supports sparse COO matrices, but not higher-rank tensors, and supports matrix multiplication between a sparse matrix and a dense matrix, but not between two sparse matrices.

2.1 Reasoning in a KB

Single-hop reasoning and $R$-neighbors. Relations can also be viewed as sets of labeled edges in a knowledge graph, the vertices of which are entities. Following this view, we define the $r$-neighbors of an entity $x$ to be the set of entities $x^{\prime}$ that are connected to $x$ by an edge labeled $r$, i.e., \textit{r$-neighbors($x)}\equiv\{x^{\prime}:(x,x^{\prime})\in r\}. Extending this to sets, we define

[TABLE]

Computing the $R$-neighbors of an entity is a single-step reasoning operation: e.g., the answer to the question $q=$“what movies were written by Christopher Nolan” is precisely the set $R$-neighbors($X$) for $R=\{\textit{writer\_of}\}$ and $X=\{\textit{Christopher\_Nolan}\}$. Multi-hop reasoning operations require nested $R$-neighborhoods, e.g. if $R^{\prime}=\{\textit{director\_of}\}$ then $R^{\prime}$-neighbors($R$-neighbors$(X))$ is all directors of movies written by Christopher Nolan.

Encoding single-hop reasoning. We would like to “soften” the $R$-neighbors, and also translate it into differentiable operations that can be performed on encodings of $X$ and $R$. Let $\textbf{v}_{X}$ encode a weighted set of entities $X$, and let $\textbf{v}_{R}$ encode a weighted set of relations of type $\tau$. We first define $\textbf{M}_{R}$ to be a weighted mixture of the relation matrices for all relations of type $\tau$, i.e., $\textbf{M}_{R}\equiv(\sum_{k=1}^{N_{\tau}}\textbf{v}_{R}[k]\cdot\textbf{M}_{r_{k}})$. We then define the relation-set following operation for $\textbf{v}_{X}$ and $\textbf{v}_{R}$ as:

[TABLE]

The numerical relation-set following operation of Eq 1 corresponds closely to the logical $R$-neighborhood operation, as shown by the claim below.

Claim 1

The support of $\textit{follow}({\textbf{v}_{X}},{\textbf{v}_{R}})$ is exactly the set of $R$-neighbors($X$).

To better understand this claim, let $\textbf{z}=\textit{follow}({\textbf{v}_{X}},{\textbf{v}_{R}})$. The claim states z can approximate the $R$ neighborhood of any hard sets $R,X$ by setting to zero the appropriate components of $\textbf{v}_{X}$ and $\textbf{v}_{R}$. It is also clear that $\textbf{z}[j]$ decreases when one decreases the weights in $\textbf{v}_{r}$ of the relations that link $x_{j}$ to entities in $X$, and likewise, $\textbf{z}[j]$ decreases if one decreases the weights of the entities in $X$ that are linked to $x_{j}$ via relations in $R$, so there is a smooth, differentiable path to reach this approximation.

The utility of approximating the single-step inference step of computing $r$ neighborhoods with the relation-set following is further supported by the experimental results below. We will also see below how to produce more complex templates by combining multiple relation-set following operations.

Implementations of relation-set following. Ignoring types for the moment, suppose the KB contains $N_{R}$ relations, $N_{E}$ entities, and $N_{T}$ triples. Typically $N_{R}<N_{E}<N_{T}\ll N_{E}^{2}$. As noted above, we must implement each $\textbf{M}_{r}$ as a sparse matrix, so collectively these matrices require space $O(N_{T})$. Each triple appears in only one relation, so $\textbf{M}_{R}$ is also size $O(N_{T})$. Since sparse-sparse matrix multiplication is not supported in Tensorflow we must implement $\textbf{x}\textbf{M}_{R}$ using dense-sparse multiplication222In fact Tensorflow requires the left multiplicand to be sparse, so really we must use dense-sparse matrix multiplication and compute $(\textbf{M}_{k}^{T}\textbf{x}^{T})^{T}$., so x must be a dense vector of size $O(N_{E})$, as is the output of relation-set following. So the space complexity of $\textit{follow}({\textbf{x}},{\textbf{r}})$ is $O(N_{T}+N_{E}+N_{R})$, if implemented as suggested by Eq 1; see Table 1. The major problem with this implementation is that, in the absence of general sparse tensor contractions, it is difficult to adapt to mini-batches, which usually make inference on GPUs is much faster. We thus call this implementation naive mixing and, in this paper, only use it without minibatches.

We consider next a setting in which x and r are replaced with matrices X and R with the minibatch size $b$. An alternative strategy is based on the observation that relation-set following for a single relation can be implemented as $\textbf{x}\textbf{M}_{r}$, which can be trivially extended to a minibatch as $\textbf{X}\textbf{M}_{r}$. The late mixing strategy mixes the output of many single-relation relation-set following steps, rather than mixing the KB:

[TABLE]

where the $k$-th column of R is “broadcast” to each element of the matrix $\textbf{X}\textbf{M}_{k}$. While there are $N_{R}$ matrices $\textbf{X}\textbf{M}_{k}$, each of size $O(bN_{E}$), they need not all be stored at once to be mixed, so the space complexity becomes $O(bN_{E}+bN_{R}+N_{T})$. However, we now need to sum up $N_{R}$ dense matrices.

An alternative to late mixing is to represent the KB with number of matrices. Each KB assertion $r(e_{1},e_{2})$ can be represented as a tuple $(i,j,k,w)$ where $i,j,k$ are the indices of $e_{1},e_{2}$, and $r$, and $w$ is the confidence associated the triple. There are $N_{T}$ such triples, so for $\ell=1,\ldots,N_{T}$ let $(i_{\ell},j_{\ell},k_{\ell},w_{\ell})$ denote the $\ell$-th triple. Let $\delta|\![{a}={b}]\!|$ denote 1 if $a=b$ and 0 otherwise. We now define these sparse matrices, which collectively define the reified KB:333Reification in logic is related to reflection in programming languages.

[TABLE]

Conceptually, $\textbf{M}_{\it subj}$ maps the index $\ell$ of the $\ell$-th triple to its subject entity; $\textbf{M}_{\it obj}$ maps $\ell$ to the object entity; and $\textbf{M}_{\it rel}$ maps $\ell$ to the relation of the $\ell$-th triple, and incidentally encodes the triple confidence $w_{\ell}$. We can now implement the relation-set following as below, where $\odot$ is Hadamard product:

[TABLE]

For a single $\textbf{x},\textbf{r}$ notice that $\textbf{x}\textbf{M}^{T}_{\it subj}$ are triples with entity in x as their subject, $\textbf{r}\textbf{M}^{T}_{\it rel}$ are the triples with a relation in r, and the Hadamard product is the intersection of these. The final multiplication by $\textbf{M}_{\it obj}$ finds the object entities of the triples in the intersection. These operations naturally extend to minibatches, as given in Eq 3. The reified KB has size $O(N_{T})$, the sets of triples that are intersected have size $O(bN_{T})$, and the final result is size $O(bN_{E})$, giving a final size of $O(bN_{T}+bN_{E})$, with no dependence on $N_{R}$.

These alternative implementations are summarized in Table 1. Note that no strategy dominates, but the analysis suggests that the reified KB is preferable if there are many relations, while the late mixing strategy may be preferable if $N_{R}$ is small or if the KB is large.

Distributed computation for large KBs. Since GPU memory is limited, we also considered distributed computation of the relation-set following. In general matrix multiplication X****M can be decomposed: X can be split into a “horizontal stacking” of $m$ submatrices, which we write as $\left[\textbf{X}_{1};\ldots;\textbf{X}_{m}\right]$, and M can be similarly partitioned into $m^{2}$ submatrices, and then we note that

[TABLE]

This can be computed without storing either X or M on a single machine. In our implementation of reified KBs, we distribute the matrices that define a reified KB “horizontally”, so that different triple ids $\ell$ are stored on different GPUs.

3 Experiments

3.1 Scalability

Following prior work [6, 10], we used a synthetic KB based on an $n$-by-$n$ grid to study scalability of inference on large KBs. Every grid cell is an entity, related to its immediate neighbors, via relations north, south, east, and west. The KB for $n$-by-$n$ thus has $n^{2}$ entities and around $4n$ triples (since edge cells have fewer than four neighbors). We measured the time to compute $\textit{follow}({\textit{follow}({\textbf{X}},{\textbf{R}})},{\textbf{R}})$ for minibatches of $b=128$ one-hot vectors, and report it as queries per second (qps) on a single GPU (e.g., qps=1280 would mean a single minibatch requires 100ms). The matrix R weights all relations uniformly, and we vary the number of relations by inventing $m$ new relation names and assigning one of the existing grid triples to each new relation.

The results are shown Figure 1 (left and middle), on a log-log scale because some differences are very large. With only four relations (the leftmost plot), late mixing is consistently about 3x faster than the reified KB method, and about 250x than the naive approach. For more than around 20 relations, the reified KB is faster: it is about 43x faster than late mixing with 1000 relations, and more than 12,000x faster than the naive approach.

Although we do not show the results, the method we call “naive” here is much more memory-efficient than using dense relation-matrices. We do not show results for smaller minibatch sizes, but they are about 40x slower with $b=1$ than with $b=128$ for both reified and late mixing.

3.2 Quality and simplicity of models

Below we present results on several datasets using models that make diverse use of relation-set following. All experiments in this section are performed with the reified KB implementation. Since the main contribution of this paper is to introduce a generally useful, scalable, differentiable, second-order reasoning operation, we introduce models that use relation-set following but are otherwise quite simple, rather than complex architectures carefully crafted for a particular task.

3.2.1 Question Answering Experiments

End-to-end QA with a large KB. WebQuestionsSP [27] contains 4737 questions posed in natural languages, all of which are answerable using Freebase [5]. Each question $q$ is labeled with the entities x that appear in it. In our experiments we used a subset of Freebase with 43 million facts and 12 million entities—the KB includes all facts in Freebase within 2-hops of entities mentioned in any question, excluding paths through some very common entities.

Freebase contains two types of nodes, one for real-world entities, and one for compound value types (CVTs), which often represent non-binary relationships or events (e.g., a movie release event, which includes a movie id, a date, and a place.) In this dataset, all questions can be answered with 1- or 2-hop chains, and all 2-hop reasoning chains pass through a CVT entity. Hence there are only two possible templates, which use three kinds of relations: relations between two ordinary entities, which are used for 1-hop questions; relations between an ordinary entity and a CVT entity, which are used for the first step of a 2-hop chain; and relations between a CVT and an ordinary entity, which are used for the second step of a 2-hop chain. Our model begins by deriving from $q$ three relation sets, one of each kind listed above, and then uniformly mixes together the two templates and applies a softmax:

[TABLE]

Note the 2-hop template contains nested relation-set following operations.

In our model, $f_{\textnormal{E}\rightarrow\textnormal{E}}$, $f_{\textnormal{E}\rightarrow\textnormal{CVT}}$, and $f_{\textnormal{CVT}\rightarrow\textnormal{E}}$ are each linear projections of a common encoding for $q$, which is a mean-pooling of the tokens in $q$ encoded with a pre-trained 128-dimensional word2vec model [16]. We use unregularized cross entropy loss. For this large KB, we split the KB across three 12-Gb GPUs, and used a fourth GPU for the rest of the model. Performance (using Hits@1) is shown in Table 2, in the first column, as the model RSF (for relation-set following).

End-to-end QA for longer reasoning chains. MetaQA [29] consists of 1.2M questions, of which 1/3 are 1-hop, 1/3 are 2-hop, and 1/3 are 3-hop. The questions also are labeled with entities and can be answered using the KB provided by the WikiMovies [17] dataset, which contains 43k entities and 186k facts. Following past work, we train and test our model with 1-hop, 2-hop or 3-hop questions separately. For each step of inference we construct a relation sets r. Let $\textbf{x}^{0}$ be the set of entities associated with $q$. The full model computes is

[TABLE]

The $f^{t}$’s are again learned linear projections of a pooled bag-of-words embedding, and again we compute the softmax of the appropriate set $\textbf{x}^{k}$ (where $k$ is the number of hops associated with task) and use cross entropy loss. Results are again shown in Table 2.

End-to-end QA for very long varying-length reasoning chains. To explore performance on even longer reasoning chains, we generated simple artificial sentences describing long chains of relationships on a 10-by-10 grid (e.g., “from center left go down then right”). We trained on 360,000 randomly generated sentences containing between 1 and 10 hops, and tested on an addition 1200 sentences.

For vary-length chains, the meaning of each relation set $\textbf{r}^{t}$ can be context-dependent, so than many fixed templates, we use an encoder-decoder model. The question is encoded with the final hidden state of an LSTM, written here $\textbf{h}_{0}$. We then generate a reasoning chain of length up to $T$ using a decoder LSTM. At iteration 0, a distribution over possible starting points (e.g., “center left”) is produced, denoted $\textbf{x}^{0}$. At iteration $t>0$, the decoder emits a scalar probability of stopping, $p^{t}$, and a distribution over relations to follow $\textbf{r}^{t}$, and updates the model, as we did for the MetaQA dataset, to let $\textbf{x}^{t}=\textit{follow}({\textbf{x}^{t-1}},{\textbf{r}^{t}})$. It also updates the decoder hidden state to $\textbf{h}^{t}$, as below:

[TABLE]

The final predicted location is a mixture of all the $\textbf{x}_{t}$’s weighted by the probability of stopping $p_{t}$ at iteration $t$, i.e., $\hat{\textbf{a}}=\textit{softmax}(\sum_{t=1}^{T}\textbf{x}^{t}\cdot p^{t}\prod_{t^{\prime}<t}(1-p^{t^{\prime}}))$. We trained on 360,000 randomly generated sentences requiring 1 and 10 hops, and tested on an additional 12,000 sentences, with $f_{r}$ again linear, $f_{p}$ a logistic function, and $f_{h}$ an LSTM cell. Results are shown in the right-hand side of Figure 1.

Discussion of QA results. In Table 2 we compare our results on the non-synthetic tasks with Key-Value Memory Network (KV-Mem) baselines [17]. For the smaller MetaQA dataset, KV-Mem is initialized with all facts within 3 hops of the query entities, and for WebQuestionsSP it is initialized by a random-walk process seeded by the query entities (see [19, 29] for details). RSF consistently outperforms the baseline, dramatically so for longer reasoning chains. The synthetic task shows that there is very little degradation as chain length increases, with Hits@1 for 10 hops still 89.7%.

We also compare to two much more complex architectures that perform end-to-end question answering in the same setting used here: VRN [29] and GRAFT-Net [19]. Both systems build question-dependent subgraphs of the KB, and then use graph CNN-like methods [13] to “reason” with these graphs. This process is much more complex to perform at test time, so arguably the systems are not strictly comparable—however, it is interesting to see that the RSF model is competitive with these approaches on the most difficult 3-hop setting.

3.2.2 Knowledge Base Completion Experiments

Knowledge base completion. In KB completion, one attempts to recover KB triples that have been removed from a KB by performing inference over the remaining triples. We looked at two KB completion datasets. The NELL-995 dataset [24] has 12 different “query relations” (i.e., triples for 12 relations have been removed) paired with a KB with 154k facts, 75k entities, and 200 relations.

In the KB completion task, a query is a relation name $q$ and a start entity x, and we assume the answers are computed with the disjunction of multiple inference chains of varying length. Each inference chain has a maximum length of $T$ and we build $N$ distinct inference chains in total.

[TABLE]

The final output is a softmax of the mix of all the $\textbf{x}_{i}^{T}$’s: i.e., we let $\hat{\textbf{a}}=\textit{softmax}(\textstyle\sum_{i\in\{1\dots N\}}\textbf{x}_{i}^{T})$. The purpose of the update $\textbf{x}_{i}^{t+1}=\textit{follow}({\textbf{x}_{i}^{t}},{\textbf{r}_{i}^{t}})+\textbf{x}_{i}^{t}$ is to give the model access to outputs from chains of length less than $T$. The encoding of $q$ is based on a lookup table, and each relation vector $f_{i}^{t}$ is a learned linear transformation of $q$’s embedding. We tune the hyperparameters $T\in\{1,\ldots,6\}$ and $N\in\{1,2,3\}$.

Discussion of KB completion results. KB completion is often performed with KB embedding methods. We record several results for two KB embedding baselines and also MINERVA, a state-of-the-art RL-based method. Baseline results for KB completion are from [9]. Again the baselines are to some degree incomparable—RL methods are generally more difficult to train, and KB embedding methods do not generalize to entities seen outside of training. Quantitatively the results are similar to on the QA tasks—the RSF model outperforms the simpler baseline methods, and is competitive with the best existing approaches.

3.2.3 Discussion of execution time on QA and KB completion

We compare the training time of our model with minibatch size of 10 on three different tasks: NELL-995, MetaQA, and WebQuestionsSP. The results are shown in Table 3 and are consistent with the results of Figure 1: training is longer with larger KBs, but even with over 40 million facts and nearly 13 million entities from Freebase, it takes less than 10 minutes to run one epoch over WebQuestionsSP (with 3097 training examples).

4 Related Work

The relation-set following operation used here is implemented in an open-source package called NQL, for neural query language. NQL implements a broader range of operations for manipulating KBs, which are described in a short companion paper [3]. This paper focuses on implementation and evaluation of the relation-set following operation, issues not covered in the companion paper.

Although NQL is a dataflow language, not a logic, it is semantically related to TensorLog [6], a probabilistic logic which also can be compiled to Tensorflow. TensorLog is in turn closely related to “proof-counting” logics such as stochastic logic programs [7]. TensorLog and its relatives do not support second-order reasoning, although other non-neural logics in the same line of work are expressive enough to support templates via reification [10, 21].

In other work, the differentiable theorem prover (DTP) is a differentiable logic which also includes as a template-instantiation approach similar the one described here. DPT appears to be much less scalable: it has not been applied to KBs larger than a few thousand triples. The Neural ILP system [25] uses approaches related to late mixing together with an LSTM controller to perform KB completion and some simple QA tasks, but it is a monolithic architecture focused on rule-learning, while in contrast we propose a re-usable neural component, which can be used in as a component in many different architectures, and a scalable implementation of this. It is also reported that neural ILP does not scale to the size of the NELL995 task reported here [9].

Neural architectures like memory networks [23], or other architectures that use attention over some data structure approximating assertions [2, 12] can be used to build soft versions of relation-set following: however, they also do not scale well to large KBs, so they are typically only used in cases where a small amount of information is relevant to a question (e.g., [22, 30]).

Graph CNNs [13] also can be used for reasoning, and often do use sparse matrix multiplication, but again existing implementations have not been scaled to tens of millions of triples/edges or millions of entities/graph nodes. Additionally while graph CNNs have been used for reasoning tasks, the formal connection between them and logical reasoning remains unclear.

An alternative to the end-to-end learning approach that is our focus here is reinforcement learning (RL) methods, which have been used to learn mappings from natural-language questions to non-differentiable logical representations [14, 15], one of the applications we consider here. RL methods have also been applied to KB completion tasks [9, 24], another task we explore. However, the gradient-based approaches enabled by our methods are generally preferred, as being easier to implement and tune on new problems.

5 Conclusions

In this paper we described scalable differentiable implementations of the second-order reasoning required to evaluate multi-hop rule templates. In particular we introduce a single new operation called relation-set following, which can be used to compositionally construct multi-hop templates in a neural model. The operation is differentiable, so loss on a proposed template instantiation can be backpropagated to the functions that instantiate variables in a template.

We evaluated a number of alternative implementations of this operation, which lead to different trade-offs with respect to time and memory, and show that an appropriate implementation of relation-set following can scale to KBs with tens of millions of facts, millions of entities, and thousands of relations on a single modern GPU. We also demonstrate experimentally that models based on relation-set following perform well on a number of tasks that require multi-hop reasoning.

The models that are learned have two other advantages, which are not explored in this paper. They have interpretable latent variables, corresponding to the template variables, and on several benchmark tasks the results exceed the current state-of-the-art. For the case of question-answering, the models we propose are compatible with recently-developed approaches for producing contextual representations of language by large-scale pre-training [11, 18].

The approaches described here suggest a number of further research topics—notably, the question of whether further improvements for QA, KB completion, and other multi-hop reasoning tasks can be obtained by improvements to the very simple architectures that we have used here in combination of relation-set following. This paper has also focused on $k$-hot encodings of sets, which are suboptimal for small-cardinality sets, suggesting the use of sketching methods for sets, which have been useful in other neural contexts [8]. The approach outlined here has also been experimentally applied only to embedding symbolic KBs in a neural model, not to embedding “soft” KBs, so extending these methods to cover soft KBs would also be of interest. However, we note that extensions of the set-based relation-set following approach to soft KBs may require additional mechanisms to represent sets of embedded entities [28, 20].