Introduction to CLIPS Expert System

CLIPS: Expert System Shell Motaz K. Saad College of IT – CS Dept.

What is expert system?
AN EXPERT SYSTEM (ES) IS A COMPUTER PROGRAM DESIGNED TO SIMULATE THE PROBLEM-SOLVING BEHAVIOR OF AN EXPERT IN A NARROW DOMAIN OR DISCIPLINE.

What is expert system? ARTIFICIAL INTELLIGENCE PROGRAMS Exhibit intelligent behavior by skillful application of heuristics make domain knowledge explicit and separate from the rest of the system KNOWLEDGE-BASED SYSTEMS Apply expert knowledge to difficult, real world problems EXPERT SYSTEMS

The structure of an expert system KNOWLEDGE BASE Domain Knowledge INFERENCE ENGINE General problem-solving knowledge FACTS RULES INTERPRETER SCHEDULER

Facts and Rules
A fact is a piece of information such as (color green)
Facts on their own are of only limited use.
The application of rules is necessary to develop a program capable of some useful function.

Rules
A rule is a formal way of specifying a recommendation, directive, or advice
A rule is expressed as
IF premise THEN conclusion
or
IF condition THEN action

Drawing inferences from rules
Forward chaining
In forward chaining, the reasoning proceeds from the IF part of the rule to the THEN part.
Backward chaining
In backward chaining, the reasoning proceeds from the THEN part to the IF part.

Expert system building tool
Programming language
An expert system can be implemented using a general purpose programming language. However, the programming languages LISP and PROLOG are typically used in expert systems implementation, in particular Artificial Intelligence applications. This is due to their capabilities in handling symbolic data efficiently.
Shells
A shell consists mainly of an inference engine and an editor to assist developers in building their knowledge base.

Shells vs. Programming languages

CLIPS: Expert System Shell
Rule-based expert systems are often known as production systems (CLIPS actually stands for C Language Integrated Production System).

The CLIPS Programming Tool
History of CLIPS
Influenced by OPS5 and ART
Implemented in C for efficiency and portability
Developed by NASA, distributed & supported by COSMIC
Runs on PC, Mac, also under UNIX and VAX VMS
CLIPS provides mechanisms for expert systems
A top-level interpreter
Production rule interpreter
Object oriented programming language
LISP-like procedural language

Components of CLIPS
Rule-Based Language
Can create a fact list
Can create a rule set
An inference engine matches facts against rules
Object-Oriented Language
Can define classes
Can create different sets of instances
Special forms allow you to interface rules and objects

Defining Facts
Facts can be asserted
CLIPS> (assert (today is sunday))
<Fact-0>
Facts can be listed
CLIPS> (facts)
f-0 (today is sunday)
Facts can be retracted
CLIPS> (retract 0)
CLIPS> (facts)

Managing Facts
Clearing all facts
CLIPS> (clear)
CLIPS> (facts)
Grouping facts - typically in a file (“today.clp”)
(deffacts today ; can be cleared with (undeffacts today)
(today is sunday)
(weather is warm)
)
After loading facts, assert with (reset)

Defining Rules
Rules have the following structure
(defrule rule-name optional-comment
optional-declaration
condition
...
condition
=>
action
...
action
)

An Example CLIPS Rule
(defrule sunday “Things to do on Sunday”
(salience 0) ; salience in the interval [-10000, 10000]
(today is Sunday)
(weather is sunny)
=>
(assert (chore wash car))
(assert (chore chop wood))
)
So, if fact list contains conditions, add assertions

Getting the Rules Started
The reset command creates a special fact
CLIPS> (load “today.clp”)
CLIPS> (facts)
CLIPS> (reset)
CLIPS> (facts)
f-0 (initial-fact) ...
(defrule start
(initial-fact)
=>
(printout t “hello”)
)

Tracing & Recording Things
Watch command can watch facts (and rules)
CLIPS> (watch facts)
CLIPS> (reset)
==> f-0 (initial-fact)
CLIPS> (retract 0)
<== f-0 (initial-fact)
Contents of dialog window can be sent to file
CLIPS> (dribble-on “dribble.clp”) ; any file name will do
...
CLIPS> (dribble-off “dribble.clp”)

