Mostly adopted from Jason Morris notes (Morris Technical Solutions)

eyelashesnectarineSoftware and s/w Development

Nov 3, 2013 (4 years and 4 days ago)

71 views

Mostly adopted from Jason Morris notes
(Morris Technical Solutions)


Developed at Sandia National Laboratories in
late 1990s.


Created by Dr. Ernest J. Friedman
-
Hill.


Inspired by the AI production rule language
CLIPS
.


Fully developed Java API for creating rule
-
based expert systems.


Rule Base

(knowledge base)


Working Memory

(fact base)


Inference Engine

(rule engine)



Pattern Matcher



decides what rules to fire
and when.


Agenda



schedules the order in which
activated rules will fire.


Execution Engine



responsible for firing rules
and executing other code.


Match

the facts against the rules.


Choose

which rules to fire.


Execute

the actions associated with the
rules.


Jess matches
facts

in the fact base to
rules

in the rule base.


The
rules

contain function calls that
manipulate the fact base and/or other Java
code.


Jess uses the
Rete

algorithm

to match
patterns.


Rete network

= an interconnected collection
of nodes = working memory.


WORKING

MEMORY

RULE

BASE

EXECUTION

ENGINE

INFERENCE

ENGINE

PATTERN

MATCHER

AGENDA


Architecturally inspired by CLIPS


LISP
-
like syntax.


Basic data structure is the
list
.


Can be used to script Java API.


Can be used to access JavaBeans.


Easy to learn and use.


(
printout

t “
Hello
Class!”
crlf
)

Your very first Jess
program!



(a b c)
; list of tokens


(1 2 3)
; list of integers


(+ 2 3)
; an expression


(“Hello world!”)
; a string


(foo ?x ?y)
; a function call

Here are some valid lists in Jess:


Named containers that hold a single value


Untyped


Begin with a ? mark


Can change types during lifetime


Assigned using
bind

function

EXAMPLE
: Adding two numbers


(
bind

?x 2)
; assign x = 2

(
bind

?y 3)
; assign y = 3

(
bind

?result (+ ?x ?y))
; find
sum

Everything is a list in Jess!

(
deffunction

get
-
input()

“Get user input from
console.”

(
bind

?s (read))

(
return

?s))


Even functions are lists.

(
deffunction

area
-
sphere
(?radius)

“Calculate the area of a
sphere”

(
bind

?area (* (* (pi) 2)(*
?radius ?radius)))

(
return

?area))

(
printout

t "The surface
area of a radius = 2 meter
sphere is " +

(area
-
sphere 2) + " m^2")

How do we use this in Jess?


Facts have a
head

and one or more
slots
.


Slots hold data (can be typed).


Multislots

can hold lists.


You can
modify

slot values at runtime.


Facts are constructed from
templates
.


Ordered



head only.


Ordered



single slot.


Unordered



multiple slot, like a database
record.


Shadow



slots correspond to properties of
a JavaBean.

Used to define the structure of a fact.

(
deftemplate


pattern “A design pattern.”

(slot name)

(slot type (default “creation”))

(slot intent)

(slot solution))

;; Asserting a new “pattern” fact.

(
printout

t “Enter pattern name:”
crlf
)

(
bind

?x
getInput
)

(
assert

(pattern (name ?x)))

Facts store the initial conditions.

;; An ordered fact with no
slots


a placeholder that
indicates state.

(assert(answer
-
is
-
valid))


;; A ordered fact of one slot

(assert(weightfactor 0.75))


defclass



creates a deftemplate from a
bean.


definstance



adds bean to working
memory.



Shadow facts are unordered facts
whose slots correspond to the
properties of a JavaBean.


… are the
knowledge
-
base

of the system.


… fire only
once

on a given set of facts.


… use
pattern constraints

to match facts.


… are much faster than
IF
-
THEN

statements.


Rules have a “left
-
hand” side (
LHS
) and a
“right
-
hand” side (
RHS
).


The LHS contains facts fitting certain
patterns
.


The RHS contains
function calls
.

;; A not very useful error handler

(
defrule

report
-
error


(error
-
is
-
present)

=>

(
printout

t “There is an error”
crlf))

Checking working memory state.

;; A more useful error handler

(
defrule

report
-
err

?err <
-

(is
-
error (msg ?msg))

=>

(
printout

t "Error was: " ?msg crlf)

(
retract

?err))

Using pattern bindings in rules.


You can
interactively

access all Java APIs
from Jess.


This makes exploring Java somewhat
easier and
immediate
.

(import
javax.swing
.*)

(import java.awt.*)

(import
java.awt.event
.*)

(set
-
reset
-
globals

FALSE)

(
defglobal

?*frame* = (new
JFrame

"Hello
You"))

(
defglobal

?*button* = (new
JButton

"Click
it"))

(?*frame*
setSize

500 300)

((?*frame*
getContentPane
) add ?*button*)

(?*frame*
setVisible

TRUE)


jess

-

inference engine “guts”.


jess.awt


GUI wrappers.


jess.factory
-

Allows extensions that “get
into the guts of Jess”.

Organized into 3 packages, 64
classes (not hard to learn)


The
reasoning engine

and the central class in
the Jess library.


Executes the built
Rete network
, and
coordinates many other activities.


Rete is essentially a
facade

for the Jess API.


It is simple. All you really need to do is to
make an instance of Rete and call one or
more Rete methods.

try

{


Rete

engine = new
Rete
();


engine.executeCommand
(
“printout t “Hello CS437”
);


engine.run
();

}

catch

(
JessException

je
){}


Download Jess at:

http://herzberg.ca.sandia.gov/jess/index.shtml


Join the Jess user community at:

http://herzberg.ca.sandia.gov/jess/mailing_list.shtml


See Dr. Friedman
-
Hill’s
Jess in Action

at:

http://www.manning.com/friedman
-
hill/



CLIPS Expert System Shell

http://www.ghg.net/clips/CLIPS.html


FuzzyJ Website

http://www.iit.nrc.ca/IR_public/fuzzy/fuzzyJToolkit2.html