intelligence Artificielle en python, Slides of Artificial Intelligence

Download intelligence Artificielle en python and more Slides Artificial Intelligence in PDF only on Docsity!

INTELLIGENCE ARTIFICIELLE

ET PROGRAMMATION EN

PYTHON

MASTER DATA SCIENCE

Réalisée par : Mme CHIHA Ibtissem : Maitre Assistante en Informatique Industrielle et Automatique 1

• Les algorithmes de recherche

Recherche sans heuristique et cout uniforme

Recherche en largeur d’une traversée (breadth-first traversal ) : BFT

Recherche en profondeur d'une traversée ( depth-first traversal ) : DFT

Recherche en largeur (breadth-first Search ) : BFS

Recherche en profondeur ( depth-first Search ): DFS

Recherche sans heuristique et cout variable

Algorithme de DIJKSTRA

Recherche avec heuristique et cout variable

Algorithme A*

Algorithme de Greedy best first

PLAN DU COURS 2

DEPTH-FIRST TRAVERSAL : DFT 4 Visited Stack : FIFO A E B F C G A B, C, E B,C, (^) F B,C B, G A E F C G B D B D D, visited = [] stack = [] def dft(visited, graph, node) : visited.append(node) stack.append(node) while stack: m = queue.pop() print (m, end = " ") for node in graph[m] : if node not in visited : visited.append(node) stack.append(node) print("Following is the Depdth-First Traversal") dft(visited, graph, 'A') queue.pop() queue.pop() F

DEPTH-FIRST TRAVERSAL : DFT 5 Visited Stack : FIFO A B G D F C A E, C, B E,C, (^) F,D E,C,F E,C A B D F C G E E,G E E visited = [] stack = [] def dft(visited, graph, node) : visited.append(node) stack.append(node) while stack: m = queue.pop() print (m, end = " ") for node in graph[m] : if node not in visited : visited.append(node) stack.append(node) print("Following is the Depdth-First Traversal") dft(visited, graph, 'A') queue.pop() queue.pop() Ou

BREADTH-FIRST SEARCH : BFS 7 Visited Queue : FIFO [A]

[A,B], [A,C], [A,E]

[A,C], [A,E]