Variables & Pattern Matching
Variables make rules more applicable
(defrule pick-a-chore
(today is ?day)
(chore is ?job)
=>
(assert (do ?job on ?day))
)
If conditions are matched, then bindings are used

Retracting Facts from a Rule
(defrule do-a-chore
(today is ?day) ; ?day must have a consistent binding
?chore <- (do ?job on ?day)
=>
(printout t ?job “ done”)
(retract ?chore)
)
We must assign a variable to item for retraction

Pattern Matching Details
One-to-one matching
(do ?job on ?day)
(do washing on monday)
Use of wild cards
(do ? ? monday)
(do ? on ?)
(do ? ? ?day)
(do $?)
(do $? monday)
(do ?chore $?when)

Using Templates
(deftemplate student “a student record”
(slot name (type STRING))
(slot age (type NUMBER) (default 18)))
CLIPS> (assert (student (name fred)))
(defrule print-a-student
(student (name ?name) (age ?age))
=>
(printout t name? “ is “ ?age)
)

Defining Functions in CLIPS
Uses a LISP or Scheme-like syntax
(deffunction function-name (arg ... arg)
action ... action)
(deffunction hypotenuse (?a ?b)
(sqrt (+ (* ?a ?a) (* ?b ?b))))
(deffunction initialize ()
(clear)
(assert (today is sunday)))

Defining Classes & Instances
Defining the class CAR
(defclass car
(is-a user)
(name)
(made-by))
Defining an instance of CAR
(make-instance corvette of car
(made-by chevrolet))

Concrete & Abstract Classes
Some classes only exist for inheritance purposes
Person Man Woman Jack Jill

Managing Instances
Commands to display instances
CLIPS> (instances)
[corvette] of car
CLIPS> (send [corvette] print)
[corvette] of car
(made-by chevrolet)
Command to group instances (in a file)
(definstances
(corvette of car (made-by chevrolet))
(thunderbird of car (made-by ford)))

Clearing & Resetting Instances
Deleting an instance
CLIPS> (send [corvette] delete)
Deleting all instances
CLIPS> (unmake-instance *)
Resetting creates an initial object
CLIPS> (reset)
CLIPS> (instances)
[initial-object] of INITIAL-OBJECT

Message Passing
The SEND function
(send [instance] message arg ... arg)
Converting from symbols to names
CLIPS> (symbol-to-instance-name corvette)
[corvette]
This is useful when SENDing from inside a rule

Limitations of CLIPS
Single level rule sets
in LOOPS, you could arrange rule sets in a hierarchy, embedding one rule set inside another
Loose coupling of rules and objects
rules can communicate with objects via message passing
rules cannot easily be embedded in objects, as in Centaur
CLIPS has no explicit agenda mechanism
the basic control flow is forward chaining
to implement other kinds of reasoning you have to manipulate tokens in working memory

Alternatives to CLIPS
Eclipse
has same syntax as CLIPS (both are based on ART)
supports goal-driven (i.e., backwards) reasoning
has a truth maintenance facility for checking consistency
can be integrated with C++ and dBase
new extension RETE++ can generate C++ header files
NEXPERT OBJECT
another rule- and object-based system
has facilities for designing graphical interfaces
has a ‘script language’ for designing user front-end
written in C, runs on many platforms, highly portable

The End! http://motaz.saad.googlepages.com

http://motaz.saad.googlepages.com	166
http://www.slideshare.net	148
http://translate.googleusercontent.com	8
http://jujo00obo2o234ungd3t8qjfcjrs3o6k-a-sites-opensocial.googleusercontent.com	6
http://64.233.189.132	1
http://74.125.153.132	1
http://static.slideshare.net	1
http://a0.twimg.com	1

Introduction to CLIPS Expert System

by Motaz Saad

Accessibility

Categories

Upload Details

Usage Rights

8 Embeds 332

Statistics

Introduction to CLIPS Expert System Presentation Transcript