Differentiable Learning of Logical Rules for Knowledge Base Reasoning
We study the problem of learning probabilistic first-order logical rules for knowledge base reasoning. This learning problem is difficult because it requires learning the parameters in a continuous space as well as the structure in a discrete space. We propose a framework, Neural Logic Programming, that combines the parameter and structure learning of first-order logical rules in an end-to-end differentiable model. This approach is inspired by a recently-developed differentiable logic called TensorLog [5], where inference tasks can be compiled into sequences of differentiable operations. We design a neural controller system that learns to compose these operations. Empirically, our method outperforms prior work on multiple knowledge base benchmark datasets, including Freebase and WikiMovies.
the structure is a discrete optimization problem, and one that involves search over a potentially large problem space. Many past learning systems have thus used optimization methods that interleave moves in a discrete structure space with moves in parameter space [12,13,14,27].
In this paper, we explore an alternative approach: a completely differentiable system for learning models defined by sets of first-order rules. This allows one to use modern gradient-based programming frameworks and optimization methods for the inductive logic programming task. Our approach is inspired by a differentiable probabilistic logic called TensorLog [5]. TensorLog establishes a connection between inference using first-order rules and sparse matrix multiplication, which enables certain types of logical inference tasks to be compiled into sequences of differentiable numerical operations on matrices. However, TensorLog is limited as a learning system because it only learns parameters, not rules. In order to learn parameters and structure simultaneously in a differentiable framework, we design a neural controller system with an attention mechanism and memory to learn to sequentially compose the primitive differentiable operations used by TensorLog. At each stage of the computation, the controller uses attention to "softly" choose a subset of TensorLog's operations, and then performs the operations with contents selected from the memory. We call our approach neural logic programming, or Neural LP.
Experimentally, we show that Neural LP performs well on a number of tasks. It improves the performance in knowledge base completion on several benchmark datasets, such as WordNet18 and Freebase15K [3]. And it obtains state-of-the-art performance on Freebase15KSelected [25], a recent and more challenging variant of Freebase15K. Neural LP also performs well on standard benchmark datasets for statistical relational learning, including datasets about biomedicine and kinship relationships [12]. Since good performance on many of these datasets can be obtained using short rules, we also evaluate Neural LP on a synthetic task which requires longer rules. Finally, we show that Neural LP can perform well in answering partially structured queries, where the query is posed partially in natural language. In particular, Neural LP also obtains state-of-the-art results on the KB version of the WIKIMOVIES dataset [16] for question-answering against a knowledge base. In addition, we show that logical rules can be recovered by executing the learned controller on examples and tracking the attention.
To summarize, the contributions of this paper include the following. First, we describe Neural LP, which is, to our knowledge, the first end-to-end differentiable approach to learning not only the parameters but also the structure of logical rules. Second, we experimentally evaluate Neural LP on several types of knowledge base reasoning tasks, illustrating that this new approach to inductive logic programming outperforms prior work. Third, we illustrate techniques for visualizing a Neural LP model as logical rules.
This paper develops a model for learning to answer queries in knowledge bases with
incomplete data about relations between entities. For example, the running example in the paper is answering
queries like HasOfficeInCountry(Uber, ?), when the relation is not directly present in the
knowledge base, but supporting relations like HasOfficeInCity(Uber, NYC) and CityInCountry(NYC, USA).
The aim in this work is to learn rules like HasOfficeInCountry(A, B) <= HasOfficeInCountry(A, C) && CityInCountry(C, B). Note that this is a bit different from learning embeddings for entities in a knowledge
base, because the rule to be learned is abstract, not depending on any specific entities.
The formulation in this paper is cast the problem as one of learning two components:
- a set of rules, represented as a sequence of relations (those that appear in the RHS of the rule)
- a real-valued confidence on the rule
The approach to learning follows ideas from Neural Turing Machines and differentiable program synthesis,
whereby the discrete problem is relaxed to a continuous problem by defining a model for executing the rules
where all rules are executed at each step and then averaged together with weights given by the confidences.
The state that is propagated from step to step is softmax distribution over entities
(though there are some additional details to handle the case where rules are of different lengths).
Given this interpretation, the paper then suggests that a recurrent neural network controller can
be used to generate the continuous parameters needed for the execution. This is analogous to the neural
network controller in Neural Turing Machines, Neural Random Access Machines, etc.
After the propagation step, the model is scored based upon how much probability ends up on the
ground truth answer to the query.
The key novelty is developing two representations of the confidence-weighted rules (one which is straightforward to optimize as a continuous optimization problem, and one as confidence weights on a set of discrete rules) along with an algorithm for converting from the continuous-optimization-friendly version to the rules version.
To my knowledge, this is a novel and interesting idea, which is a neat application of ideas from the
neural programs space.
Experimentally, the method performs very well relative to what looks to be a strong set of baselines.
The experiments are thorough and thoughtful with a nice mix of qualitative and quantitative results,
and the paper is clearly written.
One point that I think could use more clarification is what the interpretation is of what the
neural network is learning. It is not quite rules, because (if I understand correctly), the neural
controller is effectively deciding which part of the rules to apply next, during the course of execution.
This causes me a bit of confusion when looking at Table 3. Are these rules that were learned relative to
some query? Or is there a way of extracting query-independent rules from the learned model?