Vous êtes sur la page 1sur 64

Chapitre 3:Résolution de

problèmes
Algorithmes de recherche arborescente

Aymen Ayari
Email : aymen.ayari@gmail.com
GLSI 2
AU: 22-23
Plan
 IA comme agents intelligents (Rappel)
 Résolution de problèmes : Quels problèmes
? Quelles méthode ?
 Techniques de recherche non informée
 En largeur d’abord
 En profondeur d’abord
 Retour en arrière
 Techniques de recherche informée
 En meilleur d’abord
 L’algorithme A*
Naissance du terme IA (rappel)
IA comme Agents Intelligents (rappel)

Agent intelligent : tout ce qui perçoit son environnement à l’aide


de ses capteurs et qui agit sur son environnement à l’aide de ses
effecteurs.
Cycle d'action/perception (rappel)

capteurs
percevoir

Agent
?
agir
Actionneurs

La grande question de l'intelligence artificielle est la


fonction qui associe des capteurs aux actionneurs.
Types d’agent (Rappel)
 4 types de base dans l’ordre de
généralité:
 Agents reflex simples
 Agents reflex basés sur modèle
 Agents basé sur but
 Agents basé sur utilité
Agents reflex simples (Rappel)
Agents reflex basés sur modèle (Rappel)
Agents basé sur but (Rappel)
Agents basé sur utilité (Rappel)
Terminologie (Rappel)
 Entièrement ou partiellement observables
 Discrètes ou continues
 Inoffensive ou adversaire
 Déterministes ou stochastiques
 Des agents simples ou multiples
 Épisodique ou séquentielle
 Statique ou dynamique
 Certain ou incertain
Résolution de problèmes
Quel problème ?

Problèmes comminatoires.
Exemple:
Pathfinding
(Recherche de chemin)
Problème de navigation où il y a
beaucoup de choix pour
commencer.

La complexité provient du fait de


choisir le bon choix au début, et
après cela de choisir le bon choix à
la prochaine intersection. En
diffusant ainsi une séquence
d'actions
Résolution de problèmes
Complexité

La complexité du problème de navigation


est en contraste avec le type de
complexité indiqué dans le tableau ci-
contre, où la complexité provient de
l'observabilité partielle que nous ne
pouvons pas voir à travers la brume, où
sont les chemins possibles.

Nous ne pouvons pas voir le résultat de


nos actions et même les actions elles-
mêmes ne sont pas connus.

Ce type de complexité ne sera pas


traité dans cette unité.
Problème de recherche de chemin
Problème de recherche de chemin
 Consiste en :
 Un espace d'états (Les villes)
 Un modèle de transition (Fonction
successeur: Allez à la ville adjacente avec un coût
= distance)
 Un état initial (Arad), un test d’objectif ou but
(Bucharest), et d'une fonction coût de chemin
(distance)
 Une solution est une séquence d'actions (a
plan) qui transforme l'état de départ à l'état but.
Algorithme de recherche
 C’est une procédure qui calcule une (ou plusieurs)
solution à partir d'un problème (état initial,
actions, états objectifs).

 Explore l’espace d’états selon une stratégie en


commençant par l’état initial.

 L’espace d’états peut être de taille


exponentielle
Arbre de recherche
 C'est un arbre "what if" des
actions et des résultats
N, 1 E, 1

 Nœud racine = État de


départ

 Les nœuds fils


correspondent aux Pour la plupart des problèmes,
successeurs nous ne pouvons jamais réellement
construire l'arbre entier.
Recherche Arborescente (Modèle)
 Structure de Données
 Racine: état initial
 Nœuds: états
Modèle

 Arêtes: actions admissibles sur le


nœud parent
 Algorithme:
 Explorer l'arbre de recherche en
ouvrant itérativement les
nœuds
nœuds fermés nœuds ouverts
(Frontière)

Pas exploré
Critères d'évaluation des algorithmes
 Complétude: est-ce que la méthode garantit
de trouver une solution si elle existe?
 Optimalité: est-ce que la méthode trouve
la meilleure solution s'il en existe
plusieurs?
 Complexité en temps: combien de nœuds faut-
il produire pour trouver la solution?
 Complexité en espace: combien de nœuds
conserver en mémoire pour trouver la
solution?
Mesures de Complexité
 Branchement b:
Largeur maximale m
d'ouverture sur un nœud

 Profondeur d: la d
profondeur de la meilleur
solution.

 Profondeur maximum m: b
