Recherche Operationnelle Et Optimisation

Recherche opérationnelle et
Optimisation
Master 1 — Informatique
Denis Robilliard
Lisic — Univ Littoral-Côte d’opale
2010
Denis Robilliard (Lisic — Univ Littoral-Côte d’opale) Recherche opérationnelle et Optimisation 2010 1 / 100
Sommaire général
1 Généralités Stratégies évolutionnaires

Présentation de la R.O. Algorithme génétique
Optimisation Méthode de Path-Relinking
Complexité d’un algorithme Algorithme des Fourmis
Méta-heuristiques et recherche 4 Problèmes multi-critères
locale Définitions
Comparaison de deux Front Pareto
heuristiques Réduction à un objectif
2 Méthodes à solution unique Approches par
Hill-climber Pareto-domination
Recuit simulé 5 TD / TP
Recherche Tabou Exercices
Random restart Présentation des TPs
3 Méthodes à base de population La fonction de Griewank
Généralités Les matrices de Erickson
Méthodes évolutionnaires Compte-rendu
() Recherche opérationnelle et Optimisation 2 / 100
Sommaire du chapitre
1 Généralités
Présentation de la R.O.
Recherche Opérationnelle
Organisation du cours
Optimisation
Problème d’optimisation
Problème continu / discret
Exemple continu
Exemple combinatoire
Complexité d’un algorithme
Définition
Calcul de la complexité
Exemple de calcul
Conclusion
Méta-heuristiques et recherche locale
Définitions
Voisinage et optima locaux
Comparaison de deux heuristiques
Principes
2 Méthodes( )à solution uniqueRecherche opérationnelle et Optimisation 3 / 100

Définition
Origines
”Recherche Opérationnelle” vient de ”operations research” (Royaume-Uni, 2nd
guerre mondiale).
Où placer les stations radars ? Comment plannifier les vols de
surveillance anti-sous-marins ? ...
Définition
Recherche Opérationnelle : élaboration et amélioration / optimisation de
méthodes de résolution de problèmes complexes.
Deux grandes familles de méthodes :

I méthodes exactes, basées sur des principes mathématiques
I méthodes approchées ou heuristiques, souvent stochastiques (utilisation
du hasard) : quand les méthodes exactes ne sont pas disponibles ou sont
trop coûteuses ⇒ souvent !

Organisation du cours
Le cours de RO est divisé en deux, selon méthodes exactes/approchées

I Généralités et méthodes approchées (ce cours)
I méthodes exactes (cours fait par Gilles Roussel)
Pré-requis :
I un peu de maths (quantificateurs, ...),
I algorithmique et structures de données de base,
I connaissance du langage C pour les algos,
I de Java pour les TPs.
Objectifs :
I connaı̂tre le vocabulaire et les concepts de base,
I connaı̂tre et avoir compris les algorithmes de base,
I avoir implanté et utilisé quelques algorithmes sur ordinateur,
I savoir adapter un algorithme à un nouveau problème.
Organisation du cours (x 2) : 6h de cours magistral, 3h de travaux dirigés,
9h de travaux pratiques.

Problème d’optimisation
Définition
On dispose d’un ensemble S de solutions ”candidates” : c’est l’espace de
recherche.
A chaque solution est associé un réel, sa qualité, calculable par une
fonction qualité / objectif / coût / ”fitness”
On cherche la solution de meilleure qualité, appelée optimum global (ou
du moins on veut s’en approcher).
Sémantique qualité / coût

Selon le pb, on veut maximiser ou minimiser l’objectif.
Les algos seront présentés dans un contexte de minimisation (prendre
l’opposé de la qualité pour maximiser).

Problème d’optimisation : suite
Optimisation multi-critères
Très souvent on veut optimiser plusieurs fonctions/critères de qualité en
même temps : problème multi-critères, multi-objectifs.
Ex : on veut le moteur le plus puissant, mais aussi le plus léger, qui
consomme le moins possible et qui coûte le moins cher à fabriquer...
L’optimisation multi-critères est un sous-domaine spécifique (voir plus
loin).

Problème continu / discret
Problème continu
Optimisation continue : les solutions sont des vecteurs de réels : on parle
de variables réelles, et l’espace de recherche est infini.
Problème discret
L’espace de recherche est fini, discret.
Les problèmes discrets sont généralement combinatoires.
Optimisation combinatoire : une solution est une combinaison d’éléments
pris dans un ensemble discret : on parle de variables discrètes. Ex : un
sous-ensemble des arcs d’un graphe.

Problème continu / discret (suite)
Contraintes
On a souvent un ensemble de contraintes sur la valeurs des variables / la
forme des solutions (ex : pas de valeurs négatives en optimisation
continue).
La résolution de contraintes, notamment discrètes (ex : sudoku...) est un
champ spécialisé : (Constraint Solving Problem — CSP).

Exemple de problème d’optimisation continue
En utilisant 16 fragrances de base, composer un parfum intéressant :
Forme des solutions : vecteur de 16 réels (proportion de chaque
fragrance)
Contraintes : proportions dans [0, 1.0], et somme = 1.0.
Fonction objectif : moyenne des notes données par un jury
Taille de l’espace de recherche : infini !
Note
On pourrait vouloir discrétiser chaque proportion :
I On discrétise en 21 valeurs de 0% à 100% par pas de 5%
I Taille de l’espace de recherche : 2116 = 1, 43e + 21
En pratique : plus compliqué ! Exemple : on veut une solution

significativement différente de l’existant => problème multi-critères (2ème
fonction objectif : distance à l’existant).

Exemple de problème d’optimisation combinatoire
Problème du voyageur de commerce (PVC)

on veut visiter chacune des N = 25 villes où se trouvent les clients.
On ne considère que la route la + courte d’une ville à l’autre.
Trouver le circuit de longueur minimale.
Forme des solutions : vecteur de 25 entiers (numéro des villes dans

l’ordre de parcours)
Fonction objectif : longueur du parcours
Contrainte : chaque entier doit être présent une et une seule fois.
Taille de l’espace de recherche : N !/2N = 3, 102e23
En pratique : on pourrait prendre en compte des péages sur certaines routes,
le temps de parcours, etc.

Notion de complexité d’un algorithme
Définition
Complexité d’un algorithme : relation entre le temps de calcul ou la
mémoire occupée et la taille des données traitées.
On se limite à la complexité en temps de calcul, toujours supérieure à
celle en mémoire.
On exprime la relation par une fonction : temps = fn(taille).
On s’interesse au taux d’accroissement de cette fonction.
Raffinement
Pour une même taille de données, le temps peut varier selon la valeur des
données. Ex : trier un tableau presque rangé ou complètement aléatoire.
⇒ complexité dans le cas moyen, dans le pire des cas, etc.

Classes de complexité
Classes de complexité
On classe les fonctions en deux familles selon leur taux d’accroissement :
les polynômes et les exponentielles.
une fonction est dite (à croissance) polynômiale s’il existe un polynôme
qui la borne supérieurement : ∀n ∈ N, ∃b ∈ N, c ∈ R tels que f (n) ≤ c .nb
une fonction dans N est dite (à croissance) exponentielle si sa croissance
suit une progression géométrique : f (n) ≈ c .eb.n
les fonctions polynômiales croissent moins vite que les fonctions
exponentielles : il n’existe pas b ∈ N tel que ∀ n ∈ N, nb > en
Note : il existe d’autres classes plus fines de complexité.

Calcul de la complexité
Calcul du temps d’exécution

On le considére proportionnel au nombre d’instructions élémentaires
effectuées (ex : affectation, opérations arithmétiques, mais pas un tri ! Cf.
cours IASF)
La traduction d’un langage de programmation (usuel) dans un autre se fait
en temps polynômial => on peut ignorer le langage (polynômes clos par
composition).
Calcul de la taille de la donnée

