Expert System Implementation

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

Overview Implementation of Rule-Based Systems due to their more declarative nature, it can be difficult to evaluate and predict the performance of rule-based 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

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

Pattern Matching determines if two or more complex entities (patterns) are compatible with each other patterns can be (almost) anything that has a structure pictures: 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

Pattern MatchingExample Bucky and Satchel Satchel likesBucky Pattern MatchingExample images Do both images refer to the same individual? Do they have other commonalities? test ????? Bucky Bucky likes fish Bucky Bucky likes fish

Pattern Matching Example shapes ????? ?? ????? ??

Pattern Matching Examples constants and variables “Hans” “Franz” “Josef” ? “Joseph” first_name “Joseph” last_name ? “Joseph”

Pattern Matching Examples terms composed of constants, variables, functions father(X) ? “Joseph” father(X) ? father(Y) father(X) mother(X) father(father(X)) grandfather(X) ??

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(,q) if there is more than one such substitution, the most general unifier is returned used in logic programming, automated theorem proving possibly complex operation

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

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 the actual performance depends on the formulation of the rules and the contents of the working memory

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

Rete Network the name comes from the latin word rete stands for net consists of a network of interconnected nodes each node represents one or more tests on the LHS of a rule 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 rule-based system

Rete Network Example 1 (deftemplate x (slot a)) ?= y (deftemplate x (slot a)) (deftemplate y (slot b)) (defrule example-1 (x (a ?v1)) (y (b ?v1)) ==> ) ?v1 ?v1 Left.0.a ?= Right.b ?v1 = ?v1 example-1

Rete Left and Right Memories left (alpha) memory contains the left input of a join node right (beta) memory 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 (deftemplate x (slot a)) (deftemplate y (slot b)) (defrule example-1 (x (a ?v1)) (y (b ?v1)) ==> ) ?= x ?= y ?v1 ?v1 Left.0.a ?= Right.b ?v1 = ?v1 example-1

Running the Network ?v1 ?v1 ?v1 = ?v1 example-1 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 (deftemplate x (slot a)) (deftemplate y (slot b)) (defrule example-1 (x (a ?v1)) (y (b ?v1)) ==> ) ?= x ?= y ?v1 ?v1 Left.0.a ?= Right.b ?v1 = ?v1 example-1

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 ?= y ?= z ?v2 ?v2 Left.0.a ?= Right.b ?v2 = ?v2 ?v2 example-2

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) ==> ) (assert (z (c 17)) ?= x ?= y ?= z ?v2 ?v2 17 Left.0.a ?= Right.b ?v2 = ?v2 ?v2 ?v2 = 17 example-2

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

Rete Network Optimization 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-1 example-2

Further Optimizations sophisticated data structures to optimize the network hash table to presort the tokens before running the join node tests fine-tuning via parameters frequently trade-off between memory usage and time

Special Cases for Pattern Matching additional enhancements of the Rete network can be used to implement specific methods backward chaining 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 conditional element uses a special join node that ignores its right input the result of the function is passed on

Rule Formulation Pattern Order General vs. Specific Rules Simple vs. Complex Rules Loading and Saving Facts

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

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

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

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

Test Conditional Element the test conditional element should be placed as close to the top of the rule as possible reduces the number of partial matches evaluation of expressions during pattern matching is usually more efficient

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

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

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