ACL for learning abductive theories
We can ACL to learn abductive theories using ACL1 version 1. The background
knowledge is an abductive logic program containing the definitions of background
predicates, written using the usual prolog syntax, the declaration of abducible
predicates and, possibly, the definition of background integrity constraints
on the abducible predicates.
Two input files should be prepared, one containing the abductive background
knowledge (<file_stem>.bg file) and one containing the language
bias for learning constraints (<file_stem>.l file). After
having prepared the input files, the first phase of learning rules is performed
by running ACL1 and the second phase is performed by running ICL, as described
in the instructions on
how to run ACL1.
Input files format:
Format of <file_stem>.bg :
Consider the example father.bg, corresponding
to example 1 in the theoretical
each target predicate must have a "bias" clause
The <list of allowed literals> is the list of all the possible
<list of variables>,
<list of allowed
can be added to the rule <head>:-<body>
<body> is a template that can be used in order to specialize
the clauses accordingly to what is already in the body. In
the example below is a variable so that any rule can be refined with the
literals in the list. The <list of variables> must
contain the list of all the variables that may appear in the rule or its
refinements and must be the same for all bias facts relative to the same
abducibles(<list of abducible predicates>).
The variables in the abducible predicates must be all different (use _)
ic(<list of literals in the body>).
eplus(<list of positive examples>).
eminus(<list of negative examples>).
<definitions for predicates pred1,...,predn>
:-dynamic parent/2, male/1, female/1.
Format of <file_stem>.l:
See father.l as an example. See the page http://www.cs.kuleuven.ac.be/~ml/CWIS/dlab-E.shtml
for a description of the DLAB formalism used to describe the bias for ICL.
Output files format:
After the two learning phase, two files are produced, one called <file_stem>.rules
containing the rules learned in the first phase and one called <file_stem>.theory
the integrity constraints learned in the second phase. In the case of the
example, the system produces the following rule (file father.rules)
First the name of the input <file_stem> is printed, then the
values for the parameters are shown together with the total execution time.
Then follows the rules that have been learned, together with the set of
positive and negative examples covered by them and the set of assumptions
made for covering them. In the set of assumptions, each assumption is associated
to the example that generated it.
ACL1 ver 1 AbdProofProc. ver 1
File name: father
Max spec steps=10, Beamsize=5, Derivation depth=20, Verbosity=3
Execution time 0.310000 seconds. Generated rules
/*Covered positive examples: [father(david,steve),father(john,mary)]
Covered negative examples: 
Abduced literals: [[not(father(katy,ellen)),not(male(katy))],[father(david,steve),male(david)]]*/
The system also produces the following integrity constraints (file father.theory)
theory( neg ,
where the second theory clause must be considered that represents
the theory describing the positive interpretations.
[rule('(male(X) :- female(X))',
theory( pos ,
[rule('(false :- male(X),female(X))',
% no multi-class theory found
Back to the main ACL page.