Toute donnée peut être codée comme nombre (cf. IASF).
Le codage doit être raisonnable : pas en base 1. En effet 10k occupe :
I k+1 chiffres en décimal ;
I (ln(10)/ ln(2))k + 1 soit 3.32k+1 chiffres en binaire ;
I mais... 10k bâtons en base 1 !

Exemple de calcul de complexité
1 la recherche exhaustive de l’élément minimum d’une matrice carrée de
taille N ;
2 la recherche exhaustive d’une solution minimale au PVC basé sur la
même matrice de distances de taille N.
Dans les deux cas, il faut effectuer ”taille de l’espace de recherche” opérations
de comparaison :
1 cas 1) : N 2 opérations
2 cas 1) : N !/2N = O (en ) opérations
Avec une machine traitant 109 comparaisons/s , variation du temps de calcul

en fonction de la taille de la donnée :
N 10 20 30 40 50 60
algo 1 0,1 µs 0,4 µs 0,9 µs 1,6 µs 2,5 µs 3,6 µs
algo 2 181µs 6 . 109 s 4 . 1021 s 1037 s 1053 s 1071 s
Rappel : âge de l’Univers = 1017 secondes...
Conclusion sur la complexité
On sépare les problèmes en 2 classes :

I ceux solvables avec algos en temps polynômial : problèmes faciles
(indépendamment de la difficulté d’écrire l’algo)
I ceux solvables seulement (actuellement) avec algos en temps exponentiel :
problèmes difficiles, algos non faisables.
Note : déterminer si une solution est un optimum global peut être non
faisable.
Note : il y a aussi des problèmes non tractables sur ordinateur (voir cours
IASF)
Bilan
Nombreux problèmes difficiles => développement d’heuristiques en temps
polynomial pour approcher les solutions optimales.

Méta-heuristiques et recherche locale
Définitions
Méthode approchées = heuristiques
Méta-heuristique = heuristique généralisée, incomplètement spécifiée, à
adapter au problème.
Parmi les méthodes approchées, optimisation ”boı̂te noire” : ne requiert
que la capacité d’estimer la qualité des solutions
Les méta-heuristiques sont souvent stochastiques, et ”boı̂te noire”.
Classification
Les heuristiques procèdent par transformation ou par construction.
Méthodes par transformation partielle de solution, on parle aussi de
recherche locale. On cherche à améliorer peu à peu une solution
existante et complète.
Méthodes constructives : on construit une solution morceau par morceau,
généralement en se basant sur la qualité des morceaux (donc pas ”boı̂te
noire”).
Voisinage
Dans les méthodes par transformation, une solution peut souvent être
transformée en plusieurs autres possibles :
Définitions
l’ensemble des solutions transformées possibles est le voisinage de la
solution initiale.
La méthode/algorithme de transformation : opérateur de voisinage.
De nombreuses méta-heuristiques(de transformation) utilisent cette

notion de voisinage. Pour les implanter, il faut inventer et coder un
voisinage adapté au problème :
I Une solution doit avoir un nombre de voisins suffisant pour permettre d’y
trouver un voisin meilleur.
I Le voisinage ne doit pas être trop grand pour ne pas être trop long à
explorer (typiquement taille polynomiale en fonction de la taille du
problème).
I Le voisinage ne peut pas être l’espace de recherche total ⇒ recherche
aléatoire !
Voisinage dans les problèmes continus
Convolution Gaussienne
Un voisinage ”standard” en variables continues : ajouter un ”bruit”
Gaussien de moyenne 0 à chaque variable de la solution.
La variance du bruit est à adapter au problème (faible chance de grosse
modification).
v e c t o r GaussianConvolution ( v e c t o r v , i n t N, f l o a t sigma2 ) {
/ / v : v e c t e u r s o l u t i o n de t a i l l e N
/ / sigma2 : v a r i a n c e de l a d i s t r i b u t i o n Gaussienne / Normale
/ / min , max : borne minimum , maximum
f l o a t tmp ;
f o r ( i n t i = 0 ; i < N ; i ++) {
do {
tmp = GaussianRandom ( 0 , sigma2 ) ;
} while ( ( v [ i ] + tmp ) < min | | ( v [ i ] + tmp ) > max ) ;
v [ i ] = v [ i ] + tmp ;
}
return v ;
}
Voisinage dans les problèmes continus (suite)
Echantillonage gaussien :
La méthode de Box-Mueller permet d’obtenir un bruit gaussien de
moyenne µ et de variance σ2 (algo ci-dessous).
En Java, le package java.util.Random fournit un générateur gaussien
de moyenne 0 et de variance 1, que l’on peut adapter :
Gauss(µ, σ2 ) = µ + σ2 Gauss(0, 1)
f l o a t GaussianRandom ( f l o a t mu, f l o a t sigma2 ) {

/ / mu e s t l a moyenne voulue
/ / sigma2 e s t l a v a r i a n c e voulue
float x , y , g, h;
do {
x = rand ( 0 . 0 , 1 . 0 ) ; / / d i s t r i b u t i o n u n i f o r m e
y = rand ( 0 . 0 , 1 . 0 ) ; / / d i s t r i b u t i o n u n i f o r m e ( independant de x )
w = x∗x + y∗y ;
} while ( ! ( w > 0 . 0 && w < 1 . 0 ) ) ;
g = mu + sigma2 ∗ x ∗ s q r t (−2 ∗ l o g (w) / w) ;
h = mu + sigma2 ∗ y ∗ s q r t (−2 ∗ l o g (w) / w) ;
r e t u r n g ; / / ou r e t o u r n e r h , ou l e s deux
} () Recherche opérationnelle et Optimisation 20 / 100
Optima locaux
Définitions
Soit V un opérateur de voisinage, une solution s est un optimum local
(relativement à V ) si : ∀s0 ∈ V (s), f (s0 ) ≤ f (s)
Des optima locaux peuvent être contigus et former un plateau de fitness :
zone où toutes les solutions ont la même qualité.
Quand on est dans un optimum local, on ne peut plus exploiter le

voisinage, sauf en acceptant de perdre de la qualité !
Un optimum global est toujours aussi optimum local.
Problème uni/multi-modal
Problème uni-modal : il n’y a qu’un optimum local (/ au voisinage), et il est
aussi global.
Problème multi-modal : plusieurs optima locaux (/ au voisinage) ⇒ a priori
plus difficile à traiter.

Paysage de performance
Definition
Pour les problèmes en 1 ou 2 dimensions, on dessine la fonction objectif
selon l’axe vertical, comme une ”altitude”.
Le graphe obtenu est appelé paysage de performance ou fitness
landscape.
Illustration de paysage de problème uni/multi-modal

Comparaison de deux heuristiques
Principes
Problème des méthodes stochastiques : leur résultat varie d’une
exécution à l’autre sur le même problème !
Utiliser des méthodes de comparaisons statistiques pour comparer deux
ensembles de résultats : au moins 30 exécutions par méthode.
Se placer dans les conditions les plus semblables pour les deux
heuristiques (graine initiale du générateur aléatoire, nombre d’évaluations
du fitness...)
La distribution des résultats est généralement inconnue et non
Gaussienne ⇒ utiliser des test non paramétriques :
Wilcoxon-Mann-Whitney, ou encore Kolmogorov-Smirnoff (distribution
continue)...
Calcul avec ”R”

