; Expert Systems Expert Systems
Documents
Resources
Learning Center
Upload
Plans & pricing Sign in
Sign Out
Your Federal Quarterly Tax Payments are due April 15th Get Help Now >>

Expert Systems Expert Systems

VIEWS: 101 PAGES: 50

  • pg 1
									Expert Systems


      Chapter 7
Introduction to CLIPS
                                  7.5

Entering and Exiting CLIPS
A> CLIPS 
          CLIPS (V6.5 09/01/97)
CLIPS> exit
exit
CLIPS> (+ 3 4) 
7
CLIPS> (exit)
A>
                                                    7.6

                       Facts
   A “chunk” of information in CLIPS is
   called a fact.
   Facts consists of a relation name followed
   by zero or more slots and their associated
   values.
                  (person (name “John Q. Public”)
 The order in             (age 23)
which slots are           (eye-color blue)
  specified is            (hair-color black))
   irrelevant.
    Deftemplate Construct
Defining the list of valid slots for a given
relation name.
Analogous to a record structure in Pascal.
Format:
(deftemplate <relation-name> [<optional-comment>]
      <slot-definition>*)

<slot-definition> :
        (slot <slot-name> | ( multislot <slot-name>)
    Defining “person” fact
(deftemplate person “An example deftemplate”
       (slot name)
       (slot age)
       (slot eye-color)         The “person”
       (slot hair-color))         template

(person (name “John Q. Public”)
        (age 23)
        (eye-color blue)
                                The fact following
        (hair-color black))
                                  the format of
                                “person” template
          Multifield Slots
Slots of a fact that have been specified with
the slot keyword in their deftemplates are
allowed to contain only one value.
Which specified with multislot keyword are
allowed to contain zero or more values.
  Defining “person” fact
      with multislot
(deftemplate person “An example deftemplate”
  (multislot name)
  (slot age)                   Specifying
  (slot eye-color)              multislot
  (slot hair-color))

(person (name John Q. Public)
        (age 23)                  Multislot
        (eye-color blue)
        (hair-color brown))
           Ordered Facts
Facts with a relation name that has a
corresponding deftemplate are called deftemplate
facts.
Facts with a relation name that does not have a
corresponding deftemplate are called ordered
facts.
Whenever CLIPS encounters an ordered fact it
automatically creates an implied deftemplate for
that fact (as opposed to an explicit deftemplate,
created using the deftemplate construct).
Example:
  (number-list 7 9 3 4 20)
is equivalent to defining
  (deftemplate number-list (multislot values))
and then defining the fact as
  (number-list (values 7 9 3 4 20))
Cases where Ordered Facts
       are useful
Case 1: Facts consisting of just a relation name are
useful as flags and look identical regardless of
whether a deftemplate has been defined.
    (all-orders-processed)
Case 2: For facts containing a single slot, the slot
name is usually synonymous with the relation
name.
           (time (value 8:45))
can be changed to
           (time 8:45)
                              CONSTRUCT
                                    Is-a
                              DEFTEMPLATE
                Is-a                            IS-A

    IMPLIED                                        EXPLICIT
    DEFTEMPLATE                  FACT              DEFTEMPLATE
   Creates                               Is-a    Creates
                       Is-a                                     Is-a
      ORDERED                        DEFTEMPLATE
      FACT                           FACT
                                                       (deftemplate person
             Is-a
                                  Is-a                   (multislot name)
(number-list 7 9 3 4 20)                                 (slot age)
                                                         (slot eye-color)
              (person (name John Q. Public)              (slot hair-color))
                      (age 23)
                      (eye-color blue)
                      (hair-color brown))
                               CONSTRUCT
                                     Is-a
                               DEFTEMPLATE
                 Is-a                            IS-A

     IMPLIED                                        EXPLICIT
     DEFTEMPLATE                  FACT              DEFTEMPLATE
    Creates                               Is-a    Creates
                        Is-a                                     Is-a
       ORDERED                        DEFTEMPLATE
       FACT                           FACT
                                                        (deftemplate person
              Is-a
                                   Is-a                   (multislot name)
 (number-list 7 9 3 4 20)                                 (slot age)
                                                          (slot eye-color)
              (person (name John Q. Public)               (slot hair-color))
                      (age 23)
Relation Name
                      (eye-color blue)
                      (hair-color brown))
                              CONSTRUCT
                                    Is-a
                              DEFTEMPLATE
                Is-a                            IS-A

    IMPLIED                                        EXPLICIT
    DEFTEMPLATE                  FACT              DEFTEMPLATE
   Creates                               Is-a    Creates
                       Is-a                                     Is-a
      ORDERED                        DEFTEMPLATE
      FACT                           FACT
                                                       (deftemplate person
             Is-a
                                  Is-a                   (multislot name)
(number-list 7 9 3 4 20)                                 (slot age)
                                                         (slot eye-color)
            (person (name John Q. Public)                (slot hair-color))
                    (age 23)
        Fields      (eye-color blue)
                    (hair-color brown))
                              CONSTRUCT
                                    Is-a
                              DEFTEMPLATE
                Is-a                           IS-A

    IMPLIED                                       EXPLICIT
    DEFTEMPLATE                  FACT             DEFTEMPLATE
   Creates                              Is-a    Creates
                       Is-a                                    Is-a
      ORDERED                       DEFTEMPLATE
      FACT                          FACT

             Is-a
                           Slot                       (deftemplate person
                           Name Is-a                    (multislot name)
(number-list 7 9 3 4 20)                                (slot age)
                                                        (slot eye-color)
             (person (name John Q. Public)              (slot hair-color))
          Slots (age 23) blue)
                     (eye-color          Slot Value
                     (hair-color brown)) (a field)
                              CONSTRUCT
                                    Is-a
                              DEFTEMPLATE
                Is-a                            IS-A

    IMPLIED                                        EXPLICIT
    DEFTEMPLATE                  FACT              DEFTEMPLATE
   Creates                               Is-a    Creates
                       Is-a                                     Is-a
      ORDERED                        DEFTEMPLATE
      FACT                           FACT
                                                       (deftemplate person
             Is-a
                                  Is-a                   (multislot name)
(number-list 7 9 3 4 20)                                 (slot age)
                                                         (slot eye-color)
              (person (name John Q. Public)              (slot hair-color))
                      (age 23)
                      (eye-color blue)
                                                Multifield Slot
                      (hair-color brown))       Single-field Slot
                                            7.7
            Adding Facts
Syntax: (assert <facts>+)
Example:
CLIPS>
(deftemplate person
  (slot name)
  (slot age)
  (slot eye-color)
  (slot hair-color)) 
CLIPS>
(assert (person (name “John Q. Public”)
                   (age 23)
                   (eye-color blue)
                   (hair-color black))) 
<Fact-0>
CLIPS>
              Display the facts
    Syntax: (facts)
    Example:
     CLIPS> (facts) 
     f-0    (person (name “John Q. Public”)
                      (age 23)
Fact identifier,      (eye-color blue)
0: fact index         (hair-color black))
     For a total of 1 fact.
     CLIPS>
Asserting multiple facts with
        single assert
 (assert (person (name “John Q. Public”)
                  (age 23)
                  (eye-color blue)
                  (hair-color black))
         (person (name “Jane Q. Public”)
                  (age 26)
                  (eye-color green)
                  (hair-color red)))
          Removing Facts
Syntax: (retract <fact-index>+)
Example: John Q. Public can be removed
from the fact list with the command
  (retract 0)
and Jane can be removed by
  (retract 1)
Attempting to retract a nonexistent fact will
produce an error.
                                                 7.8

           Modifying Facts
Syntax: (modify <fact-index> <slot-modifier>+)
Example:
CLIPS> (modify 0 (age 24))
<Fact-2>
CLIPS> (facts) 
f-2          (person (name “John Q. Public”)
                        (age 24)
                        (eye-color blue)
    A new fact index is generated
                        (hair-color black))
For for a modified fact.
     a total of 1 fact.
CLIPS>
         Duplicating Facts
Works the same with modify but not
retracting the original fact.
Syntax: (duplicate <fact-index> <slot-modifier>+)
Example:
 CLIPS> (duplicate 2 (name “Jack S. Public”))
 <Fact-3>
 CLIPS> (facts) 
 f-2         (person (name “John Q. Public”)
                        (age 24)
                        (eye-color blue)
                        (hair-color black))
 f-3         (person (name “Jack S. Public”)
                        (age 24)
                        (eye-color blue)
                        (hair-color black))
 For a total of 2 facts.
 CLIPS>
                                                      7.9

                Debugging
Syntax: (watch <watch-item>)
The <watch-item> is one of the symbols facts,
rules, activations, statistics, compilations, focus, or
all.
By default, when CLIPS is first started,
compilations are watched and the remaining
watch items are not watched.
Example:
CLIPS> (facts 3 3) 
f-3           (person (name “Jack S. Public”)
                       (age 24)
                       (eye-color blue)
    Indicating that the fact
                       (hair-color black))
For ais being1retracted.
       total of fact.
CLIPS> (watch facts) 
CLIPS> (modify 3 (age 25)) 
<== f-3       (person (name “Jack S. Public”)
                       (age 24)
                       (eye-color blue)
                       (hair-color black))
 ==> f-4      (person (name “Jack S. Public”)
                       (age 25)
                       (eye-color blue)
                       fact
 Indicating that the (hair-color black))
     is being asserted.
<Fact-4>
CLIPS>
                                                 7.10

 Defining Initial Knowledge
It is convenient to be able to automatically
assert a set of facts instead of typing in the
same assertions from the top level.
Initial knowledge: facts that are known to
be true before running a program.
Groups of facts that represent initial
knowledge can be defined using the
deffacts construct.
        Deffacts Construct
Syntax:
(deffacts <deffacts name> [<optional comment>]
     <facts>*)
Example:
   (deffacts people “Some people we know”
      (person (name “John Q. Public”) (age 24)
                (eye-color blue) (hair-color black))
      (person (name “Jack S. Public”) (age 24)
                (eye-color blue) (hair-color black))
      (person (name “Jane Q. Public) (age 36)
                (eye-color green) (hair-color red)))
                              The reset command
    Reset                     removes all facts from
                              the fact list and then
CLIPS> (unwatch facts)       asserts the facts from
CLIPS> (reset)               existing deffacts
CLIPS> (facts)               statement.
f-0    (initial-fact)
f-1     (person (name “John Q. Public”) (age 24)
               (eye-color blue) (hair-color black))
f-2     (person (name “Jack S. Public”) (age 24)
               (eye-color blue) (hair-color black))
f-3     (person (name “Jane Q. Public) (age 36)
               (eye-color green) (hair-color red))
For a total of 4 facts.
CLIPS>
                Initial Fact
A new fact generated by the reset command
called initial-fact.
Upon startup, CLIPS automatically defines
the following two constructs:
   (deftemplate initial-fact)
   (deffacts initial-fact
          (initial-fact))
Even if no any deffacts statements defined,
a reset will assert the fact (initial-fact).
                                               7.11
                   Rules
Rules can be typed directly into CLIPS or
loaded in from a file of rules created by an
editor.
Example: pseudocode of plant monitoring
   IF the emergency is a fire
   THEN the response is
          to activate the sprinkler system
Representing emergency:
   (deftemplate emergency (slot type))
Representing response:
   (deftemplate response (slot action))
      Rule Representation
General format of a rule:
(defrule <rule name> [<comment>]
    <patterns>* ;Left-hand side (LHS)
    =>
   <actions>*)   ;Right-hand side (RHS)
Representing the rule:
   (defrule fire-emergency “An example rule”
          (emergency (type fire))
          =>
          (assert (response
                    (action activate-sprinkler-system))))
     Conditional Elements
After the rule header are zero or more
conditional elements (CEs).
The simplest type of CE is a pattern CE or
simply pattern.
Each pattern consists of one or more
constraints intended to match the fields of a
deftemplate fact.
                    Example
(defrule fire-emergency “An example rule”
       (emergency (type fire)) pattern         Conditional
       (emergency (type flood)) pattern Elements
       =>
       (assert (response
                 (action activate-sprinkler-system))))
      Rule without Pattern
If a rule has no patterns, the special pattern
(initial-fact) will be added as a pattern for the
rule.
Since the initial-fact deffacts is automatically
defined, any rules with no patterns on their
LHSs will be activated when a reset command
is performed since the (initial-fact) fact will
automatically be asserted.
Thus any rule without LHS patterns will be
placed on the agenda when a reset is
performed
                                                 7.12

       Program Execution
Syntax: (run [<limit>])
    limit: maximum number of rules to be fired
The facts asserted by a reset satisfy the
patterns of one or more rules and place
activations of these rules on the agenda.
Issuing the run command then begins
execution of the program.
    Displaying the Agenda
Syntax: (agenda)
Example:
CLIPS> (reset)
CLIPS> (assert (emergency (type fire))) 
<Fact-1>
CLIPS> (agenda)
0           fire-emergency: f-1
For a total of 1 activation.
CLIPS>
                     Run
(Example continue)
CLIPS> (run)
CLIPS> (facts)
f-0         (initial-fact)
f-1         (emergency (type fire))
f-2         (response action activate-sprinkler-system))
For a total of 3 facts.
CLIPS>
               Refraction
