For Wednesday

• Read ch. 20, sections 1, 2, 5, and 7

• No homework

Program 4

• Any questions?

Learning mini-project

• Worth 2 homeworks• Due next Monday• Foil6 is available in /home/mecalif/public/itk340/foil• A manual and sample data files are there as well.• Create a data file that will allow FOIL to learn rules

for a sister/2 relation from background relations of parent/2, male/1, and female/1. You can look in the prolog folder of my 327 folder for sample data if you like.

• Electronically submit your data file—which should be named sister.d, and turn in a hard copy of the rules FOIL learns.

Inductive Logic Programming

• Representation is Horn clauses

• Builds rules using background predicates

• Rules are potentially much more expressive than attribute-value representations

Example Results

• Rules for family relations from data of primitive or related predicates.

uncle(A,B) : brother(A,C), parent(C,B).

uncle(A,B) : husband(A,C), sister(C,D), parent(D,B).

• Recursive list programs.

member(X,[X | Y]).

member(X, [Y | Z]) : member(X, Z).

ILP• Goal is to induce a Horn clause definition for some target

predicate P given definitions of background predicates Qi.

• Goal is to find a syntactically simple definition D for P such that given background predicate definitions B – For every positive example pi: D B |= p

– For every negative example ni: D B |/= n

• Background definitions are either provided – Extensionally: List of ground tuples satisfying the predicate. – Intensionally: Prolog definition of the predicate.

Sequential Covering Algorithm

Let P be the set of positive examples

Until P is empty do

Learn a rule R that covers a large number of positives without covering any

negatives.

Add R to the list of learned rules.

Remove positives covered by R from P

• This is just an instance of the greedy algorithm for minimum set covering and does not guarantee that a minimum number of rules is learned but tends to learn a reasonably small rule set.

• Minimum set covering is an NP hard problem and the greedy algorithm is a common approximation algorithm.

• There are several ways to learn a single rule used in various methods.

Strategies for Learning a Single Rule • Top Down (General to Specific):

– Start with the most general (empty) rule.

– Repeatedly add feature constraints that eliminate negatives while retaining positives.

– Stop when only positives are covered.

• Bottom Up (Specific to General): – Start with a most specific rule (complete description of a single

instance).

– Repeatedly eliminate feature constraints in order to cover more positive examples.

– Stop when further generalization results in covering negatives.

FOIL • Basic top down sequential covering algorithm adapted for Prolog clauses. • Background provided extensionally. • Initialize clause for target predicate P to

P(X1 ,...Xr ) : .

• Possible specializations of a clause include adding all possible literals: – Qi (V1 ,...Vr )

– not(Qi (V1 ,...Vr ))

– Xi = Xj

– not(Xi = X )

where X's are variables in the existing clause, at least one of V1 ,...Vr is an existing variable, others can be new.

• Allow recursive literals if not cause infinite regress.

Foil Input Data • Consider example of finding a path in a directed acyclic

graph.

• Intended Clause:path(X,Y) : edge(X,Y).

path(X,Y) : edge(X,Z), path (Z,Y).

• Examplesedge: { <1,2>, <1,3>, <3,6>, <4,2>, <4,6>, <6,5> }

path: { <1,2>, <1,3>, <1,6>, <1,5>, <3,6>, <3, 5>, <4,2>, <4,6>, <4,5>, <6, 5> }

• Negative examples of the target predicate can be provided directly or indirectly produced using a closed world assumption. Every pair <x,y> not in positive tuples for path.

Example Induction+ : { <1,2>, <1,3>, <1,6>, <1,5>, <3,6>, <3, 5>, <4,2>, <4,6>,

<4,5>, <6, 5> } - : {<1,4>, <2,1>, <2,3>, <2,4>, <2,5> <2,6>, <3,1>, <3,2>, <3,4>,

<4,1> <4,3>, <5,1>, <5,2>, <5,3>, <5,4> <5,6>, <6,1>, <6,2>, <6,3>, <6,4> }