[A,B,F] visited = [] queue = [[start]] def bfs(graph,start,goal) : visited.append(node) queue.append(node) while queue : path=queue.pop(0) node=path[-1] else: adjacentnodes=graph.get(node,[ ]) for node2 in adjacentnodes : newpath=path.copy( ) newpath.append(node2) queue.append(newpath) solution= bfs(graph, 'A', ‘F') print( ' solution is ', solution) queue.pop( 0 ) queue.pop(0)

Recherche d’un chemin du départ A à la destination F

[A]

[A,B] [A,B,D] [A,B,F]

[A,C] [A,E], [A,B,D], [A,B,F] [A,C,G]

[A,E] [A,B,D], [A,B,F], [A,C,G] [A,E,F]

[A,B,D] [A,B,F], [A,C,G], [A,E,F]

[A,B,F]

if node in visited : continue if node ==goal : return path visited.append(node)

[A,B]

B B D F

[A,B ]

[A,B,D]

goal

BREADTH-FIRST SEARCH : DFS 8 Visited Stack : LIFO [A]

[A,B], [A,C], [A,E]

[A,B], [A,C]

[A,E,F] visited = [] stack = [[start]] def dfs(graph,start,goal) : visited.append(node) queue.append(node) while stack : path=stack.pop() node=path[-1] else: adjacentnodes=graph.get(node,[ ]) for node2 in adjacentnodes : newpath=path.copy( ) newpath.append(node2) stack.append(newpath) solution= dfs(graph, 'A', ‘F') print( ' solution is ', solution) queue.pop() queue.pop()

Recherche d’un chemin du départ A à la destination F

[A]

[A,E] [A,E,F]

[A,E,F]

if node in visited : continue if node ==goal : return path visited.append(node)

[A,E]

E E F

[A,E ]

[A,E,F]

goal

• Dijkstra : Algorithme de recherche
  • Recherche sans heuristique et coût variable
• Imaginons que l’on cherche à trouver le plus court chemin entre la ville A et la ville J.
• Tout au long de l’algorithme on va garder en mémoire le chemin le plus court depuis A pour chacune

des autres villes dans un tableau.

• On répète toujours le même processus :

1.. On choisit le sommet accessible de distance minimale comme sommet à explorer.

2.. A partir de ce sommet, on explore ses voisins et on met à jour les distances pour chacun. On ne met

à jour la distance que si elle est inférieure à celle que l’on avait auparavant

3.. On répète jusqu’à ce qu’on arrive au point d’arrivée ou jusqu’à ce que tous les sommets aient

été explorés.

DIJKSTRA 10

ALGORITHME DE DIJKSTRA 11 Visited Priority Queue : FIFO A , E , F et cost = 5 [A] 0 queue.pop(0) [A] 0 [A,E]^1 , [A,C]^3 , [A,B]^5 [A,E] 1 [A,C] 3 , [A,B] 5 , [A,E,F] 5 [A,C] 3 [A,B] 5 , [A,E,F] 5 , [A,C,G] 5 [A,B] 5

[A,E,F]5 , [A,C,G]5 ,[A,B,F]6, [A,B,D] 7

[A,E,F] 5 Goal queue.sort(key=pathcos t)

Recherche d’un plus court chemin du départ A à la destination F

13 ALGORITHME DE RECHERCHE A*

v La recherche ordonnée revient à choisir à développer le meilleur nœud au sens d’un certain critère  centrée sur le nœud ayant les meilleurs chances de mener au but L’utilisation d’une heuristique est basée sur une fonction d’évaluation pour ordonner la recherche appelée fonction heuristique nommée h(u) v h est la fonction heuristique qui estime le coût du passage de l'état u à l'état final. Soit f une fonction d’évaluation, f(n) exprime la valeur de cette fonction pour le noeud n f(n) représente le coût idéal du chemin passant par un nœud n pour arriver au but ALGORITHME DE RECHERCHE : A RECHERCHE AVEC HEURISTIQUE ET COÛT VARIABLE 14

ALGORITHME DE A*

Recherche d’un plus court chemin du départ A

à la destination F

def path_f_cost(path): g_cost= for(node,cost)in path: g_cost+=cost last_node=path[-1][0] h_cost=H_table[last_node] f_cost=g_cost+h_cost return f_cost, last_node def A_star_search(graph,start,goal) : visited=[ ] queue =[[(start, 0 )]] while queue : queue.sort(key=path_f_cost) path=queue.pop(0) node=path[-1][0] if node in visited : continue visited.append(node) if node==goal : return path else : adjacentnodes=graph.get(node,[ ]) for (node 2 ,cost) in adjacentnodes : newpath=path.copy( ) newpath.append((node 2 ,cost)) queue.append(newpath) solution= A_star_search (graph,'A','F') print('solution is', solution) print('cost of solution is', path_f_cost(solution)) Visited Priority Queue : FIFO [A] (^2) queue.pop(0) [A] 2

[A,E] 5 , [A,C] 5 , [A,B] 11

[A,C] 5 , [A,E,F] 11 [A,B] 11

[A,E] 5 [A,C] 5 [A,C,G] 5 , [A,E,F] 9 , [A,B] 11

[A,C,G] 5

[A,E,F]9 , [A,B,] 11

[A,E,F] 9 Goal (^) queue.sort(key=pathcos t)

17 ALGORITHME DE RECHERCHE GREEDY BEST FIRST

ALGORITHME DE GREEDY FIRST BEST 19 Visited Priority Queue : FIFO A , E , F et cost = [A] 2 queue.pop(0) [A] 2 [A,C]^2 , [A,E]^4 , [A,B]^6 [A,C] 2 [A,C,G]0, [A,E,]4 , , [A,B] 6 [A,C,G] 0 , [A,E] 4 , [A,B] 6

[A,E] 4 [A,E,F]4,,[A,B,] 6

[A,E,F] 4 Goal queue.sort(key=pathcos t)

Recherche d’un plus court chemin du départ A à la destination F

ALGORITHME DE GREEDY

Recherche d’un plus court chemin du départ A

à la destination F

def path_h_cost(path): g_cost= 0 for(node,cost)in path: g_cost+=cost last_node=path[- 1 ][ 0 ] h_cost=H_table[last_node] return h_cost, last_node def Greedy_search(graph,start,goal) : visited=[ ] queue =[[(start, 0 )]] while queue : queue.sort(key=path_h_cost) path=queue.pop(0) node=path[-1][0] if node in visited : continue visited.append(node) if node==goal : return path else : adjacentnodes=graph.get(node,[ ]) for (node2,cost) in adjacentnodes : newpath=path.copy( ) newpath.append((node2,cost)) queue.append(newpath) solution= Greedy_search (graph,'A','F') print('solution is', solution) print('cost of solution is', path_h_cost(solution)) Visited Priority Queue : FIFO queue.pop(0) [A] 2 [A] 2 [A,C] 2 , [A,E] 4 , [A,B] 6 [A,C] 2 [A,C,G] 4

[A,C,G] 0 , [A,E] 4 ,[A,B] 6

[A,E] 4

[A,E,F]4 , [A,B,] 9

[A,E,F] 4 Goal queue.sort(key=path_h_cos t)

[A,E]4, [A,B] 6