programming a knowledge based application l.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Programming a Knowledge Based Application PowerPoint Presentation
Download Presentation
Programming a Knowledge Based Application

Loading in 2 Seconds...

play fullscreen
1 / 52

Programming a Knowledge Based Application - PowerPoint PPT Presentation


  • 665 Views
  • Uploaded on

Programming a Knowledge Based Application Overview Rule-based Intelligent UI “Intelligence” (Knowledge-based system) Inference Engine Working Memory (Facts) Knowledge Base (Rules) Agenda User Interface Rule-based Intelligent UI Inference Engine Working Memory (Facts)

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Programming a Knowledge Based Application' - lotus


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
rule based intelligent ui
Rule-based Intelligent UI

“Intelligence”

(Knowledge-based system)

Inference Engine

Working

Memory

(Facts)

Knowledge

Base

(Rules)

Agenda

User Interface

rule based intelligent ui4
Rule-based Intelligent UI

Inference Engine

Working

Memory

(Facts)

Knowledge

Base

(Rules)

Agenda

User Interface

components of a rule based system 1
Components of a Rule-Based System (1)
  • FACT BASE or fact list represents the initial state of the problem. This is the data from which inferences are derived.
  • RULE BASE or knowledge base (KB) contains a set of rules which can transform the problem state into a solution. It is the set of all rules.
components of a rule based language 2
Components of a Rule-Based Language (2)
  • INFERENCE ENGINE controls overall execution. It matches the facts against the rules to see what rules are applicable. It works in a recognize-act cycle:
    • match the facts against the rules
    • choose which rules instantiation to fire
    • execute the actions associated with the rule
clips
CLIPS
  • CLanguage Integrated Production System
  • Public domain software
  • Supports:
    • Forward Chaining Rules based on Rete algorithm
    • Procedural Programming
    • Object-oriented programming (COOL)
  • Can be integrated with other C/C++ programs/applications
slide8
JESS
  • Java Expert System Shell
  • Inspired by CLIPS => forward chaining rule system + Rete algorithm
  • Free demo version available (trial period of 30 days)
  • Can be integrated with other Java code
production rules
Production Rules
  • Production rules were developed for use in automata theory, formal grammars, programming language design & used for psychological modeling before they were used for expert systems.
  • Also called condition-action, or situation-action rules.
  • Encode associations between patterns of data given to the system & the actions the system should perform as a consequence.
canonical systems
Canonical Systems
  • Production rules are grammar rules for manipulating strings of symbols.
  • Also called rewrite rules (they rewrite one string into another).
  • First developed by Post (1943), who studied the properties of rule systems based on productions & called his systems canonical systems.
  • He proved any system of mathematics or logic could be written as a type of production rule system.Minsky showed that any formal system can be realized as a canonical system.
example of a canonical system
Example of a Canonical System
  • Let A be the alphabet {a, b, c}
  • With axioms a, b, c, aa, bb, cc
  • Then these production rules will give all the possible palindromes (and only palindromes) based on the alphabet, starting from the above axioms.
    • (P1) $ -> a$a
    • (P2) $ -> b$b
    • (P3) $ -> c$c
example continued
Example continued
  • To generate bacab
  • P1 is applied to the axiom c to get aca
  • Then we apply P2 to get bacab
  • Using a different order gives a different result.
  • If P2 is applied to c we get bcb
  • If P1 is applied after we get abcba
production systems for problem solving
Production Systems for Problem Solving
  • In KB systems production rules are used to manipulate symbol structures rather than strings of symbols.
  • The alphabet of canonical systems is replaced by
    • a vocabulary of symbols
    • and a grammar for forming symbol structures.
rule based production systems
Rule-Based Production Systems
  • A production system consists of
    • a rule set / knowledge base / production memory
    • a rule interpreter / inference engine
      • that decides when to apply which rules
    • a working memory
      • that holds the data, goal statements, & intermediate results that make up the current state of the problem.
  • Rules have the general form

IF <pattern> THEN <action>

P1, …, Pm Q1, …, Qn

  • Patterns are usually represented by OAV vectors.
rules
RULES
  • General form: a  b

IF … THEN …

IF < antecedent, condition, LHS>

THEN <consequent, action, RHS>

  • Antecedent match against symbol structure
  • Consequent contains special operator(s) to manipulate those symbol structures
syntax of rules
Syntax of Rules
  • The vocabulary consists of
    • a set N of names of objects in the domain
    • a set P of property names that give attributes to objects
    • a set V of values that the attributes can have.
  • Grammar is usually represented by OAV triples

OAV triple is (object, attribute, value) triples

Example: (whale, size, large)

forward backward chaining
Forward & Backward Chaining
  • Production rules can be driven forward or backward.
  • We can chain forward from conditions that we know to be true towards problem states those conditions allow us to establish the goal; or
  • We can chain backward from a goal state towards the conditions necessary for establishing it.
  • Forward chaining is associated with ‘bottom-up’ reasoning from facts to goals.
  • Backward chaining is associated with ‘top-down’ reasoning from facts to goals.
