IA GLSID 2016_2019

1. Réalisé par :
Abdelatif ABAZINE
Ahmed EDDAHBI
Mouad AIT LHADJ
Abdessamad REDOUANI
Hamza BILLIHI
Anas AIT BAHA
Résolution heuristique
par espaces d‘états
Encadré par :

2. Partie1
Algorithmes de recherche
dans les espaces d‘états

3. Plan
Notion d'espace d‘états
Développement progressif d'un espace d‘états
Algorithme de recherche ordonnée

4.  Etats et opérateurs de changements d’états :
Problème deTaquin :
Etat initial Etat objectif
Notion d'espace d‘états

5. On appelle espace des états (ou espace de recherche ) d’un problème l’ensemble des états
atteignables depuis l’état initial par n’importe quelle séquence d’actions.
 Un espace des états peut être représenté par un graphe orienté :
» Les sommets représentent les états,
» Les arcs représentent les actions,
 Le graphe peut ne pas être fini
 Il existe toujours au moins un chemin entre S (état initial) et N (un sommet représentant un
état quelconque),
 Le nombre d’arcs de ce chemin constitue une distance de S vers N,
 On considère généralement qu’un espace d’état ne comporte qu’une seule racine,

6. 1. Couche de profondeur
 Couche de profondeur 1 est l’ensemble des fils de S,
 Couche de profondeur P (P > 1) rassemble les sommets qui ont un père au moins dans la
couche de profondeur P -1 mais qui n’ont aucun père à profondeur inférieure à P – 1,

7. Hypothèse 1
• Nombre de fils d'un des états est fini et non borné.
• soit p un entier, l’ensemble des sommets à distance
inferieur à p depuis l’état initial est fini ==> {sommets} est
dénombrable

8. But : par la recherche d'un chemin entre Etat i et un état objectif dans l'espace d‘états.
Les contraints : temps de calcul, mémoire, indéterministe, incomplétude, non optimal
2 Aapproches :
Développement complète d‘état Développement partiel
Développement progressif d'un espace d‘états

9. front <- {s}
reserve <- {}
pere(s) <- "rien"
enfants <- enfants(s)
JUSQUA front = {} REPETER
m <- front.getAleatoire()
SI m.isObjectif() ALORS
JUSQUA m = "rien"
REPETER
PUBLIER m
m <- pere(m)
FINJUSQUA
STOP
FINSI
front <- front- {m}
reserve <-- reserve - {m}
enfants <-- enfants - {n}
JUSQUA enfants={} REPETER
n <- enfants.getAleatoire()
enfants <- enfants - {n}
pere(n) <- m
SI n IN reserve ALORS
front <- front + {n}
reserve <- reserve - {n}
FINSI
SI n NOTIN (front,reserve) ALORS
front <- front + {n}
FINSI
FINJUSQUA
FINJUSQUA
Algorithme de recherche non ordonnée

10. front <-- {s}
reserve <-- {}
pere(s) <-- "rien"
valeur(s) <-- ff(s)
enfants <-- enfants(s)
JUSQUA front = {} REPETER
focal <- {m} IN front
val(m) est
minimale
SI m.isObjectifDans( focal )
JUSQUA m = "rien"
REPETER
PUBLIER m
m <- pere(m)
FINJUSQUA
STOP
FINSI
m <-
focal.getAleatoire()
front <- front- {m}
Reserve <- reserve + {m}
Enfants <- enfants(m)
JUSQUA enfants={} REPETER
n <- enfants.getAleatoire()
enfants <- enfants - {n}
SI n IN front &&
ff(n)<=val(n) ALORS
pere(n) <- m
val(n) <- ff(n)
FINSI
SI n IN reserve &&
ff(n)<=val(n) ALORS
front <- front +
{n}
reserve <-reserve-
{n}
pere(n) <- m
val(n) <- ff(n)
FINSI
SI n NOTIN (front,reserve)
fornt <- front +
{n}
pere(n) <- m
val(n) <- ff(n)
FINSI
FINJUSQUA
FINJUSQUA
Algorithme de recherche ordonnée

