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, corresponding to example 1 in the theoretical framework page.
  1. Bias:

  2. each target predicate must have a "bias" clause The <list of allowed literals> is the list of all the possible literals that
    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 predicate.
  3. Abducible predicates:
  4. The variables in the abducible predicates must be all different (use _)
  5. Integrity constraints:
  6. Example:
  7. Training set:
  8. Example:
  9. Background theory:
  10. Example:

Format of <file_stem>.l:

See father.l as an example. See the page 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 containing the integrity constraints learned in the second phase. In the case of the father example, the system produces the following rule (file father.rules)
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)]]*/

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.

The system also produces the following integrity constraints (file father.theory)

theory( neg ,
        complete ,
        cnf ,
       [rule('(male(X) :- female(X))', [type(cnf),cpu(0.26),heur(1),local(1,0,0,1),total(1,0,0,1)])

theory( pos ,
        complete ,
        cnf ,
       [rule('(false :- male(X),female(X))', [type(cnf),cpu(0.25),heur(1),local(1,0,0,1),total(1,0,0,1)])

% no multi-class theory found

where the second theory clause must be considered that represents the theory describing the positive interpretations.

Back to the main ACL page.

Back to the LIA Home Page

Go to the DEIS Home Page Go to the Alma Mater Home Page