Refraction: Rules in CLIPS won’t fire more
than once for a specific set of facts.
Without refraction, expert systems would
always be caught in trivial loops.
If necessary, the rule can be made to fire
again by retracting the fact
(emergency (type fire))
and asserting it again.
       Refresh Command
Used to make the rule fire again.
Syntax: (refresh <rule-name>)
Example:
CLIPS> (agenda)
CLIPS> (refresh fire-emergency) 
CLIPS> (agenda) 
0           fire-emergency: f-1
For a total of 1 activation.
CLIPS>
      Watching Activations
Example:
CLIPS> (reset) 
CLIPS> (watch activations) 
CLIPS> (assert (emergency (type fire))) 
==> Activation 0           fire-emergency: f-1
<Fact-1>
CLIPS> (agenda) 
0           fire-emergency: f-1
For a total of 1 activation.
CLIPS> (retract 1) 
<== Activation 0           fire-emergency: f-1
CLIPS> (agenda) 
CLIPS>
         Watching Rules
CLIPS will print a message whenever a rule
is fired.
Example:
CLIPS> (reset) 
CLIPS> (watch rules) 
CLIPS> (assert (emergency (type fire))) 
==> Activation 0       fire-emergency: f-1
<Fact-1>
CLIPS> (run) 
FIRE      1 fire-emergency: f-1
CLIPS> (agenda) 
CLIPS>
  Displaying Construct List
