© Franz J. Kurfess ES Implementation 1 CPE/CSC 481: Knowledge-Based Systems Dr. Franz J. Kurfess Computer Science Department Cal Poly

© Franz J. Kurfess ES Implementation 2 Usage of the Slides u these slides are intended for the students of my CPE/CSC 481 “Knowledge-Based Systems” class at Cal Poly SLO u if you want to use them outside of my class, please let me know u I usually put together a subset for each quarter as a “Custom Show” u to view these, go to “Slide Show => Custom Shows”, select the respective quarter, and click on “Show” u To print them, I suggest to use the “Handout” option u 4, 6, or 9 per page works fine u Black & White should be fine; there are few diagrams where color is important

© Franz J. Kurfess ES Implementation 3 Course Overview u Introduction u Knowledge Representation u Semantic Nets, Frames, Logic u Reasoning and Inference u Predicate Logic, Inference Methods, Resolution u Reasoning with Uncertainty u Probability, Bayesian Decision Making u Expert System Design u ES Life Cycle u CLIPS Overview u Concepts, Notation, Usage u Pattern Matching u Variables, Functions, Expressions, Constraints u Expert System Implementation u Salience, Rete Algorithm u Expert System Examples u Conclusions and Outlook

© Franz J. Kurfess ES Implementation 4 Overview Implementation of Rule-Based Systems u Motivation u Objectives u Chapter Introduction u Important Concepts u Performance Aspects u Pattern Matching u Basic Idea u Unification u Pattern Matching in Rule- Based Systems u Rete Algorithm u Overview u Rete Network u Assert and Retract u Optimizations u Improvements u Rule Formulation u General vs. Specific Rules u Simple vs. Complex Rules u Loading and Saving Facts u Important Concepts and Terms u Chapter Summary

© Franz J. Kurfess ES Implementation 5 Logistics u Introductions u Course Materials u textbooks (see below) u lecture notes u PowerPoint Slides will be available on my Web page u handouts u Web page u u Term Project u Lab and Homework Assignments u Exams u Grading

© Franz J. Kurfess ES Implementation 6 Bridge-In

© Franz J. Kurfess ES Implementation 7 Pre-Test

© Franz J. Kurfess ES Implementation 8 Motivation u pattern matching and unification are powerful operations to determine the similarity and consistency of complex structures u they are at the core of many rule-based and predicate logic mechanisms u their application goes beyond rule-based systems u study concepts and methods that are critical for the functionality and performance of rule-based systems u pattern matching and the Rete algorithm u use and formulation of rules

© Franz J. Kurfess ES Implementation 9 Objectives u comprehend the mechanics of pattern matching in rule-based systems u basic concepts and techniques u Rete algorithm u understand the effects of matching and rule formulation on the performance of rule-based systems u learn to write rule-based programs and implement systems in an efficient way u analyze and evaluate the performance of rule-based programs and systems u identify bottlenecks u formulate and implement strategies for performance improvements

© Franz J. Kurfess ES Implementation 10 Evaluation Criteria

© Franz J. Kurfess ES Implementation 11 Overview Implementation of Rule-Based Systems u due to their more declarative nature, it can be difficult to evaluate and predict the performance of rule-based systems u time to complete a task u memory usage u disk space usage u pattern matching can be used to eliminate unsuitable rules and facts u but it can also introduce substantial overhead

© Franz J. Kurfess ES Implementation 12 Chapter Introduction u Important Concepts u entities with internal structure u data structures, objects, components u terms, sentences, graphs u diagrams, images u concepts, hierarchies u Performance Aspects u somewhat different from conventional programs u less control over the runtime behavior u pattern matching can do a lot of the work

© Franz J. Kurfess ES Implementation 13 Pattern Matching u determines if two or more complex entities (patterns) are compatible with each other u patterns can be (almost) anything that has a structure u pictures: mugshot vs. person u drawings: diagrams of systems u expressions: words,sentences of a language, strings u graphs are often used as the underlying representation u the structure of the graphs must be compatible u usually either identical, or one is a sub-graph of the other u the individual parts must be compatible u nodes must have identical or compatible values uvariables are very valuable u links must indicate compatible relationships u compatibility may be dependent on the domain or task [Giarratano & Riley 1998, Friedmann-Hill 2003, Gonzalez & Dankel, 2004]

