Intro to Jess

Intro to Jess

The Java Expert System
Shell

By Jason Morris

Morris Technical Solutions

Quotable Quotes

Each problem that I solved
became a rule which served
afterwards to solve other
problems.


-

Rene Descartes

Quotable Quotes

As a rule we disbelieve all
the facts and theories for
which we have no use.

-

William James

Quotable Quotes

Hell, there are no rules here
--

we're trying to accomplish
something.


-

Thomas A. Edison

Quotable Quotes

Get your facts first, and then
you can distort them as much
as you please.


-

Mark Twain

Quotable Quotes

If the facts don't fit the
theory, change the facts.


-

Albert Einstein

Quotable Quotes

There are two rules
for success:



1) Never tell
everything you know.


-

Roger H. Lincoln


Quotable Quotes

Facts do not cease to
exist just because they
are ignored.


-

Aldous Huxley

Agenda

•
What are expert systems?

•
What are rule
-
based expert
systems?

•
Introduction to Jess

•
The Jess Language


5 minute break

Agenda

•
Scripting & The Jess API

•
Demo 1 : Design Pattern Expert

•
Demo 2 : Catalog Servlet

•
References and Further Study

•
Q & A

Expert Systems…

•
Are a branch of
artificial
intelligence
.

•
Simulate human reasoning in some
domain.

•
“Reason” by
heuristic

or
approximate methods.

•
Explain and justify solutions in
user
-
friendly terms.

Types Of Expert Systems

•
Neural Networks

•
Blackboard Systems

•
Belief (Bayesian) Networks


•
Case
-
Based Reasoning

•
Rule
-
Based Systems


Rule
-
Based Expert Systems

•
Originated from AI research in the
70s and 80s.

•
Problem data stored as
facts
.

•
“Reason” using IF…THEN…ELSE
rules.

•
Can “reason” deductively (forward
-
chaining) or inductively
(backward
-
chaining).

When to Use Rule
-
Based
Systems

•
Problem Domain

= narrow, well
-
understood domain theory

•
Knowledge Representation

= facts
and rules

•
Output

= recommendation

•
Explanation

= rule firing trace

•
Learning Ability

= generally no (but…)

Inference Process

1.
Rules and facts compared using
pattern matcher
.

2.
Matched rules
activated

into a
conflict set
.

3.
Conflict set resolved into
agenda

(process called
conflict resolution
).

4.
Rule engine
fires

on agenda.

5.
Engine cycles until
all

rules are
satisfied.

The Java Expert System Shell

•
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
-
Based Expert System
Architecture

•
Rule Base

(knowledge base)

•
Working Memory

(fact base)

•
Inference Engine

(rule engine)


Inference (Rule) Engines

•
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.

Inference Process

•
Match

the facts against the rules.

•
Choose

which rules to fire.

•
Execute

the actions associated
with the rules.

How Does Jess Work?

•
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

(ree
-
tee)
algorithm

to match patterns.

•
Rete network

= an interconnected
collection of nodes = working memory.


Jess Architecture Diagram

WORKING

MEMORY

RULE

BASE

EXECUTION

ENGINE

INFERENCE

ENGINE

PATTERN

MATCHER

AGENDA

Procedural Programming

•
Traditional programming (BASIC,
C, FORTRAN, Pascal, etc.).

•
Largely based on functions.

•
Programmer controls logic.

•
Sequential and deterministic.

•
Object
-
oriented programming is
procedural
within

object methods.

Declarative Programming

•
New programming paradigm
-

rules
.

•
Programmer does not really
control code
logic
.

•
Rule engine finds most efficient
“path” of code execution.

•
Replaces hard to maintain nested
IF…THEN…ELSE coding.


Wait a minute!

Well…yes and
no…but don’t worry,
Calvin!

What? I…I
can’t control
my code??

Thought Experiment…

•
Imagine writing a procedural/OOP
algorithm to solve a
jigsaw
puzzle
.

•
500+ pieces, different shapes and
colors.

•
Polymorphism
runs amok!

Yet we manage to solve the
puzzle…

Intuition and Rules

•
Dump the puzzle pieces on a card
table in no particular order.

•
Your brain
instinctively

begins to
apply rules to solve the puzzle!


•
What might this look like in code?



Intuitive Inferencing


(corner_found

(piece_is_corner)

=>

(
assert

corner
-
found)

(save_piece))




(edge_found

(piece_is_edge)

=>

(
assert

edge
-
found)

(save_piece))



Your brain
“knows” what to
do with a corner
piece …

… and an edge
piece.

What’s Going On…

•
Your brain recalls rules or
heuristics

to solve the problem.

•
Your brain
pattern
-
matches
,
prioritizes, and applies rules
according to the facts in memory.

•
A particular solution algorithm
emerges