Example:
CLIPS> (list-defrules) 
fire-emergency
For a total of 1 rule.
CLIPS> (list-deftemplates) 
initial-fact
emergency
response
For a total of 3 deftemplates.
CLIPS> (list-deffacts) 
initial-fact
For a total of 1 deffacts.
CLIPS>
                Pretty Print
Example:
CLIPS> (ppdefrule fire-emergency) 
(defrule MAIN::fire-emergency “An example rule”
     (emergency (type fire))
     =>
     (assert (response
                    (action activate-sprinkler-system))))
CLIPS> (ppdeftemplate response) 
(deftemplate MAIN::response
     (slot action))
CLIPS> (ppdeffacts initial-fact) 
CLIPS> (deffacts start-fact (start-fact)) 
CLIPS> (ppdeffacts start-fact) 
(deffacts MAIN::start-fact
     (start-fact))
CLIPS>
      Deleting Constructs
Example:
CLIPS> (undeffacts start-fact) 
CLIPS> (list-deffacts) 
initial-fact
For a total of 1 deffacts.
CLIPS> (undefrule fire-emergency) 
CLIPS> (list-defrules) 
CLIPS>
    Clearing all Constructs
Syntax: (clear)
Example:
CLIPS> (list-deffacts) 
CLIPS> (list-deftemplates) 
emergency
response                           After clearing, it
start-fact                       adds the initial-facts
For a total of 3 deftemplates.
CLIPS> (clear)                     deffacts to the
CLIPS> (list-deffacts)             environment.
initial-fact
For a total of 1 deffacts.
CLIPS> (list-deftemplates) 
initial-fact
For a total of 1 deftemplate.
CLIPS>
                  Printout