11. On dispose pour chaque état n une évaluation numérique ff(n) sensée mesurer la promesse
de l‘état quant à sa présence sur chemin-solution. il est préféré de développer une état la plus
prometteur
• ff () : fonction d‘évaluation. Ses valeurs
sont positif et inferieur que celles des
états prometteurs.
• L'objectif de l'utilisation de l‘ existence
de ff est de guider le choix d'un sommet
quelconque de l'ensemble frontière.
(instruction 5 de algorithme 1.1)
=> Algorithme BEST FIRST SEARCH
• Il n’est pas garanté que l’algorithme (1.2)
s’arret de son execution, ni que si un etat-
but est decouvert.
• Algorithme (1.2) restreinte les choix mais
reste non déterministe quant à la
détermination précise de l‘ état à
développer.

12. 2 8 3
1 6 4
7 0 5
2 8 3
1 6 4
0 7 5
2 8 3
1 0 4
7 6 5
2 8 3
1 6 4
7 5 0
ff=5
ff=5
ff=3
2 8 3
0 1 4
7 6 5
2 0 3
1 8 4
7 6 5
2 8 3
1 4 0
7 6 5
ff=3
ff=3
ff=4 2 3 0
1 8 4
7 6 5
0 2 3
1 8 4
7 6 5
0 8 3
2 1 4
7 6 5
2 8 3
7 1 4
0 6 5
1 2 3
0 8 4
7 6 5
1 2 3
8 0 4
7 6 5
1 2 3
0 8 4
7 6 5
ff=4
ff=2
ff=4
ff=3
ff=4
ff=2
ff=0
 ff() = h(n) = le nombre de valeurs qui sont mal placés dans leurs positions-objectif

13. Hypothèse 1
• Nombre de fils d'un des états est fini et non borné.
• soit p un entier, l’ensemble des sommets à distance inferieur à p depuis l’état initial est
fini ==> {sommets} est dénombrable
Hypothèse 2
• On s‘intéresse à obtenir chemin-solution optimal.
• En utilisant l'information des cout des arcs pour ordonner la recherche.
Hypothèse 3
• le nombre de chemins de l'espace d'états de cout inferieur à sigma(positif) est fini.
• il suffit de justifier que :
1- il existe d strictement positif tel que tous les couts des arcs supérieur strictement
à d.
ou
2- Espace des états doit être fini et les coûts sont strictement positif.
Hypothèses

14. Module
Intelligence
Artificielle

15. CHAPITRE 2
Algorithmes A, A* , Ae* et
A(Alpha)*
Encadré par :Mme. F.Akef

16. Introduction

17. Partie 1
Algorithme A

18. Définition
C’est Un algorithme de type Recherche ordonnée qui utilise une fonction d’évaluation ff tel que :
∀𝒎 ∈ 𝑬 , 𝒇𝒇 𝒎 = 𝒈𝒈 𝒎 + 𝒉𝒉(𝒎)
Avec
gg(m) : Le coût du chemin le plus court depuis l’état initial jusqu’à l’état m
hh(m) : la fonction heuristique de l’ état m , dans certain cas , on peut interpréter hh(m)
comme une estimation du coût d’un chemin minimal depuis m vers le plus proche des états
objectifs

19. Remarque
∀𝑚 ∈ 𝐸 , 𝑔𝑔 𝑚 ≥ 𝑔(𝑚)
Avec g(m) le cout du plus court chemin entre S et m
On peut donc considérer gg(m) comme une surestimation de g(m)

20. Exemple d’application
A7
S5
D6
C4
B3
F6
G30G10 G20
6
9
6
5
1
3
2
5
9 1
7
2
8
7
2
E5
2

21. Algorithme
front  { s }
réserve  { }
père « rien »
gg(s)  0
ff(s)  hh(s)
JUSQU’A front = { } REPETER
focal  l’ensemble des m de front tells que ff(m) est minimal
SI existe m objectif dans focal alors
JUSQU’A m = « rien » REPETER
publier m
m  père(m)
FINJUSQU’A
STOP
FINSI

22. Algorithme
m  élément quelconque de focal
front  front – { m }
réserve  réserve + { m }
enfants  ensemble des fils de m
JUSQU’A enfants = { } REPETER
n  élément quelquenque de enfants
enfants  enfants – { n }
SI n appartient à front et gg(m) + c(m,n) <= gg(n) alors
père(n)  m
gg(n)  gg(m) + c(m,n)
ff(n)  gg(n) + hh(n)
FINSI

