CPE/CSC 481:
Knowledge-Based Systems
Dr. Franz J. Kurfess
Computer Science Department
Cal Poly
© 2002-4 Franz J. Kurfess
ES Implementation 1
Course Overview
 Introduction
 Knowledge

Semantic Nets, Frames, Logic
 Reasoning

with Uncertainty
Probability, Bayesian Decision
Making
 Expert

and Inference
Predicate Logic, Inference
Methods, Resolution
 Reasoning

Representation
System Design
 CLIPS

Overview
Concepts, Notation, Usage
 Pattern

Matching
Variables, Functions,
Expressions, Constraints
 Expert
System
Implementation

Salience, Rete Algorithm
 Expert
System Examples
 Conclusions and Outlook
ES Life Cycle
© 2002-4 Franz J. Kurfess
ES Implementation 2
Overview Implementation of
Rule-Based Systems
 Motivation
 Rete
 Objectives

 Chapter


Important Concepts
Performance Aspects
 Pattern



Introduction
Matching
Basic Idea
Unification
Pattern Matching in RuleBased Systems




Overview
Rete Network
Assert and Retract
Optimizations
Improvements
 Rule



Algorithm
Formulation
General vs. Specific Rules
Simple vs. Complex Rules
Loading and Saving Facts
 Important
Concepts and
Terms
 Chapter Summary
© 2002-4 Franz J. Kurfess
ES Implementation 3
Logistics


Introductions
Course Materials


textbooks (see below)
lecture notes



handouts
Web page





PowerPoint Slides will be available on my Web page
http://www.csc.calpoly.edu/~fkurfess
Term Project
Lab and Homework Assignments
Exams
Grading
© 2002-4 Franz J. Kurfess
ES Implementation 4
Bridge-In
© 2002-4 Franz J. Kurfess
ES Implementation 5
Pre-Test
© 2002-4 Franz J. Kurfess
ES Implementation 6
Motivation
 pattern
matching and unification are powerful
operations to determine the similarity and
consistency of complex structures
 they
are at the core of many rule-based and predicate logic
mechanisms
 their application goes beyond rule-based systems
 study
concepts and methods that are critical for the
functionality and performance of rule-based systems
 pattern
matching and the Rete algorithm
 use and formulation of rules
© 2002-4 Franz J. Kurfess
ES Implementation 7
Objectives
 comprehend
the mechanics of pattern matching in rule-based
systems


basic concepts and techniques
Rete algorithm
 understand
the effects of matching and rule formulation on
the performance of rule-based systems
 learn to write rule-based programs and implement systems in
an efficient way
 analyze and evaluate the performance of rule-based
programs and systems


identify bottlenecks
formulate and implement strategies for performance improvements
© 2002-4 Franz J. Kurfess
ES Implementation 8
Overview Implementation of
Rule-Based Systems
 due
to their more declarative nature, it can be difficult
to evaluate and predict the performance of rulebased systems
 time
to complete a task
 memory usage
 disk space usage
 pattern
matching can be used to eliminate unsuitable
rules and facts
 but
it can also introduce substantial overhead
© 2002-4 Franz J. Kurfess
ES Implementation 10
Chapter Introduction
 Important
 entities
Concepts
with internal structure
data structures, objects, components
 terms, sentences, graphs
 diagrams, images
 concepts, hierarchies

 Performance
 somewhat
Aspects
different from conventional programs
less control over the runtime behavior
 pattern matching can do a lot of the work

© 2002-4 Franz J. Kurfess
ES Implementation 11
Pattern Matching
 determines
if two or more compelx entities (patterns)
are compatible with each other
 patterns
can be (almost) anything that has a structure
pictures: mugshot vs. person
 drawings: diagrams of systems
 expressions: words,sentences of a language, strings

 graphs
are often used as the underlying representation
the structure of the graphs must be compatible
 usually either identical, or one is a sub-graph of the other
 the individual parts must be compatible
 nodes must have identical or compatible values

 variables are very valuable
 links
must indicate compatible relationships
 compatibility may be dependent on the domain or task
© 2002-4 Franz J. Kurfess
ES Implementation
12
[Giarratano & Riley 1998, Friedmann-Hill 2003, Gonzalez & Dankel,
2004]
Pattern Matching Example
 images
 Do
both images refer to the same individual?
 Do they have other commonalities?

test
Bucky
Bucky likes fish
© 2002-4 Franz J. Kurfess
Bucky
Bucky likes fish
Bucky and Satchel
Satchel likesBucky
ES Implementation 13
Pattern Matching Example
 shapes
© 2002-4 Franz J. Kurfess
ES Implementation 14
Pattern Matching Examples
 constants