as rules “fire” on facts.

The Jess Language

•
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.

Obligatory Tradition


(
printout

t “Hello PJUG
-
ers!” crlf)

Your very first Jess
program!


Lists in Jess

•
(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:

Jess Variables

•
Named containers that hold a
single value.

•
Untyped. Begin with a ? mark.

•
Can change types during lifetime.

•
Assigned using
bind

function.

Jess Variables and Lists

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!

Control Flow

•
foreach

•
if/then/else

•
while

•
apply

•
build

•
eval

•
progn

Common

Jess
-
specific

Jess Functions

(
deffunction

get
-
input()

“Get user input from
console.”

(
bind

?s (read))

(
return

?s))


Even functions are lists.

Jess Function Example

(
deffunction

area
-
sphere
(?radius)

“Calculate the area of a
sphere”

(
bind

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

(
return

?area))

Jess Function Example

(
printout

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

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

How do we use this in Jess?

Working With Facts

•
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
.

Jess Fact Types

•
Ordered

–

head only.

•
Ordered

–

single slot.

•
Unordered

–

multiple slot, like a
database record.

•
Shadow

–

slots correspond to
properties of a JavaBean.

Deftemplate

Used to define the structure of a fact.

(
deftemplate


pattern “A design pattern.”

(slot name)

(slot type (default
“creation”))

(slot intent)

(slot solution))

Asserting Facts

;; Asserting a new “pattern”
fact.

(
printout

t “Enter pattern
name:” crlf)

(
bind

?x getInput)

(
assert

pattern (name ?x))



Facts store the initial conditions.

All Kinds of Facts

;; 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))

Shadow Facts

•
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.

Jess Rules…

•
… 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.

Rule Syntax

•
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
.

Simple Rule Example

;; 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 Complex Rule

;; 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.

More Pattern and Control
Tools

•
Literal /
variable
constraints

•
Logical
conditional
tests

•
Predicate
functions

•
Salience

•
Modules

•
Defquery

•
Backward
-
chaining


matching

control and structure

Break Time!

Let’s take a quick 5
minute pause…

Scripting Java from Jess

•
You can
interactively

access all
Java APIs from Jess.

•
This makes exploring Java
somewhat easier and
immediate
.

•
No
code
,
compile
,
debug

cycle.

Scripting Java with Jess

(import javax.swing.*)

(import java.awt.*)

(import java.awt.event.*)

(set
-
reset
-
globals FALSE)

(defglobal ?*frame* = (new JFrame "Hello PJUG"))

(defglobal ?*button* = (new JButton "Click my
PJUG"))

(?*frame* setSize 500 300)

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

(?*frame* setVisible TRUE)

swingDemo.bat

Demo 1: PAT

(Pattern Analysis Tool)


•
PAT

is a simple decision
-
tree for
choosing a Java design
-
pattern.

•
Uses

an initial
interview

to
establish problem space.

•
Recommends

a GoF Java design
-
pattern to fit the available facts.


examples/pattern.clp

The Jess API

•
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 Rete (ree
-
tee) Object

•
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.


Using the Jess API…

…is
simple…all
you really do
need to do is
call one or
more Rete
methods …

try

{


Rete engine = new
Rete();

engine.executeCommand(

“printout t “Hello PJUG”
);

engine.run();

}

catch

(JessException je {}

Demo 2: Catalog Servlet

import

jess.*;

import

javax.servlet.*;

import

javax.servlet.http.*;

import

java.io.*;


public

abstract

class

BaseServlet
extends

HttpServlet {


public

void

doPost(HttpServletRequest
request, HttpServletResponse
response)
throws

IOException,
ServletException {


doGet(request, response);


}

}...

Here is an
example of a
Jess
application
running as a
Java servlet…

Pattern References

•
Shalloway
, A.,
Design Patterns
Explained
, Addison
-
Wesley, 2002

•
Gamma
, E. et. al.,
Design
Patterns: Elements of Reusable
Object
-
Orient Software
, Addison
-
Wesley, 1995

Expert Systems References

•
Friedman
-
Hill
, E. J.,
Jess In
Action
, Manning Press, 2003

•
Jackson
, P.,
Introduction to
Expert Systems
–

3
rd

Ed
., Addison
-
Wesley, 1999

•
Giarratano
, J.,
Expert Systems:
Principals and Programming
, PSW
-
Kent, 1989

Links

•
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.s
html

•
See Dr. Friedman
-
Hill’s
Jess in
Action

at:

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


For Further Study

•
CLIPS Expert System Shell

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

•
FuzzyJ Website

http://www.iit.nrc.ca/

IR_public/fuzzy/

fuzzyJToolkit2.html


Q & A

Thanks for your
attention, and I
hope that you
try Jess
!