Transcript Introduction to Jess: Rule Based Systems In Java

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 (forwardchaining) or inductively
(backward-chaining).
When to Use Rule-Based
Systems
• Problem Domain = narrow, wellunderstood 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. FriedmanHill.
• 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
INFERENCE
ENGINE
PATTERN
MATCHER
RULE
BASE
AGENDA
EXECUTION
ENGINE
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!
What? I…I
can’t control
my code??
Well…yes and
no…but don’t worry,
Calvin!
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
Your very first Jess
program!
(printout t “Hello PJUG-ers!” crlf)
Lists in Jess
Here are some valid lists in Jess:
• (a b c)
• (1 2 3)
• (+ 2 3)
• (“Hello
• (foo ?x
; list of tokens
; list of integers
; an expression
world!”) ; a string
?y) ; a function call
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
Everything is a list in Jess!
EXAMPLE: Adding two numbers
(bind ?x 2) ; assign x = 2
(bind ?y 3) ; assign y = 3
(bind ?result (+ ?x ?y)) ; find
sum
Control Flow
Common
Jess-specific
• foreach
• if/then/else
• while
• apply
• build
• eval
• progn
Jess Functions
Even functions are lists.
(deffunction get-input()
“Get user input from
console.”
(bind ?s (read))
(return ?s))
Jess Function Example
(deffunction area-sphere
(?radius)
“Calculate the area of a
sphere”
(bind ?area (* (* (pi) 2)(*
?radius ?radius)))
(return ?area))
Jess Function Example
How do we use this in Jess?
(printout t "The surface
area of a radius = 2 meter
sphere is " +
(area-sphere 2) + " m^2")
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
Facts store the initial conditions.
;; Asserting a new “pattern”
fact.
(printout t “Enter pattern
name:” crlf)
(bind ?x getInput)
(assert pattern (name ?x))
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
Shadow facts are unordered facts
whose slots correspond to the
properties of a JavaBean.
• defclass – creates a deftemplate
from a bean.
• definstance – adds bean to
working memory.
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
Checking working memory state.
;; A not very useful error handler
(defrule report-error
(error-is-present)
=>
(printout t “There is an error”
crlf))
A More Complex Rule
Using pattern bindings in rules.
;; A more useful error handler
(defrule report-err
?err <- (is-error (msg ?msg))
=>
(printout t "Error was: " ?msg crlf)
(retract ?err))
More Pattern and Control
Tools
matching
• Literal /
variable
constraints
• Logical
conditional
tests
• Predicate
functions
control and structure
•
•
•
•
Salience
Modules
Defquery
Backwardchaining
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 designpattern to fit the available facts.
examples/pattern.clp
The Jess API
Organized into 3 packages, 64
classes (not hard to learn)
• jess - inference engine “guts”.
• jess.awt – GUI wrappers.
• jess.factory - Allows extensions
that “get into the guts of Jess”.
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…
try {
Rete engine = new
Rete();
engine.executeCommand(
“printout t “Hello PJUG”);
engine.run();
}
catch (JessException je {}
…is
simple…all
you really do
need to do is
call one or
more Rete
methods …
Demo 2: Catalog Servlet
import
import
import
import
jess.*;
javax.servlet.*;
javax.servlet.http.*;
java.io.*;
Here is an
example of a
Jess
public abstract class BaseServlet
extends HttpServlet {
application
running as a
public void doPost(HttpServletRequest
request, HttpServletResponse
response) throws IOException, Java servlet…
ServletException {
doGet(request, response);
}
}...
Pattern References
• Shalloway, A., Design Patterns
Explained, Addison-Wesley, 2002
• Gamma, E. et. al., Design
Patterns: Elements of Reusable
Object-Orient Software, AddisonWesley, 1995
Expert Systems References
• Friedman-Hill, E. J., Jess In
Action, Manning Press, 2003
• Jackson, P., Introduction to Expert
Systems – 3rd Ed., Addison-Wesley,
1999
• Giarratano, J., Expert Systems:
Principals and Programming, PSWKent, 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!