Using Prolog's Inference Engine - PowerPoint PPT Presentation

Using prolog s inference engine l.jpg
Download
1 / 31

  • 393 Views
  • Uploaded on
  • Presentation posted in: Pets / Animals

Using Prolog's Inference Engine . From: Chapter 2, Building Expert Systems in Prolog , http://www.amzi.com/ExpertSystemsInProlog/xsipfrtop.htm. Contents. The Bird Identification System User Interface A Simple Shell Summary. The Bird Identification System .

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

Download Presentation

Using Prolog's Inference Engine

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


Using prolog s inference engine l.jpg

Using Prolog's Inference Engine

From: Chapter 2, Building Expert Systems in Prolog , http://www.amzi.com/ExpertSystemsInProlog/xsipfrtop.htm


Contents l.jpg

Contents

  • The Bird Identification System

  • User Interface

  • A Simple Shell

  • Summary

Using Prolog's Inference Engine


The bird identification system l.jpg

The Bird Identification System

  • A system which identifies birds will be used to illustrate a native Prolog expert system.

  • The expertise in the system is a small subset of that contained in Birds of North America by Robbins, Bruum, Zim, and Singer.

  • The rules of the system were designed to illustrate how to represent various types of knowledge, rather than to provide accurate identification.

Using Prolog's Inference Engine


Rule formats l.jpg

Rule formats

IF

first premise, and

second premise, and

...

THEN

conclusion

conclusion :-

first_premise,

second_premise,

...

Using Prolog's Inference Engine


Rules about birds l.jpg

Rules about birds

  • The most fundamental rules in the system identify the various species of birds.

  • We can begin to build the system immediately by writing some rules. Using the normal IF THEN format, a rule for identifying a particular albatross is:

bird(black_footed_albatross):-

family(albatross),

color(dark).

bird(whistling_swan) :-

family(swan),

voice(muffled_musical_whistle).

bird(trumpeter_swan) :-

family(swan),

voice(loud_trumpeting).

IF

family is albatross and

color is white

THEN

bird is laysan_albatross

bird(laysan_albatross) :-

family(albatross),

color(white).

Using Prolog's Inference Engine


Rules about birds6 l.jpg

Rules about birds

  • In order for these rules to succeed in distinguishing the two birds, we would have to store facts about a particular bird that needed identification in the program. For example if we added the following facts to the program:

family(albatross).

color(dark).

?- bird(X).

X = black_footed_albatross

Using Prolog's Inference Engine


Rules for hierarchical relationships l.jpg

Rules for hierarchical relationships

  • The next step in building the system would be to represent the natural hierarchy of a bird classification system.

  • These would include rules for identifying the family and the order of a bird.

order(tubenose) :-

nostrils(external_tubular),

live(at_sea),

bill(hooked).

order(waterfowl) :-

feet(webbed),

bill(flat).

family(albatross) :-

order(tubenose),

size(large),

wings(long_narrow).

family(swan) :-

order(waterfowl),

neck(long),

color(white),

flight(ponderous).

Using Prolog's Inference Engine


Rules for hierarchical relationships8 l.jpg

Rules for hierarchical relationships

nostrils(external_tubular).

live(at_sea).

bill(hooked).

size(large).

wings(long_narrow).

color(dark).

?- bird(X).

X = black_footed_albatross

Using Prolog's Inference Engine


Slide9 l.jpg

bird

lysan_albatros

black_footed_albatros

trumpter_swan

family(albatros)

color(white)

family(swan)

voice(loud)

family(albatros)

color(dark)

family(albatros)

family(swan)

order(tubenose)

live(at_sea)

bill(hooked)

color(white)

Relationships between some of the rules in the Bird identification system

order(waterfowl)

neck(long)

flight(ponderous)

Using Prolog's Inference Engine


Rules for other relationships l.jpg

Rules for other relationships

  • The Canada goose can be used to add some complexity to the system.

    • Since it spends its summers in Canada, and its winters in the United States, its identification includes where it was seen and in what season.

bird(canada_goose):- family(goose), season(winter), country(united_states), head(black), cheek(white).

bird(canada_goose):- family(goose), season(summer), country(canada), head(black), cheek(white).

Using Prolog's Inference Engine


Rules for other relationships11 l.jpg