and variables
“Hans”
“Franz”
“Josef”
“Joseph”
first_name
“Joseph”
last_name
“Joseph”
© 2002-4 Franz J. Kurfess
ES Implementation 15
Pattern Matching Examples
 terms
 composed
of constants, variables, functions
father(X)
“Joseph”
father(X)
father(Y)
father(X)
mother(X)
father(father(X))
© 2002-4 Franz J. Kurfess
grandfather(X)
ES Implementation 16
Unification
 formal
specification for finding substitutions that make logical
expressions identical

the unification algorithm takes two sentences and returns a unifier for
them (if one exists)
Unify(p,q) = 
if Subst(,p) = Subst(,p)



if there is more than one such substitution, the most general unifier is
returned
used in logic programming, automated theorem proving
possibly complex operation
 quadratic in the size of the expressions
“occur check” sometimes omitted
 determines if a variable is contained in the term against which it is
© 2002-4 Franz J. Kurfess
unified
ES Implementation

17
Pattern Matching in Rule-Based
Systems
 used
to match rules with appropriate facts in working
memory
 rules
for which facts can be found are satisfied
 the combination of a rule with the facts that satisfy it is
used to form activation records

one of the activation records is selected for execution
© 2002-4 Franz J. Kurfess
ES Implementation 18
Simplistic Rule-Based
Pattern Matching
 go
through the list of rules, and check the
antecedent (LHS) of each rule against the facts in
working memory
 create
an activation record for each rule with a matching
set of facts
 repeat after each rule firing
 very
inefficient
(number of rules) * (number of facts)(number of patterns)
 the actual performance depends on the formulation of the
rules and the contents of the working memory
 roughly
© 2002-4 Franz J. Kurfess
ES Implementation 19
Rete Algorithm
 in
most cases, the set of rules in a rule-based system is
relatively constant
 the facts (contents of working memory) change frequently

most of the contents of working memory, however, don’t change every
time
 optimization


of the matching algorithm
remember previous results
change only those matches that rely on facts that changed
 the
Rete algorithm performs an improved matching of rules
and facts


invented by Charles Forgy in the early 80s
basis for many rule-based expert system shells
© 2002-4 Franz J. Kurfess
[ Friedmann-Hill 2003, Giarratano & Riley 1998,
Gonzalez & Dankel, 2004]
ES Implementation 20
Rete Network
 the

name comes from the latin word rete
stands for net
 consists

each node represents one or more tests on the LHS of a rule




of a network of interconnected nodes
input nodes are at the top, output nodes at the bottom
pattern nodes have one input, and check the names of facts
join nodes have two inputs, and combine facts
terminal node at the bottom of the network represent individual rules
a
rule is satisfied if there is a combination of facts that passes
all the test nodes from the top to the output node at the
bottom that represents the rule
 the Rete network effectively is the working memory for a rulebased system
© 2002-4 Franz J. Kurfess
ES Implementation 21
Rete Network Example 1
(deftemplate x (slot a))
(deftemplate y (slot b))
x
?=
?=
?v1
(defrule example-1
(x (a ?v1))
(y (b ?v1))
==> )
y
?v1
Left.0.a ?= Right.b
?v1
=
?v1
example-1
© 2002-4 Franz J. Kurfess
ES Implementation 22
Rete Left and Right Memories

left (alpha) memory


x
?=
?=
y
right (beta) memory


contains the left input of a join node
contains the right input of a join node
notation:
Left.p.q ?= Right.r

compare the contents of slot q in
fact p from the left memory with slot r
in the fact from the right memory
?v1
?v1
Left.0.a ?= Right.b
?v1
=
?v1
(deftemplate x (slot a))
(deftemplate y (slot b))
(defrule example-1
(x (a ?v1))
(y (b ?v1))
==> )
© 2002-4 Franz J. Kurfess
example-1
ES Implementation 23
Running the Network


only facts x and y are considered
all facts where x.a == y.b pass the
join network


all {x, y} tuples are fowarded to the
next node
compare the contents of slot q in
fact p from the left memory with slot r
in the fact from the right memory
x
?=
y
?=
?v1
?v1
Left.0.a ?= Right.b
?v1
=
?v1
(deftemplate x (slot a))
(deftemplate y (slot b))
(defrule example-1
(x (a ?v1))
(y (b ?v1))
==> )
© 2002-4 Franz J. Kurfess
example-1
ES Implementation 24
Rete Network Example 2
 shares
some facts with
Example 1
(deftemplate x (slot a))
(deftemplate y (slot b))
(deftemplate z (slot c))
(defrule example-2
(x (a ?v2))
(y (b ?v2))
(z)
==> )
?=
x
?=
?v2
y
?=
z
?v2
Left.0.a ?= Right.b
?v2 = ?v2
?v2
example-2
© 2002-4 Franz J. Kurfess
ES Implementation 25
Rete Network Example 2 with Assert
 additional