23. Algorithme
SI n appartient à réserve et gg(m) + c(m,n) <= g(n) alors
front  front + { n }
réserve  réserve – { n}
père  m
gg(n)  gg(m) + c(m,n)
ff(n)  gg(n) + hh(n)
FINSI
SI n n’appartient ni à front ni à réserve alors
front  front +{ n }
père(n) m
gg(n)  gg(m) +c(m,n)
ff(n)  gg(n)
ff(n)  g(n) + hh(n)
FINSI
FINJUSQU’A
FINJUSQU’A

24. Algorithme A et ses particuliers
Algorithme à fonction hh monotone
La fonction hh est dite monotone sur un espace d'états E lorsque
∀𝑚, 𝑛 ∈ 𝐸 𝑒𝑡 𝑝è𝑟𝑒 𝑛 = 𝑚 , ℎℎ 𝑚 = ℎℎ 𝑛 + 𝑐(𝑚, 𝑛)
Il exprime une certaine cohérence entre les valeurs prises par hh et
les couts associés aux arcs.
On a gg(m) = g(m) chaque fois qu'un état m est développé.

25. Algorithme A et ses particuliers
Algorithme du cout uniforme
Si la fonction hh est identiquement nulle on obtient un algorithme
connu sous le nom d'algorithme du cout uniforme.
En fait on obtient un algorithme dit de coût uniforme dès lors que hh
est identiquement constant ; la constante peut être vue comme une
estimation uniforme du coût d'un chemin minimal depuis n'importe quel
sommet au plus proche des objectifs.

26. Algorithme A et ses particuliers
Algorithme en largeur d'abord
Quand les valeurs des arcs sont uniformément égales à 1 on obtient un
algorithme de la famille des algorithmes en largeur d'abord :
Le développement d'un état appartenant à la couche de profondeur p tant
que tous les états des couches de profondeur q<p n'auront pas été
développés.
Principe
Chercher le but souhaité parmi tous les nœuds d’un niveau(i) donné
avant d’aller consulter leurs fils (niveau(i+1))
Continuer, niveau par niveau jusqu’au but

27. Partie 2
Algorithme A*

28. Définition
 A* est une extension de l’algorithme de Dijkstra
 Utilisé pour trouver un chemin optimal dans un graphe via l’ajout d’une heuristique
 Une heuristique h(n) est une fonction d’estimation du cout restant entre un nœud n d’un
graphe et le but (le nœud à atteindre)
 Les heuristiques sont à la base de beaucoup de travaux en IA :
 Recherche de meilleures heuristiques
 Apprentissage automatique d’heuristiques

29. Définition
• Pour décrire A*, il est pratique de décrire un algorithme générique très simple, dont A* est un
cas particulier
• Variable importantes : open et closed
• Open : contient les nœuds non encore traités, ad à la frontière de la partie du graphe
explorée jusqu’à maintenant
• Closed : contient les nœuds traités, càd à l’intérieur de la frontière délimitée par la variable
open

30. Exemple de fonctions heuristiques
• Chemin entre deux villes
• distance Euclidienne (<< à vol d’oiseau>>) entre la ville n et la ville de destination
N-Puzzle
• nombre de tuiles mal placées
• somme des distances des tuiles
• Qualité de la configuration d’un jeu par rapport à une configuration gagnante

31. Exercice d’application
S
A
B
C
G1
4
2
5
12
2
3
7
6
2
1
0

32. Algorithme
Structure nœud = {
x, y: Nombre
cout, heuristique: Nombre
}
depart = Nœud(x=_, y=_, cout=0, heuristique=0)
Fonction compare2Noeuds(n1:Nœud, n2:Nœud)
si n1.heuristique < n2.heuristique
retourner 1
ou si n1.heuristique == n2.heuristique
retourner 0
sinon
retourner -1

