What is an Expert System?

An expert system is a computer system which may be able

Lecture 4: Expert Systems to perform as usefully as a human expert in areas such as:
• Interpretation of sensory data
• Planning actions
• Diagnosing faults or diseases and suggesting remedies
ACSC 368 • Configuring industrial components
• Teaching
• Control of industrial plant
Harris Papadopoulos
• Analysis of experimental results
• etc.

Real Life Expert Systems Components of an Expert System

Example Application
MYCIN Medical diagnosis • Knowledge-base
DENDRAL Molecular structure analysis
• Inference engine
MACSYMA, Symbolic differentiation and
SAINT, MATHLAB integration • Explanation generator
HEARSAY Speech understanding
R1 (XCON) Configuration of computer
• User-interface
components
plus lots more …

Architecture of an Expert System Advantages of Expert Systems

User
• Knowledge is independent of personnel
• Easy transfer of knowledge
User Explanation
Interface Generator • Knowledge is more predictable and consistent
• Cheaper to access than a human expert
Inference
• Knowledge is easier to document
Engine • Knowledge is made explicit
But
Knowledge Knowledge acquisition may be difficult
Base

1

Production Rules
We can represent some knowledge in the form of
production rules, of general form:
IF condition THEN action
where condition is a propositional expression, or a
well-formed formula in predicate logic. E.g.:
Factual Information and
Prolog Representation
We may also need factual information. E.g.:
EB-virus is classified as herpesvirus-4.
Herpesvirus-4 is transmitted by saliva.
In Prolog:

IF
patient has high temperature AND
patient has sore throat AND
patient’s heterophil-agglutination test is positive
THEN
patient has symptoms of being infected by EB-virus
viral_infection(Patient, ‘EB-virus’) :-
temperature(Patient, high),
symptoms(Patient, sore_throat),
test(Patient, heteroagglu, positive).
classify(‘EB-virus’, herpesvirus_4).
transmission(herpesvirus_4, saliva).

Specific Case Knowledge Inference Mechanisms

We may also need specific case knowledge, e.g. stored as The natural inference mechanism for Prolog is backward
frames: chaining, i.e. start from goal.
E.g. suppose we have the following knowledge base:
patient_details([name: N, age: A, occupation: O]).
A if B, C, D
test_results([blood: B,
B if E, F
munofluorescene: MF,
C if G
heteroagglu: HA,
microagglu: MA]). To discover A, find B, C and D
To discover B, find E and F
Variables represent slots to be filled with values when we To discover C, find G
have the information. D, E, F, G are data items supplied by the user.
This is goal-driven inference.

Inference Mechanisms (cont.) ‘How’ and ‘Why’ Explanations

Another inference mechanism is forward chaining, i.e.
start from data (facts). • ‘How’ explanations tell the user how the
E.g. suppose we have the same knowledge base:
system came up with a given solution; i.e.
A if B, C, D give the sequence of rules that were applied
B if E, F in order to get to the result.
C if G
and we have the facts D, E, F, G. • ‘Why’ explanations tell the user why a
G gives C particular piece of information is needed;
E and F give B i.e. display the rule which needs the
D with derived B and C give A
information in question.
This is data-driven inference.

2
 Limitations of Expert Systems
