scholarly journals Forgetting to Learn Logic Programs

2020 ◽  
Vol 34 (04) ◽  
pp. 3676-3683
Author(s):  
Andrew Cropper
Keyword(s):  
Logic Programming ◽  
Inductive Logic Programming ◽  
Inductive Logic ◽  
Background Knowledge ◽  
Experimental Results ◽  
Learning Performance ◽  
Sample Complexity ◽  
Logic Programs ◽  
Hypothesis Space ◽  
Alternative Approaches

Most program induction approaches require predefined, often hand-engineered, background knowledge (BK). To overcome this limitation, we explore methods to automatically acquire BK through multi-task learning. In this approach, a learner adds learned programs to its BK so that they can be reused to help learn other programs. To improve learning performance, we explore the idea of forgetting, where a learner can additionally remove programs from its BK. We consider forgetting in an inductive logic programming (ILP) setting. We show that forgetting can significantly reduce both the size of the hypothesis space and the sample complexity of an ILP learner. We introduce Forgetgol, a multi-task ILP learner which supports forgetting. We experimentally compare Forgetgol against approaches that either remember or forget everything. Our experimental results show that Forgetgol outperforms the alternative approaches when learning from over 10,000 tasks.

scholarly journals Playgol: Learning Programs Through Play

2019 ◽  
Author(s):  
Andrew Cropper
Keyword(s):  
Logic Programming ◽  
Real World ◽  
Inductive Logic Programming ◽  
Inductive Logic ◽  
Experimental Results ◽  
Learning Performance ◽  
Programming System ◽  
Sample Complexity ◽  
Induction System ◽  
Learning Programs

Children learn though play. We introduce the analogous idea of learning programs through play. In this approach, a program induction system (the learner) is given a set of user-supplied build tasks and initial background knowledge (BK). Before solving the build tasks, the learner enters an unsupervised playing stage where it creates its own play tasks to solve, tries to solve them, and saves any solutions (programs) to the BK. After the playing stage is finished, the learner enters the supervised building stage where it tries to solve the build tasks and can reuse solutions learnt whilst playing. The idea is that playing allows the learner to discover reusable general programs on its own which can then help solve the build tasks. We claim that playing can improve learning performance. We show that playing can reduce the textual complexity of target concepts which in turn reduces the sample complexity of a learner. We implement our idea in Playgol, a new inductive logic programming system. We experimentally test our claim on two domains: robot planning and real-world string transformations. Our experimental results suggest that playing can substantially improve learning performance.

scholarly journals Turning 30: New Ideas in Inductive Logic Programming

2020 ◽  
Author(s):  
Andrew Cropper ◽  
Sebastijan Dumančić ◽  
Stephen H. Muggleton
Keyword(s):  
Machine Learning ◽  
Logic Programming ◽  
Inductive Logic Programming ◽  
Inductive Logic ◽  
Background Knowledge ◽  
Training Data ◽  
Future Research ◽  
Logic Programs ◽  
Recursive Programs ◽  
New Ideas

Common criticisms of state-of-the-art machine learning include poor generalisation, a lack of interpretability, and a need for large amounts of training data. We survey recent work in inductive logic programming (ILP), a form of machine learning that induces logic programs from data, which has shown promise at addressing these limitations. We focus on new methods for learning recursive programs that generalise from few examples, a shift from using hand-crafted background knowledge to learning background knowledge, and the use of different technologies, notably answer set programming and neural networks. As ILP approaches 30, we also discuss directions for future research.

scholarly journals Learning higher-order logic programs

2019 ◽  
Vol 109 (7) ◽  
pp. 1289-1322 ◽  
Author(s):  
Andrew Cropper ◽  
Rolf Morel ◽  
Stephen Muggleton
Keyword(s):  
Inductive Logic Programming ◽  
Inductive Logic ◽  
Higher Order ◽  
Order Logic ◽  
Sample Complexity ◽  
Logic Programs ◽  
Higher Order Logic ◽  
First Order ◽  
Hypothesis Space ◽  
Theoretical Results

AbstractA key feature of inductive logic programming is its ability to learn first-order programs, which are intrinsically more expressive than propositional programs. In this paper, we introduce techniques to learn higher-order programs. Specifically, we extend meta-interpretive learning (MIL) to support learning higher-order programs by allowing for higher-order definitions to be used as background knowledge. Our theoretical results show that learning higher-order programs, rather than first-order programs, can reduce the textual complexity required to express programs, which in turn reduces the size of the hypothesis space and sample complexity. We implement our idea in two new MIL systems: the Prolog system $$\text {Metagol}_{ho}$$ Metagol ho and the ASP system $$\text {HEXMIL}_{ho}$$ HEXMIL ho . Both systems support learning higher-order programs and higher-order predicate invention, such as inventing functions for and conditions for . We conduct experiments on four domains (robot strategies, chess playing, list transformations, and string decryption) that compare learning first-order and higher-order programs. Our experimental results support our theoretical claims and show that, compared to learning first-order programs, learning higher-order programs can significantly improve predictive accuracies and reduce learning times.

scholarly journals Learning Large Logic Programs By Going Beyond Entailment

2020 ◽  
Author(s):  
Andrew Cropper ◽  
Sebastijan Dumančic
Keyword(s):  
Logic Programming ◽  
Loss Function ◽  
Inductive Logic Programming ◽  
State Of The Art ◽  
Inductive Logic ◽  
Program Synthesis ◽  
Loss Functions ◽  
Logic Programs ◽  
Binary Decision ◽  
Best First Search