Test avec le logiciel libre ”R” : commandes wilcox.test
(Wilcoxon-Mann-Whitney) et ks.test (Kolmogorov-Smirnoff) ;
Exemple de calcul avec R
Avertissement : ceci un exemple ”jouet” : les données exemples sont
trop peu nombreuses (il en faudrait au moins deux fois 30).
Test de similitude entre 2 heuristiques
On Suppose que le résultats (non continu) de 2 heuristiques est :
h1 = {20, 21, 22, 23, 29} et h2 = {27, 32, 35, 39, 60}
> h1=c ( 2 0 , 21 , 22 , 23 , 29)
> h2=c ( 2 7 , 32 , 35 , 39 , 60)
> w i l c o x . t e s t ( h1 , h2 )
Wilcoxon rank sum t e s t
data : h1 and h2
W = 1 , p−v a l u e = 0.01587
a l t e r n a t i v e h y p o t h e s i s : t r u e l o c a t i o n s h i f t i s n o t equal t o 0
Interprétation
La ”p-value” est la probabilité que les heuristiques soient semblables (ici,
≈ 1, 6% avec une confiance de 95% par défaut). On peut
raisonnablement rejeter cette hypothèse.
Exemple de calcul avec R : suite
Test h1 < h2
> h1=c ( 2 0 , 21 , 22 , 23 , 29)

> h2=c ( 2 7 , 32 , 35 , 39 , 60)
> w i l c o x . t e s t ( h1 , h2 , a l t e r n a t i v e = ” g r e a t e r ” )
Wilcoxon rank sum t e s t
data : h1 and h2
W = 1 , p−v a l u e = 0.996
a l t e r n a t i v e h y p o t h e s i s : t r u e l o c a t i o n s h i f t i s g r e a t e r than 0
Interprétation
Ici, avec une confiance de 95% (par défaut) on sait qu’il y a ≈ 99.6% de
chance que h1 soit inférieure à h2 , ce qu’on peut raisonnablement
accepter.

1 Généralités
2 Méthodes à solution unique

Hill-climber
Recuit simulé
Recherche Tabou
Random restart
3 Méthodes à base de population
4 Problèmes multi-critères
5 TD / TP

Hill-climber de base
Principe : ”on suit la pente vers le bas” (minimisation)

1 soit s une solution initiale (souvent aléatoire)
2 on tire un voisin, en général choisi stochastiquement, dans le voisinage de
la solution s.
3 il remplace la solution courante s’il est meilleur
4 on itère en 2) ou on arrète quand on a un optimum local (on est alors
coincé) ou si le temps de calcul est épuisé

Hill-climber de base : algo
s o l u t i o n H i l l C l i m b e r ( s o l u t i o n s0 ) {
solution s , t ;
s = s0 ; / / copier s o l u t i o n courante
do {
t = Voisin ( s ) ; / / o b t e n i r un v o i s i n
if ( f ( t ) < f (s) ) / / un m e i l l e u r v o i s i n
s = t; / / remplacement
} while ( ! s o l u t i o n s a t i s f a i s a n t e && ! temps epuise ) ;
return s ; / / s e s t un optimum l o c a l
}

Hill-climber de base : illustration

Hill-climber gradient
Principe : ”on suit la plus grande pente vers le bas” (le ”gradient”)
comme le hill-climber de base mais tester plusieurs (tous les) voisins
avant d’accepter.
Voisin() retourne sucessivement toutes les solutions du voisinage si
celui n’est pas trop grand (Ex : heuristique Lin-Kernighan pour le PVC).

Hill-climber gradient : algo
s o l u t i o n H i l l C l i m b e r E l i t i s t e ( s o l u t i o n s0 , i n t n ) {
solution s , t , r ;
I n i t V o i s i n a g e ( s ) ; / / preparer l e 1er v o i s i n
do {
t = P r e m i e r V o i s i n ( s ) ; / / o b t e n i r un v o i s i n
f o r ( i = 0 ; i < n −1; i ++) { / / n = nombre de v o i s i n s
r = VoisinSuivant ( s ) ; / / o b t e n i r un v o i s i n
if ( f ( r ) < f ( t ) ) / / un m e i l l e u r v o i s i n
t = r; / / remplacement
}
i f ( f ( t ) < f ( s ) ) / / le meilleur voisin est meilleur
s = t;
} while ( ! s o l u t i o n s a t i s f a i s a n t e && ! temps epuise ) ;
return s ; / / s e s t un optimum l o c a l
}

Hill-climber (base) : illustration

Recuit simulé
Principe : accepter un voisin selon un critère probabiliste, qui permet d’accepter

de perdre de la qualité, donc de sortir des optima locaux. Comme on peut
perdre de la qualité, il faut stocker la meilleure solution rencontrée dans le
passé. Cette technique est inspiré de la cristallisation des métaux de fonderie.
1 soit s une solution initiale (souvent aléatoire)
2 on tire un voisin, en général choisi stochastiquement dans le voisinage de
la solution s.
3 il remplace la solution courante s’il est meilleur
4 s’il est moins bon il peut tout de même remplacer la solution courante,
selon une règle probabiliste/stochastique :
I moins il est bon, moins il a de chance d’être accepté.
I plus l’algorithme avance, moins il a de chance d’être accepté.
5 on le mémorise si c’est la meilleure solution rencontrée
6 on itère en 2) ou on arrète si le temps de calcul est épuisé

Recuit-simulé : algo
s o l u t i o n R e c u i t ( s o l u t i o n s0 , i n t n ) {
s o l u t i o n s , r , best ;
f l o a t temp ;
best = s ;
i n i t (& temp ) ; / / t e m p e r a t u r e i n i t i a l e
do {
r = V o i s i n ( s ) ; / / o b t e n i r un v o i s i n
if (
( f ( r ) < f ( s ) ) / / un m e i l l e u r v o i s i n
| | ( rand ( 0 , 1 ) < exp ( ( f ( s )− f ( r ) ) / temp ) / / r e g l e de m e t r o p o l i s
)
s = r; / / remplacement
}
r e d u i r e (& temp ) ;
i f ( f ( s ) < f ( best ) ) / / l e m e i l l e u r v o i s i n est m e i l l e u r
best = s ;
} while ( ! s o l u t i o n s a t i s f a i s a n t e && ! temps epuise && temp > 0 ) ;
return best ;
}

Règle de metropolis
Formule
Accepter r si rand (0, 1) < exp((f (s) − f (r ))/temp)
Si maximisation : rand (0, 1) < exp((f (r ) − f (s))/temp)

Planning de recuit
Question
A quelle temperature commencer ? Tester l’acceptation de 95% de
solutions aléatoires.
Quelle décroissance de température ?
I Créer des paliers de température : idéalement on devrait avoir une chance
non nulle de pouvoir atteindre n’importe quelle solution de l’espace
(ergodicité) pendant le palier.
I Faible baisse de température entre paliers : tempt +1 = c · tempt avec
0 < c < 1 proche de 1.

Recuit simulé : bilan
Est que ça marche ? Selon les problèmes... Très bon ou très mauvais
(en temps) par rapport aux autres heuristiques.
Exemple d’application : déplacement du bras de Mars Explorer.

Recherche Tabou (F. Glover, 1986)
Principe
Recherche Tabou : extension du Hill-climber.
Arrivé sur un optimum local on poursuit la recherche pour sortir du bassin
d’attraction de cet optimum.
Bassin d’attraction d’un optimum local : ensemble des solutions telles
que, en partant d’elles, le hill-climber mène au même optimum local
(rappel : dépendant du voisinage).
On accepte de perdre de la qualité, pour s’éloigner de l’optimum local.
Problème :
I On veut pouvoir accepter une bonne nouvelle solution
I On veut éviter de succomber à l’attraction des relativement bonnes
solutions que l’on laisse derrière nous autour de l’optimum local

