© c. kemke control 1 comp 4200: expert systems dr. christel kemke department of computer science...

© C. Kemke Control 1

COMP 4200: Expert SystemsCOMP 4200:

Expert Systems

Dr. Christel Kemke

Department of Computer Science

University of Manitoba


Rule-based Systems ControlRule-based Systems Control

Procedural Control Conflict Resolution Strategies Salience Modules


Procedural ControlProcedural Control

if-then-else

while-do


Procedural Control in ActionsProcedural Control in Actions

Procedural Control Elements can appear on the RHS of a rule or in message-handlers of classes.

(if <predicate-expression>

then <expression>+

[else <expression>+ ]) ;;else-part optional

(while <predicate-expression>

[do] <expression>* ]) ;;‘do’ not mandatory


Example – if-then-elseExample – if-then-else

(defrule special-age “18, 21, 100”(or (person (name ?name) (age ?age&18))

(person (name ?name) (age ?age&21)) (person (name ?name) (age ?age&100)))

=>(if (= ?age 18) then (printout t ?name “ can buy beer in Canada.”)

else (if (= ?age 21) then (printout t ?name “ can buy beer in the USA.”)

else(if (= ?age 100) then (printout t “The major will visit ” ?name ))...)


Rule Activation and Execution

Rule Activation and Execution

Pattern Matching, Rule Activation, Rule Execution

Conflict Set, Conflict Resolution, Strategies


Facts, Rules, Pattern Matching

Facts, Rules, Pattern Matching

Forward-chaining systems begin with an initial set of facts and in an inference process generate new facts until a goal state is reached.

Facts are entered into the Working Memory (WM).

The conditions of each rule are matched to these facts Pattern Matching (e.g. Rete Algorithm)

Rules whose conditions are satisfied are activated and entered on the agenda.


Rule ActivationRule Activation The pattern matching algorithm determines, in

which sequence rules are being activated, i.e. placed on the agenda.

In CLIPS, you cannot easily determine the sequence of rule activations.

Thus, do not write programs, which implicitly depend on a certain sequence of facts activating rules.


Conflict ResolutionConflict Resolution The set of activated rules on the agenda is called

the Conflict Set. Choosing which of the activated rules to fire next

is known as Conflict Resolution. A simple strategy is to select rules according to

the order, in which they are put on the agenda. CLIPS, for example, uses a stack (last-in first-out).

There are different types of Conflict Resolution Strategies.


Conflict Resolution StrategiesConflict Resolution Strategies

There are two categories of strategies: global strategies local strategies

Global Strategies are domain-independent and part of the Rule Interpreter/Inference Engine.

Local Strategies are domain-dependent and implemented as part of the Rule Base.


Conflict Resolution: Refractoriness

Conflict Resolution: Refractoriness

Refractoriness

Forward chainers typically implement a refractory conflict resolution strategy - once a rule is fired, it isn't used again on the same data


Conflict Resolution: SpecificityConflict Resolution: Specificity

Specificity:

Choose a rule with the most conditions or the most specific conditions ahead of a more general rule (prefer most specific knowledge instead of general knowledge)


Conflict Resolution: RecencyConflict Resolution: Recency

Recency:

Fire a rule first that is activated by a fact just added to Working Memory, i.e. fire most recently activated rule first ( focus on one line of reasoning, with all related facts and rules)


Explicit ControlExplicit Control

Salience Meta-Rules


SalienceSalience

We can use salience measures to prioritize rules.

CLIPS provides a built-in method for prioritizing rules:

(declare (salience value))

Salience values can range from -10000 to +10000. Default is 0.

We can thus force the execution of one rule over another. We can implement sequencing of rules.


Rule Prioritization in ClipsRule Prioritization in Clips

for example, consider the following rules... (forced order of execution)


Two Nifty RulesTwo Nifty Rules

(defrule fire-first(declare (salience 30))(priority first)

=> (printout t "Print First" crlf) )

(defrule fire-second(declare (salience 20))(priority second)

=>(printout t "Print Second" crlf) )


And One More... And One More...

(defrule fire-third

(declare (salience 10))

(priority third)

=>

(printout t "Print Third" crlf) )


Getting Ready to Run...Getting Ready to Run...

(assert (priority second))(assert (priority first))(assert (priority third))

(agenda)

30 fire-first: f-220 fire-second: f-110 fire-third: f-3For a total of 3 activations.


Running This...Running This...

The CLIPS agenda acts like a stack - last rule on, first fired

If salience were not used, the third rule, then the first, then the second would fire, due to the sequence of facts and activation of rules:

(assert (priority second))

(assert (priority first))

(assert (priority third))


Reasoning ControlReasoning Control

Classes of Rules


Categories of RulesCategories of Rules

Salience values are arbitrary; often what we want is that a certain class of rules are considered before others.

This can be built into the rules themselves using a kind of 'tag'

IF (status is check-for-emergencies) ....

and employed by setting a fact to allow various categories of rules to be selected - for example, asserting that the status is check-for-emergencies

Another rule can be implemented to change status to the next group of rules.


Categories ExampleCategories Example

(deffacts control-information

(phase detection)

(phase-after detection isolation)

(phase-after isolation recovery)

)


Categories ExampleCategories Example

(defrule change-phase(declare (salience -10))?phase <- (phase ?current-phase)(phase-after ?current-phase ?next-phase)

=> (retract ?phase)(assert (phase ?next-phase)

)

Context Limiting


Another Way...Another Way...

(deffacts control-information

(phase detection)

(phase-sequence isolation recovery detection))


Another Way...Another Way...

(defrule change-phase(declare (salience -10))?phase <- (phase ?current-phase)?list <- (phase-sequence ?next-phase $?other-phases)=> (retract ?phase ?list)(assert (phase ?next-phase)(assert (phase-sequence ?other-phases ?next-phase))

)


ExplanationExplanation

Note the $?other-phases

The $ operator causes the variable to be bound to several symbols (the remainder of the list of phases, in this case) rather than one. Note that the $ is not part of the variable name and isn't used later when referencing the variable.


ExplanationExplanation

This approach could be used in a monitoring or control system - forward reasoning is typically used in such systems because we get information, then want to see the ramifications of it (analyze, provide treatment, and so on)


Control: Meta-RulesControl: Meta-Rules

Meta-Rules

Use Meta-Rules to divide rules into classes. Choose one class over another at a given point.

This implements domain-dependent knowledge about which set of rules to use during reasoning.

CLIPS provides a Module-construct with similar effects.

© c. kemke control 1 comp 4200: expert systems dr. christel kemke department of computer science...

Documents

kemke control

strategies slide

general rule

rule execution conflict

rule base

mandatory slide

data slide

sequence of rule activations