© Franz J. Kurfess ES Implementation 14 ????? Pattern Matching Example u images u Do both images refer to the same individual? u Do they have other commonalities? v test Bucky Bucky likes fish Bucky Bucky likes fish Bucky and Satchel Satchel likesBucky

© Franz J. Kurfess ES Implementation 15 Pattern Matching Example u shapes ?? ?????

© Franz J. Kurfess ES Implementation 16 Pattern Matching Examples u constants and variables “Hans” “Franz” ? “Josef” “Joseph” first_name “Joseph” ? last_name “Joseph”

© Franz J. Kurfess ES Implementation 17 Pattern Matching Examples u terms u composed of constants, variables, functions ? father(X) “Joseph” ? father(Y)father(X) mother(X) ?? father(father(X))grandfather(X)

© Franz J. Kurfess ES Implementation 18 Unification u formal specification for finding substitutions that make logical expressions identical u the unification algorithm takes two sentences and returns a unifier for them (if one exists) Unify(p,q) =  if Subst( ,p) = Subst( ,q) u if there is more than one such substitution, the most general unifier is returned u used in logic programming, automated theorem proving u possibly complex operation u quadratic in the size of the expressions u “occur check” sometimes omitted v determines if a variable is contained in the term against which it is unified

© Franz J. Kurfess ES Implementation 19 Pattern Matching in Rule-Based Systems u used to match rules with appropriate facts in working memory u rules for which facts can be found are satisfied u the combination of a rule with the facts that satisfy it is used to form activation records v one of the activation records is selected for execution

© Franz J. Kurfess ES Implementation 20 Simplistic Rule-Based Pattern Matching u go through the list of rules, and check the antecedent (LHS) of each rule against the facts in working memory u create an activation record for each rule with a matching set of facts u repeat after each rule firing u very inefficient u roughly (number of rules) * (number of facts) (number of patterns) u the actual performance depends on the formulation of the rules and the contents of the working memory

© Franz J. Kurfess ES Implementation 21 Rete Algorithm u in most cases, the set of rules in a rule-based system is relatively constant u the facts (contents of working memory) change frequently u most of the contents of working memory, however, don’t change every time u optimization of the matching algorithm u remember previous results u change only those matches that rely on facts that changed u the Rete algorithm performs an improved matching of rules and facts u invented by Charles Forgy in the early 80s u basis for many rule-based expert system shells [ Friedmann-Hill 2003, Giarratano & Riley 1998, Friedmann-Hill 2003, Gonzalez & Dankel, 2004]

© Franz J. Kurfess ES Implementation 22 Rete Network u the name comes from the latin word rete u stands for net u consists of a network of interconnected nodes u each node represents one or more tests on the LHS of a rule u input nodes are at the top, output nodes at the bottom u pattern nodes have one input, and check the names of facts u join nodes have two inputs, and combine facts u terminal node at the bottom of the network represent individual rules u 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 u the Rete network effectively is the working memory for a rule- based system

© Franz J. Kurfess ES Implementation 23 Rete Network Example 1 (deftemplate x (slot a)) (deftemplate y (slot b)) (defrule example-1 (x (a ?v1)) (y (b ?v1)) ==> ) ?= x ?= y Left.0.a ?= Right.b example-1 ?v1 ?v1 = ?v1

© Franz J. Kurfess ES Implementation 24 Rete Left and Right Memories u left (alpha) memory u contains the left input of a join node u right (beta) memory u contains the right input of a join node u notation: Left.p.q ?= Right.r u compare the contents of slot q in fact p from the left memory with slot r in the fact from the right memory (deftemplate x (slot a)) (deftemplate y (slot b)) (defrule example-1 (x (a ?v1)) (y (b ?v1)) ==> ) ?= x ?= y Left.0.a ?= Right.b example-1 ?v1 ?v1 = ?v1

