Learning in First-Order Logic using Greedy ... - ResearchGate

Learning in First-Order Logic using Greedy Evolutionary Algorithms
Federico Divina
divina@cs.vu.nl
Elena Marchiori
elena@cs.vu.nl
Department of Mathematics and Computer Sciences, Vrije Universiteit, De Boelelaan 1081a, 1081 HV Amsterdam
The Netherlands
Abstract
In evolutionary computation ‘learning’ is a
byproduct of the evolutionary process as
successful individuals are retained through
stochastic trial and error. This learning process
can be rather slow, due to the weak strategy
used to guide evolution. A way to overcome
this drawback is to incorporate greedy
operators in the evolutionary process.
This paper investigates the effectiveness of
this approach for inductive concept learning
in (a fragment of) First-Order Logic (FOL).
This is done by means of a new greedy evolutionary
algorithm. The algorithm evolves
a population of Horn clauses. Randomized
greedy operators are employed for generalizing
and specializing a clause. The degree of
greediness of each operator is determined by
a parameter. In this way, the user can control
the greediness of the learning process by
setting the parameters to specific values.
A typical case study in Inductive Logic Programming
(the KRK endgame problem) is
used for testing the learning method. The
effect of the greedy operators on the learning
process is analyzed, by means of extensive
experiments with different values of their parameters.
Moreover, the robustness of the
method to noise in the training examples is
investigated.
1. Introduction
Learning from examples in FOL, also known as Inductive
Logic Programming (ILP) (Muggleton & Raedt,
1994), constitutes a central topic in Artificial Intelligence,
with relevant applications to problems in complex
domains like natural language and molecular computational
biology (Muggleton, 1999). Given a FOL
description language used to express possible hypotheses,
a set of positive examples, and a set of negative
examples, one has to find a hypothesis which covers
all positive examples and none of the negative ones
(cf. (Kubat et al., 1998; Mitchell, 1997)).
Learning hypotheses in FOL is a hard task because the
search space (of all hypotheses)has prohibitive size,
also when restrictions on the representation are imposed
(e.g. Datalog clauses). A standard approach to
tackle this problem, adopted in the majority of FOL
learning systems, is to use specific search strategies,
like the general-to-specific (hill-climbing) search (e.g.
(Quinlan, 1990)) and the inverse resolution mechanism
(e.g. (Muggleton & Buntine, 1988)).
An alternative approach, based on evolutionary computation,
employ a multi-point search strategy where
randomized operators (mutation and crossover) are
used to move in the search space, and a fitness function
is used to guide the search (by means of a probabilistic
selection process) (Jong et al., 1993). The resulting
learning methods are in general weaker than the ILP
ones, but more effective in escaping from attraction
basins (local optima) during the search for a best hypothesis.
This paper investigates a learning framework which
unites these two approaches. This is done via generalization/specialization
operators which are incorporated
in the mutation process of a simple evolutionary
algorithm. Four randomized greedy operators are introduced,
two for generalizing and two for specializing
a clause. Each operator is equipped with a parameter
which determines its degree of greediness. Different
values of the parameters determine different search
strategies: low values yield weak learning methods,
like standard evolutionary algorithms, while high values
yield more greedy learning methods, like Inductive
Logic Programming systems.
The resulting hybrid evolutionary algorithm is tested
on a case study which appears frequently in the ILP
literature, learning illegal white-to-move positions in