fact asserted
?=
(deftemplate x (slot a))
(deftemplate y (slot b))
(deftemplate z (slot c))
(defrule example-2
(x (a ?v2))
(y (b ?v2))
(z)
==> )
x
?=
?v2
y
z
?=
?v2
17
Left.0.a ?= Right.b
?v2 = ?v2
?v2
?v2
=
17
example-2
(assert (z (c 17))
© 2002-4 Franz J. Kurfess
ES Implementation 26
Assert and Retract with Rete



asserting additional facts imposes some more constraints on the network
retracting facts indicates that some previously computed activation
records are not valid anymore, and should be discarded
in addition to the actual facts, tags are sent through the networks




ADD to add facts (i.e. for assert)
REMOVE to remove facts (i.e. for retract)
CLEAR to flush the network memories (i.e. for reset)
UPDATE to populate the join nodes of newly added rules

already existing join nodes can neglect these tokens
© 2002-4 Franz J. Kurfess
ES Implementation 27
Rete Network Optimization
 networks
with shared facts can
be combined
?=
x
?=
y
?=
z
(deftemplate x (slot a))
(deftemplate y (slot b))
(deftemplate z (slot c))
Left.0.a ?= Right.b
(defrule example-1
(x (a ?v1))
(y (b ?v1))
==> )
(defrule example-2
(x (a ?v2))
(y (b ?v2))
(z)
==> )
© 2002-4 Franz J. Kurfess
example-1
example-2
ES Implementation 28
Further Optimizations
 sophisticated
data structures to optimize the network
 hash
table to presort the tokens before running the join
node tests
 fine-tuning
 frequently
© 2002-4 Franz J. Kurfess
via parameters
trade-off between memory usage and time
ES Implementation 29
Special Cases for Pattern Matching
 additional
enhancements of the Rete network can be
used to implement specific methods
 backward

requires a signal indicating to the network that a particular fact is
needed
 not


conditional element
indicates the absence of a fact
requires special join nodes and special fields in the tokens passing
through the network
 test


chaining
conditional element
uses a special join node that ignores its right input
the result of the function is passed on
© 2002-4 Franz J. Kurfess
ES Implementation 30
Exploring the Rete Network in Jess
 (watch

diagnostic output when rules are compiled
example-1: +1+1+1+2+t



+1 one-input (pattern) node added to the Rete network
+2 two-input (pattern) node added
+t terminal node added
 (view)

compilations) function
function
graphical viewer of the Rete network in Jess
 (matches


<rule-name>) function
displays the contents of the left and right memories of the join nodes
for a rule
useful for examining unexpected rule behavior
© 2002-4 Franz J. Kurfess
ES Implementation 31
Rule Formulation
 Pattern
Order
 General vs. Specific Rules
 Simple vs. Complex Rules
 Loading and Saving Facts
© 2002-4 Franz J. Kurfess
[Giarratano & Riley 1998]
ES Implementation 32
Pattern Order
 since
Rete saves information about rules and facts, it
can be critical to order patterns in the right way
 otherwise
a potentially huge number of partial matches can
be generated
© 2002-4 Franz J. Kurfess
ES Implementation 33
Example Pattern Order
(deffacts information
(find-match a c e g)
(item a)
(item b)
(item c)
(item d)
(item e)
(item f)
(item g))
(defrule match-1
(find-match ?x ?y ?z ?w)
(item ?x)
(item ?y)
(item ?z)
(item ?w)
==>
(assert (found-match ?x ?y ?z
© 2002-4 Franz J. Kurfess
(deffacts information
f1
(find-match a c e g)
f2
(item a)
f3
(item b)
f4
(item c)
f5
(item d)
f6
(item e)
f7
(item f)
f8
(item g))
(defrule match-1
P1
(item ?x)
P2
(item ?y)
P3
(item ?z)
P4
(item ?w)
P5
(find-match ?x ?y ?z ?w)
==>
?w)) (assert (found-match ?x ?y ?z ?w))
[Giarratano & Riley 1998]
ES Implementation 34
Pattern Matches
 full
P1:
P2:
P3:
P4:
P5:
matches
f1
f2,f3,f4,f5,f6,f7,f8
f2,f3,f4,f5,f6,f7,f8
f2,f3,f4,f5,f6,f7,f8
f2,f3,f4,f5,f6,f7,f8
 full matches
P1: f1
P2: f2,f3,f4,f5,f6,f7,f8
P3: f2,f3,f4,f5,f6,f7,f8
P4: f2,f3,f4,f5,f6,f7,f8
P5: f2,f3,f4,f5,f6,f7,f8
 partial matches
P1:
[f1]
P1-2: [f1,f2]
P1-3: [f1,f2,f4]
P1-4: [f1,f2,f4,f6]
P1-5: [f1,f2,f4,f6,f8]
 partial matches
P1:
[f2,f3,f4,f5,f6,f7,f8]
P1-2: [f2,f2],[f2,f3],[f2,f4],[f2,f5],
[f2,f6],[f2,f7],[f2,f8],
[f3,f2],[f3,f3],[f3,f4],[f3,f5],
[f3,f6],[f3,f7],[f3,f8],
...
Total: 29 full, 5 partial matches
P1-3, P1-4: ...
P1-5: [f2,f4,f6,f8, f1]
Total: 29 full, 2801 partial matches
© 2002-4 Franz J. Kurfess
ES Implementation 35
Guidelines for Pattern Ordering
 most
specific patterns first
 smallest
number of matching facts
 largest number of variable bindings to constrain other facts
 patterns
matching volatile facts go last
 facts
that are changing frequently should be used by
patterns late in the LHS
 smallest number of changes in partial matches
 may cause a dilemma with the above guideline
 patterns
matching the fewest facts first
 reduces
the number of partial matches
© 2002-4 Franz J. Kurfess
ES Implementation 36
Multifield Variables
 multifield
wildcards and multifield variables are very
powerful, but possible very inefficient
 should
only be used when needed
 limit their number in a single slot of a pattern
© 2002-4 Franz J. Kurfess
ES Implementation 37
Test Conditional Element
test conditional element should be placed as
close to the top of the rule as possible
 the
 reduces
the number of partial matches
 evaluation of expressions during pattern matching is
usually more efficient
© 2002-4 Franz J. Kurfess
ES Implementation 38
Built-In Pattern Matching Constraints
 the
built-in constraints are always more efficient than the
equivalent expression
 not so good:
(defrule primary-color
color ?x&: (or (eq ?x red)
(eq ?x green)
(eq ?x blue)
==>
(assert (primary-color ?x)))
 better:
(defrule primary-color
color ?x&red|green|blue)
==>
(assert (primary-color ?x)))
© 2002-4 Franz J. Kurfess
ES Implementation 39
General vs. Specific Rules
 some
knowledge can be expressed through many
specific, or a few general rules
 specific
rules generate a top-heavy Rete network with
many pattern nodes and fewer join nodes
 general rules offer better opportunities for sharing pattern
and join nodes
 it usually is easier to write an inefficient general rule than
an inefficient specific rule
© 2002-4 Franz J. Kurfess
ES Implementation 40
Simple vs. Complex Rules
 simple
rules are sometimes elegant, but not
necessarily efficient
 storing

temporary facts can be very helpful
especially in recursive or repetitive programs
© 2002-4 Franz J. Kurfess
ES Implementation 41
Loading and Saving Facts
 facts
can be kept in a file, and loaded into memory
when needed
 (load-facts)
and (save-facts) functions
 may
lead to visibility or scoping problems if the respective
deftemplates are not contained in the current module
© 2002-4 Franz J. Kurfess
ES Implementation 42
Figure Example
© 2002-4 Franz J. Kurfess
ES Implementation 43
Post-Test
© 2002-4 Franz J. Kurfess
ES Implementation 44
Use of References
 [Giarratano
& Riley 1998]
 [Russell & Norvig 1995]
 [Jackson 1999]
 [Durkin 1994]
[Giarratano & Riley 1998]
© 2002-4 Franz J. Kurfess
ES Implementation 46
Important Concepts and Terms














agenda
assert
backward chaining
constant
fact
expert system (ES)
expert system shell
forward chaining
join node
knowledge base
knowledge-based system
left (alpha) memory
matches
matching
© 2002-4 Franz J. Kurfess














pattern
pattern matching
pattern node
RETE algorithm
retract
right (beta) memory
rule
substitution
term
test conditional element
unification
variable
view
working memory
ES Implementation 47
Summary ES Implementation
 for
rule-based systems, an efficient method for pattern
matching between the rule antecedents and suitable facts is
very critical

matching every rule against all possible facts repeatedly is very
inefficient
 the


Rete algorithm is used in many expert system shells
it constructs a network from the facts and rules in the knowledge base
since certain aspects of the knowledge base are quite static, repeated
matching operations can be avoided
a
few strategies can be used by programmers to achieve
better performance




most specific patterns first, patterns with volatile facts last
careful use of multifield variables, general rules
use of the test conditional element, built-in pattern constraints
loading and saving of facts
© 2002-4 Franz J. Kurfess
ES Implementation 48
© 2002-4 Franz J. Kurfess
ES Implementation 49