TP d Intelligence Artificielle

Transcription

1 TP d Intelligence Artificielle Ce projet d intelligence artificielle consiste à représenter un environnement et à le sécuriser à l aide d un robot. Pour cela, le robot est équipé d un certain nombre de capteurs et est capable de se déplacer et de détecter les éléments autour de lui. Il dispose en plus de sondes qu il peut déposer et reprendre à volonté pour l aider à sécuriser le monde. L environnement à sécuriser est clos (il peut éventuellement être accessible de l extérieur par un nombre limité de portes) et peut contenir des obstacles que le robot peut déplacer, mais en aucun cas il ne peut voir derrière un obstacle ou une paroi. Enfin, le robot peut explorer le monde puis le sécuriser ou bien l explorer et le sécuriser simultanément. Pour réaliser ce projet, le choix du ou des langages nous a été laissé libre. Nous avons utilisé deux langages : Prolog et Java. Le langage Prolog nous sert à définir le monde à explorer et les différentes contraintes de déplacement du robot, tandis que le Java nous sert essentiellement à réaliser l interface graphique de notre monde et à interroger Prolog. Enoncé En plus des données qui figurent sur l énoncé du TP, nous avons ajouté quelques règles à suivre : - les sondes sont des points qui surveillent dans un rayon alentour de 1. - une sonde fait une case - le robot détruit les sondes s'il passe dessus - le robot se déplace selon un quadrillage dans les directions haut, bas, gauche, droite - les cloisons sont définies sur les intersections de cases et sont infranchissables - le robot possède des "pinces" et peut déplacer les obstacles avec lui - le robot ne voit pas ce qu'il y a derrière les obstacles - le robot doit vérifier qu'il est passé partout dans le monde - le robot place les sondes, et il en possède autant qu il le souhaite - il existe des portes de sortie (parois particulières) Prolog Prolog est un langage de programmation logique. Le but était de faire un langage de programmation qui permettait d'utiliser l'expressivité de la logique au lieu de définir pas à pas la succession d'instructions que doit exécuter un ordinateur. Prolog est utilisé dans de nombreux programmes d intelligence artificielle. Un des avantages de Prolog est d avoir ses syntaxe et sémantique très simples et claires (le but original était de procurer un outil pour les linguistes ignorant l informatique)

2 Une des particularités de prolog est que l'on peut construire une base de connaissance dans un ordre indéterminé. Prolog résoudra ensuite des séries de problèmes logiques. Nous avons donc réalisé la définition de notre monde en Prolog et Java ne fait qu interroger Prolog afin de savoir quels sont les déplacements possibles pour notre robot. Le programme Prolog comporte 2 parties : la base de faits et la base de règles. La base de faits (aussi appelée base de connaissances en IA) décrit tous les éléments présents dans notre monde : la position du robot à l état initial, les parois, les obstacles La base de règles comporte les différentes règles dont dispose notre monde, il s agit essentiellement de règles de déplacement de notre robot en fonction de la connaissance du monde. Constantes Notre programme Prolog utilise 4 constantes qui correspondent aux 4 directions de déplacement possibles : haut, bas, gauche et droite. La base de faits Notre base de faits comporte de nombreux prédicats que nous allons vous détailler ci-dessous : robot(nomrobot,coordx,coordy) : le robot nomrobot se trouve en (coordx,coordy). explore(coordx,coordy) : la case de coordonnées (coordx,coordy) a été explorée. obstacle(nomobstacle,coordx,coordy) : l obstacle nomobstacle se trouve en (coordx,coordy). possedeobstacle(nomrobot,nomobstacle,coordx,coordy) : le robot nomrobot se trouve en (coordx,coordy) et possède l obstacle nomobstacle. sonde(nomsonde,coordx,coordy) : la sonde nomsonde se trouve en (coordx,coordy). paroi(coordx1,coordy1,coordx2,coordy2) : une paroi se situe entre les cases (coordx1, coordy1) et (coordx2, coordy2). En effet, nous avons décidé de modéliser une case comme une intersection entre 2 cases, ce qui fait qu une paroi n a pas d épaisseur proprement dit. L affichage d une paroi sera expliqué dans la partie Java plus bas. porte(coordx1,coordy1,coordx2,coordy2) : une porte se situe entre les cases (coordx1, coordy1) et (coordx2, coordy2). Une porte n empêche pas le robot de voir ce qui se trouve derrière et le robot peut également passer par les portes. Une porte se trouve à l intérieur du monde. sortie(coordx1,coordy1,coordx2,coordy2) : une sortie se situe entre les cases (coordx1, coordy1) et (coordx2, coordy2). Une sortie est une porte particulière, qui donne sur le monde extérieur, qui empêche le robot de voir ce qui se trouve derrière et le robot ne peut pas passer par les sorties, car le monde est semi-fermé. Une sortie sépare notre monde du monde extérieur