la profondeur maximale
de l'arbre.

Si l'arbre explore tous les états


possibles sa complexité est en O(bm)
Taille d'espace d'états exponentielle
Problème: Manger toute la
nourriture
 Positions de
Pacman : 10 x 12 =
120
 Compteur de
nourriture: 30
 Quel est la taille de l’espaces
d’états?
Recherche Arborescente
Tree Search
MakeList(x)
Entrée: un problème avec nœud initial x
Construire une liste avec le nœud initial
Sortie: chemin depuis n jusqu'au but
RemoveFront(List)
Algorithme:
Enlever le premier nœud de la liste
opens ← MakeList(x)
loop do Set ← Expand(node)
if opens is empty then return Ouvrir un nœud, c'est-à-dire appliquer
failure node ← tous les actions possibles sur le
nœud et retourner les états
RemoveFront(opens)
if Goal(node) then return Path(node) List ← Insert(List, Set)
opens ← Insert(opens, Insérer dans la liste « List » l'ensemble
Expand(node)) de nœuds « Set »
end
Recherche en largeur d’abord

Breast-First Search (BFS)


Recherche Arborescente (BFS)
Breadth-First Search
Algorithme: Tree search
Utilise une liste comme une file (FIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertLast(opens,
Expand(node))
end
Recherche Arborescente (BFS)
Breadth-First Search
Algorithme: Tree search
Utilise une liste comme une file (FIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertLast(opens,
Expand(node))
end
Recherche Arborescente (BFS)
Breadth-First Search
Algorithme: Tree search
Utilise une liste comme une file (FIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertLast(opens,
Expand(node))
end
Recherche Arborescente (BFS)
Breadth-First Search
Algorithme: Tree search
Utilise une liste comme une file (FIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertLast(opens,
Expand(node))
end
Recherche Arborescente (BFS)
Breadth-First Search
Algorithme: Tree search
Utilise une liste comme une file (FIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertLast(opens,
Expand(node))
end
Recherche Arborescente
Breadth-First Search
Algorithme: Tree search
Utilise une liste comme une file (FIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertLast(opens,
Expand(node))
end
Recherche en profondeur d’abord

Depth-First Search (DFS)


Recherche Arborescente (DFS)
Depth-First Search
Algorithme: Tree search
Utilise une liste comme une Pile (LIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertFirst(opens,
Expand(node))
end
Recherche Arborescente (DFS)
Depth-First Search
Algorithme: Tree search
Utilise une liste comme une Pile (LIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertFirst(opens,
Expand(node))
end
Recherche Arborescente (DFS)
Depth-First Search
Algorithme: Tree search
Utilise une liste comme une Pile (LIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertFirst(opens,
Expand(node))
end
Recherche Arborescente (DFS)
Depth-First Search
Algorithme: Tree search
Utilise une liste comme une Pile (LIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertFirst(opens,
Expand(node))
end
Recherche Arborescente (DFS)
Depth-First Search
Algorithme: Tree search
Utilise une liste comme une Pile (LIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertFirst(opens,
Expand(node))
end
Recherche Arborescente (DFS)
Depth-First Search
Algorithme: Tree search
Utilise une liste comme une Pile (LIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertFirst(opens,
Expand(node))
end
Recherche Arborescente (DFS)
Depth-First Search
Algorithme: Tree search
Utilise une liste comme une Pile (LIFO)

opens ← MakeList(x)
loop do
if opens is empty then return
failure node ← Pop(opens)
if Goal(node) then return Path(node)
opens ← InsertFirst(opens,
Expand(node))
end
Questions
Est-ce qu’un espace fini d'états donne toujours un arbre de recherche fini ?

Non, Il pourrait y avoir des cas où l’arbre de recherche a une profondeur infini

Comment éviter une recherche infinie dans depth-first-search ?

• Recherche en profondeur limitée (Depth-Limited Search ) incomplet.


•Recherche par approfondissement itératif (Iterative Deepening Search)
(complet)
Retour en arrière (Backtracking Search)

Technique pour la recherche de solutions dans un graphe implicite, où


les nœuds représentent des solutions partiellement construits.

Variante de la recherche en profondeur d’abord dans laquelle les


nœuds ne sont étendues que s'ils sont "prometteurs" dans le
sens d'être des précurseurs possibles pour une solution
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Retour en arrière (Backtracking Search)
Backtracking Search
Algorithme: tree search
Ne rajoute qu'un ouvert à la fois

Backtrack(node)
if promising(node) then
if Goal(node) then
report
Path(node)
else
for each child u of node)
backtrack(u)
Propriété de l’algorithme DFS

 Complétude: DFS ne garanti pas de trouver une solution


si elle existe.

 Complexité temporelle: si DFS trouve une


solution, le temps nécessaire est beaucoup moins que
BFS.

 Complexité spatiale : Mémoire nécessaire est beaucoup


moins que BFS.

 Optimalité : Solution trouvée n'est pas assuré d'être le


meilleur
Recherche heuristique

Meilleur d'abord (Best-first search)


Meilleur d'abord (Best-first search)
 Compromis entre recherche en largeur et
recherche en profondeur

 On associe à chaque état n une mesure


d'utilité unique U(n)

 On utilise cette mesure pour :


 Choisir l'état suivant à traiter
 Rajouter les successeurs d'un état à la liste d'états
à traite
Mesure d'utilité
 g(n) est le coût jusqu'à
présent pour atteindre n
(coût du chemin jusqu'à n). …

 h(n) est le coût estimé pour


aller de n vers un état
final.

 f(n) est le coût total estimé


pour aller d'un état initial vers
un état final en passant
par n (f(n) = g(n) + h(n)).
Meilleur d'abord (Best-first search)
• Cas spéciaux :
Algorithme: tree search
•Ouvrir
Recherche ennœud
toujours le coûtle uniforme
moins coûteux
(Uniform Cost Search)
opens ← MakeList(x)
• U(n) =g(n)
loop do
if opens is empty then return
•Recherche gloutonne (Greedy
failure node ← Pop(opens)
search)
if Goal(node) then return Path(node)
• U(n) =h(n)
opens ← InsertBest(opens,
Expand(node))
End • Algorithme A*,
• U(n) = f(n)
InsertBest(opens, set )
for each node in set do
SortedInsert(opens, node, U(node)
Uniform-cost search
Explore les contours en coût croissant
Problème de ”Uniform-cost search”
La bonne: UCS est … c1
complète et optimale! c2
c3
Le mauvais:

Explore les options dans
chaque "direction"

Aucune information sur la
localisation de l'objectif
Start Goal
Greedy best-first search

Explore les états les plus proches de l'objectif.

Route finding problem : Distance directe au ville d'arrivé.


Problème de ”Greedy best-first
search”
Greedy va mal lorsqu'il y a un impasse.
Combining UCS and Greedy

Uniform-cost ordonne par le coût du chemin, ou le coût en arrière g(n)


Greesy Best-first ordonne par la distance à l'objectif ou le coût en avant h(n)
5
e h=1
1
1 3 2
S a d G
h=6 1 h=5
h=2 h=0
1
c b
h=7 h=6


A* Search ordonne par la somme: f(n) = g(n) +
h(n)
Quand doit-on mettre fin à A*?
Doit-on arrêter lors de l'enfilement d'un but?

2 A 2
h=2
S h=3 G
h=0
B 3
2
h=1

Non: on ne s'arrêtera que lorsque nous avons un
objectif défilé.
Heuristiques Admissible


Une heuristique h est admissible (optimistic) si:

Où h*(n) est le vrai coût vers le but le plus proche

Ne jamis surestimé!
Heuristique triviales et Dominance
● Dominance: ha ≥ hc if


Heuristiques forment un demi-treillis:
le Max des heuristiques admissibles est
recevable:


Heuristiques triviales

En bas du treillis est l'heuristique zéro
(qu'est ce que cela nous donne?)
– En haut du treillis est l'heuristique
exacte
Optimalité de A*: blocage

Notation:

G*: un nœud de plus bas coût
(but)

G: un autre nœud but
Optimalité de A*: blocage
Prouve: …

Qu'est-ce qui pourrait aller mal?

Nous pourrions avoir de la pop un
objectif sous-optimale G au large de la
frontière avant G *

Cela ne peut pas se produire:

Imaginez un objectif sous-optimale G
est dans la file.

Un certain nœud n qui est un sous-
chemin de G * doit aussi être à la
frontière (pourquoi?)

n va apparaitre de la pop avant G
Example: 8 Puzzle

Quels sont les états?

Combien d'Etats?

Quelles sont les actions?

Quels sont les Etats que nous pouvions atteindre à partir
de l'état de départ?

Ce que les coûts devraient être?

Vous aimerez peut-être aussi