Rules for other relationships

country(united_states):- region(mid_west).

country(united_states):- region(south_west).

country(united_states):- region(north_west).

country(united_states):- region(mid_atlantic).

country(canada):- province(ontario).

country(canada):- province(quebec).

region(new_england):- state(X), member(X, [massachusetts, vermont, ....]).

region(south_east):- state(X), member(X, [florida, mississippi, ....]).

bird(mallard):- family(duck), voice(quack), head(green).

bird(mallard):- family(duck), voice(quack), color(mottled_brown).

Using Prolog's Inference Engine


User interface l.jpg

User Interface

  • The system can be dramatically improved by providing a user interface which prompts for information when it is needed, rather than forcing the user to enter it beforehand.

  • The predicate ask will provide this function.

Using Prolog's Inference Engine


Attribute value pairs l.jpg

Attribute Value pairs

  • Before looking at ask, it is necessary to understand the structure of the data which will be asked about.

  • All of the data has been of the form: "attribute-value".

    • For example, a bird is a mallard if it has the following values for these selected bird attributes:

AttributeValue

family duck

voice quack

head green

Using Prolog's Inference Engine


Attribute value pairs14 l.jpg

Attribute Value pairs

  • This is one of the simplest forms of representing data in an expert system, but is sufficient for many applications.

  • More complex representations can have "object-attribute-value" triples, where the attribute-values are tied to various objects in the system.

  • Still more complex information can be associated with an object and this will be covered in the chapter on frames.

  • For now the simple attribute-value data model will suffice.

Using Prolog's Inference Engine


Asking the user l.jpg

Asking the user

  • The ask predicate will have to determine from the user whether or not a given attribute-value pair is true.

  • The program needs to be modified to specify which attributes are askable.

  • This is easily done by making rules for those attributes which call ask.

eats(X):- ask(eats, X).

feet(X):- ask(feet, X).

wings(X):- ask(wings, X).

neck(X):- ask(neck, X).

color(X):- ask(color, X).

  • Now if the system has the goal of finding color(white) it will call ask, rather than look in the program. If ask(color, white) succeeds, color(white) succeeds

Using Prolog's Inference Engine


Asking the user16 l.jpg

Asking the user

  • The simplest version of ask

ask(Attr, Val):- write(Attr:Val),write('? '), read(yes).

?- bird(X).

nostrils : external_tubular? yes.

live : at_sea? yes.

bill : hooked? yes.

size : large? yes.

wings : long_narrow? yes.

color : white? yes.

X = laysan_albatross

Using Prolog's Inference Engine


Asking the user17 l.jpg

Asking the user

  • There is a problem with this approach.

    • If the user answered "no" to the last question, then the rule for bird(laysan_albatross) would have failed and backtracking would have caused the next rule for bird(black_footed_albatross) to be tried.

    • The first subgoal of the new rule causes Prolog to try to prove family(albatross) again, and ask the same questions it already asked.

    • It would be better if the system remembered the answers to questions and did not ask again.

Using Prolog's Inference Engine


Remembering the answer l.jpg

Remembering the answer

ask(A, V):- known(yes, A, V), % succeed if true !. % stop looking

ask(A, V):- known(_, A, V), % fail if false !, fail.

ask(A, V):- write(A:V), % ask user write('? : '), read(Y), % get the answer asserta(known(Y, A, V)), % remember it Y == yes. % succeed or fail

Using Prolog's Inference Engine


Multi valued answers l.jpg

Multi-valued answers

  • The ask predicate now assumes that each particular attribute value pair is either true or false.

    • This means that the user could respond with a "yes" to both color:white and color:black.

  • In effect, we are letting the attributes be multi-valued.

    • This might make sense for some attributes such as voice but not others such as bill, which only take a single value.

Using Prolog's Inference Engine


Multi valued answers20 l.jpg

Multi-valued answers

  • The best way to handle this is to add an additional predicate to the program which specifies which attributes are multi-valued:

multivalued(voice).multivalued(feed).

Using Prolog's Inference Engine


Menus for the user l.jpg

Menus for the user

  • The user interface can further be improved by adding a menu capability which gives the user a list of possible values for an attribute.

  • It can further enforce that the user enter a value on the menu.

size(X):- menuask(size, X, [large, plump, medium, small]).