the chess endgame White King and Rook versus Black
King. The results of experiments on datasets for this
problem indicate that the presence of greediness in the
operators is beneficial for the learning process, but
that too much greediness may affect negatively the
learning process. Satisfactory performance can also be
obtained also when greediness is used in only one operator.
Moreover, the hybrid algorithm exhibit a robust
behaviour when different levels of noise are introduced
in the training dataset.
This investigation suggests an experimental methodology
for designing greedy evolutionary algorithms for
inductive learning, where the user constructs a suitable
search strategy for a considered learning problem,
by setting the greediness parameters to specific values
(which are experimentally determined).
2. Evolutionary Approaches
One can distinguish two main inductive learning approaches
based on evolutionary computation, called
Pittsburgh and Michigan (cf. (Michalewicz, 1996)).
In the first approach, an individual represents an entire
set of rules, a population of rule sets is maintained, and
selection and genetic operators are used to produce
new generations of rule sets. Instances of this approach
are e.g. GIL (Janikow, 1993), GLPS (Leung & Wong,
1995) and STEPS (Kennedy & Giraud-Carrier, 1999).
In contrast, the Michigan approach employs a representation
where an individual represents one rule,
and individuals co-operate and compete in the evolutionary
process. In this approach specific strategies
have to be designed in order to extract a non redundant
hypothesis from the final population. Systems for
FOL learning based on this approach are e.g. REGAL
(Giordana & Neri, 1996), DOGMA (Hekanaho, 1998).
Both approaches present advantages and drawbacks.
Encoding a whole hypothesis in each individual allows
an easier control of the genetic search but introduces
a large redundancy, that can lead to populations
hard to manage and to individuals of enormous size.
In the Michigan approach, co-operation/competition
between different individuals reduces redundancy and
more complex problems can be handled, but also more
sophisticated strategies may have to be designed, for
coping with the presence in the population of superindividuals
which lead the evolutionary process to a
premature convergence.
This paper adopts the Michigan approach.
3. A Greedy Evolutionary Algorithm
This section describes the components of a hybrid
evolutionary algorithm for inductive learning in FOL,
called GEL (Greedy Evolutionary Learner). The algorithm
evolves a population of Horn clauses using a
mutation process for moving in the search space, a
fitness function for measuring the quality of clauses,
and a probabilistic selection/replacement mechanism
for culling fitter rules from the population. In order
to guide the search, the mutation process uses four
greedy operators described in the next section. A best
hypothesis is extracted from the final population using
a heuristic procedure.
3.1 Notation and Terminology
The algorithm considers Horn clauses of the form
p(X, Y ) ← r(X, Z), q(Y, a).
consisting of atoms whose arguments are either variables
(e.g. X, Y, Z) or constants (e.g. a). The lefthand
side of the rule is called head, and the righthand-side
body, of the clause. These rules have a
declarative interpretation (universally quantified FOL
implications) and a procedural interpretation (in order
to solve p(X, Y ) solve r(X, Z) and q(Y, a)). A set
of Horn clauses forms a logic program, which can be
directly (in a slightly different syntax) executed in the
programming language Prolog.
Thus the goal of GEL is to induce a logic program from
a set of training examples. The number of examples
in the (training) set is denoted by nte, the number of
its positive (negative) examples by pos (neg, respectively).
A clause covers an example if the theory formed by the
clause and the background knowledge logically entails
the example. Given a clause cl, the number of positive
(negative) examples covered by a cl is denoted by pos cl
(neg cl respectively).
3.2 Representation and Fitness
The algorithm operates on Horn clauses of restricted
form (described above).
The fitness of a clause cl is defined by
fitness(cl) = w 1 ∗ neg cl + nte − pos cl
where the integer w 1 > 1 is a weight used to favor
clauses covering few negative examples.
So GEL has to evolve clauses with minimum fitness.