© Franz J. Kurfess ES Implementation 25 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 u compare the contents of slot q in fact p from the left memory with slot r in the fact from the right memory (deftemplate x (slot a)) (deftemplate y (slot b)) (defrule example-1 (x (a ?v1)) (y (b ?v1)) ==> ) ?= x ?= y Left.0.a ?= Right.b example-1 ?v1 ?v1 = ?v1

© Franz J. Kurfess ES Implementation 26 Rete Network Example 2 u 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 ?= y ?= z Left.0.a ?= Right.b example-2 ?v2 ?v2 = ?v2 ?v2

© Franz J. Kurfess ES Implementation 27 Rete Network Example 2 with Assert u 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) ==> ) (assert (z (c 17)) ?= x ?= y ?= z Left.0.a ?= Right.b example-2 ?v2 ?v2 = ?v2 ?v2 ?v2 = 17 17

© Franz J. Kurfess ES Implementation 28 Assert and Retract with Rete u asserting additional facts imposes some more constraints on the network u retracting facts indicates that some previously computed activation records are not valid anymore, and should be discarded u 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 v already existing join nodes can neglect these tokens

© Franz J. Kurfess ES Implementation 29 Rete Network Optimization u networks with shared facts can be combined (deftemplate x (slot a)) (deftemplate y (slot b)) (deftemplate z (slot c)) (defrule example-1 (x (a ?v1)) (y (b ?v1)) ==> ) (defrule example-2 (x (a ?v2)) (y (b ?v2)) (z) ==> ) ?= x ?= y ?= z Left.0.a ?= Right.b example-1example-2

© Franz J. Kurfess ES Implementation 30 Further Optimizations u sophisticated data structures to optimize the network u hash table to presort the tokens before running the join node tests u fine-tuning via parameters u frequently trade-off between memory usage and time

© Franz J. Kurfess ES Implementation 31 Special Cases for Pattern Matching u additional enhancements of the Rete network can be used to implement specific methods u backward chaining v requires a signal indicating to the network that a particular fact is needed  not conditional element v indicates the absence of a fact v requires special join nodes and special fields in the tokens passing through the network  test conditional element v uses a special join node that ignores its right input v the result of the function is passed on

© Franz J. Kurfess ES Implementation 32 Exploring the Rete Network in Jess  (watch compilations) function  diagnostic output when rules are compiled example-1: t  +1 one-input (pattern) node added to the Rete network  +2 two-input (pattern) node added  +t terminal node added  (view) function u graphical viewer of the Rete network in Jess  (matches ) function u displays the contents of the left and right memories of the join nodes for a rule u useful for examining unexpected rule behavior

© Franz J. Kurfess ES Implementation 33 Rule Formulation u Pattern Order u General vs. Specific Rules u Simple vs. Complex Rules u Loading and Saving Facts [Giarratano & Riley 1998]

© Franz J. Kurfess ES Implementation 34 Pattern Order u since Rete saves information about rules and facts, it can be critical to order patterns in the right way u otherwise a potentially huge number of partial matches can be generated

© Franz J. Kurfess ES Implementation 35 Example Pattern Order (deffacts information (find-match a c e g)f1 (item a)f2 (item b)f3 (item c)f4 (item d)f5 (item e)f6 (item f)f7 (item g))f8 (defrule match-1 (find-match ?x ?y ?z ?w)P1 (item ?x)P2 (item ?y)P3 (item ?z)P4 (item ?w)P5 ==> (assert (found-match ?x ?y ?z ?w)) (deffacts information (find-match a c e g) (item a) (item b) (item c) (item d) (item e) (item f) (item g)) (defrule match-2 (item ?x) (item ?y) (item ?z) (item ?w) (find-match ?x ?y ?z ?w) ==> (assert (found-match ?x ?y ?z ?w)) [Giarratano & Riley 1998]

© Franz J. Kurfess ES Implementation 36 Pattern Matches  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 u 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] Total: 29 full, 5 partial matches u full matches P1: f2,f3,f4,f5,f6,f7,f8 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: f1 u 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],... P1-3, P1-4:... P1-5: [f2,f4,f6,f8, f1] Total: 29 full, 2801 partial matches

© Franz J. Kurfess ES Implementation 37 Adding another Fact  what is the effect on the two cases if another fact (item h) is added?  no significant changes for match-1 u in particular, no additional partial matches  major changes for match-2 u another 1880 partial matches

© Franz J. Kurfess ES Implementation 38 Guidelines for Pattern Matches u try to formulate your rule such that the number of matches is low u full and partial matches u try to limit the number of old partial matches u removing those also is time-consuming u in general, the state of the system should be reasonably stable u matches u assertion, retraction, modification of facts

© Franz J. Kurfess ES Implementation 39 Guidelines for Pattern Ordering u most specific patterns first u smallest number of matching facts u largest number of variable bindings to constrain other facts u patterns matching volatile facts go last u facts that are changing frequently should be used by patterns late in the LHS u smallest number of changes in partial matches u may cause a dilemma with the above guideline u patterns matching the fewest facts first u reduces the number of partial matches

© Franz J. Kurfess ES Implementation 40 Multifield Variables u multifield wildcards and multifield variables are very powerful, but possible very inefficient u should only be used when needed u limit their number in a single slot of a pattern

© Franz J. Kurfess ES Implementation 41 Test Conditional Element  the test conditional element should be placed as close to the top of the rule as possible u reduces the number of partial matches u evaluation of expressions during pattern matching is usually more efficient

© Franz J. Kurfess ES Implementation 42 Built-In Pattern Matching Constraints u the built-in constraints are always more efficient than the equivalent expression u not so good: (defrule primary-color color ?x&: (or (eq ?x red) (eq ?x green) (eq ?x blue) ==> (assert (primary-color ?x))) u better: (defrule primary-color color ?x&red|green|blue) ==> (assert (primary-color ?x)))

© Franz J. Kurfess ES Implementation 43 General vs. Specific Rules u some knowledge can be expressed through many specific, or a few general rules u specific rules generate a top-heavy Rete network with many pattern nodes and fewer join nodes u general rules offer better opportunities for sharing pattern and join nodes u it usually is easier to write an inefficient general rule than an inefficient specific rule

© Franz J. Kurfess ES Implementation 44 Simple vs. Complex Rules u simple rules are sometimes elegant, but not necessarily efficient u storing temporary facts can be very helpful v especially in recursive or repetitive programs

© Franz J. Kurfess ES Implementation 45 Loading and Saving Facts u facts can be kept in a file, and loaded into memory when needed  (load-facts) and (save-facts) functions u may lead to visibility or scoping problems if the respective deftemplates are not contained in the current module

© Franz J. Kurfess ES Implementation 46 Figure Example

© Franz J. Kurfess ES Implementation 47 Post-Test

© Franz J. Kurfess ES Implementation 48 Evaluation u Criteria

© Franz J. Kurfess ES Implementation 49 Use of References u [Giarratano & Riley 1998] [Giarratano & Riley 1998] u [Russell & Norvig 1995] [Russell & Norvig 1995] u [Jackson 1999] [Jackson 1999] u [Durkin 1994] [Durkin 1994] [Giarratano & Riley 1998]

© Franz J. Kurfess ES Implementation 50 Important Concepts and Terms u agenda  assert u backward chaining u constant u fact u expert system (ES) u expert system shell u forward chaining u join node u knowledge base u knowledge-based system u left (alpha) memory  matches u matching u pattern u pattern matching u pattern node u RETE algorithm  retract u right (beta) memory u rule u substitution u term  test conditional element u unification u variable  view u working memory

© Franz J. Kurfess ES Implementation 51 Summary ES Implementation u for rule-based systems, an efficient method for pattern matching between the rule antecedents and suitable facts is very critical u matching every rule against all possible facts repeatedly is very inefficient u the Rete algorithm is used in many expert system shells u it constructs a network from the facts and rules in the knowledge base u since certain aspects of the knowledge base are quite static, repeated matching operations can be avoided u a few strategies can be used by programmers to achieve better performance u most specific patterns first, patterns with volatile facts last u careful use of multifield variables, general rules  use of the test conditional element, built-in pattern constraints u loading and saving of facts

© Franz J. Kurfess ES Implementation 52