3 La base de règles libre(x,y) :- not(robot(_,x,y)), not(obstacle(_,x,y)), not(possedeobstacle(_,_,x,y). Une case de coordonnée (X,Y) est libre si cette case ne possède ni de robot, ni d obstacle et ni de robot possédant un obstacle. Le prédicat mur prend en paramètres les coordonnées de 2 cases et renvoi vrai si une paroi ou une sortie infranchissable existe entre ses 2 cases. Ce prédicat permet de ne pas tester à chaque règle si il n y a pas de paroi ni de sortie : mur(x1,y1,x2,y2) :- paroi(x1,y1,x2,y2). mur(x1,y1,x2,y2) :- sortie(x1,y1,x2,y2). A noter que dans notre repère, l axe des abscisses va de gauche à droite et l axe des ordonnées de haut en bas comme suit : abscisses ordonnées Le prédicat peut_prendre possède 3 paramètres qui sont le nom du robot, le nom de l obstacle à prendre et la direction dans laquelle prendre cet obstacle (une des quatre constante de direction). peut_prendre(a,b,haut) :- robot(a,x,y), Y1 is Y-1, obstacle(b,x,y1), not(mur(x,y1,x,y)). Pour qu un robot puisse prendre un obstacle, il faut que le robot soit sur une case conjointe à celle de l obstacle, et qu il n y ait pas de mur entre les 2 cases. Dans cette règle, il s agit de vérifier si le robot peut prendre un obstacle situé au dessus de sa case, donc la coordonnée de l obstacle en ordonné doit être égale à Y-1 tandis que l abscisse du robot sera la même que celle de l obstacle. Il en est de même pour les 3 autres directions où seul le Y1 is Y-1 change. Le prédicat prend possède 3 paramètres qui sont les mêmes que la règle précédente. prend(a,b,haut) :- peut_prendre(a,b,haut),retract(robot(a,x,y)),y1 is Y-1, retract(obstacle(b,x,y1)),assertz(possedeobstacle(a,b,x,y)). Pour qu un robot prenne un obstacle, il faut que le robot puisse prendre cet obstacle. On supprime le robot et l obstacle de la base de faits et on ajoute le fait possedeobstacle. Il en est de même pour les 3 autres directions où seul le Y1 is Y-1 change. Le prédicat deposeob possède lui aussi 3 paramètres : le nom d un robot, le nom d un obstacle et enfin une direction : deposeob(a,b,haut) :- possedeobstacle(a,b,x,y), Y1 is Y-1, libre(x,y1), detruit(a,_), not(mur(x,y1,x,y)), retract(possedeobstacle(a,b,x,y)), assertz(obstacle(b,x,y1)), assertz(robot(a,x,y)). Pour qu un robot dépose un obstacle, cet objet doit être possédé par ce robot, la case voisine doit être libre (ici la case du dessus) et il ne doit pas y avoir de mur (paroi ou sortie) entre cette case libre et la case du robot et de son obstacle. Si ces conditions sont respectées, alors le fait - 3 -

4 possedeobstacle sera supprimé de la base de faits tandis que les faits robot et obstacle seront ajoutés. Si une sonde se trouvait sur la case ou sera posée l obstacle, elle sera supprimée au préalable. Si il s agit d une sonde à déposer, la règle utilisée deposesonde sera différente. Du fait que le robot possède un nombre de sondes illimitées, il n y a pas de fait à vérifier. Cependant, on vérifie tout de même qu il n y a pas d autre sonde placée à coté afin que celles-ci ne sécurisent pas la même zone : deposesonde(x,y) :- X1 is X-1, X2 is X+1, Y1 is Y-1, Y2 is Y+1, not(sonde(_,x1,y)),not(sonde(_,x2,y)), not(sonde(_,x,y1)), not(sonde(_,x,y2)),!,assertz(sonde(sondesecu,x,y)). Le prédicat detruit a deux paramètres : le nom d un robot et le nom d une sonde. Cette règle doit supprimer la sonde si elle se situe sur la même case que le robot. Cette règle doit donc être appelée après chaque déplacement du robot. detruit(a,b) :- robot(a,x,y),sonde(b,x,y),retract(sonde(b,x,y)). detruit(a,b) :- possedeobstacle(a,_,x,y), sonde(b,x,y), retract(sonde(b,x,y)). Une sonde est supprimée de la base si elle se trouve sur la même case qu un robot ou qu un robot possédant un obstacle. Le prédicat deplacable a deux paramètres : le nom d un robot et la direction du déplacement. Cette règle doit renvoyée vrai si le robot donné peut se déplacé dans la direction donnée. deplacable(a,haut) :- robot(a,x,y), Y1 is Y-1, libre(x,y1), not(mur(x,y1,x,y)). Pour qu un robot soit déplaçable, la case qu il veut atteindre doit être libre et il ne doit pas y avoir de mûr (paroi ou sortie) entre sa case et celle qu il veut atteindre. Cette règle ne fonctionne que si le robot ne possède pas d objet. Nous avons réalisé les mêmes règles pour le déplacement du robot qui possède un obstacle (deplacableob qui possède un paramètre supplémentaire avec le nom de l obstacle possédé) et le déplacement du robot sur une case où se trouve un obstacle (deplacableobstacle qui possède également 3 paramètres) : deplacableob(a,b,haut) :- possedeobstacle(a,b,x,y), Y1 is Y-1, libre(x,y1), not(mur(x,y1,x,y)). deplacableobstacle(a,b,haut) :- robot(a,_,_), peut_prendre(a,b,haut). Pour cette dernière règle, il suffit de vérifier la règle peut_prendre expliquée précédemment. Nous avons réalisé une règle peut_aller qui correspond à une disjonction des 3 règles deplacable vue ci-dessus qui n est utilisée que par Java pour connaître les différentes possibilités du robot à tout instant : peut_aller(a,haut) :- deplacable(a,haut). peut_aller(a,haut) :- deplacableobstacle(a,_,haut). peut_aller(a,haut) :- deplacableob(a,_,haut)

5 Cette règle renverra donc vrai si le robot A peut aller en haut. Nous avons fait de même pour les 3 autres directions. Enfin, la dernière règle que nous avons réalisée est se_deplace qui possède deux paramètres : le nom du robot à déplacer et la direction du déplacement. se_deplace(a,haut) :- deplacable(a,haut),!, retract(robot(a,x,y)), securise(x,y), Y1 is Y-1, assertz(robot(a,x,y1)), assertz(explore(x,y1)), detruit(a,_). Pour déplacer un robot dans une direction, il faut que celui-ci soit déplaçable dans la direction voulue (voir règle deplacable ci-dessus). Un robot est également déplaçable s il possède un obstacle ou s il veut aller sur une case où se trouve un obstacle, c est pourquoi nous testons également les règles deplacableob et deplacableobstacle en lieu et place de deplacable dans la règle précédente. Si le robot est déplaçable, alors on supprime de la base de faits le robot à sa position initiale (ou possedeobstacle) et on ajoute la nouvelle position du robot (respectivement possedeobstacle), le fait explore de la nouvelle case du robot et enfin on teste si une sonde était présente sur cette nouvelle case par la règle detruit. A noter également l appel à la règle securise(x,y) décrite plus loin dans la partie sécurisation. Voici les 2 autres règles se_deplace toujours pour la direction haut : se_deplace(a,haut) :- deplacableobstacle(a,b,haut),!,prend(a,b,haut), retract(possedeobstacle(a,b,x,y)),securise(x,y), Y1 is Y-1, assertz(possedeobstacle(a,b,x,y1)),deposeob(a,b,bas),assertz(explore(x,y1)), detruit(a,_). se_deplace(a,haut) :- deplacableob(a,b,haut), retract(possedeobstacle(a,b,x,y)),securise(x,y),y1 is Y-1, assertz(possedeobstacle(a,b,x,y1)),assertz(explore(x,y1)),detruit(a,_). Pour la première règle, si le robot est déplaçable sur une case possédant un obstacle, alors on prend cet obstacle, on supprime la fait possedeobstacle de la case courante pour ajouter le fait possedeobstacle sur la case située au dessus dans cette règle, puis on dépose l obstacle sur la case d où le robot arrive, donc dans la direction opposée. La seconde règle consiste à déplacer un robot vers le haut tout en possédant un obstacle, donc on supprime simplement de la base de faits possedeobstacle de la case courante pour l ajouter sur la nouvelle case. Cette dernière règle ne nous sert pas dans notre implémentation java

6 Sécurisation Deux modes de sécurisation de notre monde nous étaient possibles : l exploration du monde et sa sécurisation simultanée ou bien l exploration puis la sécurisation. Nous avons opté pour une sécurisation et une exploration simultanée ce qui permet un gain de temps pour le robot. Cette sécurisation se réalise par Prolog. À chaque déplacement du robot, nous faisons appel à la règle securise(x,y)qui, en fonction des éléments qui entourent la position du robot avant son déplacement, déposera ou non une sonde sur cette case. Voici la règle securise : securise(x,y) :- zoneasecuriser(x,y),!,deposesonde(x,y). securise(_,_). La règle zoneasecuriser sera détaillée ci-dessous, mais cette règle securise nous montre que si la zone est à sécuriser, alors le robot déposera une sonde, sinon la règle securise(_,_) renverra vrai ce qui permettra au robot de tout de même effectuer son déplacement. Il reste désormais à définir les zones à sécuriser. Une zone est à sécuriser lorsqu il s agit d un «passage» donnant sur une pièce ou d une issue sur le monde extérieur. Il s agit donc de placer des sondes devant : - les portes intérieures (porte) - les portes extérieures (sortie) empêchant à un intrus de rentrer dans notre monde - les parois lorsqu elles forment une ouverture. Voici une analyse des différentes possibilités : avec en bleu la case(x,y) à sécuriser, et représente les parois. On place donc une sonde lorsque le robot se trouve devant deux parois horizontales et une ouverture ou une paroi verticale, une paroi horizontale et une ouverture. Dans cet exemple, il s agit de vérifier si la zone est à sécuriser par rapport au monde situé au dessus de lui, mais il faut faire de même pour les 3 autres directions. Voici la règle que nous avons défini pour sécuriser au dessus : zoneasecuriser(x,y) :- X1 is X+1, porte(x,y,x1,y). // Une porte se trouve au dessus zoneasecuriser(x,y) :- X1 is X+1, sortie(x,y,x1,y). // Une sortie se trouve au dessus zoneasecuriser(x,y) :- X1 is X-1, X2 is X+1, Y1 is Y-1, paroi(x1,y1,x1,y), paroi(x2,y1,x2,y), not(paroi(x,y1,x,y)). // cas 1 représenté ci-dessus zoneasecuriser(x,y) :- X1 is X-1, X2 is X+1, Y1 is Y-1, paroi(x1,y1,x1,y), paroi(x,y1,x2,y1), not(paroi(x,y1,x,y)). // cas 2 représenté ci-dessus zoneasecuriser(x,y) :- X1 is X-1, X2 is X+1, Y1 is Y-1, paroi(x1,y1,x,y1), paroi(x2,y1,x2,y), not(paroi(x,y1,x,y)). // cas 3 représenté ci-dessus - 6 -

7 Voici 2 exemples de monde sécurisés par notre robot : Avec : notre robot dans sa position finale : les obstacles : les sondes placées par notre robot pour sécuriser le monde - 7 -

8 Java Tout ce qui concerne la connaissance du monde est implémenté dans la partie Prolog. Java va questionner Prolog pour récupérer des informations et afficher ce que le robot perçoit. La stratégie d exploration est réservée à Java. Les fichiers Jeu.java Contient la matrice d entiers qui représente la scène vue par le robot. Cette matrice évolue au fil de l exploration du monde et des réactions du robot. DamierPanel.java extends JPanel. Affiche la matrice d affichage du monde. Transforme la matrice d entiers du Jeu.java en images. Fenetre.java extends JFrame. C est le container qui reçoit l affichage de la matrice de Jeu.java. Main.java Lance la fenêtre et exécute l exploration du monde. C est lui qui décide quelle direction doit prendre le robot, en fonction des informations que lui renvoie Prolog. tp.java Classe statique. Effectue le lien avec Prolog. Contient des fonctions qui questionnent Prolog et récupèrent les informations du monde. Contient notamment : static int NB_LIGNES //nombre de lignes du monde static int NB_COLONNES//nombre de colonnes du monde static int TAILLE_VUE//la taille de la vue du robot Les fonctions d accès à Prolog Initialisation public static void chargerfichierprolog(string filename) On spécifie à Java quel fichier Prolog (.pl) sera utilisé par Sicstus. public static void remplirmatricefrombase() On charge les éléments de la base de faits qui serviront au lancement de l application : Le robot. public static void chargerrobot() On recherche le nom du robot. C est utile pour l interrogation dans Prolog après. Interrogation public static String localiser(string coord_x1,string coord_y1) Renvoie le prédicat de ce qui se trouve dans la case coord_x1, coord_y1. null si case vide. Peut être : robot, obstacle, sonde public static String localiser(vector coord_1, Vector coord_2) Renvoie le prédicat de ce qui se trouve entre les cases dont les coordonnées sont contenues dans les vecteurs coord_1 et coord_2. null si case vide

9 Peut être : paroi, porte, sortie public static Vector trouver2param(string predicat) public static Vector trouver4param(string predicat) Renvoie l ensemble des résultats de l interrogation de la base de faits Prolog, pour un prédicat. Exemple : trouver2param( obstacle ), renvoie la liste des obstacles trouver4param( paroi ), renvoie la liste des parois public static Vector trouverrobot(string nomrobot) Renvoie les coordonnées de la case où se situe le robot dont le nom est passé en paramètre. public static void vision(vector coord_robot) Met à jour la matrice d affichage java, en lui ajoutant les cases visibles depuis la position passée en paramètre. public static boolean explore(string coord_x,string coord_y) Renvoie vrai si la case coord_x, coord_y a déjà été visité par le robot. public static Vector deplacable(string nomrobot) Renvoie les directions possibles (haut, bas, gauche, droite) pour un déplacement de la part du robot dont le nom est passé en paramètre. Actions public static void deplacer(string nomrobot, String direction) Fait appel à la fonction se_deplace dans Prolog. Le robot nomrobot se déplace dans une direction (haut, bas, gauche, droite). La base de faits en est modifiée. Idée générale L algorithme de parcours On recherche tout d abord la position de robot et ajoute de sa capacité de vision à la matrice d'affichage Java. C est le point de départ. Java ne connaît que ça. On questionne Prolog pour savoir où se déplacer. Il fois que l on a décidé où aller, on assert la nouvelle position du robot dans prolog, on met à jour la matrice d affichage, et on se souvient des cases où on pouvait aller et où on a pas encore été (liste d attente). On affichage la nouvelle matrice (en tenant compte de la vision) et on recommence à questionner Prolog. On arrête lorsque l on estime avoir explorer toutes les cases. L algorithme variables : deplacement //sens du déplacement positionrobot // position du robot taillevision //taille de la vision du robot listeattente //case non visitées, dont on connait l'existence matrice //matrice d'affichage Java (ce que connait Java) chemin //chemin déjà parcouru (mémoire pour backtrack) - 9 -

10 algorithme : Debut positionrobot := trouverrobot() ajouter(matrice, positionrobot) repeter deplacement := null ajouter(matrice, vision(positionrobot, taillevision)) afficher(matrice) deplacable := questionnerprolog(deplacementpossible, positionrobot) //On regarde où est ce que Prolog dit qu'on peut se déplacer si (deplacable en haut) alors si non(case du haut deja exploree) alors ajouter(listeattente, case) deplacement = haut si (deplacable à droite) alors si non(case de droite deja exploree) alors ajouter(listeattente, case) deplacement = droite si (deplacable en bas) alors si non(case du bas deja exploree) alors ajouter(listeattente, case) deplacement = bas si (deplacable à gauche) alors si non(case de gauche deja exploree) alors ajouter(listeattente, case) deplacement = gauche //Si on peut se déplacer au moins dans une direction si deplacement!= null alors positionrobot := deplacerdansprolog(positionrobot,deplacement) retirer(listeattente,positionrobot) ajouter(chemin,position) sinon si vide(listeattente) alors Fin de l algorithme // on a tout parcouru sinon //On revient sur nos pas positionrobot := deplacerdansprolog(positionrobot, derniereposition(chemin)) retirer(listeattente,positionrobot) retirer(chemin, derniereposition(chemin)) Fin finrepeter tantque(nonvide(listeattente))

11 Explications On récupère les directions où peut se déplacer le robot. Dans l ordre des possibilités, il pourra aller à gauche puis en bas, puis à droite, puis en haut. Ainsi pour un parcours d une pièce vide, voici son parcours : Jaune : départ Bleu : arrivée Sur un exemple simple comme celui-ci, on peut constater deux intérêts à l algorithme. Tout d abord il finit, et ça c est important (quand la liste d attente est vide), et ensuite, il ne passe pas deux fois sur la même case. Sur cette exemple, le parcours optimal. En ajoutant des obstacles et des parois : Jaune : départ Bleu : arrivée Gris : obstacle ou paroi Chemin Vert : Chemin arrière (Back track) Cette illustration ne correspond pas tout à fait à notre algorithme qui, lorsque le robot rencontre un obstacle, le prend pour le mettre sur la case d où il provient. On peut tirer différentes conclusions de cet exemple qui met en évidence les points positifs et négatifs de notre algorithme : Points positifs - l algorithme fini - l algorithme est simple et rapide (pas de temps de perdu pour des calculs complexes) - le back tracking est présent mais pas omniprésent (4 fois) - 28 cases (plus de la moitié) sont explorées une et une seule fois. - Le maximum d exploration pour une même case est de 3 fois (2 cases concernées). C est très peu. Le robot évite de repasser au même endroit

12 Points négatifs - Dans certains cas de Back track, on aurait pu gagner quelques déplacements. On voit sans trop réfléchir que dans le coin bas-gauche et haut-droite de l exemple, on revient sur nos pas alors que l on pourrait coupé directement. 25 cases sont explorées deux fois (à cause du back track). Il faut relativiser en pensant que le back track est obligatoire donc il existe tout le temps des cases explorées plusieurs fois. Par contre, il est évident que certaines cases auraient pu n être explorée qu une seule fois. Il faut faire un choix entre rapidité d exécution et minimisation du nombre de cases parcourues. - La case bleue (arrivée) est explorée en dernier alors qu il aurait été préférable de l explorer au moment où on était en bas-droite. On aurait ainsi évité un back track important pour une seule case. Conclusion Ce TP nous a permis de mettre en œuvre un programme utilisant à la fois le langage Prolog spécifiquement pour réaliser l intelligence artificielle de notre robot, et le langage Java pour interroger Prolog et créer un affichage graphique. Notre programme réalise le travail demandé, à savoir explorer et sécuriser un monde clos. Cependant, si nous devions améliorer celui-ci, nous rajouterions un algorithme de parcours du plus court chemin afin de diminuer le nombre de déplacements de notre robot lorsqu il se trouve dans une zone ou tout exploré mais qu il lui reste d autres zones non explorées plus loin