forward backward chaining chaining

Concrete facts

Fact:

Saw dorsal

Fin

- NO

Fact:

Saw tail fin

-NO

Saw dorsal

Fin

- NO

Saw tail fin

-NO

and

Inferred:

Beluga

Goal:

Beluga

Forward Backward Chaining Chaining

facts

goal

palindrome example
Palindrome Example
  • If we have the following grammar rules

(P1) $ -> a$a

(P2) $ -> b$b

(P3) $ -> c$c

  • They can be used to generate palindromes  forward chaining

apply P1, P1, P3, P2, to c > aca aacaa caacaac -

  • Or they can be used to recognize palindromes  backward chaining

bacab matches the RHS of P2 but acbcb will not be accepted by any RHS

forward chaining
Forward Chaining

Determine

possible

rules to fire

Rule

base

Working

memory

Conflict set

Select

rule to

fire

Conflict

resolution

strategy

Fire

rule

Rulefound

No rule found

Exit if specified by the rule

Exit

Fig. based on http://ai-depot.com/Tutorial/RuleBased-Methods.html

chaining clips jess
Chaining & CLIPS/JESS
  • CLIPS and JESS uses forward chaining.
  • The LHS of rules are matched against working memory.
  • Then the action described in the RHS of the rule, that fires after conflict resolution, is performed.
palindrom example
Palindrom Example
  • To generate bacab
  • P1 is applied to the axiom c to get aca
  • Then we apply P2 to get bacab
  • Using a different order gives a different result.
  • If P2 is applied to c we get bcb
  • If P1 is applied after we get abcba
markov algorithm
Markov algorithm
  • A Markov algorithm (1954) is a string rewriting system that uses grammar-like rules to operate on strings of symbols. Markov algorithms have been shown to have sufficient power to be a general model of computation.
  • Important difference from canonical system: now the set of rules is ordered
palindrom example revisited
Palindrom example revisited
  • To generate bacab
  • P1 is applied to the axiom c to get aca
  • Then we apply P2 to get bacab
  • Using a different order gives a different result.
  • If P2 is applied to c we get bcb
  • If P1 is applied after we get abcba
making it more efficient
Making it more efficient
  • The Rete algorithm is an efficient pattern matching algorithm for implementing rule-based expert systems.
  • The Rete algorithm was designed by Dr. Charles L. Forgy of Carnegie Mellon University in 1979.
  • Rete has become the basis for many popular expert systems, including OPS5, CLIPS, and JESS.
rete algorithm
RETE algorithm

Creates a decision tree where each node corresponds to a pattern occurring at the left-hand side of a rule

Each node has a memory of facts that satisfy the pattern

Complete LHS as defined by a path from root to a leaf.

rete example

Rules: IF x & y THEN p

IF x & y & z THEN q

Rete example

x?

y?

z?

Pattern

Network

x?

y?

Join Network

p

q

8 nodes