Recherche Tabou (suite)
Compromis
Pour éviter de retourner en arrière, on garde en mémoire une liste de
transformations interdites : liste “tabou”.
Pour saisir une éventuelle bonne occasion, un critère “d’aspiration”
permet de passer outre à la liste tabou dans certains cas précis.
La liste tabou peut contenir :

I les solutions récemment explorées (faible)
I l’inverse des transformations récemment explorées (mieux)
Il faut la parcourir souvent, donc sa taille est un facteur critique :
I Trop grande, elle est coûteuse
I Trop courte, on risque de tourner en rond
I ⇒ faire varier sa taille dynamiquement
Critère d’aspiration standard : améliorer la meilleure solution trouvée (on
est donc sorti de l’optima local)

Recherche Tabou (suite)
Alors que l’arrêt de l’algorithme du grimpeur est garanti par construction,

l’algorithme Tabou peut boucler infiniment puisqu’il s’autorise à gagner
puis à perdre en qualité des solutions.
Critère d’arrêt habituel : stopper l’exploration quand on n’a pas réussi à
améliorer la meilleure solution trouvée pendant un nombre d’itérations
donné.

Recherche Tabou : illustration

Recherche Tabou : algo
s o l u t i o n tabou ( s0 : s o l u t i o n ) {
s o l u t i o n s , t , old , b e s t ;
i n t compteur ; l i s t e T ; / / l i s t e tabou
s = s0 ;
b e s t = s0 ;
compteur = 0 ;
while ( compteur < BORNE) {
compteur = compteur + 1 ;
/ / o b t e n i r m e i l l e u r v o i s i n non taboue ( ou a s p i r e )
t = meilleur voisin (s , T) ;
old = s ;
s = t;
if ( f ( i ) < f ( best ) ) {
best = i ;
compteur = 0 ; / / i n i t temps recherche
}
m e t t r e a j o u r (& old , &s , &T ) ;
}
return best ;
}
Random restart
Idée
Chacune des heuristiques explore une (infime) partie de l’espace de
recherche.
Toutes sont génées par les optima locaux de la partie de l’espace
explorée.
⇒ relancer l’algo avec une autre solution initiale, générée
stochastiquement ou avec un schéma systématique de diversification.
on peut aussi modifier le paramètrage de l’algorithme, lors de ces

nouveaux essais : changer le planning de recuit, la taille de la liste tabou,
...

1 Généralités

Généralités
Méthodes évolutionnaires
Principes
Vocabulaire
Reproduction asexuée / sexuée
Caractéristiques générales
Stratégies évolutionnaires
Algorithme génétique
Méthode de Path-Relinking
Algorithme des Fourmis
Étude des insectes sociaux
Stigmergie artificielle
Méthodes à base de population
Principe : prendre en compte plusieurs solutions simultanément.
Méthodes évolutionnaires
Plusieurs méthodes à base de population de solutions s’inspirent de
l’évolution Darwinienne.
Idée : l’évolution a su assembler des molécules pour créer des être
vivants sophistiqués
⇒ modéliser l’évolution de solutions à un problème donné.
Il existe d’autres méthodes de population, d’inspiration plus intuitive.

Méthodes évolutionnaires : principes
Théorie de l’évolution Darwinienne

Principe de ”sélection naturelle” (Darwin, 1859)
Evolution = survie des meilleurs ?
⇒ Evolution =
I Reproduction des individus suffisamment bien
adaptés.
I Apparition de variations lors de la
reproduction.
I Accumulation des caractères favorables.
Pinsons de Darwin

Méthodes évolutionnaires : vocabulaire
Le vocabulaire est fortement emprunté à la biologie :
Table d’équivalence
individu = solution
population = ensemble d’individus
fitness = qualité
évaluation = calcul du fitness pour tous les individus de la population
génotype / génome / chromosome = encodage d’une solution
phénotype = représentation de la solution afin de calculer sa qualité (peut
être semblable ou pas à son génome)
géne = position dans le génome
allèle = valeur d’un gène

Méthodes évolutionnaires : vocabulaire (suite)
Table d’équivalence (suite)

sélection = choix des solutions destinées à être répliquées
parent = solution sélectionnée pour être répliquée
enfant = parent après réplication et variation / tranformation
mutation = variation / transformation
crossover = recombinaison de parties du génome des parents pour
produire les enfants
génération = itération de l’algorithme comprenant le remplacement d’une
population par la population fille.

Méthodes évolutionnaires : schéma général

Modèles de réplication / reproduction
Modèles naturels
La nature offre deux modèles de reproduction :
I Reproduction asexuée ou clônage, plutôt organismes simples
(unicellulaires, moisissures, fraisiers, pucerons, ...) ⇒ variation du génome
par mutation.
I Reproduction sexuée, plutôt organismes complexes ⇒ variation du
génome par mutation et par recombinaison des génomes des parents.
Modélisation informatique
Stratégies évolutionnaires (Schwefel & Rechenberg, 1969) : mutation
seule, généralement implantée comme une transformation dans un
voisinage.
Algorithme génétique (Holland, 1974) : mutation et recombinaison.

Principe de la recombinaison
Recombinaison
Recombiner c’est mélanger les caractères des parents.
Attention à utiliser un mélange non moyennant !
Exemple : mélanger de l’eau et du vin ne permet jamais de retrouver soit

de l’eau soit du vin pur ⇒ c’est un mélange moyennant.
Objection du XIXème siècle à la théorie de Darwin : la spéciation est
impossible.

Recombinaison (suite)
Recombinaison discrète
Si les génes sont discrets (cas des génomes des êtres vivants), alors la
recombinaison par crossover n’est pas moyennante.

Recombinaison (suite)
Recombinaison continue
Si les gènes sont continus, il faut simuler un caractère discret pour obtenir
un effet non moyennant.
Exemple de 2 gènes numériques parents : tirer la valeur du gène

recombiné selon une distribution de probabilité non moyennante
⇒ BLX-0.5 et BGX-like sont beaucoup plus généraux que BLX-0.

Méthodes évolutionnaires : caractéristiques générales
Caractéristiques
Coûteuses en temps de calcul : on manipule des populations parfois de
l’ordre du million d’individus.
⇒ à réserver aux problèmes difficiles.
Généralement stochastiques ⇒ maintenir la variété des individus.
Très paramétrées : taille de la population, nombre de génération,
opérateurs de variations, ...
Assez robustes au paramétrage.
Efficaces si on sait introduire de la connaissance sur le problème,
notamment dans les opérateurs de variations, et dans l’évaluation (gain
de temps).