33. AlgorithmeFonction cheminPlusCourt(g:Graphe, objectif:Nœud, depart:Nœud)
closedList = File()
openList = FilePrioritaire(comparateur=compare2Noeuds)
openList.ajouter(depart)
tant que openList n'est pas vide
u = openList.depiler()
si u.x == objectif.x et u.y == objectif.y
reconstituerChemin(u)
terminer le programme
pour chaque voisin v de u dans g
si v existe dans closedList avec un cout inférieur ou si v existe dans openList avec un
cout inférieur
neRienFaire()
sinon
v.cout = u.cout +1
v.heuristique = v.cout + distance([v.x, v.y], [objectif.x, objectif.y])
openList.ajouter(v)
closedList.ajouter(u)
terminer le programme (avec erreur)

34. Algorithmes A*
particuliers
Si l’hypothèse 1.2 est vérifiée, on a: h(n)>=0, Alors, l’algorithme du cout uniforme( et donc
l’algorithme en largeur d’abord, obtenu comme cas particulier) est un algorithme A* puisque:
∀ 𝒏 hh(n) = 0 <= h(n)

35. Partie 3
Cas Particuliers

36. Algorithmes Ae*
Les algorithmes Ae* sont des algorithmes de type A, et en plus il satisfont la
contrainte :
∀n hh(n) ≤ h(n) + e où e est une constante
NB : Les Algorithmes A* sont des cas particuliers d’algorithmes Ae*

37. Algorithmes Ae*
Les algorithmes A𝛼* sont des algorithmes de type A, et en plus il satisfont la
contrainte :
∀n hh(n) ≤ (1 + 𝛼)h(n) où 𝛼 est une constante
NB : Les Algorithmes A* sont des cas particuliers d’algorithmes A𝛼*

38. Récapitulatif

39. Intelligence
Artificielle
PROGRAMME DE LISP DE BASE POUR LES ALGORITHMES A
(A*, AE*, A𝛼*)

40. Préparé et présenté par :
Chapitre 3:
PROGRAMME DE LISP DE BASE POUR LES ALGORITHMES A
(A*, AE*, A𝛼*)
BADAOUI Khawla LOUFRANI Ghita BOULAALA Hiba
Encadré par: Mme F.AKIF
LATRACH Soumaya HOUNDAZE Zakaria EL MOUHADAB Issam

41. Introduction

42. Rappel

43. L’algorithme A
C’est Un algorithme de type Recherche ordonnée qui utilise une fonction
d’évaluation ff ∀𝒎 ∈ 𝑬 , 𝒇𝒇 𝒎 = 𝒈𝒈 𝒎 + 𝒉𝒉(𝒎)
Avec :
 gg(m) : Le coût du chemin le plus court depuis l’état initial jusqu’à l’état m
 hh(m) : la fonction heuristique de l’ état m

44. Exemple d’application de
l’algorithme A
A4
S3
C3
F1
B7
G10
G20
1
4
4
6 2
8
5
3
1
9
2
E2
5

45. Algorithme A et ses cas
particuliers
• Algorithme à fonction hh monotone:
La fonction hh est dite monotone sur un espace d'états E lorsque
∀𝑚, 𝑛 ∈ 𝐸 𝑒𝑡 𝑝è𝑟𝑒 𝑛 = 𝑚 , ℎℎ 𝑚 = ℎℎ 𝑛 + 𝑐(𝑚, 𝑛)
Il exprime une certaine cohérence entre les valeurs prises par hh et les
couts associés aux arcs.
On a gg(m) = g(m) chaque fois qu'un état m est développé.
Si la fonction hh est identiquement nulle ou constante, on obtient un
algorithme connu sous le nom d'algorithme du cout uniforme.
• Algorithme du cout uniforme
Quand les valeurs des arcs sont uniformément égales à 1 on obtient un
algorithme de la famille des algorithmes en largeur d'abord.
• Algorithme en largeur d'abord

46.  A* est une extension de l’algorithme de Dijkstra
 Utilisé pour trouver un chemin optimal dans un graphe via l’ajout d’une heuristique
 Une heuristique h(n) est une fonction d’estimation du cout restant entre un nœud n d’un
graphe et le but (le nœud à atteindre)
 Les heuristiques sont à la base de beaucoup de travaux en IA :
• Recherche de meilleures heuristiques
• Apprentissage automatique d’heuristiques
L’algorithme A*

