Recherche Artificielle:part2

							Résolution des problèmes et
 Algorithmes de recherche
          Demo VI




                              1
                  Intorduction

• Les algorithmes de recherche sont un mécanisme de
   résolution
général qui :
   – se déroule dans un espace appelé espace d'états.
   – explore systématiquement toutes les alternatives.
   – trouve la séquence d'étapes menant à la solution.
   – toute recherche orientée vers un but se déroule
   dans l'espace du problème (espace d'états).
   – toute recherche dans l'espace du problème
   constitue un modèle général de comportement
   intelligent.

                                                         2
• Méthodes aveugles :
      - Algorithme de recherche en profondeur
  d’abord.
      - Algorithme de recherche en largeur d’abord.

• Méthodes informées : Heuristiques
  - Recherche du meilleur d’abord



                                                      3
             EXEMPLES Les 8 reines:




• état initial: n'importe quel arrangement de 8 reines sur l'échiquier
• opérateurs: ajouter une reine sur n'importe quelle case
• test-but: 8 reines placées, absence d'attaque
• coût-chemin: pas applicable

                                                                         4
Algorithme de recherche en profondeur d’abord
             (Depth first search)


Principe : Pour trouver un chemin vers la solution Sol, à
partir d’un noeud N donné vers un noeud but :

– Si N est un noeud but alors Sol =[N], ou

– S’il existe un noeud N1 successeur de N tel qu’il
  existe un chemin Sol1 de N1 vers le noeud but, alors
  Sol = [N | Sol1].


                                                   5
3- Algorithme de recherche en profondeur d’abord
               (Depth first search)

                          a

                  b                   c

          d           e           f       g


     h        i               j       k




                                              6
Implentation Prolog de l’Algorithme de recherche en
     profondeur d’abord (Depth first search)

 • fi Prolog :
   solve(N,[N]) :- goal(N).
   solve(N,[N | Sol1]) :- s(N,N1), solve(N1,Sol1).

 • Recherche :?- solve(a,Sol)

 • Algorithme récursif ≡ prolog explore les alternatives en
   profondeur d’abord.



                                                              7
         Exemple profondeur d’abord : 8 reines
•   Noeuds : position des reines sur des files.
     – noeud initial : liste vide.
     – Noeud successeur : placer une autre reine sur la file suivante
       de telle façon qu’elle ne peut pas attaquer les reines existantes.
     – noeud but : position des 8 reines telle que chacune des 8 reines
       ne peut pas attaquer les autres.

Prolog : (les définitions éxactes des prédicats comme
   noattack/2 p. 103 Bratko)
s(Queens, [Queen | Queens]) :-
   member(Queen,[1,2,3,4,5,6,7,8]),
                               % place queen into any row
   noattack(Queen,Queens).
goal([_,_,_,_,_,_,_,_]).           % position with 8 queens

?- solve([], Solution).                                                     8
Recherche en profondeur d’abord évitant les
                  cycles



                         a

                 b                   c

         d           e           f       g


    h        i               j       k

                                             9
 Pb : L’algorithme de recherche en profondeur
d’abord fonctionne bien sauf dans le cas ou il y a
             un cycle sur le graphe.
