Professional Documents
Culture Documents
L’application de la méthode
d’essaim particulaire
Promotion 2008-2009
Sommaire
Introduction générale 01
II.1. Applications 09
II.2. Configuration de la méthode 10
II.2.1. Nombre de particules 10
II.2.2. Topologie du voisinage 10
II.2.3. Coefficients de confiance 10
II.2.4. Vitesse maximale et coefficient de constriction 11
II.2.5. Facteur d’inertie 11
II.2.6. Initialisation de l’essaim 12
II.2.7. Critères d’arrêt 12
II.3. L’organigramme de principe de la méthode d’essaims particulaires 13
II.4 .Exemple d’application de PSO en langage C 14
II.4.1. Exemple 1 : Recherche du champ minimum entre deux stations 14
II.4.2. Exemple 2 : Recherche le point minimum d’une fonction 16
Conclusion générale
L’annexe : Code source en C d’une version simple de PSO 17
Référence Biographique 18
25
Introduction Générale :
L’apparition des algorithmes évolutionnistes à fait l’effet d’une bombe dans les domaines de la
contraintes.
Pour cela nous présentons une métaheuristique apparue dernièrement : la méthode d’optimisation
L'OEP est une technique encore peu connue en France, fondée sur la notion de coopération entre
des agents (Les particules) qui peuvent être vus comme des « animaux » aux capacités assez
limitées.
L'échange d'information entre eux fait que, globalement, ils arrivent néanmoins à résoudre des
problèmes difficiles, comme c'est le cas, par exemple, chez les abeilles vivant en essaim
Après une présentation succincte des origines, le travail propose une description informelle de
utiliser, la PSO se révèle particulièrement efficace pour les problèmes d'optimisation non
linéaire.
particulaire en programmation en C.
1
2
Chapitre I Optimisation par l’essaim particulaire
I.1.Introduction sur Optimisation par l’essaim particulaire: [1] [2] [3] [4]
Dans PSO, la recherche à travers l'espace du problème peut être pensée de comme le vol d'un
essaim de particules (points dans l'espace). L'objectif est avoir les particules converger sur
l'optimum de la fonction, beaucoup de comme un troupeau d'oiseaux converge sur quelque
destination. Les particules sont distribuées initialement aléatoirement à travers le problème
espacez et donné une vélocité initiale.
Chaque particule se tient au courant de son emplacement et aptitude (la valeur de la fonction qui
est optimisée), aussi bien que la meilleure place (et aptitude correspondante) il a rencontré si loin
dans son vol.
Avec le temps, la vélocité de chaque particule est ajustée afin qu'il déplace stochastique vers sa
propre meilleure place et la meilleure place a trouvé par une autre particule dans son voisinage.
Le voisinage d'une particule est le sous-ensemble de particules dans l'essaim avec lequel il a la
communication directe. Ce réseau de rapports entre toutes les particules est connu comme la
sociométrie, ou topologie de l'essaim.
L'algorithme arrête quand quelque critère a rencontré quand PSO est appliqué aux problèmes
vécus, les évaluations de la fonction elles-mêmes sont la partie la plus chère de l'algorithme.
Par conséquent, quand comparer deux variations PSO, c'est utile s’ils les deux ont utilisé le
même nombre d'évaluations de la fonction.
Dans les expériences qui suivent, l'essaim est distribué un certain nombre d'évaluations de la
fonction et termine quand ce nombre est atteint.
3
Chapitre I Optimisation par l’essaim particulaire
L’optimisation par essaim particulaire (OEP) est une méthode née en 1995 aux états unis sous le
nom de L'optimisation de l'essaim de la particule (PSO).
Initialement, ses deux concepteurs, Russel Eberhard James Kennedy, cherchaient à modéliser
des interactions sociales entre des «agents » devant atteindre un objectif donne dans un espace
de recherche commun, chaque agent ayant une certaine capacité de mémorisation et de
traitement de l’information.
La règle des bases étant qu’il ne devait y avoir aucun chef d’orchestre, ni même aucune
connaissance par les agents de l’ensemble des informations. Seulement des connaissances
locales.
Des les premières simulations, le comportement collectif de ces agents évoquait celui d’un
essaim d’être vivants convergeant parfois en plusieurs sous- essaims vers des sites intéressants.
Ce compétemment se retrouve dans bien d’autre modèle, explicitement inspires des systèmes
naturels. Ici, la métaphore la plus pertinente est probablement celle de l’essaim d’abeilles,
particulièrement du fait qu’une abeille ayant trouve un site prometteur sait en informer certaines
de ces consœurs et que celle-ci vent tenir comte de cette information pour leur prochain
déplacement.
Le fonctionnement de l’OEP fait qu’elle peut être rangée dans les méthodes itératives ‘on
approche peut à peut de la solution) et stochastique. Sous ce terme un peu technique, on
retrouve un comportement qui aussi vieux que la vie elle- même : améliorer sa situation en ce
déplaçant partiellement au hasard et partiellement.
La version historique peut facilement être décrite en ce plaçant du point de vue d’une particule.
Au départ de l’algorithme, un essaim est reparti au hasard dirigé dans l’espace de rechercher,
4
Chapitre I Optimisation par l’essaim particulaire
Chaque particule est capable d’interroger un certain nombre de ses congénères (ses
informatrices, dont elle- même) et d’obtenir de chacune d’entre elles sa propre
meilleure performance (et la qualité afférente).
Le premier point se comprend facilement, mais les deux autres nécessitent quelques précisions.
Les informatrices sont définies une fois pour toutes de la manière suivante (figure I.1).
Figure I.1. Le cercle virtuel pour un essaim de sept particules. [1] [2] [3] [4]
Une fois la meilleure informatrice détectée, la modification de la vitesse est une simple
5
Chapitre I Optimisation par l’essaim particulaire
I.4.Principales
Principales caractéristiques : [1] [2] [3] [4]
Cette méthode présente quelques propriétés intéressantes, qui on fait un bon outil pour de
nombreux problèmes d’optimisation, particulièrement les problèmes fortement non linéaire,
continus ou mixtes (certaines variables étant réelles et d’autres entières) :
Elle est facile à programmer, quelque lignes de code suffisant dans n’emporte quel
langage évalue.
Elle est robuste (de mauvais choix de paramètres dégrades les performances, mais
n’empêche pas d’obtenir une solution).
6
Chapitre I Optimisation par l’essaim particulaire
Pour réaliser son prochain mouvement, chaque particule combine trois tendances : suivre sa
vitesse propre, revenir vers sa meilleure performance, aller vers la meilleure performance de ses
informatrices.
I.5.Pour en savoir plus sur l’optimisation par essaim particulaire : [1] [2] [3] [4]
A ce jour, environ 250 articles sur le sujet ont été publiés, mais très peu en français. Un excellent
point d’entrée est le site Particle Swarm Central, avec une bibliographie très complète, des liens
vers des documents et des programmes à télécharger, ainsi qu’une liste de chercheurs travaillant
dans ce domaine.
Le livre Swarm Intelligence, écrit par les deux concepteurs de la méthode, y consacre quelques
chapitres et donne des aperçus plus généraux sur les questions d’intelligence collective.
7
8
Chapitre II Application de la méthode d’essaim particulaire en C
9
Chapitre II Application de la méthode d’essaim
essaim particulaire en C
II.2.
.2. Configuration de la méthode : [6]
II.2.1. Nombre de particules :
La quantité de particules allouées à la résolution du problème dépend essentiellement de deux
paramètres :
La taille de l’espace de recherche et le rapport entre les capacités de calcul de la machine et le
temps maximum de recherche.
Il n’y a pas de règle pour déterminer ce paramètre, faire de nombreux essais permet de se doter
de l’expérience nécessaire à l’appréhension
l’a de ce paramètre.
II.2.2.
.2.2. Topologie du voisinage :
La topologie du voisinage défini avec qui chacune des particules va pouvoir communiquer.
Il existe de nombreuses combinaisons dont les suivantes sont les plus utilisées :
a) topologie en étoile : chaque particule est reliée à toutes les autres. L’optimum du voisinage est
l’optimum global.
b) topologie en anneau : chaque particule est reliée à n particules (en général, n = 3) c’est la
topologie la plus utilisée.
c) topologie en rayon : les particules ne communiquent qu’avec une seule particule centrale.
FIGURE.II.. 1 – (a) anneau (avec n = 2), (b) rayon, (c) étoile. [6]
II.2.3.
.2.3. Coefficients de confiance :
Les variables de confiance pondèrent les tendances de la particule à vouloir suivre son instinct de
conservation ou son panurgisme. Les variables aléatoires p1 et p2 peuvent être définis de la façon
suivante :
10
Chapitre II Application de la méthode d’essaim particulaire en C
Où r1 et r2 suivent une loi uniforme sur [0..1] et c1 et c2 sont des constantes positives
déterminées de façon empirique et suivant la relation c1 + c2 <= 4.
Les études de SHI et EBERHART indiquent que l’utilisation d’un coefficient de constriction
donne généralement un meilleur taux de convergence sans avoir à fixer de vitesse maximale.
Cependant, dans certains cas, le coefficient de constriction seul ne permet pas la convergence
vers la solution optimale pour un nombre d’itérations donné.
En plus du coefficient de constriction, ce qui, permet d’améliorer les performances globales de
l’algorithme.
Une grande valeur de Y (>1) est synonyme d’une grande amplitude de mouvement et
donc, in fine, d’exploration globale.
Une faible valeur de Y (<1) est synonyme de faible amplitude de mouvement et donc,
d’exploration locale.
11
Chapitre II Application de la méthode d’essaim particulaire en C
Fixer ce facteur, revient donc à trouver un compromis entre l’exploration locale et l’exploration
globale.
Le calcul de la vitesse est alors défini par :
La position des particules ainsi que leur vitesse initiale doivent être initialisés aléatoirement
12
Chapitre II Application de la méthode d’essaim
essaim particulaire en C
13
Chapitre II Application de la méthode d’essaim
essaim particulaire en C
II.4 .Exemple
Exemple d’application de PSO en langage C :
II.4.1. Exemple 1 : Recherche du champ minimum entre deux stations : [1] [2] [3] [4]
Voici un exemple très simplifié s’inspirant d’un problème réel. On considère deux stations A et
B, émettrices d’un champ électromagnétique sinusoïdal décroissant avec la distance. On cherche
le point entre ces deux stations où le champ total reçu à un instant
instant donné est minimum. La figure
1.4 donne une idée des champs en tout point entre les deux stations, distantes de 2,7 km. En
posant x comme étant la distance à la station A, on a les équations suivantes :
Figure II.2.
II.2 Les stations A et B et leurs sommation. [[1] [2] [3] [4]
14
Chapitre II Application de la méthode d’essaim particulaire en C
À un instant donné, les valeurs des champs reçus se répartissent selon des sinusoïdes amorties.
La distance entre les stations (ici 2,7 km) n’étant pas en rapport simple avec la longueur d’onde,
le point où le champ total est minimum n’est pas facilement calculable.
De plus, les méthodes classiques (gradients, par exemple) échouent du fait de l’existence de
multiples minimums locaux. Par contre, il est très facile d’ajouter la fonction à minimiser au
programme PSO donné en annexe.
Une solution un peu meilleure peut être obtenue avec plus d’itérations, mais le gain est très
minime.
On peut dire que l’augmentation de nombre maximum d'évaluations de la fonction a donné plus
de précision pour trouver le minimum de champ total.
15
Chapitre II Application de la méthode d’essaim particulaire en C
F(x) = x 3 - 9 * x 2 +24 * x – 12
Il est très facile de trouver le point minimum de la fonction F(x) par l’application de
programme de la PSO pour cette fonction. (Voir l’annexe)
Et pour cela, il faut initialiser les paramètres suivants :
Il faut bien choisir l’intervalle de rechercher pour ne pas diverger vers une autre solution
fausse.
Si on compare entre les deux essais, on peut dire que l’augmentation de nombre
16
Conclusion générale
Les résultats obtenus par PSO sont très satisfaisants, elles confirment bien
principaux :
dépendance.
inconvénients.
supplémentaire pour remédier au problème d’optimum local. Cet outil peut être
hybridé avec la PSO pour avoir un outil d’optimisation encore plus puissant et
plus efficace.
17
L’annexe : Code source en C d’une version simple de PSO
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define D_max 100 // Dimension maximale de l'espace de recherche
struct position {int taille;double x[D_max]; double f;}; // Position d'une particule et sa
performance
struct vecteur {int taille;double v[D_max];}; // Vitesse d'une particule
// Sous-programmes//
double alea(double a,double b); // Nombre pseudo-aléatoire entre a et b
double ma_fonction (struct position x, int fonction); // Fonctions à minimiser
// Variables globales//
int nb_eval; // Nombre total d'évaluations
//================PROGRAMME PRINCIPAL=====================//
int main(int argc, char *argv[])
{
double c1,cmax; // Coefficients de confiance
int D; // Dimension de l'espace de recherche
int d; // Numéro de la dimension courante
double eps; // Précision souhaitée
int eval_max; // Nombre max d'évaluations de la fonction
double eval_moyen; // Nombre moyen d'évaluations
double fmin; // Objectif à atteindre
int fonction; // Numéro de la fonction à minimiser
int g; // Numéro de la meilleure informatrice
int k;
struct position P[D_max]; // Positions
struct position P_m[D_max]; // Meilleures positions trouvées
struct position meilleure; // Toute meilleure position trouvée
int K; // Taille des groupes d'informatrices
18
L’annexe : Code source en C d’une version simple de PSO
double min_f;
int N; // Taille de l'essaim
int n; // Numéro de la particule courante
int n_exec,n_exec_max; // Pour exécutions multiples
int rang;
int signe;
struct vecteur V[D_max]; // Vitesses
double xmin,xmax; // Intervalle pour l'espace de recherche
// Paramètres de réglage//
c1=0.738; // Confiance en la tendance actuelle
cmax=1.51; // Confiance maximale en les informatrices
N=20; // Taille de l’essaim (comme un test d’arrêt)
K=3; // Nombre de liens d'information
// Problème à traiter//
fonction=5 ; // La fonction choisi
xmin=0; xmax=2.7; // Intervalle pour l'espace de recherche
D=1; // Espace de recherche
eps=0.00001; // Précision souhaitée
fmin=0; // Valeur minimale à atteindre, à la précision
eval_max=20005; // Nombre maximum d'évaluations (comme un test d'arret )
n_exec_max=1; // Nombre d'exécutions
n_exec=0;
eval_moyen=0;
// Initialisations des positions et vitesses//
init:
for (n=0;n<N;n++)
{ P[n].taille=D;
for (d=0;d<D;d++)
P[n].x[d]=alea(xmin,xmax);
19
L’annexe : Code source en C d’une version simple de PSO
V[n].taille=D;
for (d=0;d<D;d++) V[n].v[d]=alea ((xmin-xmax)/2, (xmax-xmin)/2) ;}
// Evaluations initiales//
nb_eval=0;
for (n=0;n<N;n++)
{
P[n].f=ma_fonction(P[n],fonction); // Evaluation de la position
P_m[n]=P[n]; // Meilleure position = position initiale
}
//Mémorisation du meilleur résultat atteint jusqu'ici//
meilleure=P_m[0];
for (n=0;n<N;n++) if (P_m[n].f<meilleure.f) meilleure=P_m[n];
boucle: // Itérations
for (n=0;n<N;n++) // Pour chaque particule
{
// Meilleure informatrice dans le i-groupe circulaire de taille K//
g=n;
min_f=P_m[n].f;
signe=1;
k=1;
autre_informatrice:
rang=n+signe*k;
if (rang>N-1) rang=rang-N+1;
if (rang<0) rang=rang+N-1;
if (P_m[rang].f<min_f) {g=rang;min_f=P_m[rang].f;}
if (k<K) {signe=-signe;k=k+1; goto autre_informatrice; }
// Calcul de la nouvelle vitesse//
for (d=0;d<D;d++) V[n].v[d]=c1*V[n].v[d]+alea(0,cmax)*(P_m[n].x[d]-
P[n].x[d])+alea(0,cmax)*(P_m[g].x[d]-P[n].x[d]);
20
L’annexe : Code source en C d’une version simple de PSO
// Déplacement//
for (d=0;d<D;d++) P[n].x[d]=P[n].x[d]+V[n].v[d];
// Confinement d'intervalle//
for (d=0;d<D;d++)
{
if (P[n].x[d]<xmin) {P[n].x[d]=xmin;V[n].v[d]=0;} // ou bien V[n].v[d]=-0.5* V[n].v[d]
if (P[n].x[d]>xmax) {P[n].x[d]=xmax;V[n].v[d]=0;} // ou bien V[n].v[d]=-0.5*
V[n].v[d]
}
// Evaluation de la nouvelle position//
P[n].f=ma_fonction(P[n],fonction);
// Mise à jour de la meilleure position//
if (P[n].f<P_m[n].f) P_m[n]=P[n];
// Mémorisation du meilleur résultat atteint jusqu'ici//
if (P_m[n].f<meilleure.f) meilleure=P_m[n];
}
// Test de fin//
if (fabs(meilleure.f-fmin)>eps && nb_eval<eval_max) goto boucle;
21
L’annexe : Code source en C d’une version simple de PSO
22
L’annexe : Code source en C d’une version simple de PSO
case 1: // Sphère//
f=0;
for(d=0;d<D;d++)
f=f+x.x[d]*x.x[d];
break;
case 2:
// Pour test du confinement. Utiliser un xmin >=0//
f=0;
for(d=0;d<D;d++)
f=f+sqrt(x.x[d]);
break;
case 3:
// Alpine. Min 0 en (0,0 ...0)//
f=0;
for( d=0;d<D;d++)
{
f=f+sqrt(fabs(x.x[d]*sin(x.x[d])));
} break;
case 4:
// Rosenbrock, fonction Banane. Min 0 en (1, ...1)//
f=0;
for (d=0;d<D-1;d++)
{
xd=1-x.x[d];
f=f+xd*xd;
xd= x.x[d]*x.x[d]-x.x[d+1];
f=f+100*xd*xd; }
break;
23
L’annexe : Code source en C d’une version simple de PSO
case 5:
// Chercher minimum champ entre le Champ_A =e-x (1+sin (10x))//
// et le Champ_B =e- 2.7-x (1+sin (10 2.7-x ))//
f=0;
for(d=0;d<D;d++)
{
f=f+(exp(-x.x[d])*(1+sin(10*x.x[d]))+exp(-(fabs(2.7-x.x[d])))*(1+sin(10*(fabs(2.7-x.x[d])))));
}
break;
case 6:
//fonction de cour//
3
// F(x) = x - 9 * x 2 +24 * x – 12//
f=0;
for(d=0;d<D;d++)
{
f=f+(x.x[d]*x.x[d]*x.x[d]-9*x.x[d]*x.x[d]+24*x.x[d]-12);
}
break;
}
return f;
}
24
Référence Bibliographique
Sites Internet :
[7] : Méthode des essaims particulaires :
http://www.particleswarm.net/Séminaire OEP’2003
http://www.particleswarm.net/oep_2003/
http://www.particleswarm.info/
[8] : Groupe de travail sur les métaheuristiques :
http://www.lifl.fr/~talbi/META
[9] : Livre récent sur les métaheuristiques :
http://www.eyrolles.com/php.informatique/Ouvrages/ouvragem.php3?ouv_ean13
=9782212113686
25