A major challenge in inductive logic programming (ILP) is learning large programs. We argue that a key limitation of existing systems is that they use entailment to guide the hypothesis search. This approach is limited because entailment is a binary decision: a hypothesis either entails an example or does not, and there is no intermediate position. To address this limitation, we go beyond entailment and use 'example-dependent' loss functions to guide the search, where a hypothesis can partially cover an example. We implement our idea in Brute, a new ILP system which uses best-first search, guided by an example-dependent loss function, to incrementally build programs. Our experiments on three diverse program synthesis domains (robot planning, string transformations, and ASCII art), show that Brute can substantially outperform existing ILP systems, both in terms of predictive accuracies and learning times, and can learn programs 20 times larger than state-of-the-art systems.

scholarly journals Logical reduction of metarules

2019 ◽  
Vol 109 (7) ◽  
pp. 1323-1369
Author(s):  
Andrew Cropper ◽  
Sophie Tourret
Keyword(s):  
Logic Programming ◽  
Open Problem ◽  
Inductive Logic Programming ◽  
Inductive Logic ◽  
Learning Task ◽  
Reduction Technique ◽  
Trade Off ◽  
Hypothesis Space ◽  
General Derivation ◽  
Sld Resolution

AbstractMany forms of inductive logic programming (ILP) use metarules, second-order Horn clauses, to define the structure of learnable programs and thus the hypothesis space. Deciding which metarules to use for a given learning task is a major open problem and is a trade-off between efficiency and expressivity: the hypothesis space grows given more metarules, so we wish to use fewer metarules, but if we use too few metarules then we lose expressivity. In this paper, we study whether fragments of metarules can be logically reduced to minimal finite subsets. We consider two traditional forms of logical reduction: subsumption and entailment. We also consider a new reduction technique called derivation reduction, which is based on SLD-resolution. We compute reduced sets of metarules for fragments relevant to ILP and theoretically show whether these reduced sets are reductions for more general infinite fragments. We experimentally compare learning with reduced sets of metarules on three domains: Michalski trains, string transformations, and game rules. In general, derivation reduced sets of metarules outperform subsumption and entailment reduced sets, both in terms of predictive accuracies and learning times.

scholarly journals Induction of Non-Monotonic Logic Programs to Explain Boosted Tree Models Using LIME

2019 ◽  
Vol 33 ◽  
pp. 3052-3059 ◽  
Author(s):  
Farhad Shakerin ◽  
Gopal Gupta
Keyword(s):  
Logic Programming ◽  
Inductive Logic Programming ◽  
State Of The Art ◽  
Inductive Logic ◽  
Nonmonotonic Logic ◽  
Global Behavior ◽  
Logic Programs ◽  
Tree Models ◽  
Boosted Tree ◽  
Classification Evaluation

We present a heuristic based algorithm to induce nonmonotonic logic programs that will explain the behavior of XGBoost trained classifiers. We use the technique based on the LIME approach to locally select the most important features contributing to the classification decision. Then, in order to explain the model’s global behavior, we propose the LIME-FOLD algorithm —a heuristic-based inductive logic programming (ILP) algorithm capable of learning nonmonotonic logic programs—that we apply to a transformed dataset produced by LIME. Our proposed approach is agnostic to the choice of the ILP algorithm. Our experiments with UCI standard benchmarks suggest a significant improvement in terms of classification evaluation metrics. Meanwhile, the number of induced rules dramatically decreases compared to ALEPH, a state-of-the-art ILP system.

ILP Applications to Software Engineering

2011 ◽  
pp. 74-102
Author(s):  
Daniele Gunetti
Keyword(s):  
Software Engineering ◽  
Logic Programming ◽  
Inductive Logic Programming ◽  
Inductive Logic ◽  
Logic Programs ◽  
Automatic Synthesis ◽  
Integrated Framework ◽  
Testing And Debugging ◽  
True Logic

Though inductive logic programming (ILP for short) should mean the “induction of logic programs”, most research and applications of this area are only loosely related to logic programming. In fact, the automatic synthesis of “true” logic programs is a difficult task, since it cannot be done without a lot of information on the sought programs, and without the ability to describe in a simple way well-restricted searching spaces. In this chapter, we argue that, if such knowledge is available, inductive logic programming can be used as a valid tool for software engineering, and we propose an integrated framework for the development, maintenance, reuse, testing, and debugging of logic programs.

scholarly journals Least Generalizations and Greatest Specializations of Sets of Clauses

1996 ◽  
Vol 4 ◽  
pp. 341-363 ◽  
Author(s):  
S. H. Nienhuys-Cheng
Keyword(s):  
Logic Programming ◽  
Inductive Logic Programming ◽  
Inductive Logic ◽  
Background Knowledge ◽  
Ordered Sets ◽  
Finite Sets ◽  
Systematic Treatment ◽  
Finite Set ◽  
Complete Discussion ◽  
Survey Results

The main operations in Inductive Logic Programming (ILP) are generalization and specialization, which only make sense in a generality order. In ILP, the three most important generality orders are subsumption, implication and implication relative to background knowledge. The two languages used most often are languages of clauses and languages of only Horn clauses. This gives a total of six different ordered languages. In this paper, we give a systematic treatment of the existence or non-existence of least generalizations and greatest specializations of finite sets of clauses in each of these six ordered sets. We survey results already obtained by others and also contribute some answers of our own. Our main new results are, firstly, the existence of a computable least generalization under implication of every finite set of clauses containing at least one non-tautologous function-free clause (among other, not necessarily function-free clauses). Secondly, we show that such a least generalization need not exist under relative implication, not even if both the set that is to be generalized and the background knowledge are function-free. Thirdly, we give a complete discussion of existence and non-existence of greatest specializations in each of the six ordered languages.

Sign in / Sign up

Export Citation Format

Share Document