Solution : Ajouter un mécanisme de détection de cycle :
 (Un nœud qui est déjà présent dans le chemin de recherche du nœud
   initial vers le nœud courant ne peut pas être pris en considération
   une 2eme fois.

fi depthfirst(Path, Node, Solution)

Path : chemin (liste de nœuds) entre le nœud initial et Node.
Node : état à partir duquel un chemin vers l’état but doit être trouvé.
Solution : Path étendu par Node vers le nœud but.

Prolog :
Path : liste dans l’ordre inverse des nœuds.

                                                                      10
Programme de recherche depthfirst évitant les
                 cycles

 solve(Node,Solution) :- depthfirst([],Node, Solution)
 % Solution est un chemin acyclique entre Node et le nœud but.


 depthfirst(Path,Node,[Node | Path]) :-goal(Node).
 depthfirst(Path,Node,Sol) :-
     s(Node,Node1),
     not member(Node1,Path),       %éviter le cycle
     depthfirst([Node | Path], Node1, Sol).
     % depthfirst(Path, Node, Solution) : extending the path [Node | Path] to
       a goal gives Solution



                                                                            11
    Recherche en profondeur limitée
Pb : Le programme (depthfirst) peut être perdu dans une recherche
   en profondeur infinie ≡ espace d’états infini.
   fi rater le noeud but en explorant indéfiniment un espace d’états
   infini tout en s’éloigant du but (pb des 8 reines).

• Solution : Pour éviter des branches infinies et non cycliques, on
  limite la profondeur de la recherche :
        depthfirst2(Node, Solution, Maxdepth).
fi La recherche ne peut pas aller au delà de la limite de la profondeur
  ≡ Décrémenter Maxdepth pendant chaque appel récursif /
  Maxdepth >= 0.



                                                                      12
 Programme de recherche en profondeur limitée


depthfirst2(Node,[Node],_) :- goal(Node).

depthfirst2(Node,[Node | Sol], Maxdepth) :-
Maxdepth > 0,
S(Node,Node1),
Max1 is Maxdepth -1,
depthfirst2(Node1, Sol, Max1).

% depthfirst2(Node,Solution, Maxdepth) : Solution est un
  chemin pas plus long que Maxdepth de Node vers le nœud
  but.


                                                       13
4. Algorithme de recherche en largeur d’abord
            (breadth first search)




                         a

                 b                   c

        d            e           f       g


   h         i               j       k

                                                14
       Algorithme de recherche en largeur d’abord
                 (breadth first search)

Principe : visiter les nœuds les plus proches du nœud de départ.

Implémentation : maintenir un ensemble de nœuds candidats a
  chaque étape (maintenir un ensemble de chemins).

breadthfirst (Paths,Solution)

Ævrai s’il y a un chemin de l’ensemble des chemins candidats
   pouvant être étendu vers les nœuds buts.
Solution: est un chemin étendu.
Paths: une liste de chemins.
Chaque chemin : liste de nœuds dans l’ordre inverse.

                                                                   15
      Algorithme de recherche en largeur d’abord
étant donné un ensemble de chemins candidats,

Initialisation: [[StartNode]]
1- si le top du premier chemin est un nœud but alors ce chemin est la
   solution        du problème.
   sinon
          – enlever le premier chemin de l’ensemble des chemins
                         candidats.
          – générer tous les chemins étendus d’un niveau possibles de
            ce chemin.
          – ajouter cet ensemble d’extension a la fin de l’ensemble des
            candidats.
          – aller à 1.



                                                                     16
                   Exemple de la figure :


1- [[a]]
2- [[b,a],[c,a]]
3- [[c,a],[d,b,a],[e,b,a]]
4- [[d,b,a],[e,b,a],[f,c,a],[g,c,a]]


• [[f,c,a],[g,c,a],[h,d,b,a],[i,e,b,a],[j,e,b,a]]
• La recherche rencontre le path [f,c,a] qui contient un
  nœud but f fi Solution


                                                           17
                 recherche en largeur d’abord
                     (breadth first search)
solve(Start, Solution):- breadthfirst([[Start]],Solution).
% Solution est le chemin du Start vers Goal.

breadthfirst([[Node | Path] | _],[Node | Path]):- goal(Node).
breadthfirst([Path | Paths], Solution):-
        extend(Path,NewPaths),
        conc(Paths,NewPaths,Paths1),
        breadthfirst(Paths1,Solution).
extend([Node | Path],NewPaths):-
        Bagof([NewNode,Node | Path],
        (s(Node,NewNode),not member(NewNode,[Node | Path])),
        NewPaths),
        !.
extend(Path,[]).         %bagof failed: Node has no successor

                                                                18
bagof : construire les extensions des chemins à un niveau.
conc : concaténation des listes.
member : l’algorithme prévoit la présence des cycles.




                                                             19
     Comparaison de 4 algorithmes :
  b = facteur de branchement
  d = profondeur de la solution
  dmax = limite de la profondeur pour l’algorithme
    de recherche depthfirst (d£dmax)
                               Time    Space   Shortest
                                               solution
                                               guaranteed
Breadthfirst                   bd      bd      yes
Depthfirst                     bdmax   dmax    no
Iterative deepening            bd      d       yes
Bidirectional, if applicable   bd/2    bd/2    yes
                                                            20