Université Mohamed Seddik Benyahia

Département d’Informatique
Master 1:SIAD
Module: Méta-Heuristiques

Impléntation de l’algorithme de coloine des

fourmis pour résourde le problème de TSP
(NP Complete)

Présenté par :Boukhezar Abderrahmane

Boukemha Fouad

Année universitaire 2022 / 2023 1

 LE CONTENU

 Introduction
I. Colonie des fourmis
II. Application Réel de cette Algorithme
III implémentaion de l’algorithme
 Conclusion (Les langages programmtions utilises )
 Bibliographie

2
 INTRODUCTION

Les algorithmes de colonies de fourmis (en anglais : ant colony optimization, ou ACO)
sont des algorithmes inspirés du comportement des fourmis, ou d'autres espèces
formant un superorganisme, et qui constituent une famille de métaheuristiques
d’optimisation.

Initialement proposé par Marco Dorigo et al. dans les années 19901,2, pour la recherche
de chemins optimaux dans un graphe, le premier algorithme s’inspire du comportement
des fourmis recherchant un chemin entre leur colonie et une source de nourriture. L’idée
originale s'est depuis diversifiée pour résoudre une classe plus large de problèmes et
plusieurs algorithmes ont vu le jour, s’inspirant de divers aspects du comportement des
fourmis.[1]

3
En anglais, le terme consacré à la principale classe d’algorithme est « Ant Colony
Optimisation » (ACO). Les spécialistes réservent ce terme à un type particulier
d'algorithme. Il existe cependant plusieurs familles de méthodes s'inspirant du
comportement des fourmis. En français, ces différentes approches sont regroupées
sous les termes : « algorithmes de colonies de fourmis », « optimisation par colonies
de fourmis », « fourmis artificielles » ou diverses combinaisons de ces variantes. [1]

4
Application Réel de cette Algorithme

Les variantes combinatoires peuvent avoir un avantage, par rapport aux autres
métaheuristiques, dans le cas où le graphe étudié peut changer dynamiquement
au cours de l’exécution : la colonie de fourmis s’adaptera de façon relativement
flexible aux changements. Ceci semble être intéressant pour le routage réseau.

Les algorithmes de colonies de fourmis ont été appliqués à un grand nombre de

problèmes d’optimisation combinatoire, allant de l'affectation quadratique au
repli de protéine ou au routage de véhicules. Comme beaucoup de
métaheuristiques, l’algorithme de base a été adapté aux problèmes dynamiques,
en variables réelles, aux problèmes stochastiques, multi-objectifs ou aux
implémentations parallèles, etc. [1]

5
II.2.Implémentation de cette algorithme en python:

Étape 1 :
Intialization important des parameters :

num_ants = 20
num_iterations = 100
alpha = 8
beta = 10
rho = 0.9
Q=1

6
Étape 2:
Sélectionnez Ville/Nœud au départ :
Entrez les coordonnées X,Y pour chaque ville

7
Étape 3:
Calculer la distance entre chaque ville [2]

8
Étape 3:
Selection de ville de départ

Étape 4:
Construire une chemin la ville actuelle à la ville non-visitée

9
next_city = np.random.choice(list(unvisited_cities), p=probabilities )

Cette ligne de code sélectionne la prochaine ville à visiter pour une fourmi donnée en utilisant
les probabilités calculées précédemment. La fonction `np.random.choice` de la bibliothèque
NumPy est utilisée pour choisir une ville parmi la liste des villes non visitées `unvisited_cities`.
Les probabilités de cette ville sont données par la liste `probabilités` calculées précédemment.
La clause `p=probabilities` spécifie à `np.random.choice` d'utiliser les probabilités pour
effectuer le choix. Ceci garantit que les personnes ne sont pas sélectionnées avec une
probabilité proportionnelle à leur attractivité, définie par la quantité de phéromones déposées
sur chaque arête et la distance entre la ville actuelle et la ville sélection.

11
ce bloc de code est chargé de mettre à jour les niveaux de phéromones sur les bords du
graphique en fonction de la distance parcourue par chaque fourmi. Il parcourt toutes les
fourmis de la colonie, calcule la distance parcourue par chaque fourmi à l'aide de la fonction
objective_function et met à jour les niveaux de phéromones sur les bords en conséquence.

Plus précisément, il calcule d'abord la distance parcourue par la fourmi j en utilisant

objective_function(ants[j]). Si la distance est inférieure à la meilleure distance actuelle
(best_distance), il met à jour les variables best_distance et Meilleur_parcour pour stocker la
meilleure distance actuelle et le chemin correspondant.

Ensuite, il parcourt chaque arête visitée par ant j et met à jour le niveau de phéromone en
utilisant la formule suivante :
pheromone_matrix[ants[j][k]][ants[j][k+1]] = (1-f.rho)*pheromone_matrix[ants[j][k]][ants[j]
[k+1]] + f.rho*(f.Q/distance)
12
La première ligne de la fonction calcule la distance totale du chemin en additionnant les
distances entre chaque paire de villes adjacentes dans le chemin. Cela se fait à l'aide
d'une compréhension de liste qui itère sur la plage d'indices de la liste de chemins et
calcule la distance entre la ville actuelle et la ville suivante dans le chemin, à l'aide de la
matrice de distance. La somme de ces distances est stockée dans la variable
total_distance.

La deuxième ligne de la fonction ajoute la distance entre la dernière ville du chemin et

la première ville du chemin, en utilisant la matrice de distance. Cela est nécessaire car
le chemin représente une boucle fermée et la distance entre la dernière ville et la
première ville doit être incluse dans la distance totale.

13
Distance entre (1,1)=0, [1]

Distance entre (1,2)=3.16227766

Distance entre (1,3)=5.83095189

Distance entre (1,4)=5.09901951

Distance entre (1,5)=2.82842712

Distance entre (1,6)=5.

P(1,2)=0.245542467
P(1,3)=0.000540420767
P(1,4)=0.00206661642
P(1,5)=0.749336141
P(1;6)=0.002514354861
Le total est =1
Solution set=[0.245542467,0.000540420767,0.2481495042,0.9974856452,1]
Chosir un value randome entre (0,,,,,,1)
On applique this formula : next_city = np.random.choice(list(unvisited_cities), p=probabilities 14
Le city 4=(random_value<=solutin_set) true
Déplacer la fourmis de la ville de départ à 4
On repete les memes opéraion avec la ville 4
Et on ajoute la distance précédent à la nouvelle distance
Et ajoute distance entre la dernière ville et la première ville doit être incluse dans la distance
totale.
À la fin nous avons le plus court chemin de premier fourmis
Et on répete avec les fourmis qui restent et finalement nous choisisons la distance totale
minimale entre les distances minimaux totales dans les autres chemin

15
16
17
Les langages programmtions utilises et les Paradigme de
programmation

On utilisons python avec ses librairies comme

numpy ,matplotlib
Et utilise le POO

18
Bibliographie :

[1] :https://fr.wikipedia.org/wiki/Algorithme_de_colonies_de_fourmis

[2] :https://en.wikipedia.org/wiki/Euclidean_distance

19