• Start with empty rule: path(X,Y) : . • Among others, consider adding literal edge(X,Y) (also

consider edge(Y,X), edge(X,Z), edge(Z,X), path(Y,X), path(X,Z), path(Z,X), X=Y, and negations)

• 6 positive tuples and NO negative tuples covered. • Create “base case” and remove covered examples:

path(X,Y) : edge(X,Y).

+ : { <1,6>, <1,5>, <3, 5>, <4,5> }

- : { <1,4>, <2,1>, <2,3>, <2,4>, <2,5> <2,6>, <3,1>, <3,2>, <3,4>, <4,1>, <4,3>, <5,1>, <5,2>, <5,3>, <5,4> <5,6>, <6,1>, <6,2>, <6,3>, <6,4> }

• Start with new empty rule: path(X,Y) : . • Consider literal edge(X,Z) (among others...) • 4 remaining positives satisfy it but so do 10 of 20 negatives• Current rule: path(x,y) : edge(X,Z). • Consider literal path(Z,Y) (as well as edge(X,Y), edge(Y,Z), edge(X,Z),

path(Z,X), etc....) • No negatives covered, complete clause.

path(X,Y) : edge(X,Z), path(Z,Y).

• New clause actually covers all remaining positive tuples of path, so definition

is complete.

Picking the Best Literal

• Based on information gain (similar to ID3). |p|*(log2 (|p| /(|p|+|n|)) - log2 (|P| /(|P|+|N|)))

P is number of positives before adding literal L

N is number of negatives before adding literal L

p is number of positives after adding literal L

n is number of negatives after adding literal L

• Given n predicates of arity m there are O(n2m) possible literals to chose from, so branching factor can be quite large.

Other Approaches

• Golem

• CHILL

• Foidl

• Bufoidl

Domains

• Any kind of concept learning where background knowledge is useful.

• Natural Language Processing

• Planning

• Chemistry and biology– DNA– Protein structure

Why Neural Networks?

Why Neural Networks?• Analogy to biological systems, the best examples we have of

robust learning systems. • Models of biological systems allowing us to understand how

they learn and adapt. • Massive parallelism that allows for computational efficiency. • Graceful degradation due to distributed represent-ations that

spread knowledge representation over large numbers of computational units.

• Intelligent behavior is an emergent property from large numbers of simple units rather than resulting from explicit symbolically encoded rules.

Neural Speed Constraints

• Neuron “switching time” is on the order of milliseconds compared to nanoseconds for current transistors.

• A factor of a million difference in speed.

• However, biological systems can perform significant cognitive tasks (vision, language understanding) in seconds or tenths of seconds.

What That Means• Therefore, there is only time for about a hundred

serial steps needed to perform such tasks. • Even with limited abilties, current AI systems

require orders of magnitude more serial steps. • Human brain has approximately 1011 neurons

each connected on average to 104 others, therefore must exploit massive parallelism.

Real Neurons• Cells forming the basis of neural tissue

– Cell body

– Dendrites

– Axon

– Syntaptic terminals

• The electrical potential across the cell membrane exhibits spikes called action potentials.

• Originating in the cell body, this spike travels down the axon and causes chemical neuro-transmitters to be released at syntaptic terminals.

• This chemical difuses across the synapse into dendrites of neighboring cells.

Real Neurons (cont)

• Synapses can be excitory or inhibitory.

• Size of synaptic terminal influences strength of connection.

• Cells “add up” the incoming chemical messages from all neighboring cells and if the net positive influence exceeds a threshold, they “fire” and emit an action potential.

Model Neuron(Linear Threshold Unit)

• Neuron modelled by a unit (j) connected by weights, wji, to other units (i):

• Net input to a unit is defined as:

netj = wji * oi

• Output of a unit is a threshold function on the net input:– 1 if netj > Tj

– 0 otherwise

Neural Computation

