Post on 24-Jul-2016
description
1
OUTILS MATHEMATIQUES
PROJET :
OPTIMISATION
Corentin Macqueron
Fadli Tarik
2
1. Introduction
Le but de ce projet est de mettre en application les acquis théoriques
du cours « Outils mathématiques ». Nous avons choisi de nous
intéresser au domaine de l’optimisation.
L’objectif est de mettre en œuvre des algorithmes d’optimisation afin
de déterminer des extrema de fonctions, avec ou sans contraintes, à
l’aide du logiciel de calcul Matlab.
2. Matlab
Matlab est logiciel de calcul scientifique développé par la société
américaine The MathWorks. C’est un langage de programmation
interprété, intégré dans un environnement de développement.
D’une grande simplicité, Matlab est un logiciel extrêmement puissant
et polyvalent, utilisé aussi bien en Mathématiques qu’en Physique,
Ingénierie, Géosciences ou même Génomique.
3. Optimisation
L’optimisation est une branche des Mathématiques qui traite de la
recherche de l’extremum d’une fonction.
Cette discipline est motivée par de nombreux cas pratiques aussi bien
en économie qu’en ingénierie : minimisation des coûts ou
maximisation des profits, minimisation des pertes d’énergie ou
maximisation d’un rendement.
Il existe un grand nombre de méthodes d’optimisation. Il n’est en
général pas possible d’obtenir un extremum de façon analytique,
c’est pourquoi on a recours aux méthodes numériques.
3
Il est également possible d’utiliser des algorithmes « génétiques »,
inspirés de la théorie de l’Evolution.
Dans le cadre de ce projet, nous nous limiterons aux fonctions de
deux variables.
3.1. Optimisation sans contrainte
3.1.1. Algorithme du gradient
Le but de l’optimisation sans contrainte est de trouver le minimum
ou le maximum d’une fonction f(x,y) sans imposer de contraintes sur
les variables x et y.
Nous avons choisi d’étudier la fonction f suivante :
𝑓 𝑥, 𝑦 = 𝑥 𝑒−𝑥²−𝑦²
La représentation de cette fonction est la suivante :
4
Nous allons chercher à déterminer le maximum de cette fonction sur
ℝ². Nous avons choisi pour cela d’utiliser la méthode du gradient. La
technique est simple : on part d’un point quelconque, on évalue le
gradient de la fonction en ce point, qui nous indique la direction de
plus grande pente. Il suffit alors de calculer la position du point
suivant dans cette direction, en usant d’un pas Δx (constant ici pour
plus de simplicité). Il est important d’arrêter le calcul lorsque le
maximum est atteint. Pour ce faire, il est possible d’utiliser plusieurs
conditions d’arrêt, comme une condition de gradient nul ou un écart
faible entre deux itérés successifs (méthode choisie ici).
Le programme développé sous Matlab est relativement simple et
donne des résultats très satisfaisants. Il est à noter que, bien
évidemment, cet algorithme ne peut rechercher qu’un extremum
local et non pas global. Ainsi, en fonction du point d’initialisation, il
est possible que l’algorithme parte à l’infini chercher une solution
qu’il ne trouvera pas. Il est donc important d’imposer une condition
d’arrêt autre que celles déjà évoquées, en arrêtant par exemple le
calcul après un certain nombre maximal d’itérations.
L’algorithme est le suivant :
- Choix de la précision d’arrêt ε
- Choix du nombre maximal d’itérations N
- Initialisation de x0
- Calcul des itérations : 𝑥𝑘+1 = 𝑥𝑘 + ∆𝑥 ∙ ∇𝑓
- Inspection de la condition d’arrêt :
si 𝑥𝑘+1 − 𝑥𝑘 < 𝜀
ou si
𝑘 > 𝑁
alors STOP
5
Le code développé cherche le maximum à partir de plusieurs
positions de départ x0.
Voici le graphique renvoyé par Matlab :
On y voit les trajectoires des points, depuis leur initialisation et au fur
et à mesure des itérations. Certaines trajectoires convergent bien
vers le maximum, tandis que d’autres divergent en partant à l’infini.
Ceci est dû au fait que leur point d’initialisation ne leur permet pas de
« voir » le maximum global.
Le code complet est donné en annexe 1.
6
3.1.2. Algorithme génétique
Nous allons maintenant reprendre la fonction f et tenter de la
maximiser, sans contrainte, à l’aide d’un algorithme dit génétique.
Un tel algorithme est appelé ainsi car il est basé sur la théorie
darwinienne de l’Evolution.
La méthode est la suivante : on crée de manière aléatoire une
population d’individus dont les deux gènes sont les coordonnées en x
et y. Le couple (x,y) d’un individu est son génotype, et la valeur que
prend la fonction en ce point est appelée phénotype. Pour chaque
génotype, on évalue le phénotype, puis l’on ne retient que les 50%
d’individus possédant le meilleur phénotype. Les 50% restants sont
éliminés. Ce principe est basé sur celui de la sélection naturelle.
Ensuite, les individus restants sont « croisés » entre eux, imitant le
brassage génétique rencontré dans la nature. Ici, cela revient à
échanger des coordonnées entre les individus. Il est également
possible de faire « muter » les gènes des individus en modifiant
légèrement leurs coordonnées de manière aléatoire. Cette méthode
est clairement inspirée des mutations génétiques aléatoires ayant
lieu dans le monde vivant. Dans le code développé, il s’est avéré que
le croisement des gènes des individus suffisait à obtenir d’excellents
résultats, sans avoir recours aux mutations.
L’algorithme génétique que nous avons développé s’est avéré
extrêmement performant, bien plus encore que la méthode du
gradient.
Les images ci-dessous illustrent le comportement des individus,
itération après itération.
7
Initialisation de la population
Itération n°1
8
Itération n°2
Itération n°3
9
Itération n°4
Itération n°7
10
Itération n°15
Le code complet est donné en annexe 4.
3.2. Optimisation avec contrainte
L’optimisation avec contrainte est la recherche d’un extremum, en
tenant compte de certaines contraintes, qui peuvent être des
contraintes d’égalité ou d’inégalité.
3.2.1. Contrainte d’inégalité :
Nous avons choisi d’étudier la fonction f suivante :
𝑓 𝑥, 𝑦 = 𝑥3 + 0.2𝑦
11
La contrainte sur x et y est :
𝑓 𝑥, 𝑦 < 𝑐(𝑥, 𝑦)
Avec :
𝑐 𝑥, 𝑦 = 1 − 𝑦²
On cherche à se ramener à un simple problème d’optimisation sans
contraintes afin de réutiliser l’algorithme du gradient.
Pour cela, on utilise une méthode dite de pénalisation. On va
construire une nouvelle fonction g à partir de la fonction f et de la
contrainte c :
𝑔 𝑥, 𝑦 = 𝑓 𝑥, 𝑦 − 𝐴 ∙ 𝑚𝑎𝑥 {0, 𝑐′ 𝑥, 𝑦 }
Avec :
𝑐′ 𝑥, 𝑦 = 𝑓 𝑥, 𝑦 − 𝑐 𝑥, 𝑦 = 0
A est un coefficient positif, souvent appelé multiplicateur de
Lagrange. La fonction max renvoie c’ si ce terme est positif, et zéro
sinon.
En d’autres termes, si la contrainte est violée, la fonction f est
diminuée, souvent de manière considérable car A est généralement
choisi très grand. Or, l’algorithme cherche à maximiser cette
fonction, il va donc tout naturellement rechercher une solution ne
violant pas cette contrainte, sans quoi la fonction est diminuée au
lieu d’être augmentée.
12
Il s’agit donc d’une méthode de pénalité dans le sens ou si la
contrainte est violée, la fonction est modifiée de telle sorte qu’elle
pénalise l’algorithme pour avoir violé la contrainte imposée.
C’est une méthode simple et relativement efficace, permettant de se
ramener à un problème d’optimisation sans contrainte.
L’algorithme est pratiquement le même que précédemment. La seule
différence est introduite au moment du calcul du gradient : on évalue
au préalable si la contrainte est violée et, le cas échéant, on calcule le
gradient de la fonction f pénalisée, autrement dit de g. Autrement,
on calcule simplement le gradient de f.
Ainsi, si la contrainte est violée, le gradient de g va venir pénaliser la
solution, la forçant à respecter la contrainte.
Il est difficile d’établir un critère d’arrêt dans le cas présent. En effet,
la condition de gradient nul n’est pas forcément vérifiée à l’optimum
du problème. Le code s’arrête donc au bout d’un certain nombre
d’itérations, sans avoir réellement trouvé le maximum, mais en étant
clairement sur sa voie. Il serait possible de mettre en mémoire la
trajectoire de la solution sous la forme d’un vecteur unidimensionnel
afin d’en calculer la dérivée et d’arrêter le processus lorsque cette
dérivée s’annule. Il n’est cependant pas évident de déterminer une
dérivée de façon précise : l’intégration numérique est plus fiable que
la dérivation numérique. De plus, les possibles « à-coups » de la
solution risquent d’induire une dérivée non-nulle là où l’on s’attend à
ce qu’elle le soit. Les graphiques suivants illustrent bien ce
phénomène.
13
On constate sur ces trois images que la solution n’est pas
parfaitement stable à l’optimum. La dérivée l’est encore moins :
On pourrait envisager de filtrer la solution et/ou sa dérivée, par
exemple avec une moyenne mobile, mais ce n’est pas l’objectif de ce
projet.
1. Tracé de la solution en fonction des itérations
2. Zoom sur la crête 3. Nouveau zoom
Dérivée numérique de la solution
14
Voici le graphique produit par Matlab :
En couleurs opaques, il s’agit de la fonction f que l’on veut maximiser.
En transparent, il s’agit de la contrainte c que l’on ne doit pas
dépasser.
On voit que la trajectoire de la solution se comporte correctement.
Elle suit la plus grande pente tant que la contrainte n’est pas violée,
puis lorsque celle-ci est dépassée, la solution continue de chercher la
plus grande pente, tout en restant sous la contrainte.
La valeur de A doit cependant être ajustée. Il arrive en effet que,
lorsque la valeur de A est trop grande, la solution est tellement
pénalisée que le processus doit recommencer depuis le début, voire
pire s’il est renvoyé vers une position encore plus éloignée du
maximum que ne l’était le point d’initialisation.
15
Ce phénomène est illustré par le graphique ci-après :
On constate en effet que lorsque la solution viole la contrainte, elle
est très rudement pénalisée, effectuant un brutal retour en arrière au
lieu de suivre de près la contrainte. Ce phénomène peut ralentir
l’obtention de la solution optimale.
16
L’algorithme est testé avec d’autres surfaces, et on voit bien la
solution respecter une contrainte d’infériorité dans l’illustration
suivante :
Le code complet est donné en annexe 2.
3.2.2. Contrainte d’égalité :
On revient à la fonction f de départ :
𝑓 𝑥, 𝑦 = 𝑥 𝑒−𝑥²−𝑦²
On cherche à maximiser f sous la contrainte suivante :
𝑓 𝑥, 𝑦 = 𝑐(𝑥, 𝑦)
Avec :
𝑐 𝑥, 𝑦 = 0.1𝑥 + 0.1𝑦
17
Ce qui revient à maximiser la fonction f aux points d’intersection avec
la fonction c. L’intersection des deux surfaces est illustrée ci-
dessous (f est en couleurs opaques, c est transparente) :
Une fois encore, on cherche à se ramener à un simple problème
d’optimisation sans contraintes en vue de réutiliser l’algorithme du
gradient.
On va de nouveau utiliser une méthode de pénalisation. On construit
une nouvelle fonction g à partir de la fonction f et de la contrainte c :
𝑔 𝑥, 𝑦 = 𝑓 𝑥, 𝑦 − 𝐴 ∙ 𝑐′²(𝑥, 𝑦)
Avec de nouveau :
𝑐′ 𝑥, 𝑦 = 𝑓 𝑥, 𝑦 − 𝑐 𝑥, 𝑦 = 0
18
La technique est très semblable à précédemment, mais la contrainte
est plus sévère. C’est pourquoi la fonction c’ doit être élevée au
carré. En effet, on cherche à maximiser la fonction f. Or, si c’ devient
négatif sans être élevé au carré, la fonction g va augmenter et
l’algorithme aura tendance à choisir cette solution, qui apparaîtra
meilleure que c’ = 0 qui est pourtant la contrainte à respecter. Il faut
donc pénaliser plus durement la solution, en élevant au carré c’ afin
de forcer la solution à respecter la contrainte. A est de nouveau un
coefficient multiplicateur, positif, venant pondérer la pénalisation
infligée.
L’algorithme est plus drastique que précédemment. On n’évalue plus
au préalable si la contrainte est violée : on suppose qu’elle l’est
toujours, c’est-à-dire qu’on optimise systématiquement g et jamais f.
La méthode du gradient donne de très bons résultats, comme
l’illustre le graphique ci-dessous :
19
On voit la solution évoluer précisément sur l’intersection des deux
surfaces de f et c, qui ont dû être mises en couleur transparentes
pour aider à visualiser la trajectoire de la solution.
Le coefficient A doit là encore être ajusté pour ne pas perturber le
processus et la solution doit être initialisée sur un point relativement
proche de l’intersection des deux surfaces.
Pour les mêmes raisons que précédemment, le processus est stoppé
à partir d’un certain nombre d’itérations et non pas en fonction d’un
critère d’arrêt.
Le code complet est donné en annexe 3.
20
4. Conclusion
Ce projet nous a permis de nous initier à la pratique de problèmes
d’optimisation concrets en développant nos propres codes de calcul à
l’aide du logiciel Matlab, qui s’avère être un outil de travail très
puissant. Concernant l’algorithme génétique, il est intéressant de
remarquer comment l’observation du Vivant peut se révéler utile aux
Mathématiques, en aboutissant à une méthode extrêmement simple
et néanmoins très performante.
21
Annexe 1 – Code Matlab – Optimisation sans contrainte
% OUTILS MATHEMATIQUES %
% PROJET : OPTIMISATION %
% METHODE DU GRADIENT - SANS CONTRAINTES %
clc % nettoyage de l'écran clear; % suppression des variables en mémoire
ext=2.5; % détermine la taille de la grille pour le tracé de la fonction delta=0.1; % pas constant
[X,Y]=meshgrid(-ext:delta:ext,-ext:delta:ext); % grille pour le tracé de la
fonction
Z=X.*exp(-X.^2-Y.^2); % fonction étudiée
surf(X,Y,Z) % tracé de la fonction étudiée hold all
xlabel('X') % label des axes ylabel('Y')
X0=[-2.5 -2 -1 0 0.5 1.5 2.5]; % différentes positions initiales en X Y0=[-2.5 -2 -1 0 0.5 1.5 2.5]; % différentes positions initiales en Y
for x0=X0 % boucle sur les positions initiales en X
for y0=Y0 % boucle sur les positions initiales en Y
x=x0; % initialisation des positions y=y0;
epsilon=1; % initialisation de la condition d'arrêt
iteration=0; % initialisation du compteur d'itérations
while epsilon>10^-4 % vérification de la condition d'arrêt
iteration=iteration+1; % incrémentation du compteur d'itération
gradx=exp(-x^2-y^2)*(1-2*x^2); % calcul du gradient en X grady=exp(-x^2-y^2)*(-2*x*y); % calcul du gradient en Y
oldx=x; % sauvegarde des anciennes positions oldy=y;
x=x+delta*gradx; % calcul des nouvelles positions y=y+delta*grady;
22
z=x*exp(-x^2-y^2); % valeur de la fonction à la nouvelle
position
hold all plot3(x,y,z,'s','MarkerEdgeColor','k',... % tracé du point
solution 'MarkerFaceColor','k',... 'MarkerSize',4)
epsilon=((x-oldx)^2+(y-oldy)^2)^0.5; % calcul de la distance
entre les deux dernières itérations
if iteration>1000 % vérification de la condition d'arrêt en cas
de convergence lente ou de divergence
epsilon=0;
end
end
end
end
23
Annexe 2 – Code Matlab – Optimisation avec contrainte d’inégalité
% OUTILS MATHEMATIQUES %
% PROJET : OPTIMISATION %
% METHODE DU GRADIENT - AVEC CONTRAINTE - INEGALITE %
clc % nettoyage de l'écran clear; % suppression des variables en mémoire
A=5; % multiplicateur de Lagrange ext=1; % détermine la taille de la grille pour le tracé de la fonction grd=0.1; % détermine le pas de la grille delta=0.001; % pas constant N=5000; % nombre d'itérations
[X,Y]=meshgrid(-ext:grd:ext,-ext:grd:ext); % grille pour le tracé de la
fonction
Z=X.^3+0.2*Y; % fonction étudiée Z2=1-Y.^2; % fonction de contrainte
surf(X,Y,Z2) % tracé de la contrainte alpha(0.3) % effet de transparence hold all surf(X,Y,Z) % tracé de la fonction étudiée hold all xlabel('X') % label des axes ylabel('Y')
x=0.1; % position initiale en X y=-0.5; % position initiale en Y
for i=1:N % boucle d'itérations
if x^3+0.2*y-1+y^2>0 % contrainte violée
gradx=2*x^2-A; % gradient en X pénalisé grady=0.2-A; % gradient en Y pénalisé
else % contrainte respectée
gradx=2*x^2; % gradient en X non pénalisé grady=0.2; % gradient en Y non pénalisé
end
x=x+delta*gradx; % calcul de la nouvelle position en X y=y+delta*grady; % calcul de la nouvelle position en Y
z=x^3+0.2*y; % valeur de la fonction à la nouvelle position
24
hold all plot3(x,y,z,'s','MarkerEdgeColor','k',... % tracé du point solution 'MarkerFaceColor','k',... 'MarkerSize',3)
end
25
Annexe 3 – Code Matlab – Optimisation avec contrainte d’égalité
% OUTILS MATHEMATIQUES %
% PROJET : OPTIMISATION %
% METHODE DU GRADIENT - AVEC CONTRAINTE - EGALITE %
clc % nettoyage de l'écran clear; % suppression des variables en mémoire
A=50; % multiplicateur de Lagrange grd=0.1; % pas de la grille delta=0.01; % pas constant N=5000; % nombre d'itérations
[X,Y]=meshgrid(-2:grd:2,-2:grd:2); % grille pour le tracé de la fonction
Z=X.*exp(-X.^2-Y.^2); % fonction étudiée Z2=0.1*X+0.1*Y; % fonction contrainte
surf(X,Y,Z2) % tracé de la contrainte hold all surf(X,Y,Z) % tracé de la fonction étudiée alpha(0.5) % effet de transparence hold all xlabel('X') % label des axes ylabel('Y')
x=-0.4; % position initiale en X y=-1; % position initiale en Y
for i=1:N % boucle d'itérations
gradx=exp(-x^2-y^2)-2*x^2*exp(-x^2-y^2)+2*(-A)*(x*exp(-x^2-y^2)-1/10*x-
1/10*y)*(exp(-x^2-y^2)-2*x^2*exp(-x^2-y^2)-1/10); % gradient en X
grady=-2*x*y*exp(-x^2-y^2)+2*(-A)*(x*exp(-x^2-y^2)-1/10*x-1/10*y)*(-
2*x*y*exp(-x^2-y^2)-1/10); % gradient en Y
x=x+delta*gradx; % calcul de la nouvelle position en X y=y+delta*grady; % calcul de la nouvelle position en Y
z=x*exp(-x^2-y^2); % valeur de la fonction à la nouvelle position
hold all plot3(x,y,z,'s','MarkerEdgeColor','k',... % tracé du point solution 'MarkerFaceColor','k',... 'MarkerSize',5)
End
26
Annexe 4 – Code Matlab – Optimisation sans contrainte – Algorithme génétique % OUTILS MATHEMATIQUES %
% PROJET : OPTIMISATION %
% ALGORITHME GENETIQUE - SANS CONTRAINTE %
clc; % nettoyage de l'écran clear; % suppression des variables en mémoire
xmin=-2; % définition du domaine xmax=2; ymin=-2; ymax=2;
[X,Y]=meshgrid(xmin:0.1:xmax, ymin:0.1:ymax); % création de la grille Z=X.*exp(-X.^2-Y.^2); % fonction étudiée
A=2; % amplitude des coordonnées initiales
% construction de la matrice des individus initiaux % coordonnées aléatoires sur tout le domaine
Organism1(1:20,1:2)=A*rand(20,2); Organism1(21:40,1)=A*rand(20,1); Organism1(21:40,2)=-A*rand(20,1); Organism2(1:20,1)=-A*rand(20,1); Organism2(1:20,2)=A*rand(20,1); Organism2(21:40,1:2)=-A*rand(20,2); New=[Organism1;Organism2]; % matrice des individus initiaux
Eval=zeros(80,1);
for N=1:15 % nombre d'itérations
figure
pcolor(X,Y,Z); % tracé de la fonction étudiée hold all shading interp
for i=1:80
plot(New(i,1),New(i,2),'square','markersize',5,'markeredgecolor','k','marke
rfacecolor','k'); % tracé des individus end
27
for i=1:80 Eval(i,1)=New(i,1)*exp(-New(i,1)^2-New(i,2)^2); % évaluation de la
fonction aux coordonnées des individus end
Selected=zeros(40,2);
for i=1:40 % boucle sur 50% du nombre total d'individus
check=max(Eval); % détermination du meilleur individu
for j=1:80 if Eval(j,1)==check chosen=j; % position du meilleur individu end end
Selected(i,:)=New(chosen,:); % sélection du meilleur individu
Eval(chosen,1)=0; % raz du meilleur individu qui cède sa place
end
New(1:40,:)=Selected(:,:); % sélection des meilleurs 50% d'individus
New(41:80,1)=Selected(:,1);
for i=1:39 New(40+i,2)=Selected(i+1,2); % croisement inter-individu end
New(80,2)=Selected(1,2);
H=gcf; % capture écran moovie(N)=getframe(H); % création d'un film
end