Stratégies évolutionnaires (µ, λ)
Caractéristiques
Elles correspondent au schéma de reproduction asexué, sans partage
d’information entre solutions.
Toutefois la sélection se fait en comparant le fitness des solutions (donc
différent d’une heuristique à solution unique itérée plusieurs fois).
Deux variantes principales :
I S.E.(µ, λ) : les µ meilleurs des λ enfants remplacent les µ parents ;
I S.E.(µ + λ) : les µ meilleurs des µ parents + λ enfants remplacent les µ
parents ;
Utilisées plutôt sur les problèmes continus.
Heuristique du 1/5ème
Une règle heuristique pour adapter la variance du bruit Gaussien sur les
problèmes continus : augmenter la variance si plus de 1/5ème des enfants
sont de fitness meilleurs que les parents, la diminuer si c’est moins de
1/5ème , laisser identique sinon.
Stratégies évolutionnaires (µ, λ)
s o l u t i o n E v o l S t r a t ( i n t mu, i n t lambda ) {
s o l u t i o n b e s t = NULL ;
int child ;
P o p u l a t i o n P , Q;
i n i t ( P , lambda ) ; / / c r e e r l a pop i n i t i a l e de t a i l l e lambda
i n i t (Q, mu) ; / / t e m p o r a i r e pour r e p r o d u c t e u r s
while ( 1 ) {
f o r ( i n t i = 0 ; i < lambda ; i ++) / / e v a l pop
Evaluer (P[ i ] ) ;
t r i e r ( P ) ; / / par c o u t c r o i s s a n t
i f ( b e s t == NULL | | f i t n e s s ( P [ 0 ] ) < f i t n e s s ( b e s t ) )
best = P [ 0 ] ;
i f ( s o l u t i o n s a t i s f a i s a n t e ( b e s t ) | | temps epuise )
return best ;
c o p i e r (Q, P , mu) ; / / Q [ 0 . . mu−1] <− P [ 0 . . mu− 1];
child = 0;
f o r ( i n t i =0; i < mu; i ++) / / l e s mu m e i l l e u r s
f o r ( i n t j = 0 ; j < lambda /mu; j ++)
P [ c h i l d ++] = Muter ( Copie (Q[ i ] ) ) ; / / nouvel e n f a n t
}
}
Stratégies évolutionnaires (µ + λ)
s o l u t i o n E v o l S t r a t ( i n t mu, i n t lambda ) {
int child ;
Population P;
i n i t ( P , mu+lambda ) ; / / pop i n i t , t a i l l e mu+lambda
while ( 1 ) {
f o r ( i n t i = 0 ; i < mu+lambda ; i ++) / / e v a l pop
Evaluer (P[ i ] ) ;
t r i e r ( P ) ; / / par c o u t c r o i s s a n t
best = P [ 0 ] ;
i f ( s o l u t i o n s a t i s f a i s a n t e ( b e s t ) | | temps epuise )
return best ;
c h i l d = mu;
f o r ( i n t i =0; i < mu; i ++) / / l e s mu m e i l l e u r s
f o r ( i n t j = 0 ; j < lambda /mu; j ++)
P [ c h i l d ++] = Muter ( Copie ( P [ i ] ) ) ; / / nouvel e n f a n t
}
}

Caractéristiques
Imite la reproduction sexuée ⇒ partage d’information entre solutions.
Deux variantes principales :
I A.G. générationnel : les enfants d’une génération remplacent tous les
parents de la génération précédente.
I A.G. ”steady state” : chaque enfant remplace immédiatement un parent
moins bon et devient parent potentiel.
”Elitisme” : conserver une fraction des meilleurs parents à la génération
suivante (même si tous les enfants sont meilleurs).
Cas binaire
Les solutions sont des vecteurs de bits.
Les opérateurs de transformations standards sont :
I La mutation ”bit-flip” qui inverse certains bits selon une probabilité donnée.
I Le crossover 1-point qui coupe 2 vecteurs parents au même endroit et
échange deux moitiés pour créer les enfants.

