Optimisation mathématique

27
1 OUTILS MATHEMATIQUES PROJET : OPTIMISATION Corentin Macqueron Fadli Tarik

description

Rapport de projet d'optimisation mathématique, avec algorithmes classiques et génétiques

Transcript of Optimisation mathématique

Page 1: Optimisation mathématique

1

OUTILS MATHEMATIQUES

PROJET :

OPTIMISATION

Corentin Macqueron

Fadli Tarik

Page 2: Optimisation mathématique

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.

Page 3: Optimisation mathématique

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 :

Page 4: Optimisation mathématique

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

Page 5: Optimisation mathématique

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.

Page 6: Optimisation mathématique

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.

Page 7: Optimisation mathématique

7

Initialisation de la population

Itération n°1

Page 8: Optimisation mathématique

8

Itération n°2

Itération n°3

Page 9: Optimisation mathématique

9

Itération n°4

Itération n°7

Page 10: Optimisation mathématique

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𝑦

Page 11: Optimisation mathématique

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.

Page 12: Optimisation mathématique

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.

Page 13: Optimisation mathématique

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

Page 14: Optimisation mathématique

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.

Page 15: Optimisation mathématique

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.

Page 16: Optimisation mathématique

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𝑦

Page 17: Optimisation mathématique

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

Page 18: Optimisation mathématique

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 :

Page 19: Optimisation mathématique

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.

Page 20: Optimisation mathématique

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.

Page 21: Optimisation mathématique

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;

Page 22: Optimisation mathématique

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

Page 23: Optimisation mathématique

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

Page 24: Optimisation mathématique

24

hold all plot3(x,y,z,'s','MarkerEdgeColor','k',... % tracé du point solution 'MarkerFaceColor','k',... 'MarkerSize',3)

end

Page 25: Optimisation mathématique

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

Page 26: Optimisation mathématique

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

Page 27: Optimisation mathématique

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