3.3 Initialization
Each clause cl of the initial population is generated in
two phases as follows.
First, a ground (i.e. with no variables) clause is constructed
whose head is a positive example randomly
selected from the training set, and whose body consists
of all atoms in the background knowledge having
at most one argument which does not occur in the
head. This procedure is similar to the one used in
CLINT (Raedt, 1992), but in CLINT each argument
of the body occurs also in the head of the clause.
All other elements in the background knowledge having
at least one argument occurring in the head are
inserted in a list B cl associated to cl. Atoms of this
list may be added to the clause body during the evolutionary
process (using a specialization operator).
Next, cl is obtained from this ground clause by applying
one of the two generalization operators (described
in Sections 4.1, 4.2), randomly chosen.
3.4 Evolutionary Cycle
At each iteration the probabilistic tournament selection
mechanism (cf. (Blickle, 2000)) is used (better
the fitness yields higher the probability of selection),
to select a number of individuals. Then every selected
individual undergoes the mutation process.
No other evolutionary operator is used. In particular,
crossover is not used, in accordance with the conviction
that ‘a sum of optimal parts rarely leads to
an optimal overall solution’, which is the key to the
(philosophical) distinction between evolutionary and
genetic algorithms (cf. (Porto, 2000)).
3.5 Mutation Process
The mutation process consists of the repeated application
of the greedy operators to an individual until
its fitness does not increase (or a maximum number of
iterations is reached).
At each iteration one of the four greedy operators is
applied. This operator is chosen as follows. First, a
(randomized) test decides whether it will be a generalization
or a specialization operator. Next, one of the
two operators of the chosen class is randomly selected.
The test decides to generalize a clause cl with probability
p gen (cl) = 1 ( )
poscl − neg cl
+ α
2 nte
otherwise it decides to specialize it (with probability
1 − p gen (cl)). The constant α = 1 + 0.5 ∗ (neg − pos)
is used to slightly bias the decision towards generalization.
The probability p gen (cl) is maximal when cl
covers all positive and no negative examples, and it is
minimal in the dual case.
3.6 Hypothesis Extraction
At the end of the evolutionary process, a best logic program
covering all the positive examples and no negative
ones has to be extracted from the final population.
This problem can be translated in an instance of the
weighted set covering problem as follows. Each individual
cl of the final population is a column with
positive weight equal to
weight cl = neg cl ∗ fitness(cl) + 1
and each positive example is a row. The problem consists
of finding a subset of the set of columns, covering
all the rows and having minimum total weight. The
weight of a column is defined in this way in order to
prefer clauses covering few negative examples. A fast
(heuristic) algorithm (cf. (Caprara et al., 1998)) is
applied to this problem instance to find a best logic
program.
4. Greedy Operators
A clause cl is generalized either by replacing (all occurrences
of) a constant of the clause with a variable,
or by deleting an atom from the body of the clause.
Dually, cl is specialized either by replacing (all occurrences
of) a variable of cl with a constant, or by adding
an atom to the body of cl.
The four operators utilize parameters N1, . . . , N4, respectively,
in their definition, and a gain function.
When applied to operator τ and clause cl, the gain
function yields the difference between the clause fitness
before and after the application of that operator
gain(cl, τ) = fitness(cl) − fitness(τ(cl)).
The four operators are defined below.
4.1 Variable into Constant
Consider the set Con consisting of N1 constants of cl
randomly chosen, and the set V ar consisting of all the
variables of cl and of a fresh variable.
For each a in Con and for each X in V ar, compute
gain(cl, {a/X}), the gain of cl when all occurrences of
a are replaced by X.
Choose a substitution {a/X} yielding the highest gain
(ties are broken randomly), and generalize cl by replacing
all occurrences of a with X.