Syntax: (printout <logical-name> <print-items> *)
Example:         Stands for the standard
                 output
(defrule fire-emergency device of terminal.
    (emergency (type fire))
    =>
    (printout t “Activate the sprinkler system”
                  crlf))
Output:
“Activate the sprinkler system”
                          Carriage
                     return/Line feed
                                                      7.15

           Multiple Rules
(defrule fire-emergency
       (emergency (type fire))
       =>
       (printout t “Activate the sprinkler system”
                    crlf))
(defrule flood-emergency
       (emergency (type flood))
       =>
       (printout t “Shut down electrical equipment”
                    crlf))
  Rules with Multiple Patterns
(deftemplate extinguisher-system
       (slot type)
       (slot status))
(defrule class-A-fire-emergency
       (emergency (type class-A-fire))
       (extinguisher-system (type water-sprinkler)
                              (status off))
       =>
       (printout t “Activate water sprinkler” crlf))
(defrule class-B-fire-emergency
       (emergency (type class-B-fire))
       (extinguisher-system (type carbon-dioxide)
                              (status off))
       =>
       (printout t “Use carbon dioxide extinguisher” crlf))
                                              7.17

       Loading Constructs
Syntax: (load <file-name>)
Example:
CLIPS> (load “fire.clp”) 
Defining deftemplate: emergency
Defining deftemplate: response
Defining defrule: fire-emergency +j
TRUE
CLIPS>
If compilations are not being watched, then
the character *, %, and $ will be used for
defrules, deftemplates, and deffacts.
         Saving Constructs
Syntax: (save <file-name>)
Example:
(save “B:fire.clp”)
                   Comments
;* Programmer: G. D. Riley
; Deftemplates here
(deftemplate emergency (slot type))
;
;The purpose of this rule is to activate
; the sprinkler system if there is a fire
(defrule fire-emergency
        ; There is a fire emergency
        (emergency (type fire))
        =>
        ; Activate the sprinkler system
        (printout t “Activate the sprinkler system”
                      crlf))

								
To top