s o l u t i o n GA( i n t popsize , i n t n ) { / / n : nombre d ’ ” e l i t e s ”
s o l u t i o n b e s t = NULL , Pa , Pb , Ca , Cb ;
P o p u l a t i o n P , Q;
i n i t ( P , popsize ) ;
do {
f o r ( i n t i = 0 ; i < popsize ; i ++) / / e v a l pop
Evaluer (P[ i ] ) ;
t r i e r (P ) ; / / par c o u t c r o i s s a n t
best = P [ 0 ] ;
c o p i e r (Q, P , n ) ; / / Q [ 0 . . n −1] <− P [ 0 . . n −1]
f o r { i n t i = 0 ; i < ( popsize − n ) / 2 ; i ++) {
Pa = S e l e c t i o n ( P ) ; Pb = S e l e c t i o n ( P ) ;
Crossover (&Pa , &Pb , &Ca , &Cb ) ;
Q[ i ∗2+n ] = M u t a t i o n ( Ca ) ; Q[ i ∗2+1+n ] = M u t a t i o n ( Cb ) ;
}
P=Q;
while ( ! s o l u t i o n s a t i s f a i s a n t e ( b e s t ) && ! temps epuise ) ;
return best ;
}

A.G. : sélection, mutation
Sélection par tournoi
s o l u t i o n TournamentSelection ( P o p u l a t i o n P , i n t t o u r n a m e n t s i z e ) {
s o l u t i o n b e s t = P [ rand ( 0 ,N− 1]; / / t i r a g e a l e a d ’ un i n d i v i d u
f o r ( i n t i =2; i <= t o u r n a m e n t s i z e ; i ++) {
s o l u t i o n n e x t = P [ rand ( 0 ,N− 1];
i f ( f i t n e s s ( next ) < f i t n e s s ( best ) ) / / next est m e i l l e u r
best = next ;
}
return best ;
}
La sélection est indépendante a priori de la forme des solutions.

Il existe d’autres méthodes de sélection, éventuellement multi-critères.

A.G. binaire : mutation
Mutation bit-flip
s o l u t i o n B i t −F l i p M u t a t i o n ( s o l u t i o n v , f l o a t p ) {
/ / p : p r o b a b i l i t e d ’ i n v e r s e r un b i t
f o r ( i n t i =0; i < L ; i ++) / / L e s t l a l o n g u e u r de v
i f ( rand ( 0 . 0 , 1 . 0 ) < p )
v [ i ] = ˜ v [ i ] ; / / i n v e r s i o n du ieme b i t
return v ;
}
Les opérateurs de mutation sont dépendants de la forme des solutions.

Pour les problèmes continus, utiliser la notion de convolution Gaussienne.

A.G. binaires : crossover
Crossover 1-point binaire
void One−P o i n t C r o s s o v e r ( s o l u t i o n ∗ pa , s o l u t i o n ∗ pb ,
s o l u t i o n ∗ ca , s o l u t i o n ∗ cb ) {
i n t tmp ;
c o p i e r S o l u t i o n ( ca , pa ) ; c o p i e r S o l u t i o n ( cb , pb ) ;
i n t c = rand ( 0 , L −1) ; / / L = t a i l l e des s o l u t i o n s
f o r ( i n t i = c ; i < L ; i ++) {
tmp = ca [ i ] ; ca [ i ] = cb [ i ] ; cb [ i ] = tmp ;
}
}
Les opérateurs de crossover sont aussi dépendants de la forme des

solutions.
Pour les problèmes continus, utiliser la notion de recombinaison non
moyennante.

Méthode de Path-Relinking
Caractéristiques
méthode à base de population mais sans fondements évolutionnaires.
Principe :
I Utiliser des redémarrages d’un algo de recherche locale pour obtenir une
archive d’optima locaux.
I Explorer l’espace en parcourant les solutions situées entre paires d’optima
locaux.
I Optimiser ces solutions intermédiaires dans l’espoir d’obtenir de nouveaux
optima, qui pourront être intégrés à l’archive.
Pré-requis (pour relier les solutions entre elles) :
I opérateur de voisinage ergodique
I mesure de distance entre solutions et/ou calcul de la différence entre
solutions (relativement au voisinage)

Path-Relinking : algo
s o l u t i o n P a t h R e l i n k i n g ( s o l u t i o n ol1 , s o l u t i o n o l 2 ) {
s o l u t i o n best , courant , tmp , c i b l e ;
Population P;
i f ( f ( ol1 ) < f ( ol2 ) ) {
best = c i b l e = ol1 ; courant = ol2 ;
} else {
best = c i b l e = ol2 ; courant = ol1
};
while ( c o u r a n t ! = c i b l e ) {
t r i e r (P ) ; / / par c o u t c r o i s s a n t
t r i e r D i s t ( P ) ; / / par d i s t a n c e c r o i s s a n t e a c i b l e
c o u r a n t = P [ 0 ] ; / / l e m e i l l e u r des p l u s proches de c i b l e
tmp = OptimLocale ( c o u r a n t ) ; / / recherche l o c a l e
i f ( f ( tmp ) < f ( b e s t ) )
b e s t = tmp ;
}
return best ;
}

Algorithme des Fourmis : étude des insectes sociaux
Présentation
≈ 2% des insectes ont un comportement social :
fourmis, termites, abeilles.
⇒≈ 1016 insectes sociaux !
50% sont des fourmis.
100 millions d’années d’évolution...
Quelques exemples :
I Les Atta coupent des feuilles d’arbres et
organisent des ”autoroutes” pour aller les
chercher.
I Les Oecophylla construisent des ponts entre
feuilles. fourmis Oecophylla
I Les Eciton organisent des raids de chasse
comprenant jusqu’à 200.000 individus.

Théorie de l’auto-organisation
Principe
Un comportement ”intelligent” (en fait adapté) au niveau macrosocpique
émerge d’interactions simples au niveau microscopique.
Cela n’exclut pas la possibilité de comportements complexes
indépendants au niveau microscopique.
4 composantes de base :
I Amplification positive : les bons comportements sont renforcés (ex :
recrutement de fourmis).
I Renforcement négatif : les mauvais comportements sont évités (ex :
abandon d’anciennes pistes périmées).
I Fluctuations aléatoires : de nouvelles solutions peuvent être découvertes
(ex : marches aléatoires).
I Interactions multiples : le succès repose sur le grand nombre d’agents (ex :
colonies de 30 à plusieurs millions de fourmis).

Auto-organisation chez les fourmis
Principes
Les agents communiquent :
I directement : contact par les antennes, visuel, sonore ...
I indirectement : en modifiant l’environnement par des dépôts de
phéromones.
La communication indirecte s’appelle stigmergie, et est essentielle à la
coordination des activités des fourmis.
Stigmergie par phéromones

Une type de phéromone attire les autres fourmis ;
Elle s’évapore au cours du temps ;
Elle est déposé par les fourmis lors de leurs déplacements ;
La quantité déposée est controllée par la fourmi ;
Les individus du même nid partagent des phéromones de même type.

Exemple de stigmergie chez la fourmi
Sélection du plus court chemin
Chemin plus court ⇒ plus haute fréquence de passage
⇒ Accroissement de la concentration en phéromone
⇒ Evaporation sur les autres chemins
⇒ Le chemin le plus court devient le principal (une fraction des fourmis
continuera d’emprunter les autres).

Stigmergie artificielle
Principe
Simuler par des agents informatiques le comportements des insectes
sociaux ⇒ Ant Colony Optimisation (ACO).
Ajouter des heuristiques (hill-climber, tabou...) pour raffiner les solutions.
⇒ résolution de problèmes d’optimisation combinatoire : routage,
ordonnancement... (PVC, QAP, SOP, fouille de données, e-learning, ...)
En pratique
On gère une mémoire de phéromones, associé aux éléments du
problème. Ex : choisir le sommet suivant dans un PVC :
⇒ Préférer les arcs avec de forts dépôts de phéromone.
⇒ Ajouter de la phéromone sur les arcs constituant de bons circuits.
⇒ Diminuer régulièrement la phéromone (évaporation) pour ”oublier” les
arcs peu utilisés (mauvais circuits).
C’est une méthode constructive (ajout d’arcs).
Fourmis artificielles pour le PVC
Probabilité de choisir un arc
Un agent fourmi situé sur un noeud du graphe va choisir le prochain
noeud à visiter. La probabilité de choisir l’arc (i,j) dépend :
I de la concentration relative en phéromone τ, par rapport à tous les arcs
issus du sommet i ;
I d’une mesure heuristique η de la qualité de la composante (ex : inverse de
la longueur de l’arc) :
β
ταi ,j ηi ,j
⇒ P [(i , j )] = β où α, β : importance relative de τ et η.
∑k ∈succ(i ) (ταi ,k ηi ,k )
Mise à jour : renforcement et évaporation

Renforcement : ∀ solution s et ∀ arc (i , j ) ∈ s : τi ,j = τi ,j + 1/Fitness(s) où
le fitness est la longueur du tour (le plus petit, le mieux).
Pour l’évaporation on applique : ∀ arc (i , j ) du graphe : τi ,j = (1 − ε)τi ,j
avec 0 < ε << 1
On borne τ : τmin ≤ τi ,j ≤ τmax ⇒ ainsi tous les arcs ont une chance.
Fourmis et PVC : algo
s o l u t i o n ACO PVC( i n t popSize , s o l u t i o n p i s t e [ ] ) {
/ / p i s t e : t a b l e a u de s o l u t i o n s , une par f o u r m i
do {
f o r ( i n t i = 0 ; i < popSize ; i ++) { / / l e s f o u r m i s
p i s t e [ i ] [ 0 ] = 0 ; / / on demarre t o u j o u r s en v i l l e 0
f o r ( i n t j = 1 ; j < N ; j ++) / / c o m p l e t e r l e t o u r
p i s t e [ i ] [ j ] = ChoixFourmi ( p i s t e [ i ] [ j − 1]) ; / / c h o i s i r v i l l e
}
f o r ( i n t i = 0 ; i < popSize ; i ++) { / / optimisation heuristique
RechercheLocale ( p i s t e [ i ] ) ; / / ex : h e u r i s t i q u e LK
f o r ( i n t i = 0 ; i < popSize ; i ++) { / / evaluation
Evaluer ( p i s t e [ i ] ) ;
i f ( b e s t == NULL | | f i t n e s s ( p i s t e [ i ] ) < f i t n e s s ( best ) )
best = p i s t e [ i ] ;
}
f o r ( i n t i = 0 ; i < popSize ; i ++) / / MAJ pheromone
MiseAJourPheromone ( p i s t e [ i ] ) ; / / en f o n c t i o n du f i t n e s s
} while ( ! s o l u t i o n s a t i s f a i s a n t e ( b e s t ) && ! temps epuise ) ;
return best ;
}
1 Généralités
Définitions
Front Pareto
Réduction à un objectif
Combinaison linéaire
Approches évolutionnaires
Approches par Pareto-domination
Rang Pareto
Gestion de la diversité
5 TD / TP

Problèmes multi-critères
Définitions
Problème multicritère ⇒ plusieurs fonctions objectifs à optimiser
simultanément, avec souvent des objectifs partiellement contradictoires.
Une solution x est Pareto-dominante vis à vis d’une solution y si :
I x est supérieure ou égale à y et sur tous les objectifs
I x est strictement meilleure que y sur au moins un objectif.
Si x Pareto-domine y , il n’y a aucune utilité à proposer y .

Front Pareto
Définition
Les solutions de l’espace de recherche non Pareto-dominée forment le
front Pareto.
On parle de solutions Pareto-optimales (et on étend ces concepts aux
solutions effectivement visitées par l’algorithme).
Les solutions Pareto-optimales sont incomparables entre elles ⇒ elles
réalisent des compromis différents / aux objectifs
Le front Pareto n’est pas forcément continu, et il peut être très étendu.
On cherche à échantillonner au mieux les solutions du front Pareto ⇒ on
veut une collection de solutions non Pareto-dominée et pas une seule
solution-compromis.
⇒ les méthodes à base de population sont à privilégier comme
l’algorithme génétique.

Front Paréto : illustration

Réduction à un objectif
Combinaison linéaire
Une méthode ancienne : prendre une combinaison linéaire des objectifs.
Ex : f (s) = 2 ∗ Perf (s) + Duree(s) − 3 ∗ Cout (s)
Problèmes :
I Comment fixer les poids ?
I Les solutions préférées ne sont pas toujours les plus proches du front
Pareto théorique. Exemple avec f (s) = fx (s) + fy (s) :

Réduction à un objectif (suite)
Approches évolutionnaires
Utiliser une méthode évolutionnaire à base de population, modifier la
sélection.
Pour éviter de déterminer des poids, utiliser la sélection par tournoi :
I Tournoi ”lexicographique” : considérer un ordre sur les objectifs
ex : Cout (s) > Perf (s) > Duree(s))
I Tournoi avec objectif tiré aléatoirement.
I Tournoi avec comparaison majoritaire des fonctions objectives.

Réduction à un objectif : tournoi lexicographique
s o l u t i o n MultiobjLexicographicTournament (
P o p u l a t i o n P , i n t sizePop ,
i n t t u r n S i z e , i n t ObjNumber , / / t a i l l e t o u r n o i , nombre d ’ o b j e c t i f s
ObjFun ∗ f ) { / / f : t a b l e a u de p o i n t e u r de f o n c t i o n s o b j e c t i f s
s o l u t i o n Best = P [ random ( 0 , sizePop −1) ] ;

f o r ( i n t i = 1 ; i < t u r n S i z e −1; i ++) { / / t a i l l e du t o u r n o i
s o l u t i o n Next = P [ random ( 0 , sizePop −1) ]
f o r ( i n t j = 0 ; j < ObjNumber ; j ++) { / / p a r c o u r s l e s o b j e c t i f s
i f ( ( f [ j ] ) ( Next ) < f [ j ] ( Best ) ) { / / m e i l l e u r
Best = Next ; break ;
} else i f ( ( f [ j ] ) ( Next ) > ( f [ j ] ) ( Best ) ) / / p i r e
break ;
/ / e l s e i t e r a t i o n s u i v a n t e , comparer avec a u t r e o b j e c t i f
}
}
}
r e t u r n Best ;
}

Approches par Pareto-domination
Rang Pareto
Assigner le (fitness de) rang 1 aux solutions non dominées.
Assigner le rang 2 à celles dominées uniquement par celles de rang 1.
Assigner le rang 3 aux solutions dominées uniquement par celles de rang
2 et 1, etc...
L’algo se code facilement en ignorant à chaque étape les solutions des
rangs précédents

Rang Pareto : illustration

Extraction du front Pareto-dominant
P o p u l a t i o n ParetoDominantFront ( P o p u l a t i o n G) {
/ / G : groupe de s o l u t i o n dont on v e u t un f r o n t
F = {} / / Le f r o n t , v i d e au d e p a r t
f o r each s o l u t i o n G[ i ] de G {
F = F + {G[ i ] } / / a j o u t e r G[ i ] / / on l e suppose dans l e f r o n t
f o r each s o l u t i o n F [ j ] de F a u t r e que G[ i ] {
i f ( F [ j ] Pareto −domine G[ i ] )
F = F − { G[ i ] } / / l e r e t i r e r
else i f (G[ i ] Pareto −domine F [ j ] )
F = F − { F [ j ] } / / un p r e t e n d a n t a r e t i r e r
}
}
return F
}

Gestion de la diversité
Espacement — Sparsity
On souhaite que le front soit échantillonné le mieux possible
⇒ utiliser une mesure d’espacement en plus du rang Pareto.
Ex : sommer les dimensions des côtés de la boı̂te qui contient un point du
front et s’arrète à ses voisins.

Calcul de l’espacement
P o p u l a t i o n A s s i g n S p a r s i t y ( P o p u l a t i o n R, O b j e c t i v e s O) {
/ / R : P o p u l a t i o n s t r u c t u r e e en rangs Pareto
/ / O = {O[ 1 ] , . . . , O[ n ] } o b j e c t i f s
f o r each rang Pareto F de R {
f o r each s o l u t i o n F [ j ] de F {
F [ j ] . espacement = 0 ;
f o r each o b j e c t i f O[ i ] de O {
t r i e r O b j ( F , O[ i ] ) / / F par v a l e u r d ’ o b j e c t i f i c r o i s s a n t
F [ 0 ] = INFINITY ;
F [ LAST ] = INFINITY ;
f o r ( j = 1 ; j < LAST ; j ++)
F [ j ] . espacement = F [ j ] espacement + O[ i ] ( F [ j − 1]) −
O[ i ] ( F [ j + 1 ] ) ;
}
}
return F ;
}

Utilisation de l’espacement
Algorithme NSGA-II
Lors de la phase de sélection, lorsque 2 individus ont même fitness (rang)
Pareto, on préfère celui qui a le plus grand espacement.
L’algorithme NSGA-II (K. Deb, 2000) utilise l’espacement et intègre en
plus une archive des meilleures solutions trouvées, dans le cadre d’une
stratégie évolutionnaire (µ + λ).

1 Généralités
5 TD / TP
Exercices
Présentation des TPs
La fonction de Griewank
Les matrices de Erickson
Compte-rendu

TD exo 0
Codage de Gray
B o ol V e c t or GrayEncode ( B o o l V e c t o r v ) {
B o o lV e c t or w = v ;
f o r ( i = 1 ; i < w . s i z e ( ) ; i ++)
i f ( v [ i − 1])
w[ i ] = ˜w [ i ] ;
r e t u r n w;
}
Sur l’espace de recherche des entiers codés sur 4 bits :

Donnez la table de codage décimal habituel vers code de Gray ;
Commentez.
Soit la fonction objectif : f (x ) = x si x ≤ 8 ou 0 sinon.
Représentez f(x) en codage habituel, puis en code de Gray. Commentez.

TD exo 1
Coloration de graphe
On veut colorer un graphe avec le nombre minimum K de couleurs.
Est-ce un problème d’optimisation ?

De quel type ?
Quelle est la forme des solutions ?
Que peut-on dire de l’espace de recherche ?
Proposer un opérateur de voisinage et de crossover.

TD exo 2
Sac à dos
Soit un ensemble O = {O0 , O1 , . . . , On } ;
Chaque objet est caractérisé par sa taille t (0i ) et sa valeur v (Oi ) ;
On veut remplir un sac de capacité C avec un sous-ensemble S ⊂ O ;
Soit i0 , i1 , . . . , ik les numéros des objets de S, il faut :
I maximiser la valeur des objets emmenés : ∑k
j =0 v (Oij )
I respecter la capacité maximum du sac : ∑k
j =0 t (Oij ) ≤ C
Caractériser ce problème d’optimisation.


TD exo 3
Sudoku 4x4
Un sudoku 4x4 se compose d’une grille de 4x4 cases ;
divisée en 4 régions de 2x2 cases ;
la grille est déjà partiellement remplie ;
il faut la compléter avec des nombres entre 1 et 4 ;
de telle sorte qu’un chiffre n’apparaisse jamais 2 fois dans chaque ligne,
chaque colonne et chaque région.

Proposer un opérateur de voisinage et de crossover, sans oublier que les
chiffres déjà donnés dans la grille initiale sont fixés !

TD exo 4
Bi-section de graphe
Soit un graphe G = (S , A), on veut le partitionner en deux sous-graphes
de même ordre (nombre de noeuds), tels que le nombre d’arcs allant d’un
sous-graphe à l’autre soit minimal.
Plus formellement, soit G = (S , A), on cherche G0 = (S 0 , A0 ) et
G00 = (S 00 , A00 ) tels que :
I S = S 0 ∪ S 00
I |S 0 | = |S 00 |
I Soit C un sous-ensemble de A défini par C = {x ∈ A tels que I (x ) ∈ S 0 et
T (x ) ∈ S 00 ou bien I (x ) ∈ S 00 et T (x ) ∈ S 0 }, avec I (x ) et T (x ) les

applications associant respectivement le sommet initial et le sommet
terminal de l’arc x ;
I Le cardinal de C est minimum.


Présentation des TPs
Nous aborderons en TD/TP la résolution de deux problèmes d’optimisation :

1 la fonction de Griewank
2 les matrices de Erickson
Nous attaquerons ces problèmes avec 3 heuristiques stochastiques vues en
cours :
le Hill-Climber
la Stratégie Evolutionnaire (µ, λ)
le Recuit Simulé
Pour des raisons pratiques (l’horaire de TP est limité) vous testerez les 2
premiers algorithmes sur la fonction de Griewank, et le dernier sur les matrices
de Erickson.

Fonction de Griewank
Définition
La fonction de Griewank est donnée par la formule :
n
2
n √
f (x1 , x2 , . . . , xn ) = (x
∑ i / 4000) − ∏ cos(xi / i ) + 1
i =1 i =1
On cherche x1 , x2 , . . . , xn tels que f prend sa valeur minimum.

Chaque variable xi prend ses valeurs dans [−600; 600]
Nous fixerons n = 10.
Note : on connait l’optimum global, qui est le point origine. On pourra donc
facilement constater en TP si l’heuristique fait converger les xi vers 0.

Fonction de Griewank : illustration pour n = 2

Fonction de Griewank : questions

De quel type ?
Proposer un opérateur de voisinage.

Matrices de Erickson
Problème (d’après M.J. Erickson,“Introduction to Combinatorics”,1963)

Trouver un entier positif n vérifiant la propriété suivante : quelque soit la
matrice binaire carrée de taille n × n, il existe i , j , k tels que les éléments de la
matrice d’indice (i , j ), (i + k , j ), (i , j + k ), (i + k , j + k ) ont la même valeur.
Les 4 éléments forment un carré et sont tous soit de valeur 0 soit de

valeur 1 : on parle de carré constant ou encore de carré
monochromatique (en assimilant 0 et 1 à des couleurs).
C’est un problème assez difficile, résolu en 2009 par énumération de
l’espace de recherche sur ordinateur : on peut toujours trouver un carré
constant dès que la taille de la matrice est n ≥ 15.

Matrices de Erickson (suite)
Nous nous interesseront au problème dérivé plus simple :
Définition du problème dérivé

Matrice de Erickson : matrice binaire carrée de taille n, sans carré
constant.
Trouver une matrice de Erickson pour un n donné.
On traitera en TP les problèmes de taille n = 8 à n = 14 (on sait qu’il est

inutile de chercher au delà de la taille 14).
Pour une taille donnée, on cherche à éliminer les carrés constants.
Note : le problème en taille 14 est assez difficile.

Matrices de Erickson : illustration pour n = 14

Matrices de Erickson : questions

De quel type ?
Proposer un opérateur de voisinage.

Compte-rendu
Vous rendrez :
un compte-rendu (format pdf) comportant les noms de étudiants du
binôme, les résultats obtenus et commentés (qualité, temps d’exécution,
...), avec les algos et le paramétrage complet utilisé pour les obtenir.
le code source compilable sous Unix.
Vous enverrez le tout par e-mail à
robilliard@lisic.univ-littoral.fr en respectant impérativement
le format suivant :
I fichiers rassemblés dans un répertoire à votre nom
I répertoire compressé dans une archive à votre nom au format zip ou tar.gz
I Note importante : ce format permet d’éviter les conflits de noms et les
écrasements accidentels de fichiers lors de la correction.
Attention, les compte-rendus ne respectant pas ce format recevront
la note 0.

Références
Essentials of Metaheuristics, S. Luke,

http://cs.gmu.edu/˜sean/book/metaheuristics/, 2009, (d’où
viennent certaines illustrations)
Local Search in Combinatorial Optimization, E. Aarts & J. K. Karel éd.,
Wiley, 1997.
Optimisation Combinatoire, de M. Sakarovitch, Hermann, 1984.
Algorithmes Génétiques, D.E. Goldberg, Addison Wesley, 1994,
(traduction française).
Statistiques, cours et problèmes, M.R. Spiegel, Mc Graw Hill, 1993.

Recherche Operationnelle Et Optimisation

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Recherche Operationnelle Et Optimisation

Transféré par

Droits d'auteur :

Formats disponibles

Recherche opérationnelle et

Lisic — Univ Littoral-Côte d’opale

1 Généralités Stratégies évolutionnaires

2 Méthodes( )à solution uniqueRecherche opérationnelle et Optimisation 3 / 100

Deux grandes familles de méthodes :

() Recherche opérationnelle et Optimisation 4 / 100

Le cours de RO est divisé en deux, selon méthodes exactes/approchées

() Recherche opérationnelle et Optimisation 5 / 100

Sémantique qualité / coût

() Recherche opérationnelle et Optimisation 6 / 100

() Recherche opérationnelle et Optimisation 7 / 100

() Recherche opérationnelle et Optimisation 8 / 100

() Recherche opérationnelle et Optimisation 9 / 100

En pratique : plus compliqué ! Exemple : on veut une solution

() Recherche opérationnelle et Optimisation 10 / 100

Problème du voyageur de commerce (PVC)

Forme des solutions : vecteur de 25 entiers (numéro des villes dans

() Recherche opérationnelle et Optimisation 11 / 100

() Recherche opérationnelle et Optimisation 12 / 100

() Recherche opérationnelle et Optimisation 13 / 100

Calcul du temps d’exécution

Calcul de la taille de la donnée

() Recherche opérationnelle et Optimisation 14 / 100

Avec une machine traitant 109 comparaisons/s , variation du temps de calcul

On sépare les problèmes en 2 classes :

() Recherche opérationnelle et Optimisation 16 / 100

De nombreuses méta-heuristiques(de transformation) utilisent cette

f l o a t GaussianRandom ( f l o a t mu, f l o a t sigma2 ) {

Quand on est dans un optimum local, on ne peut plus exploiter le

() Recherche opérationnelle et Optimisation 21 / 100

Illustration de paysage de problème uni/multi-modal

() Recherche opérationnelle et Optimisation 22 / 100

Calcul avec ”R”

> h1=c ( 2 0 , 21 , 22 , 23 , 29)

Wilcoxon rank sum t e s t

() Recherche opérationnelle et Optimisation 25 / 100

2 Méthodes à solution unique

3 Méthodes à base de population

() Recherche opérationnelle et Optimisation 26 / 100

Principe : ”on suit la pente vers le bas” (minimisation)

() Recherche opérationnelle et Optimisation 27 / 100

() Recherche opérationnelle et Optimisation 28 / 100

() Recherche opérationnelle et Optimisation 29 / 100

() Recherche opérationnelle et Optimisation 30 / 100

() Recherche opérationnelle et Optimisation 31 / 100

() Recherche opérationnelle et Optimisation 32 / 100

Principe : accepter un voisin selon un critère probabiliste, qui permet d’accepter

() Recherche opérationnelle et Optimisation 33 / 100

() Recherche opérationnelle et Optimisation 34 / 100

Si maximisation : rand (0, 1) < exp((f (r ) − f (s))/temp)

() Recherche opérationnelle et Optimisation 36 / 100

() Recherche opérationnelle et Optimisation 37 / 100

() Recherche opérationnelle et Optimisation 38 / 100

La liste tabou peut contenir :

() Recherche opérationnelle et Optimisation 39 / 100

Alors que l’arrêt de l’algorithme du grimpeur est garanti par construction,

() Recherche opérationnelle et Optimisation 40 / 100

() Recherche opérationnelle et Optimisation 41 / 100

on peut aussi modifier le paramètrage de l’algorithme, lors de ces

() Recherche opérationnelle et Optimisation 43 / 100

2 Méthodes à solution unique

3 Méthodes à base de population

Principe : prendre en compte plusieurs solutions simultanément.

Il existe d’autres méthodes de population, d’inspiration plus intuitive.