optimisation cours.pdf

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
Présentation de la R.O.
Optimisation
Complexité d’un algorithme
Méta-heuristiques et recherche
locale
Comparaison de deux
heuristiques
2 Méthodes à solution unique
Hill-climber
Recuit simulé
Recherche Tabou
Random restart
3 Méthodes à base de population
Généralités
Méthodes évolutionnaires
Stratégies évolutionnaires
Algorithme génétique
Méthode de Path-Relinking
Algorithme des Fourmis
4 Problèmes multi-critères
Définitions
Front Pareto
Réduction à un objectif
Approches par
Pareto-domination
5 TD / TP
Exercices
Présentation des TPs
La fonction de Griewank
Les matrices de Erickson
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

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) : N2
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).
vector GaussianConvolution ( vector v , int N, float sigma2 ) {
/ / v : vecteur so lu ti on de t a i l l e N
/ / sigma2 : variance de la d i s t r i b u t i o n Gaussienne / Normale
/ / min , max : borne minimum , maximum
float tmp ;
for ( int 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)
float GaussianRandom ( float mu, float sigma2 ) {
/ / mu est la moyenne voulue
/ / sigma2 est la variance 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 uniforme
y = rand (0.0 , 1.0) ; / / d i s t r i b u t i o n uniforme ( independant de x )
w = x∗x + y∗y ;
} while ( ! ( w > 0.0 && w < 1.0) ) ;
g = mu + sigma2 ∗ x ∗ sqrt (−2 ∗ log (w) / w) ;
h = mu + sigma2 ∗ y ∗ sqrt (−2 ∗ log (w) / w) ;
return g ; / / ou retourner h , ou les 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 (20 , 21 , 22 , 23 , 29)
> h2=c (27 , 32 , 35 , 39 , 60)
> wilcox . t e s t ( h1 , h2 )
Wilcoxon rank sum t e s t
data : h1 and h2
W = 1 , p−value = 0.01587
a l t e r n a t i v e hypothesis : true lo ca ti on s h i f t i s not equal to 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 (20 , 21 , 22 , 23 , 29)
> h2=c (27 , 32 , 35 , 39 , 60)
> wilcox . t e s t ( h1 , h2 , a l t e r n a t i v e =” greater ” )
Wilcoxon rank sum t e s t
data : h1 and h2
W = 1 , p−value = 0.996
a l t e r n a t i v e hypothesis : true l oca ti on s h i f t i s greater 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
Hill-climber
Recuit simulé
Recherche Tabou
Random restart
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
so lu ti on H i l l C l i m b e r ( so lu tio n s0 ) {
s olu ti on s , t ;
s = s0 ; / / copier so lu ti on courante
do {
t = Voisin ( s ) ; / / obtenir un voisin
i f ( f ( t ) < f ( s ) ) / / un meilleur voisin
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 est 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
so lu ti on H i l l C l i m b e r E l i t i s t e ( sol ut io n s0 , int n ) {
so lu ti on s , t , r ;
InitVoisinage ( s ) ; / / preparer le 1er voisin
do {
t = PremierVoisin ( s ) ; / / obtenir un voisin
for ( i = 0; i < n−1; i ++) { / / n = nombre de voisins
r = VoisinSuivant ( s ) ; / / obtenir un voisin
i f ( f ( r ) < f ( t ) ) / / un meilleur voisin
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 est 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
so lu ti on Recuit ( s olu ti on s0 , int n ) {
so lu ti on s , r , best ;
float temp ;
best = s ;
i n i t (&temp ) ; / / temperature i n i t i a l e
do {
r = Voisin ( s ) ; / / obtenir un voisin
i f (
( f ( r ) < f ( s ) ) / / un meilleur voisin
| | ( rand (0 ,1) < exp ( ( f ( s )−f ( r ) ) / temp ) / / regle de metropolis
)
s = r ; / / remplacement
}
reduire (&temp ) ;
i f ( f ( s ) < f ( best ) ) / / le meilleur voisin est meilleur
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
so lu ti on tabou ( s0 : s ol uti on ) {
so lu ti on s , t , old , best ;
int compteur ; l i s t e T ; / / l i s t e tabou
s = s0 ;
best = s0 ;
compteur = 0;
while ( compteur < BORNE) {
compteur = compteur + 1;
/ / obtenir meilleur voisin non taboue ( ou aspire )
t = m e i l l e u r v o i s i n ( s , T) ;
old = s ;
s = t ;
i f ( f ( i ) < f ( best ) ) {
best = i ;
compteur = 0; / / i n i t temps recherche
}
mettre a jour (& 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
Principes
Vocabulaire
Reproduction asexuée / sexuée
Caractéristiques générales
Stratégies évolutionnaires
Algorithme des Fourmis
Étude des insectes sociaux
Stigmergie artificielle

Méthodes à base de population
Principe : prendre en compte plusieurs solutions simultanément.
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 (µ,λ)
so lu ti on Evol Strat ( int mu, int lambda ) {
s olu ti on best = NULL;
int c h i l d ;
Population P, Q;
i n i t (P, lambda ) ; / / creer la pop i n i t i a l e de t a i l l e lambda
i n i t (Q, mu) ; / / temporaire pour reproducteurs
while (1) {
for ( int i = 0; i < lambda ; i ++) / / eval pop
Evaluer (P[ i ] ) ;
t r i e r (P) ; / / par cout croissant
i f ( best == NULL | | f i t n e s s (P [ 0 ] ) < f i t n e s s ( best ) )
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 ( best ) | | temps epuise )
return best ;
copier (Q, P, mu) ; / / Q[ 0 . . mu−1] <− P [ 0 . . mu−1];
c h i l d = 0;
for ( int i =0; i < mu; i ++) / / les mu meilleurs
for ( int j = 0; j < lambda /mu; j ++)
P[ c h i l d ++] = Muter ( Copie (Q[ i ] ) ) ; / / nouvel enfant
}
}

Stratégies évolutionnaires (µ+λ)
so lu ti on Evol Strat ( int mu, int lambda ) {
s olu ti on best = NULL;
int c h i l d ;
Population P;
i n i t (P, mu+lambda ) ; / / pop i n i t , t a i l l e mu+lambda
while (1) {
for ( int i = 0; i < mu+lambda ; i ++) / / eval pop
Evaluer (P[ i ] ) ;
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 ( best ) | | temps epuise )
return best ;
c h i l d = mu;
for ( int i =0; i < mu; i ++) / / les mu meilleurs
for ( int j = 0; j < lambda /mu; j ++)
P[ c h i l d ++] = Muter ( Copie (P[ i ] ) ) ; / / nouvel enfant
}
}

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.

so lu ti on GA( int popsize , int n ) { / / n : nombre d ’ ” e l i t e s ”
so lu ti on best = NULL, Pa, Pb, Ca, Cb;
Population P, Q;
i n i t (P, popsize ) ;
do {
for ( int i = 0; i < popsize ; i ++) / / eval pop
Evaluer (P[ i ] ) ;
best = P [ 0 ] ;
copier (Q, P, n ) ; / / Q[ 0 . . n−1] <− P [ 0 . . n−1]
for {int i = 0; i < ( popsize − n ) / 2 ; i ++) {
Pa = Selection (P) ; Pb = Selection (P) ;
Crossover (&Pa, &Pb, &Ca, &Cb) ;
Q[ i ∗2+n ] = Mutation (Ca) ; Q[ i ∗2+1+n ] = Mutation (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 ( best ) && ! temps epuise ) ;
return best ;
}

A.G. : sélection, mutation
Sélection par tournoi
so lu ti on TournamentSelection ( Population P, int tournament size ) {
so lu ti on best = P[ rand (0 ,N−1]; / / t i r a g e alea d ’ un i n d i v i d u
for ( int i =2; i <= tournament size ; i ++) {
so lu ti on next = 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 meilleur
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
so l u t i on Bit−FlipMutation ( so lut io n v , float p ) {
/ / p : p r o b a b i l i t e d ’ inverser un b i t
for ( int i =0; i < L ; i ++) / / L est la longueur de v
i f ( rand (0.0 , 1.0) < p )
v [ i ] = ˜ v [ i ] ; / / inversion 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−PointCrossover ( s ol uti on ∗pa , s ol ut io n ∗pb ,
so lu ti on ∗ca , s ol ut io n ∗cb ) {
int tmp ;
copierSolution ( ca , pa ) ; copierSolution ( cb , pb ) ;
int c = rand (0 , L−1) ; / / L = t a i l l e des solutions
for ( int 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.

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
so lu ti on PathRelinking ( s ol uti on ol1 , s ol uti on ol2 ) {
so lu ti on 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 ( courant != c i b l e ) {
t r i e r D i s t (P) ; / / par distance croissante a c i b l e
courant = P [ 0 ] ; / / le meilleur des plus proches de c i b l e
tmp = OptimLocale ( courant ) ; / / recherche locale
i f ( f ( tmp ) < f ( best ) )
best = 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.
I Les Eciton organisent des raids de chasse
comprenant jusqu’à 200.000 individus.
fourmis Oecophylla

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) :
⇒ P[(i,j)] =
τα
i,j η
β
i,j
∑k∈succ(i)(τα
i,k η
β
i,k )
où α, β : importance relative de τ et η.
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
so lu ti on ACO PVC( int popSize , s ol uti on piste [ ] ) {
/ / piste : tableau de solutions , une par fourmi
so lu ti on best = NULL;
do {
for ( int i = 0; i < popSize ; i ++) { / / les fourmis
piste [ i ] [ 0 ] = 0; / / on demarre toujours en v i l l e 0
for ( int j = 1; j < N; j ++) / / completer le tour
piste [ i ] [ j ] = ChoixFourmi ( piste [ i ] [ j −1]) ; / / c h o i s i r v i l l e
}
for ( int i = 0; i < popSize ; i ++) { / / optimisation heuristique
RechercheLocale ( piste [ i ] ) ; / / ex : heuristique LK
for ( int i = 0; i < popSize ; i ++) { / / evaluation
Evaluer ( piste [ i ] ) ;
i f ( best == NULL | | f i t n e s s ( piste [ i ] ) < f i t n e s s ( best ) )
best = piste [ i ] ;
}
for ( int i = 0; i < popSize ; i ++) / / MAJ pheromone
MiseAJourPheromone ( piste [ i ] ) ; / / en fonction 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 ( best ) && ! temps epuise ) ;
return best ;
}

1 Généralités
Définitions
Front Pareto
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

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
so lu ti on MultiobjLexicographicTournament (
Population P, int sizePop ,
int turnSize , int ObjNumber , / / t a i l l e tournoi , nombre d ’ o b j e c t i f s
ObjFun ∗ f ) { / / f : tableau de pointeur de fonctions o b j e c t i f s
so lu ti on Best = P[ random (0 , sizePop −1) ] ;
for ( int i = 1; i < turnSize −1; i ++) { / / t a i l l e du tournoi
so lu ti on Next = P[ random (0 , sizePop −1) ]
for ( int j = 0; j < ObjNumber ; j ++) { / / parcours les o b j e c t i f s
i f ( ( f [ j ] ) ( Next ) < f [ j ] ( Best ) ) { / / meilleur
Best = Next ; break ;
} else i f ( ( f [ j ] ) ( Next ) > ( f [ j ] ) ( Best ) ) / / pire
break ;
/ / else i t e r a t i o n suivante , comparer avec autre o b j e c t i f
}
}
}
return 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
Population ParetoDominantFront ( Population G) {
/ / G : groupe de so lu ti on dont on veut un f r o n t
F = {} / / Le front , vide au depart
for each so lu ti on G[ i ] de G {
F = F + {G[ i ]} / / ajouter G[ i ] / / on le suppose dans le f r o n t
for each s olu ti on F [ j ] de F autre que G[ i ] {
i f (F [ j ] Pareto−domine G[ i ] )
F = F − { G[ i ] } / / le r e t i r e r
else i f (G[ i ] Pareto−domine F [ j ] )
F = F − { F [ j ] } / / un pretendant 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
Population AssignSparsity ( Population R, Objectives O) {
/ / R : Population structuree en rangs Pareto
/ / O = {O[ 1 ] , . . . , O[ n ] } o b j e c t i f s
for each rang Pareto F de R {
for each so lu ti on F [ j ] de F {
F [ j ] . espacement = 0;
for 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 valeur d ’ o b j e c t i f i croissant
F [ 0 ] = INFINITY ;
F [LAST] = INFINITY ;
for ( 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
La fonction de Griewank
Les matrices de Erickson
Compte-rendu

TD exo 0
Codage de Gray
BoolVector GrayEncode ( BoolVector v ) {
BoolVector w = v ;
for ( i = 1; i < w. size ( ) ; i ++)
i f ( v [ i −1])
w[ i ] = ˜w[ i ] ;
return 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 = (S0,A0) et
G00 = (S00,A00) tels que :
I S = S0 ∪S00
I |S0| = |S00|
I Soit C un sous-ensemble de A défini par C = {x ∈ A tels que I(x) ∈ S0 et
T(x) ∈ S00 ou bien I(x) ∈ S00 et T(x) ∈ S0}, 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.

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 :
f(x1,x2,...,xn) =
n
∑
i=1
(x2
i /4000)−
n
∏
i=1
cos(xi /
√
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.

optimisation cours.pdf

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie optimisation cours.pdf

Ähnlich wie optimisation cours.pdf (20)

optimisation cours.pdf