Intro to Jess The Java Expert System

Shell

By Jason MorrisMorris Technical Solutions

Agenda

• What are expert systems?• What are rule-based expert

systems?• Introduction to Jess• The Jess Language

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

• 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

WORKINGMEMORY

RULE BASE

EXECUTIONENGINE

INFERENCEENGINE

PATTERNMATCHER

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

(corner_found(piece_is_corner)=>(assert corner-found)(save_piece))

(edge_found(piece_is_edge)=>(assert edge-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 World!” crlf)(printout t “Hello World!” 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.” ;optional

(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

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)

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 {}

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, 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.shtml

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

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

For Further Study

• CLIPS Expert System Shellhttp://www.ghg.net/clips/CLIPS.html

Q & A

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