Assuntos para 2Assuntos para 2oo exercício exercícioMétodos de Computação Métodos de Computação
InteligenteInteligente11oo semestre de 2002 semestre de 2002
Jacques RobinCIn-UFPE
Assuntos para o 2Assuntos para o 2oo exercício exercício
Tema do 2o exercício: sistemas especialistas Leitura: capítulos 15 e 16 de Prolog Programming for Artificial
Intelligence, 3rd Ed. de Ivan Bratko Tarefas:
Implementar um shell de sistema especialista com funcionalidades de:
Máquina de inferência Aquisição interativa de conhecimento Justificação das perguntas de aquisição Explicação de raciocínio
Implementar uma base de conhecimento brinquedo na linguagem de representação do conhecimento aceita pelo shell
Testar o shell com essa base de conhecimento Equipes de 4 alunos
Assuntos para o 2Assuntos para o 2oo exercício exercício
Sistema especialista baseado em redes bayesianas em Prolog, Flora, JEOPS ou Java
Sistema especialista combinando encadeamento de regras para frente e para trás em Prolog, Flora, JEOPS ou Java
Sistema especialista combinado frames com regras encadeadas para frente em Prolog ou Java
Sistema especialista combinado frames com regras encadeadas para trás em Prolog ou Java
2 equipes podem escolher o mesmo assunto, do momento que escolhem duas linguagens de programação diferentes
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência encadeando regrasinferência encadeando regras
Codificação da base de fatos• fact(TermoProlog).
Codificação da base de regras
• if P1 conj ... conj Pn then C onde
• P1 ... Pn e C são termos Prolog
• conj é and ou or
Codificação das consultas• forward deriva todos os fatos
Exemplo de base de conhecimentoif hallWet and kitchenDry then leakInBathroomif hallWet and bathroonDry then problemInKitchenif windowClosed or noRain then noWaterFromOutsideif problemInKitchen and noWaterFromOutside then leakInKitchen
Exemplos de consulta?- forwardDerive: problemInKitchenDerive: noWaterFromOutsideDerive: leakInKitchenNo more facts
?- is_true(leak_in_kitchen).yes
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência encadeando regrasinferência encadeando regras
Para frente::- op( 800, fx, if).:- op( 700, xfx, then).:- op( 300, xfy, or).:- op( 200, xfy, and).
forward :- new_derived_fact(P), !, write('Derived: '), write(P), nl, assert(fact(P)), forward ; write('No more facts').
new_derived_fact(Concl) :- if Cond then Concl, not fact(Concl), composed_fact(Cond). composed_fact(Cond) :- fact(Cond).
composed_fact(Cond1 and Cond2) :- composed_fact(Cond1),
composed_fact(Cond2). composed_fact(Cond1 or Cond2) :- composed_fact(Cond1) ;
composed_fact(Cond2).
Pata trás::- op( 800, fx, if).:- op( 700, xfx, then).:- op( 300, xfy, or).:- op( 200, xfy, and).
is_true( P) :- fact( P).is_true( P) :- if Condition then P, is_true( Condition). is_true( P1 and P2) :- is_true( P1),
is_true( P2).is_true( P1 or P2) :- is_true( P1) ; is_true( P2).
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência encadeando regras para trásinferência encadeando regras para trás
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência baseada em framesinferência baseada em frames
Codificação dos triplos <frame slot value>• fatos frame(Slot,Value).• com um predicado por cada frame do domínio
Codificação dos gatilhos • regras da forma: trigger(Frame,Value) :- ....• com um predicado trigger por cada gatilho do domínio
Associação dos triplos <frame slot trigger>• fatos frame(Slot, execute(gatilho(Frame,Value), Frame,Value)).• um por par <frame trigger> do domínio
Codificação das consultas• calcular valor de um slot de um frame
value(Frame, Slot,Value)
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência baseada em framesinferência baseada em frames
Hierarquia de conceitos:bird(a_kind_of, animal). albatross(a_kind_of, bird).kiwi(a_kind_of, bird).
Propriedades dos conceitos e default das
suas especializações e instâncias:bird(moving_method, fly).bird(active_at, daylight). albatross(colour, black_and_white).albatross(size, 115).kiwi(size, 40).kiwi(colour, brown).
Instâncias de conceitos:albert(instance_of, albatross).ross(instance_of, albatross).
Sobrescrita de propriedades default:kiwi(moving_method, walk). kiwi(active_at, night).albert(size, 120).ross(size, 40).
Gatilho: animal(relative_size,
execute(relative_size(Object, Value), Object, Value) ).relative_size(Object,RelativeSize) :- value(Object,size,Objsize), value(Object,instance_of,ObjClass), value(ObjClass,size,ClassSize), RelativeSize is ObjSize/ClassSize * 100.
Exemplo de consultas?- value(ross,moving_method,M).M = fly.?- value(ross,relative_size,R)R = 34.78.
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência baseada em framesinferência baseada em frames
% Valor declarada no próprio frame:value(Frame,Slot,Value) :- value(Frame,Frame,Slot,Value).
% Valor herdada do super conceito imediato:value(Frame,SuperFrame,Slot,Value) :- Query =.. [SuperFrame,Slot,Information], call(Query), process(Information,Frame,Value), !.
% Valor herdada de conceitos mais altos na hierarquia:
value(Frame,SuperFrame,Slot,Value) :- parent(SuperFrame,ParentSuperFrame), value(Frame,ParentSuperFrame,Slot,Value).
% Acessar super-conceito na hierarquia:parent(Frame,ParentFrame) :- (Query =.. [Frame,a_kind_of,ParentFrame] ; Query =..
[Frame,instance_of,ParentFrame]), call(Query).
% Information é derivada por um gatilhoprocess(execute(Goal,Frame,Value),Frame,V
alue) :- !, call(Goal).% Information é um valor declaradoprocess(Value,_,Value).
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência baseada redes bayesianasinferência baseada redes bayesianas
Codificação da estrutura da rede• predicado parent(ParentNode, Node)
Codificação das probabilidades da rede• predicado p(Node, PriorProbability)• predicado p(Node,
ListOfParentNodeValues, ConditionalProbability)i.e., p(N0 | N1 ... Nn)
Codificação das consultas a rede• predicado probs(Node, ListOfNodeValues
ConditionalProbability)i.e., p(N0 | N1 ... Nn)
Exemplo de rede:parent(burglary, sensor). parent(lightning, sensor). parent(sensor, alarm).parent(sensor, call).
p(burglary, 0.001).p(lightning, 0.02).p(sensor, [ burglary, lightning], 0.9).p(sensor, [ burglary, not lightning], 0.9).p(sensor, [ not burglary, lightning], 0.1).p(sensor, [ not burglary, not lightning],
0.001).p(alarm, [ sensor], 0.95).p(alarm, [ not sensor], 0.001).p(call, [ sensor], 0.9).p(call, [ not sensor], 0.0).
Exemplo de consulta:?- prob(burglary, [call, not lightning], P).P = 0.473934
Implementação Prolog de máquina de Implementação Prolog de máquina de inferência baseada redes bayesianasinferência baseada redes bayesianas
prob([X | Xs], Cond, P) :- !, prob(X, Cond, Px),
prob(Xs, [X | Cond], PRest), P is Px * PRest.prob([], _, 1) :- !. prob(X, Cond, 1) :- member(X, Cond), !. prob(X, Cond, 0) :- member(not X, Cond), !. prob(not X, Cond, P) :- !, prob(X, Cond, P0), P is 1 - P0.prob(X, Cond0, P) :- delete(Y, Cond0, Cond), predecessor(X, Y), !, prob(X, Cond, Px), prob(Y, [X | Cond], PyGivenX), prob(Y, Cond, Py), P is Px * PyGivenX / Py. prob(X, Cond, P) :- p(X, P), !.
% Coloca prob(X, Cond, P) :- !, findall((CONDi,Pi), p(X,CONDi,Pi), CPlist), sum_probs(CPlist, Cond, P).
% Calcula p(X|Cond) como somatórios nos % predecessores Si de X na rede de
% p(X|Si)*p(Si|Cond)sum_probs([], _, 0).sum_probs([(COND1,P1)|CondsProbs], COND,
P) :- prob(COND1, COND, PC1), sum_probs(CondsProbs, COND, PRest), P is P1 * PC1 + PRest.
% Busca por predecessores subindo na redepredecessor(X, not Y) :- !, predecessor(X, Y).predecessor(X, Y) :- parent(X, Y).predecessor(X, Z) :- parent(X, Y), predecessor(Y, Z).
% Predicados utilitáriosmember(X, [X | _]).member(X, [_ | L]) :- member(X, L).delete(X, [X | L], L).delete(X, [Y | L], [Y | L2]) :- delete(X, L, L2).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
Codificação das regras para o shell: RuleName :: if Condition then Conclusion, onde:
Condition é um termo Prolog Conclusion são termos Prolog conectados por and, or ou not
Codificação dos fatos para o shell: fact :: ShellFact onde: ShellFact é um fato Prolog ou uma regras Prolog
Sintaxe natural: Operadores Prolog podem ser usados para definir propriedades podem ser definidos e
aparecer nas regras e fatos do shell para tornar a aparência da base de conhecimento “mais natural”
Aquisição interativa dos fatos via o shell: askable(Term) indica que o termo Prolog Term é um dos fatos do shell cujo valor (os valores
das suas variáveis não instanciadas) pode ser pedido para o usuário durante o raciocínio
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás% Operadores de ‘sintaxe natural’:- op( 100, xfx, [ has, gives, 'does not', eats, lays, isa]).:- op( 100, xf, [ swims, flies]).
% Base de regrasrule1 :: if Animal has hair or Animal gives milk then Animal isa mammal.rule2 :: if Animal has feathers or (Animal flies and Animal lays eggs) then Animal isa bird.rule3 :: if Animal isa mammal and (Animal eats meat or (Animal has 'pointed teeth' and Animal has claws and Animal has 'forward pointing eyes' )
then Animal isa carnivore.rule4 :: if Animal isa carnivore and Animal has 'tawny color' and Animal has 'dark spots' then Animal isa cheetah.rule5 :: if Animal isa carnivore and Animal has 'tawny color' and Animal has 'black stripes'
then Animal isa tiger.rule6 :: if Animal isa bird and Animal 'does not' fly and Animal swims then Animal isa penguin.rule7 :: if Animal isa bird and Animal isa 'good flyer' then Animal isa albatross.
% Base de fatosfact :: X isa animal :- member( X, [cheetah, tiger, penguin, albatross]).askable( _ gives _, 'Animal' gives 'What'). askable( _ flies, 'Animal' flies).askable( _ lays eggs, 'Animal' lays eggs). askable( _ eats _, 'Animal' eats 'What').askable( _ has _, 'Animal' has 'Something'). askable( _ 'does not' _, 'Animal' 'does not' fly).askable( _ swims, 'Animal' swims). askable( _ isa 'good flyer', 'Animal' isa 'good flyer').member(X,[X | _]). member( X, [_ | Rest]) :- member( X, Rest).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás% Base de regrasbroken_rule :: if on(Device) and device( Device) and (not working(Device)) and connected( Device, Fuse) and proved( intact( Fuse))
then proved( broken( Device)).fuse_ok_rule :: if connected( Device, Fuse) and working( Device) then proved( intact( Fuse)).fused_rule :: if connected( Device1, Fuse) and on( Device1) and (not working( Device1)) and samefuse( Device2, Device1) and on( Device2) and (not working( Device2))
then proved( failed( Fuse)).same_fuse_rule :: if connected( Device1, Fuse) and connected( Device2, Fuse) and different( Device1, Device2) then samefuse( Device1, Device2).device_on_rule :: if working( Device) then on( Device).
% Base de fatosfact :: different( X, Y) :- not (X = Y).fact :: device( heater). fact :: device( light1). fact :: device( light2). fact :: device( light3).fact :: device( light4).fact :: connected( light1, fuse1). fact :: connected( light2, fuse1). fact :: connected( heater,
fuse1).fact :: connected( light3, fuse2). fact :: connected( light4, fuse2).askable( on(D), on('Device')). askable( working(D), working('Device')).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
Question, please:peter isa tiger.Is it true: peter has hair?yes.Is it true: peter eats meat?no.Is it true: peter has pointed teeth?yes.Is it true: peter has claws?why.To investigate, by rule3, peter is a
carnivore To investigate, by rule 5, peter is a tiger This was your question.Is it true: peter has claws?yes.Is it true: peter has forward pointing
eyes?yes.Is it true: peter has tawny colour?yes.Is it true: peter has black stripes?
yes.(peter is a tiger) is trueWould you like to see how?yes.peter is a tiger was derived by rule5 from peter isa carnivore was derived by rule3 from peter is mamamal was derived by rule1 from peter has hair was told and peter has pointed teeth was told and peter has claws was told and peter has forward pointing eyes was told and peter has tawny color was told and peter has black stripes was toldQuestion, please:
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
Predicados principais: expert: dispara o sistemas especialista explore(Goal,Trace,Answer):
dispara encadeamento de regras para trás para tentar provar objetivo Goal
guarda em Trace a lista dos objetivos intermediários que foram provados, junto a regra utilizada para prova cada um
guarda em Answer a árvore da prova de Goal
useranswer(Goal,Trace,Answer): caso Goal for askable, pergunta Goal para o
usuário caso a resposta a essa pergunta for yes or
no, instância Answer com essa resposta caso a resposta a essa pergunta for why,
apresenta Trace como respota usa getreply(Reply) para recuperar de
maneira robusta a resposta do usuário
present(Answer): apresenta Answer para o usuário como resposta a perguntas de tipo how?
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
% Operadores do shell:- op( 900, xfx, ::).:- op( 800, xfx, was).:- op( 870, fx, if).:- op( 880, xfx, then).:- op( 550, xfy, or).:- op( 540, xfy, and).:- op( 300, fx, 'derived by').:- op( 600, xfx, from).:- op( 600, xfx, by).:- op( 900, fy, not).
% Predicado driver do shellexpert :- getquestion(Question), (answeryes(Question) ;
answerno( Question)).
getquestion(Question) :- nl, write( 'Question, please '), nl,
read( Question).
answeryes(Question) :- markstatus( negative), explore( Question, [], Answer),
positive( Answer), markstatus( positive), present( Answer), nl, write('More solutions? '), getreply( Reply), Reply = no.
answerno( Question) :- retract(no_positive_answer_yet), !, explore( Question, [], Answer),
negative( Answer), present( Answer), nl, write('More negative solutions? '), getreply( Reply), Reply = no.
markstatus( negative) :- assert(no_positive_answer_yet).markstatus( positive) :- retract(no_positive_answer_yet), ! ; true.
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
explore(Goal,Trace, _) :- copy_term( Goal, Copy), member( Copy by Rule, Trace), instance_of( Copy, Goal), !, fail.
explore(Goal,Trace, Goal is true was 'found as a fact') :- fact :: Goal.
explore(Goal,Trace, Goal is TruthValue was 'derived by' Rule from Answer) :- Rule :: if Condition then Goal, explore( Condition, [Goal by Rule | Trace], Answer), truth( Answer, TruthValue).
explore( Goal1 and Goal2, Trace, Answer) :- !, explore( Goal1, Trace, Answer1), continue( Answer1, Goal1 and Goal2, Trace, Answer).
explore( Goal1 or Goal2, Trace, Answer) :- exploreyes( Goal1, Trace, Answer) ; exploreyes( Goal2, Trace, Answer).
explore( Goal1 or Goal2, Trace, Answer1 and Answer2) :- !, not exploreyes( Goal1, Trace, _), not exploreyes( Goal2, Trace, _), explore( Goal1, Trace, Answer1), explore( Goal2, Trace,
Answer2).
explore( not Goal, Trace, Answer) :- !, explore( Goal, Trace, Answer1), invert( Answer1, Answer).
explore( Goal, Trace, Goal is Answer was told) :- useranswer( Goal, Trace, Answer).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
exploreyes( Goal, Trace, Answer) :- explore( Goal, Trace, Answer), positive( Answer).
continue( Answer1, Goal1 and Goal2, Trace, Answer) :- positive( Answer1), explore( Goal2, Trace, Answer2), (positive( Answer2), Answer = Answer1 and Answer2 ; negative( Answer2), Answer =
Answer2 ).continue( Answer1, Goal1 and Goal2, _, Answer1) :- negative( Answer1).
truth( Question is TruthValue was Found, TruthValue) :- !.truth( Answer1 and Answer2, TruthValue) :- truth( Answer1, true), truth( Answer2, true), !, TruthValue = true ; TruthValue = false.
positive( Answer) :- truth( Answer, true).negative( Answer) :- truth( Answer, false).
invert( Quest is true was Found, (not Quest) is false was Found).invert( Quest is false was Found, (not Quest) is true was Found).
instantiated( Term) :- numbervars(Term, 0, 0).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
useranswer( Goal, Trace, Answer) :- askable( Goal, _), freshcopy( Goal, Copy), useranswer( Goal, Copy, Trace, Answer, 1).useranswer( Goal, _, _, _, N) :- N > 1, instantiated( Goal), !, fail. useranswer( Goal, Copy, _, Answer, _) :- wastold( Copy, Answer, _), instance_of( Copy, Goal), !. useranswer( Goal, _, _, true, N) :- wastold( Goal, true, M), M >= N.useranswer( Goal, Copy, _, Answer, N) :- end_answers( Copy), instance_of( Copy, Goal), !, not wastold( Goal, _, _), Answer = false. useranswer( Goal, _, Trace, Answer, N) :- askuser( Goal, Trace, Answer, N).
askuser( Goal, Trace, Answer, N) :- askable( Goal, ExternFormat), format( Goal, ExternFormat, Question, [], Variables), ask( Goal, Question, Variables, Trace, Answer, N).
ask( Goal, Question, Variables, Trace, Answer, N) :- nl, ( Variables = [], !, write( 'Is it true: ') ; write( 'Any (more) solution to: ')), write( Question), write('? '), getreply( Reply), !, process( Reply, Goal, Question, Variables, Trace, Answer, N).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
process( no, Goal, _, _, _, false, N) :- freshcopy( Goal, Copy), wastold( Copy, true, _), !, assertz( end_answers( Goal)), fail ; nextindex( Next), assertz( wastold( Goal, false, Next)).
format( Var, Name, Name, Vars, [Var/Name|Vars]) :- var( Var), !.format( Atom, Name, Atom, Vars, Vars) :- atomic( Atom), !, atomic( Name).format( Goal, Form, Question, Vars0, Vars) :- Goal =.. [Functor|Args1], Form =.. [Functor|Forms], formatall( Args1, Forms, Args2, Vars0, Vars), Question =.. [Functor|Args2], !.format( Goal, _, Question, Vars0, Vars) :- format( Goal, Goal, Question, Vars0, Vars).
formatall( [], [], [], Vars, Vars).formatall( [X|XL], [F|FL], [Q|QL], Vars0, Vars) :- formatall( XL, FL, QL, Vars0, Vars1), format( X, F, Q, Vars1, Vars).
askvars( []).askvars( [Variable/Name|Variables]) :- nl, write( Name), write( ' = '), read( Variable),
askvars( Variables).
showtrace([]) :- nl, write('This was your question'), nl.showtrace( [Goal by Rule | Trace]) :- nl, write( 'To investigate, by '), write( Rule), write( ', '), write( Goal), showtrace( Trace).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
instance_of( Term, Term1) :- copy_term( Term1, Term2), numbervars( Term2, 0, _), !, Term = Term2.
freshcopy( Term, FreshTerm) :- asserta( copy( Term)), retract( copy( FreshTerm)), !.
nextindex( Next) :- retract( lastindex( Last)), !, Next is Last + 1, assert( lastindex( Next)).
:- assert( lastindex( 0)), assert( wastold( dummy, false, 0)), assert( end_answers( dummy)).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
present( Answer) :- nl, showconclusion( Answer), nl, write( 'Would you like to see how?'), nl, getreply( Reply), ( Reply = yes, !, show( Answer) ; true ).
showconclusion( Answer1 and Answer2) :- !, showconclusion( Answer1), write( ' and '), showconclusion( Answer2).showconclusion( Conclusion was Found) :- write( Conclusion).
show( Solution) :- nl, show( Solution, 0), !. show( Answer1 and Answer2, H) :- !, show( Answer1, H), tab( H), write(and), nl, show( Answer2,
H).show( Answer was Found, H) :- tab( H), writeans( Answer), nl, tab( H), write( ' was '),
show1( Found, H). show1( Derived from Answer, H) :- !, write( Derived), write(' from'), nl, H1 is H + 4, show( Answer,
H1). show1( Found, _) :- write( Found), nl.
writeans( Goal is true) :- !, write( Goal).writeans( Answer) :- write( Answer).
getreply(Meaning) :- read( Reply), means( Reply, Meaning), ! ; nl, write('Answer unknown, try again please!'), nl, getreply( Meaning).
Implementação Prolog de shell de Implementação Prolog de shell de sistema especialista encadeando regras sistema especialista encadeando regras
para tráspara trás
means( why, why) :- !. means( w, why) :- !.means( yes, yes) :- !. means( y, yes) :- !.means( no, no) :- !. means( n, no) :- !.
member( X, [X|_]).member( X, [_|L]) :- member( X, L).
numbervars( Term, N, Nplus1) :- var( Term), !, Term = var/N, Nplus1 is N + 1.numbervars( Term, N, M) :- Term =.. [Functor | Args], numberargs( Args, N, M).
numberargs( [], N, N) :- !.numberargs( [X | L], N, M) :- numbervars( X, N, N1), numberargs( L, N1, M).