47. • Pour décrire A*, il est pratique de décrire un algorithme générique très simple, dont A* est un
cas particulier
• Variable importantes : open et closed
• Open : contient les nœuds non encore traités, càd à la frontière de la partie du graphe
explorée jusqu’à maintenant
• Closed : contient les nœuds traités, càd à l’intérieur de la frontière délimitée par la variable
open

48. S7
A2
B6
C3
E0
1
3
4 5
2
2
G4
1
Exemple d’application de
l’algorithme A*

49. L’algorithme Ae*
Les algorithmes Ae* sont des algorithmes de type A, et en plus il satisfont la contrainte :
∀n hh(n) ≤ h(n) + e
où e est une constante
NB : Les Algorithmes A* sont des cas particuliers d’algorithmes Ae*

50. L’algorithme A
𝛼 *
Les algorithmes A𝛼* sont des algorithmes de type A, et en plus il satisfont la
contrainte :
∀n hh(n) ≤ (1 + 𝛼)h(n)
où 𝛼 est une constante
NB : Les Algorithmes A* sont des cas particuliers d’algorithmes A𝛼*

51. PROGRAMME DE BASE POUR LES ALGORITHMES A
(A*, AE*, A𝛼*) en JAVA

52. Eléments de base du
programme
• Etiquette:
Etat Etiquete père Gg Ff

53. • La liste « front » :
• La liste « reserve » :

54. Procédures générales et
procédures spécifiques
La procédure générale « crée »

55. La procédure spécifique « hh »

56. La procédure spécifique « Objectif »

57. La procédure spécifique « developperEtat »

58. Suite de La procédure spécifique « developperEtat »

59. Suite de La procédure spécifique « developperEtat »

60. La procédure générale « Focal »

61. La procédure générale « TransfererPere »

62. La procédure générale « RangerFils »

63. Suite de la procédure générale « RangerFils »

64. Suite de la procédure générale « RangerFils »

65. La procédure générale « RechordA »

66. Exemple
d’application

67. Problème deTaquin :
1 2 3
X 4 5
7 8 6
1 2 3
4 5 6
7 8 X
Etat Initial Etat Objectif

68. Exercice
d’application
Problème deTaquin :
1 2 4
5 6 3
7 6 X
1 2 3
4 5 6
7 8 X
Etat Initial Etat Objectif

69. Récapitulatif

70. Chapitre 4
Démonstration d’essai

71. Rappel

72. Etat Etiquete père Gg Ff
La class Etiquette

73. Les listes utilisés

74. fonctions

75. 2 8 3
1 6 4
7 X 5
1 2 3
8 X 4
7 6 5
Etat Initial Etat Objectif
Simulation

76. Les Fonctions Spécifiques
 FonctionsSpecefiques.java
 public static int hh(char etat);
 public static EtatCout[] developperEtat(Character etat);
 Retourner un tableau des états fils.
 public static boolean objectif(Character curEtat);
 Retourner VRAI si l’état courant et un état objectif (=‘m’).
 public static void publishEtat(Character etat);
 Afficher l’état

77. Deuxième exemple

78. Le jeu de l’âne rouge

79. Jeu de l’âne rouge:
L’âne rouge est un puzzle à pièces coulissantes ou casse-tête de déplacements
proche du taquin.
L’âne rouge est un jeu où il faut faire coulisser des pièces de différentes formes.
Il y’a 4 types de pièces :
• 4 rectangles verticaux
• 4 petits carrés
• 1 rectangle horizontal
• 1 grand carré : c’est l’âne rouge
But : Faire sortir l’âne rouge par le bas, au centre du plateau

80. Algorithme de recherche en largeur
BFS est un algorithme de parcours de graphe par recherche en largeur d’abord
Principe :
• Chercher le but souhaité parmi tous les nœuds d’un niveau i donné avant d’aller
consulter leur fils (niveau i+1)
• Continuer, niveau par niveau jusqu’au but
Propriétés:
Effectuer plus rapidement une recherche dans un graphe
Trouver une solution est toujours garantie s’il existe
La solution trouvée est la moins profonde

81. Pseudo code de l’algorithme:

82. Exemple:

83. Application de l’algorithme sur le jeu:

84. Quelques exemples:

86. Implémentation
Structure du projet