• Difficulty in capturing ‘deep’ knowledge of problem
domain. E.g. MYCIN lacks knowledge of human
physiology.
• Lack of robustness and flexibility. Humans can go back
to first principles.
• Inability to provide ‘deep’ explanations. Normally they
can only say what they did, not why they took the
particular approach.
• Difficulties in verification (e.g. 100s of rules, safety
critical applications …).
• Little or no learning from experience – performance
does not improve on its own.
Restaurant Knowledge-Base Facts
tobe_filled(your_favourites(X)).
tobe_filled(your_price(X)).
tobe_filled(your_location(X)).
specialities(‘Le Marecage’, [chicken, duck, frog]).
specialities(‘Le Grand Couteau’, [duck, frog, snake, snail]).
: close(‘Paris 18’, ‘Paris 17’).
average_price(‘Le Marecage’, cheap).
average_price(‘Le Grand Couteau’, expensive).
:
restaurant_location(‘Le Marecage’, ‘Clamart’).
restaurant_location(‘Le Grand Couteau’, ‘Paris 17’).
User Interface
expert :-
nl, write(‘Hello! I am an expert on Paris restaurants.’),
menu.
menu :-
nl, write(‘Choose your question:’),
nl, write(‘1 Which restaurant suits me best?’),
nl, write(‘2 Which restaurant serves my favourite
dishes?’),
nl, write(‘3 Which restaurant charges my prices?’),
nl, write(‘4 Which restaurant is close to me?’),
nl, write(‘5 Exit’),
nl, write(‘Please choose: ’), read(X), option(X).
Restaurant Knowledge-Base Rules
best_restaurant(X) :- serve_favourites(X), good_price(X),
close_location(X).
serve_favourites(X) :- your_favourites(Y),
specialities(X, Z), included(Y, Z).
good_price(X) :- your_price(Y), average_price(X, Y).
close_location(X) :- your_location(Y),
restaurant_location(X, Z), close(Y, Z).
included([], _).
included([H|T], L) :- member(H, L), included(T, L).
Restaurant Knowledge-Base Facts
(cont.)
:
close(X, X).
:
close(‘Paris 15’, ‘Paris 18’).
User Interface (cont.)
option(1) :- process(best_restaurant(X)), nl,
write(‘The restaurant that suits you best is ’),
write(X), menu.
option(2) :- process(serve_favourites(X)), nl,
write(‘The restaurant that serves your
favourites is ’), write(X), menu.
option(3) :- process(good_price(X)), nl,
write(‘The restaurant that charges your prices
is ’), write(X), menu.
option(4) :- process(close_location(X)), nl,
write(‘The restaurant that is closer to you is ’),
write(X), menu.
3
 User Interface (cont.)
option(5) :- retract(already_asked(X)),
retract(already_answered(Y)), fail.
option(5) :- nl, write(‘Goodbye!’).
option(X) :- out_of_range(X),
nl, write(‘No such option – please try again.’),
menu.
option(_) :- nl,
write('Sorry I cannot find such a restaurant'),
menu.
out_of_range(X) :- not(member(X, [1, 2, 3, 4, 5])).
More User Interface
ask_user(your_favourites(X)) :-
nl, write(‘Please list your favourite dishes, e.g.
[lobster, fish, clam] etc.’), nl, write(‘: ’), read(X).
ask_user(your_price(X)) :-
nl, write(‘What price band do you want to pay: cheap,
middle, or expensive?’), nl, write(‘: ’), read(X).
ask_user(your_location(X)) :-
nl, write(‘Where do you live?’), nl, write(‘: ’), read(X).
Extend User Interface
option(1) :- process(best_restaurant(X), Proof), nl,
write(‘The restaurant that suits you best is ’),
write(X), can_explain(Proof), menu.
option(2) :- process(serve_favourites(X), Proof), nl,
write(‘The restaurant that serves your favourites
is ’), write(X), can_explain(Proof), menu.
option(3) :- process(good_price(X), Proof), nl,
write(‘The restaurant that charges your prices
is ’), write(X), can_explain(Proof), menu.
option(4) :- process(close_location(X), Proof), nl,
write(‘The restaurant that is closer to you is ’),
write(X), can_explain(Proof), menu.
Inference Engine
Extend the Prolog meta-interpreter:
process(true) :- !.
process((Goal, Goals)) :- !, process(Goal), process(Goals).
process(Goal) :- clause(Goal, SubGoals),
process(SubGoals).
process(Goal) :- tobe_filled(Goal), Goal =.. [Pred, Arg],
already_asked(Pred), !,
already_answered(Goal).
process(Goal) :- tobe_filled(Goal), Goal =.. [Pred, Arg],
Goalx =.. [Pred, X], ask_user(Goalx),
assert(already_asked(Pred)),
assert(already_answered(Goalx)),
Goal = Goalx.
‘How’ Explanations
Extend the Prolog meta-interpreter:
process(true, ‘match with a fact’) :- !.
process((Goal, Goals), and(Proof, Proofs)) :- !,
process(Goal, Proof), process(Goals, Proofs).
process(Goal, by(Goal, Proof)) :-
clause(Goal, SubGoals), process(SubGoals, Proof).
process(Goal, by(Goal, user_given)) :-
tobe_filled(Goal), Goal =.. [Pred, Arg],
already_asked(Pred), !, already_answered(Goal).
process(Goal, by(Goal, user_given)) :- tobe_filled(Goal),
Goal =.. [Pred, Arg], Goalx =.. [Pred, X],
ask_user(Goalx), assert(already_asked(Pred)),
assert(already_answered(Goalx)), Goal = Goalx.
Extend User Interface (cont.)
can_explain(Proof) :-
nl, write(‘Do you want to know how, yes or no? ’),
read(X), explain_respond(X, Proof).
explain_respond(no, _).
explain_respond(yes, Proof) :-
explain(Proof, 2).
explain(by(Goal, Proof), Intent) :-
tab(Intent), write(Goal), write(‘ by ’),
explain_step(Proof, Intent).
explain(and(Proof1, Proof2), Intent) :-
explain(Proof1, Intent), nl, tab(Intent), write(‘and’),
nl, nl, explain(Proof2, Intent).
4
 Extend User Interface (cont.)