• McCollough and Pitts (1943) show how linear threshold units can be used to compute logical functions.

• Can build basic logic gates – AND: Let all wji be (Tj /n)+ where n = number of

inputs

– OR: Let all wji be Tj+

– NOT: Let one input be a constant 1 with weight Tj+e and the input to be inverted have weight Tj

Neural Computation (cont)

• Can build arbitrary logic circuits, finite state machines, and computers given these basis gates.

• Given negated inputs, two layers of linear threshold units can specify any boolean function using a two layer AND OR network.

Learning

• Hebb (1949) suggested if two units are both active (firing) then the weight between them should increase:

wji = wji + ojoi

– is a constant called the learning rate – Supported by physiological evidence

Alternate Learning Rule

• Rosenblatt (1959) suggested that if a target output value is provided for a single neuron with fixed inputs, can incrementally change weights to learn to produce these outputs using the perceptron learning rule. – Assumes binary valued input/outputs

– Assumes a single linear threshold unit.

– Assumes input features are detected by fixed networks.

Perceptron Learning Rule

• If the target output for output unitj is tj

wji = wji + (tj - oj)oi

• Equivalent to the intuitive rules: – If output is correct, don't change the weights

– If output is low (oj = 0, tj =1), increment weights for all inputs which are 1.

– If output is high (oj = 1, tj =0), decrement weights for all inputs which are 1.

• Must also adjust threshold:

Tj = Tj + (tj - oj)

• or equivalently assume there is a weight wj0 = -Tj for an extra input unit 0 that has constant output o0 =1 and that the threshold is always

0.

Perceptron Learning Algorithm

• Repeatedly iterate through examples adjusting weights according to the perceptron learning rule until all outputs are correct

Initialize the weights to all zero (or randomly)

Until outputs for all training examples are correct

For each training example, e, do

Compute the current output oj

Compare it to the target tj and update the weights

according to the perceptron learning rule.

Algorithm Notes

• Each execution of the outer loop is called an epoch.

• If the output is considered as concept membership and inputs as binary input features, then easily applied to concept learning problems.

• For multiple category problems, learn a separate perceptron for each category and assign to the class whose perceptron most exceeds its threshold.

• When will this algorithm terminate (converge) ??

Representational Limitations

• Perceptrons can only represent linear threshold functions and can therefore only learn data which is linearly separable (positive and negative examples are separable by a hyperplane in n dimensional space)

• Cannot represent exclusive or (xor)

Perceptron Learnability

• System obviously cannot learn what it cannot represent. • Minsky and Papert(1969) demonstrated that many functions

like parity (n input generalization of xor) could not be represented.

• In visual pattern recognition, assumed that input features are local and extract feature within a fixed radius. In which case no input features support learning – Symmetry

– Connectivity

• These limitations discouraged subsequent research on neural

networks.

Perceptron Convergence and Cycling Theorems

• Perceptron Convergence Theorem: If there are a set of weights that are consistent with the training data (i.e. the data is linearly separable), the perceptron learning algorithm will converge (Minsky & Papert, 1969).

• Perceptron Cycling Theorem: If the training data is not linearly separable, the Perceptron learning algorithm will eventually repeat the same set of weights and threshold at the end of some epoch and therefore enter an infinite loop.

Perceptron Learning as Hill Climbing

• The search space for Perceptron learning is the space of possible values for the weights (and threshold).

• The evaluation metric is the error these weights produce when used to classify the training examples.

• The perceptron learning algorithm performs a form of hill climbing (gradient descent), at each point altering the weights slightly in a direction to help minimize this error.

• Perceptron convergence theorem guarantees that for the linearly separable case there is only one local minimum and the space is well behaved.

Perceptron Performance

• Can represent and learn conjunctive concepts and M of N concepts (true if any M of a set of N selected binary features are true).

• Although simple and restrictive, this high bias algorithm performs quite well on many realistic problems.

• However, the representational restriction is limiting in many applications.