4.2 Atom Deletion
Consider the set Atm consisting of N2 atoms of cl
randomly chosen.
For each A in Atm, compute gain(cl, −A), the gain of
cl when A is deleted from cl.
Choose an atom A yielding the highest gain
gain(cl, −A) (ties are broken randomly), and generalize
cl by deleting A from its body.
Insert the deleted atom A into a list D cl containing
atoms which have been deleted from cl. Atoms from
this list may be added to the clause during the evolutionary
process by means of a specialization operator.
4.3 Constant into Variable
Consider a variable X of cl randomly selected, and the
set Con consisting of N3 constants (of the problem
language) randomly chosen.
For each a in Con, compute gain(cl, {X/a}), the gain
of cl when all occurrences of X are replaced by a.
Choose a substitution {X/a} yielding the highest gain
(ties are broken randomly), and specialize cl by replacing
all occurrences of X with a.
4.4 Atom Addition
Consider the set Atm consisting of N4 atoms of B cl
(introduced in the initialization of GEL) and of N4
atoms of D cl , all randomly chosen.
For each A in Atm, compute gain(cl, +A), the gain of
cl when A is added to cl.
Choose an atom A yielding the highest gain
gain(cl, +A) (ties are broken randomly), and specialize
cl by adding A from its body.
Remove A from its original list (B cl or D cl ).
5. Experimental Setup
The case study used to test GEL is the problem
of learning illegal positions in the chess endgame
domain White King and Rook versus Black King
(KRK endgame) (Muggleton et al., 1989; Quinlan,
1990). The concept to learn is expressed by the
predicate illegal(A, B, C, D, E, F ) which states that
the position where the White King is at (A, B),
the White Rook at (C, D) and the Black King at
(E, F ) is an illegal White-to-move position. For instance,
illegal(g, 6, c, 7, c, 8) is an illegal White-tomove
position. The background knowledge consists
of facts about the two predicates adjacent(A, B) and
less than(A, B), indicating that rank/file A is adjacent
and less than rank/file B, respectively. The
dataset originates from (Muggleton et al., 1989), and
is available at
http://oldwww.comlab.ox.ac.uk/oucl/groups/machlea
rn/chess.html. It consists of 5 training sets of 100
examples, and 1 test set of 5000 examples. The
background knowledge contains 50 elements.
The parameter setting of GEL is obtained after performing
a small number of tuning experiments, and
their choice is based on a tradeoff between efficiency
and performance. The population contains 200 individuals.
The tournament size is 4. At each iteration,
15 individuals are selected (using the tournament selection
mechanism) and mutation process is applied
to each of them. The algorithm terminates after 30
iterations.
6. Results
The effect of varying the value of one greedy parameter
Ni (i in 1, . . . , 4) is investigated, when the values of the
other parameters are fixed, and are either all equal to
1 (no greediness) or all equal to their maximum values
max (full greediness). In this way, a parameter setting
can be described by a pair (Ni = v, w), meaning that
Ni has value v and all other parameters have value w.
For each parameter setting, 25 runs of the GEL are
performed, 5 runs with different random seeds for
each of the 5 training sets. One run of GEL takes
on the average about 2 minutes on a Sun Ultra 250,
UltraSPARC-II 400MHz.
For each run, the simplicity (i.e. number of clauses)
of the resulting logic program, and its accuracy on the
test set (i.e. number of correctly classified test examples
divided by the total number of test examples) are
computed. The average of the results over the 25 runs
is considered as final result (standard deviation is not
reported because the results do not differ too much
from each other).
The results are illustrated in Figure 1. For each parameter
Ni, the (average) values of accuracy (left column)
and simplicity (right column) are plotted for different
values of Ni in the two configurations w = 1 and
w = max.
The results indicate that the best accuracy is obtained
when greediness is present in all the parameters. However,
satisfactory results are obtained also when greediness
is incorporated in only one parameter (e.g. in the
parameter setting (N3 = 14, w = 1)). Moreover, too
much greediness seems to have a negative influence

0.94
0.92
Ni = 1
Ni = max
10
9
Ni = 1
Ni = max
Accuracy
0.9
0.88
0.86
0.84
0.82
Nr. clauses
8
7
6
5
0 2 4 6 8 10 max
N1
0 2 4 6 8 10 max
N1
0.94
0.92
Ni = 1
Ni = max
10
9
Ni = 1
Ni = max
Accuracy
0.9
0.88
0.86
0.84
0.82
Nr. clauses
8
7
6
5
0 1 2 4 6 max
N2
0 1 2 4 6 max
N2
0.94
0.92
Ni = 1
Ni = max
10
9
Ni = 1
Ni = max
Accuracy
0.9
0.88
0.86
0.84
0.82
Nr. clauses
8
7
6
5
0 2 6 10 14 18 max
N3
0 2 6 10 14 18 max
N3
0.94
0.92
Ni = 1
Ni = max
10
9
Ni = 1
Ni = max
Accuracy
0.9
0.88
0.86
0.84
0.82
Nr. clauses
8
7
6
5
0 1 2 4 6 max
N4
0 1 2 4 6 max
N4
Figure 1. Accuracy and number of clauses for different values of the N parameters