explain_step(‘match with a fact’, _) :-
!, write(‘match with a fact’), nl.
explain_step(user_given, _) :-
!, write(‘user given’), nl.
explain_step(Proof, Intent) :-
NewIn is Intent + 4, nl, nl, explain(Proof, NewIn).
‘Why’ Explanations (cont.)
Extend the Prolog meta-interpreter:
process(Goal, by(Goal, user_given), Rules) :-
tobe_filled(Goal), Goal =.. [Pred, Arg],
already_asked(Pred), !, already_answered(Goal).
process(Goal, by(Goal, user_given), Rules) :-
tobe_filled(Goal),
Goal =.. [Pred, Arg], Goalx =.. [Pred, X],
ask_user(Goalx, Rules), assert(already_asked(Pred)),
assert(already_answered(Goalx)), Goal = Goalx.
Extend ask_user (cont.)
respond(why, Goal, [Rule|Rules]) :- !, nl,
display_rule(Rule), nl, ask_user(Goal, Rules).
respond(why, Goal, []) :- !, nl,
write(‘No more explanation!’), nl, ask_user(Goal, []).
respond(Ans, Goal, Rules) :-
Goal =.. [Pred, Arg], Arg = Ans.
display_rule((Goal :- SubGoals)) :-
write(Goal), write(‘ :- ’), write(SubGoals).
‘Why’ Explanations
Extend the Prolog meta-interpreter:
process(true, ‘match with a fact’, Rules) :- !.
process((Goal, Goals), and(Proof, Proofs), Rules) :- !,
process(Goal, Proof, Rules),
process(Goals, Proofs, Rules).
process(Goal, by(Goal, Proof), Rules) :-
clause(Goal, SubGoals),
process(SubGoals, Proof, [(Goal :- SubGoals)|Rules]).
Extend ask_user
ask_user(your_favourites(X), Rules) :-
nl, write(‘Please list your favourite dishes, e.g. [lobster,
fish, clam] etc.’), nl, write(‘: ’), read(Y),
respond(Y, your_favourites(X), Rules).
ask_user(your_price(X), Rules) :-
nl, write(‘What price band do you want to pay: cheap,
middle, or expensive?’), nl, write(‘: ’), read(Y),
respond(Y, your_price(X), Rules).
ask_user(your_location(X), Rules) :-
nl, write(‘Where do you live?’), nl, write(‘: ’), read(Y),
respond(Y, your_location(X), Rules).
Extend option
option(1) :- process(best_restaurant(X), Proof, []), nl,
write(‘The restaurant that suits you best is ’),
write(X), can_explain(Proof), menu.
option(2) :- process(serve_favourites(X), Proof, []), nl,
write(‘The restaurant that serves your favourites
is ’), write(X), can_explain(Proof), menu.
option(3) :- process(good_price(X), Proof, []), nl,
write(‘The restaurant that charges your prices
is ’), write(X), can_explain(Proof), menu.
option(4) :- process(close_location(X), Proof, []), nl,
write(‘The restaurant that is closer to you is ’),
write(X), can_explain(Proof), menu.