MIA – TME 4

Download Report

Transcript MIA – TME 4 

1
MOTEUR DE PLANIFICATION STRIPS EN PROLOG
MIA – TME 4
Planification STRIPS en prolog
L’objectif de cette s´eances de TME est de programmer un moteur de planification STRIPS en
utilisant le langage Prolog.
1
Moteur de planification STRIPS en Prolog
Il s’agit de programmer l’algorithme de planification en chaˆınage arri`ere STRIPS vu en TD. On
rappelle que ce dernier se base sur trois ´el´ements : une pile de buts, un ´etat courant et un plan en
cours. Il s’agit de traiter la pile de buts avec les trois op´erations suivantes :
– Retrait : retirer le but s’il est d´ej`
a r´ealis´e dans la situation courante.
– D´eveloppement : remplacer le but par une action qui le r´ealiserait, en rajoutant les pr´econditions
de l’action avec celle-ci
– Ex´ecution : si le but est une action, l’ex´ecuter dans l’´etat courant, et mettre ainsi `a jour le plan
en cours et l’´etat courant avant de retirer l’action de la pile de buts.
Le seul point de choix de l’algorithme est donc l’op´eration de D´eveloppement. Il s’agira donc de bien
ce ce choix, en permettant des backtrack pour tester les autres options. En particulier, chaque action a
des param`etres qu’il faut instantier correctement. Le premier exercice se concentre sur l’instantiation
et le choix d’une action correcte pour un but donn´e. Nous verrons ensuite comment r´ealiser le moteur,
en traitant d’abord le d´eveloppement et les autres op´erations.
Exercice 1 - Choix et instantiation d’une action.
Une action sera repr´esent´ee par un fait action(Action, LPrecond, LDel, LAdd, LConstr), ou
Action est le nom de l’action (avec ses param`etres variables), LPrecond la liste de ses pr´e-conditions,
LDel la listes des pr´edicats retir´es par l’action, Ladd la liste des pr´edicats ajout´es par l’action et
LConstr la liste des contraintes sur les variables. Par exemple, on pourrait repr´esenter une action de
d´eplacement de X vers Y comme suit :
action(SeDeplacer(X,Y),[position(X)],[position(X)],[position(Y)],[X\=Y]).
L’id´ee est de choisir une action dont la liste LAdd contient un ´el´ement unifiable au but courant. Il
faut alors instantier le reste des variables et param`etres de l’action pour pouvoir l’appliquer. Pour ce
faire, on teste toutes les instantions des variables `a partir de l’´etat courant.
1. Programmer un pr´edicat diffs(+LVar, +LVal,-Diff) qui renvoie une liste Diff=LVal\LVar
correspondant `
a une instantiation (possiblement partielle) des variables de LVar, le backtrack
devant permettre de tester toutes les instantiations (quitte `a en avoir trop comme sur le 3`eme
exemple). Ainsi on doit obtenir :
?- diffs([p(X),q(X)],[p(a),q(b)],Res).
X = a, Res = [q(a)] ;
X = b, Res = [p(b)] ;
Res = [p(X),q(X)] ;
?- diffs([p(X),q(Y)],[p(a),q(b)],Res).
X = a, Y = b, Res = [] ;
X = a, Res = [q(Y)] ;
Y = b, Res = [p(X)] ;
Res = [p(X),q(Y)] ;
?- diffs([p(X),q(X)],[p(a),p(b),q(b)],Res).
X = a, Res = [q(a)] ;
X = b, Res = [] ;
Charg´es de TD/TME : BOURGNE Gauvain, BAZIN Alexandre
Responsable du cours : GANASCIA Jean-Gabriel
1
2
X = b, Res = [q(b)] ; ou
X = b, Res = [p(b)] ; ou
Res = [p(X),q(Y)] ;
APPLICATION ET TEST
X = b, Res = [] ;
X = b, Res = [] ;
On se servira du pr´edicat member(X,L).
2. Programmer un pr´edicat instantiate(+Act,+PreCond,+Etat,-RemainingPreCond) qui ´etant
donn´e une action Act avec une pr´e-condition PreCond, et un ´etat courant Etat, renvoie, pour
chaque instantiation compl`ete des variables de PreCond faite en s’appuyant sur l’´etat, la liste
RemainingPreCond des pre-conditions qu’il resterait `a assurer avant de pouvoir appliquer l’action
dans l’´etat courant.
On utilisera le pr´edicat Diffs/3 et le pr´edicat term variables(+T,-L), qui permet de r´ecup´erer
la liste L des variables (libres) qui apparaissent dans le terme T.
3. Programmer un pr´edicat checkConstr(+ConstraintList) qui n’est v´erifi´e que si toutes les
conditions/contraintes de la liste ConstraintList sont v´erifi´ees. Les contraintes sont donn´ees
sont la forme de conditions portant sur des variables, qu’on supposera avoir ´et´e instanci´ees `
a
une ´etape pr´ec´edente. On pourra utiliser le pr´edicat call(+C) pour v´erifier qu’une condition
C est v´erifi´ee. Dans notre exemple d’action de d´eplacement, par exemple, si l’on a d´ej`a tent´e
d’instantier les variables X et Y , la condition C=X\=Y a donc ´et´e instanti´ee en, par exemple
a\=b ou a\=a. Un appel `
a call(C) r´eussira dans le premier cas et ´echouera dans le second.
4. Programmer un pr´edicat trouverAction(+Etat,+But,-Act,-RemainingPreCond,-FullPreCond)
qui, ´etant donn´e un ´etat courant Etat, cherche une action Act permettant de r´ealiser le but
But, en donnant aussi les pr´e-conditions instanti´ees de cette action : aussi bien celles qui restent `a v´erifier vis `
a vis de l’´etat courant (RemainingPreCond) que les pr´e-conditions instanti´ees
compl`etes (FullPreCond).
Exercice 2 - Algorithme de planification.
1. Programmer un pr´edicat appliquerAction(+Etat, +Act, -NouvelEtat), qui d´etermine le nouvel ´etat NouvelEtat, obtenu en appliquant l’action Act `a l’´etat Etat. On pourra utiliser les
pr´edicats prolog subtract(L,Sub,LRes) et union(L1,L2,LRes) pour retrancher ou ajouter des
´el´ements `
a une liste.
2. Programmer un pr´edicat afficherOp(+Codeop, +Etat, +Buts, +Plan, +But) qui affiche une
´etape de r´esolution (Retrait, D´eveloppement ou Ex´ecution) avec les d´etails utiles au d´ebuggage.
3. Programmer un pr´edicat resoudre(+Etat,+Buts,+PlanCourant,-PlanFinal), qui trouve un
plan en fonction de l’´etat, de la listes de buts et du plan courant. Selon les cas, il applique l’une
des ´etapes de r´esolution possible. On peut l’´ecrire en une r`egle par type de r´esolution, plus une
r`egle de terminaison pour r´ecup´erer le plan final.
4. Programmer un pr´edicat plan(-Plan), qui trouve un plan permettant de rejoindre l’´etat final donn´e par le pr´edicat etat final(+F) en partant de l’´etat initial donn´e par le pr´edicat
etat initial(+I). Ces deux pr´edicats seront d´efinis ult´erieurement en fonction du probl`eme.
2
Application et test
Exercice 3 - Singe et banane simplifi´
e.
On consid`ere une version simple du probl`eme du singe et des bananes. Pour les constantes, on
a trois positions : a, b, c, un singe singe, une caisse caisse et des bananes bananes. Les pr´edicats
utilis´es pour repr´esenter les ´etats sont :
– position(O,L) indiquant que l’objet O (singe, caisse ou bananes) est `a l’emplacement L (a,b,
ou c).
– posssede(I,O) indiquant que l’individu I (singe) poss`ede l’objet O (bananes).
Initialement, le singe est en position a, les bananes en b et la caisse en c.
On definit 3 actions :
– d´
eplacer(P,Q) qui permet au singe d’aller de l’emplacement P `a l’emplacement Q.
Charg´es de TD/TME : BOURGNE Gauvain, BAZIN Alexandre
Responsable du cours : GANASCIA Jean-Gabriel
2
2
APPLICATION ET TEST
– pousser(U,V) qui permet au singe de pousser la caisse depuis l’emplacement U vers l’emplacement V. Le singe doit initialement ˆetre `a cˆot´e de la caisse (mˆeme emplacement).
– cueillir bananes(U) qui permet au singe de cueillir de cueillir des bananes `a l’emplacement
U en montant sur une caisse. Il faut pour cela que le singe et la caisse soit sous les bananes.
1. Ecrire un pr´edicat etat initial(+I), qui d´efinit l’´etat initial.
u le singe poss`ede les bananes.
2. Ecrire un pr´edicat etat final(+F), qui d´efinit l’´etat final o`
3. Ecrire les pr´edicats act(+Act, +Pre,+Ldel, +Ladd,+LContraintes) pour d´efinir les 3 actions
consid´er´ees.
4. Obtenir un plan en appelant le pr´edicat plan(P) d´efinit pr´ec´edemment. G´en´erer plusieurs plans
en backtrackant. Regarder l’influence de l’ordre des listes de pr´econditions dans les actions sur
l’ex´ecution de l’algorithme.
Exercice 4 - Singe et banane complet.
On prend maintenant la version du singe et des bananes vue en TD (avec des pr´edicats niveau,
des actions prendre et monteCaisse, etc...).
1. Ecrire un pr´edicat etat initial(+I), qui d´efinit l’´etat initial.
2. Ecrire un pr´edicat etat final(+F), qui d´efinit l’´etat final o`
u le singe poss`ede les bananes.
3. Ecrire les pr´edicats action(+Act, +Pre,+Ldel, +Ladd,+LContraintes) pour d´efinir les 3 actions consid´er´ees.
4. Obtenir des plans en appelant le pr´edicat plan(P) d´efinit pr´ec´edemment. Que constate-t-on ?
Comment l’expliquez vous ? Comment le corriger ?
5. Comparer votre algorithme avec l’algorithme propos´e en cours
(http://www-poleia.lip6.fr/ ganascia/MIA., t´el´echarger le fichier singe.pl). quels sont
les principales diff´erences ? Changer les actions et les pr´edicats d’´etats initiaux et finaux pour
mod´eliser le probl`eme du singe et des bananes dans sa version vue en TD, et ex´ecuter le programme.
Charg´es de TD/TME : BOURGNE Gauvain, BAZIN Alexandre
Responsable du cours : GANASCIA Jean-Gabriel
3