(http://aaaprod.gsfc.nasa.gov/teas/Jess/JessUMBC/sld010.htm)

rete example30

Rules: IF x & y THEN p

IF x & y & z THEN q

Rete example

x?

y?

z?

Pattern

Network

Join Network

p

q

6 nodes

(http://aaaprod.gsfc.nasa.gov/teas/Jess/JessUMBC/sld010.htm)

rete example31

Rules: IF x & y THEN p

IF x & y & z THEN q

Rete example

x?

y?

z?

Pattern

Network

Join Network

p

q

5 nodes

(http://aaaprod.gsfc.nasa.gov/teas/Jess/JessUMBC/sld010.htm)

matching patterns
Matching Patterns
  • At each cycle the interpreter looks to see which rules have conditions that can be satisfied.
  • If a condition has no variables it will only be satisfied by an identical expression in working memory.
  • If the condition contains variables then it will be satisfied if there is an expression in working memory with an attribute-value pair that matches it in a way that is consistent with the way other conditions in the same rule have already been matched.
example of matching
Example of matching

(whale (species Beluga) (tail_fin NO)(dorsal_fin NO))

Matches the pattern (with variables)

(whale (species ?name) (tail_fin ?flukes) (dorsal_fin ?fin)

the working memory
The Working Memory
  • Holds data in the form of OAV vectors.
  • These data are then used by the interpreter to activate the rules.
  • The presence or absence of data elements in the working memory will trigger rules by satisfying patterns on the LHS of rules.
  • Actions such as assert or modify the working memory.
conflict resolution
Conflict Resolution
  • Production systems have a decision-making step between pattern matching & rule firing.
  • All rules that have their conditions satisfied are put on the agenda in CLIPS.
  • The set of rules on the agenda is sometimes called the conflict set.
  • Conflict resolution selects which rule to fire from the agenda.
  • Packages like CLIPS provide more than one option for conflict resolution
  • Sensibility (quick response to changes in WM) and Stability (continuous reasoning).
conflict resolution in clips
Conflict Resolution in CLIPS
  • First, CLIPS uses salience to sort the rules. Then it uses the other strategies to sort rules with equal salience.
  • CLIPS uses refraction, recency & specificity in the form of following 7 strategies:
    • The depth strategy
    • The breadth strategy
    • The simplicity strategy
    • The complexity strategy
    • The LEX strategy
    • The MEA strategy
    • It is possible also to set strategy to random
  • Syntax: (set-strategy <strategy>)
salience
Salience
  • Normally the agenda acts like a stack.
  • The most recent activation placed on the agenda is the first rule to fire.
  • Salience allows more important rules to stay at the top of the agenda regardless of when they were added.
  • If you do not explicitly say, CLIPS will assume the rule has a salience of 0.
    • a positive salience gives more weight to a rule
    • a negative salience gives less weight to a rule
refractoriness
Refractoriness
  • A rule should not be allowed to fire more than once for the same data.
  • Prevents loops
  • Used in CLIPS and JESS (need to (refresh) to bypass it)
example
Example
  • Simplified description of some varieties of cultivated apples:
rules41
Rules
  • The simple way – write standard if..then rules:

IF (color == red && size == large)

THEN variety = Cortland

We will need: 4 rules (+ rule(s) for asking questions) => minimum 5 rules

BUT: can do it in 2 rules in CLIPS/JESS

define template
Define Template

(deftemplate apple

(multislot variety (type SYMBOL) )

(slot size (type SYMBOL))

(slot color (type SYMBOL) (default red))

)

Other useful slot type: NUMBER

JESS note: in JESS multislots don’t have type

CLIPS allow both SYMBOL and STRING types, JESS – only STRING

assert facts
Assert Facts

(deffacts apple_varieties

(apple (variety Cortland) (size large) (color red))

(apple (variety Golden delicious) (size large) (color yellow))

(apple (variety Red Delicious) (size medium) (color red))

(apple (variety Granny Smith) (size large) (color green))

)

create rules rule 1
Create Rules – Rule 1

(defrule ask-size

(declare (salience 100)) ;NOTE: JESS don’t use salience

(initial-fact)

=>

(printout t “Please enter the apple characteristics :“  crlf)

(printout t “- color (red, yellow, green) : “)

(bind ?ans1 (read))

(printout t crlf “-size (large or medium) : “)

(bind ?ans2 (read))

(assert (apple (variety users) (color ?ans1) (size ?ans2)))

)

create rules rule 2
Create Rules – Rule 2

(defrule variety

(declare (salience 10)) ;JESS NOTE – take this out

(apple (variety users) (size ?s) (color ?c))

(apple (variety ?v&:(neq ?v users))(size ?s) (color ?c))

=>

(printout t “You’ve got a “ ?v crlf)

(halt)

)

run clips
Run CLIPS
  • Type the code in a file, save it (e.g. apples.clp)
  • start CLIPS (type clips or xclips in UNIX/LINUX)
  • do: File -> Load (in XCLIPS) or type

(load “apples.clp”)

  • when the file is loaded CLIPS will display:

defining deftemplate apple

defining deffacts apple_varieties

defining defrule ask-size +j

defining defrule variety +j+j

TRUE

run clips47
Run CLIPS
  • Type (reset) to put your initial facts in the fact base
  • CLIPS>(run)

Please enter the apple characteristics:

- color red, yellow, green: red

- size (large or medium) : large

You’ve got a Cortland

CLIPS> (exit)

run jess
Run JESS
  • UNIX command line:

java –classpath jess.jar jess.Main

  • Or start an applet console.html
  • Jess> (batch apples.clp)

TRUE

Jess> (reset)

TRUE

Jess> (run)

Please enter the apple characteristics:

- color red, yellow, green: red

- size (large or medium) : large

You’ve got a Cortland

2

Jess> (exit)

clips resources
CLIPS resources
  • Official CLIPS website (maintained by Gary Riley):

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

  • CLIPS Documentation:

http://www.ghg.net/clips/download/documentation

  • Examples:

http://www.ghg.net/clips/download/executables/examples/

integrating clips into c c
Integrating CLIPS into C/C++
  • Go to the source code
  • Replace CLIPS main with user-defined main (follow the instructions within the main)
  • #include “clips.h” in classes that will use it
  • Compile all with ANSI C++ compiler
resources for clips c integration
Resources for CLIPS C++ integration
  • CLIPS advanced programming guide
  • Anonymous ftp from hubble.jsc.nasa.gov directory pub/clips/Documents
  • DLL for CLIPS 5.1 for Windows at ftp.cs.cmu.edu directory pub/clips/incoming
  • Examples can be found also at http://ourworld.compuserve.com/homepages/marktoml/cppstuff.htm and http://www.monmouth.com/%7Ekm2580/dlhowto.htm
jess resources
JESS resources
  • http://herzberg.ca.sandia.gov/jess/
  • Includes instructions and examples for embedding JESS into a Java program (http://herzberg.ca.sandia.gov/jess/docs/61/embedding.html ) and or creating Java GUI from JESS (see http://herzberg.ca.sandia.gov/jess/docs/61/jessgui.html)