Preliminary Introduction to JESS

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.

WORKINGMEMORY

RULE BASE

EXECUTIONENGINE

INFERENCEENGINE

PATTERNMATCHER

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)(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 PJUG"))

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

(?*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 Shellhttp://www.ghg.net/clips/CLIPS.html FuzzyJ Websitehttp://www.iit.nrc.ca/IR_public/fuzzy/fuzzyJToolkit2.html