on the learning process, possibly because it confines
the search to limited regions in the neighbourhood of
local optima. In general, accuracy does not increase
monotonically with respect to greediness, and exhibits
different behaviour for the four parameters.
The results concerning simplicity do not allow to derive
any general functional relationship between simplicity
and greediness of the operators. Simple programs
are obtained for both very low and very high
values of the parameters, with a somehow irregular
behaviour for the other settings.
7. Noise
It is interesting to test the robustness of GEL when a
controlled amount of noise is introduced in the training
dataset, as done in (Lavrač & Džeroski, 1994; Lavrač
et al., 1996). Three different types of noise are added
at different noise levels: noise in arguments (type na),
noise in class (positive and negative) (type nc), and
noise in both arguments and class (type nb). For
each training set, and for each type of noise, seven
datasets with different noise levels (5, 10, 15, 20, 30, 50,
and 80%) are generated (meaning that p% of the examples
are corrupted by replacing a value with a random
value in the domain).
GEL is tested in a setting with moderate greediness,
with N1 = 2, N2 = 1, N3 = 2, N4 = 4. The results
of the experiments are illustrated in Figure 2 (as in
previous experiments, the average results over all the
runs are considered).
As expected, a rapid decay in accuracy and simplicity
is obtained when the noise level increases, with
programs containing more and more clauses. A comparison
with results of other ILP systems on the
same datasets, like FOIL, DOGMA and mFOIL (cf.
(Hekanaho, 1998)), indicate that the performance of
GEL is comparable to the one of FOIL, being slightly
worse than FOIL for low levels of noise, and slightly
better for noise levels of 50 and 80%. These ILP systems
use specific mechanisms for noise handling, while
GEL robustness to noise is mainly due to its stochastic
nature.
8. Related Work
There are few systems for inductive learning in FOL
based on evolutionary algorithms.
REGAL (Giordana & Neri, 1996) and DOGMA
(Hekanaho, 1998) are hybrids between the Pittsburgh
and Michigan approach, use a restricted Horn clause
language, and an explicit bias for restricting the search
Accuracy
Nr. clauses
0.9
0.88
0.86
0.84
0.82
0.8
0.78
0.76
0.74
0.72
0.7
0.68
0.66
0.64
0.62
0.6
24
22
20
19
18
17
16
15
14
13
12
11
10
9
8
0 5 10 15 20 30 50 80
noise level
on arguments
on classes
on both
0 5 10 15 20 30 50 80
noise level
on arguments
on classes
on both
Figure 2. Accuracy and simplicity for different levels of
noise
space. They use simple specialization and generalization
operators incorporated in crossover operators
(acting on bit representations) and a standard blind
mutation operator.
A more compact and complete binary representation
is used in a recent framework (Tamaddoni-Nezhad &
Muggleton, 2000) for incremental learning in FOL. Encoding
of solutions is based on a bottom clause (of
a subsumption lattice) constructed according to the
background knowledge using some ILP methods such
as Inverse Entailment. Novel crossover operators for
generalization and specialization based on this representation
are introduced. The encoding and operators
can be interpreted in standard ILP concepts.
GLPS (Leung & Wong, 1995) and STEPS (Kennedy
& Giraud-Carrier, 1999) are based on the Pittsburgh
approach. The systems evolve a population of logic
programs. GLPS uses the same restrictions of the form
of the clauses as GEL, represents a logic program by
means of an AND-OR tree, and utilizes standard blind
two-points crossover.
STEPS uses a tree-like representation employed in Genetic
Programming, and works on strongly typed (Escher)
programs, hence it uses modified genetic operators
to handle type constraints. However, like in
GLPS, no (other) knowledge is incorporated into the