flight(X):- menuask(flight, X, [ponderous, agile, flap_glide]).

Using Prolog's Inference Engine


Menus for the user22 l.jpg

Menus for the user

can be implemented using a

sophisticated windowing interface

menuask(A, V, MenuList) :- write('What is the value for'), write(A), write('?'), nl, write(MenuList), nl, read(X), check_val(X, A, V, MenuList), asserta( known(yes, A, X) ), X == V.

check_val(X, A, V, MenuList) :- member(X, MenuList), !.

check_val(X, A, V, MenuList) :- write(X), write(' is not a legal value, try again.'), nl, menuask(A, V, MenuList).

Using Prolog's Inference Engine


A simple shell l.jpg

A Simple Shell

  • The bird identification program has two distinct parts:

    • the knowledge base, which contains the specific information about bird identification; and

    • the predicates which control the user interface.

  • By separating the two parts, a shell can be created which can be used with any other knowledge base.

    • For example, a new expert system could be written which identified fish.

    • It could be used with the same user interface code developed for the bird identification system.

Using Prolog's Inference Engine


A simple shell24 l.jpg

A Simple Shell

  • The minimal change needed to break the two parts into two modules is a high level predicate which starts the identification process.

top_goal(X) :- bird(X).

  • The shell has a predicate called solve, which does some housekeeping and then solves for the top_goal. It looks like:

solve :- abolish(known, 3), define(known, 3), top_goal(X), write('The answer is '), write(X), nl.

solve :- write('No answer found.'), nl.

Using Prolog's Inference Engine


A simple shell25 l.jpg

A Simple Shell

  • In summary, the predicates of the bird identification system have been divided into two modules. The predicates which are in the shell called Native, are:

solve - starts the consultation;

ask - poses simple questions to the users and

remembers the answers;

menuask - presents the user with a menu of choices;

supporting predicates for the above three predicates.

Using Prolog's Inference Engine


A simple shell26 l.jpg

A Simple Shell

  • The predicates which are in the knowledge base are:

top_goal - specifies the top goal in the knowledge base;

rules for identifying or selecting whatever it is the

knowledge base was built for (for example

bird, order, family, and region);

rules for attributes which must be user supplied (for

example size, color, eats, and wings);

multivalued - defines which attributes might have multiple values.

Using Prolog's Inference Engine


A simple shell27 l.jpg

A Simple Shell

  • To use this shell with a Prolog interpreter, both the shell and the birds knowledge base must be consulted. Then the query for solve is started.

?- consult(native).

yes

?- consult('birds.kb').

yes

?- solve.

nostrils : external_tubular?

Using Prolog's Inference Engine


Command loop l.jpg

Command loop

  • The shell can be further enhanced to have a top level command loop called go. To begin with, go should recognize three commands:

    • load - Load a knowledge base.

    • consult - Consult the knowledge base by satisfying the top goal of the knowledge base.

    • quit - Exit from the shell.

go :- greeting, repeat, write('> '), read(X), do(X), X == quit.

greeting :- write('This is the Native Prolog shell.'), nl, write('Enter load, consult, or quit at the prompt.'), nl.

do(load) :- load_kb, !.

do(consult) :- solve, !.

do(quit).

do(X) :- write(X), write('is not a legal command.'), nl, fail.

Using Prolog's Inference Engine


Command loop29 l.jpg

Command loop

  • Two other commands which could be added at this point are:

    • help - provide a list of legal commands;

    • list - list all of the knowns derived during the consultation (useful for debugging).

load_kb :- write('Enter file name: '), read(F), reconsult(F).

Using Prolog's Inference Engine


Slide30 l.jpg

User interface

go

ask

menuask

Major predicates of Native Prolog shell

Inference

engine

solve

load

Knowledge

base

top_goal

rules

multi_valued

askable

Working

storage

known

Using Prolog's Inference Engine


Command loop31 l.jpg

Command loop

  • Using an interpreter the system would run as follows:

?- consult(native).

yes

?- go.

This is the native Prolog shell.

Enter load, consult, or quit at the prompt.

>load.

Enter file name: 'birds.kb'.

>consult.

nostrils : external_tubular ? yes.

...

The answer is black_footed_albatross

>quit.

?-

Using Prolog's Inference Engine


  • Login