6,513 research outputs found
Learning programs by learning from failures
We describe an inductive logic programming (ILP) approach called learning
from failures. In this approach, an ILP system (the learner) decomposes the
learning problem into three separate stages: generate, test, and constrain. In
the generate stage, the learner generates a hypothesis (a logic program) that
satisfies a set of hypothesis constraints (constraints on the syntactic form of
hypotheses). In the test stage, the learner tests the hypothesis against
training examples. A hypothesis fails when it does not entail all the positive
examples or entails a negative example. If a hypothesis fails, then, in the
constrain stage, the learner learns constraints from the failed hypothesis to
prune the hypothesis space, i.e. to constrain subsequent hypothesis generation.
For instance, if a hypothesis is too general (entails a negative example), the
constraints prune generalisations of the hypothesis. If a hypothesis is too
specific (does not entail all the positive examples), the constraints prune
specialisations of the hypothesis. This loop repeats until either (i) the
learner finds a hypothesis that entails all the positive and none of the
negative examples, or (ii) there are no more hypotheses to test. We introduce
Popper, an ILP system that implements this approach by combining answer set
programming and Prolog. Popper supports infinite problem domains, reasoning
about lists and numbers, learning textually minimal programs, and learning
recursive programs. Our experimental results on three domains (toy game
problems, robot strategies, and list transformations) show that (i) constraints
drastically improve learning performance, and (ii) Popper can outperform
existing ILP systems, both in terms of predictive accuracies and learning
times.Comment: Accepted for the machine learning journa
End-to-End Differentiable Proving
We introduce neural networks for end-to-end differentiable proving of queries
to knowledge bases by operating on dense vector representations of symbols.
These neural networks are constructed recursively by taking inspiration from
the backward chaining algorithm as used in Prolog. Specifically, we replace
symbolic unification with a differentiable computation on vector
representations of symbols using a radial basis function kernel, thereby
combining symbolic reasoning with learning subsymbolic vector representations.
By using gradient descent, the resulting neural network can be trained to infer
facts from a given incomplete knowledge base. It learns to (i) place
representations of similar symbols in close proximity in a vector space, (ii)
make use of such similarities to prove queries, (iii) induce logical rules, and
(iv) use provided and induced logical rules for multi-hop reasoning. We
demonstrate that this architecture outperforms ComplEx, a state-of-the-art
neural link prediction model, on three out of four benchmark knowledge bases
while at the same time inducing interpretable function-free first-order logic
rules.Comment: NIPS 2017 camera-ready, NIPS 201
Efficient Predicate Invention using Shared NeMuS
Amao is a cognitive agent framework that tacklesthe invention of predicates with a different strat-egy as compared to recent advances in InductiveLogic Programming (ILP) approaches like Meta-Intepretive Learning (MIL) technique. It uses aNeural Multi-Space (NeMuS) graph structure toanti-unify atoms from the Herbrand base, whichpasses in the inductive momentum check. Induc-tive Clause Learning (ICL), as it is called, is ex-tended here by using the weights of logical compo-nents, already present in NeMuS, to support induc-tive learning by expanding clause candidates withanti-unified atoms. An efficient invention mecha-nism is achieved, including the learning of recur-sive hypotheses, while restricting the shape of thehypothesis by adding bias definitions or idiosyn-crasies of the language
Learning Logic Programs by Discovering Higher-Order Abstractions
Discovering novel abstractions is important for human-level AI. We introduce
an approach to discover higher-order abstractions, such as map, filter, and
fold. We focus on inductive logic programming, which induces logic programs
from examples and background knowledge. We introduce the higher-order
refactoring problem, where the goal is to compress a logic program by
introducing higher-order abstractions. We implement our approach in STEVIE,
which formulates the higher-order refactoring problem as a constraint
optimisation problem. Our experimental results on multiple domains, including
program synthesis and visual reasoning, show that, compared to no refactoring,
STEVIE can improve predictive accuracies by 27% and reduce learning times by
47%. We also show that STEVIE can discover abstractions that transfer to
different domain
- …