genetic operators.
9. Conclusions
The main contribution of this paper is a new framework
for evolving a population of Horn clauses, which
unites ILP and evolutionary computation. The framework
allows the user to experiment with search strategies
of different degree of greediness, by setting the
parameters of four greedy operators which are used in
the mutation process of a hybrid evolutionary algorithm.
The research of this paper concerned a possible integration
of greedy search strategies in FOL learning
methods based on evolutionary computation. The development
of a successful inductive learning system
based on the framework proposed in this paper, and its
application to real life problems, needs further investigation.
Other interesting topics to be addressed in
future research include the extension of the framework
to deal with multiple predicates and recursion.
References
Blickle, T. (2000). Tournament selection. In T. Bäck,
D. Fogel and T. Michalewicz (Eds.), Evolutionary
computation 1, 181–187. Bristol and Philadelphia:
IoP.
Caprara, A., Fischetti, M., & Toth, P. (1998). Algorithms
for the set covering problem (Technical Report).
DEIS Operation Research Technical Report,
Italy.
Giordana, A., & Neri, F. (1996). Search-intensive concept
induction. Evolutionary Computation, 3, 375–
416.
Hekanaho, J. (1998). DOGMA: a GA based relational
learner. Proceedings of the 8th International Conference
on Inductive Logic Programming (pp. 205–214).
Springer Verlag.
Janikow, C. (1993). A knowledge intensive genetic algorithm
for supervised learning. Machine Learning,
13, 198–228.
Jong, K. D., Spears, W., & Gordon, D. (1993). Using
Genetic Algorithms for Concept Learning. Machine
Learning, 13(1/2), 155–188.
Kennedy, C. J., & Giraud-Carrier, C. (1999). A depth
controlling strategy for strongly typed evolutionary
programming. GECCO 1999: Proceedings of the
First Annual Conference (pp. 1–6). Morgan Kauffman.
Kubat, M., Bratko, I., & Michalski, R. (1998). A review
of Machine Learning Methods. In R. Michalski,
I. Bratko and M. Kubat (Eds.), Machine learning
and data mining. Chichester: John Wiley and Sons
Ltd.
Lavrač, N., & Džeroski, S. (1994). Inductive logic programming:
Techniques and applications. Ellis Horwood.
Lavrač, N., Džeroski, S., & Bratko, I. (1996). Handling
imperfect data in inductive logic programming. In
L. De Raedt (Ed.), Advances in Inductive Logic Programming,
48–64. IOS Press.
Leung, K., & Wong, M. (1995). Genetic logic programming
and applications. IEEE Expert, 10(5), 68–76.
Michalewicz, Z. (1996). Genetic algorithms + data
structures = evolution programs. Berlin: Springer-
Verlag.
Mitchell, T. (1997). Machine learning. Series in Computer
Science. McGraw-Hill.
Muggleton, S. (1999). Inductive logic programming:
issues, results and the challenge of learning language
in logic. Artificial Intelligence, 114, 283–296.
Muggleton, S., Bain, M., Hayes-Michie, J., & Michie,
D. (1989). An experimental comparison of human
and machine learning formalisms. Proceedings of the
6th International Workshop on Machine Learning
(pp. 113–118). Morgan Kaufmann.
Muggleton, S., & Buntine, W. (1988). Machine invention
of first-order predicates by inverting resolution.
Proceedings of the Fifth International Machine
Learning Conference (pp. 339–352). Morgan Kaufmann.
Muggleton, S., & Raedt, L. D. (1994). Inductive logic
programming: Theory and methods. Journal of
Logic Programming, 19-20, 669–679.
Porto, V. (2000). Evolutionary programming. In
T. Bäck, D. Fogel and T. Michalewicz (Eds.), Evolutionary
computation 1, 89–102. Bristol and Philadelphia:
IoP.
Quinlan, J. (1990). Learning logical definition from
relations. Machine Learning, 5, 239–266.
Raedt, L. D. (1992). Interactive concept learning and
constructive induction by analogy. Machine Learning,
8, 107–150.

Tamaddoni-Nezhad, A., & Muggleton, S. (2000).
Searching the subsumption lattice by a genetic algorithm.
Proceedings of the 10th International Conference
on Inductive Logic Programming (pp. 243–253).
Springer Verlag.