Optimisation mathématique

Page 1

OUTILS MATHEMATIQUES

PROJET :

OPTIMISATION Corentin Macqueron Fadli Tarik 1

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. 2

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 :

3

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 4

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.

5

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.

6

Initialisation de la population

ItÊration n°1 7

Itération n°2

Itération n°3 8

Itération n°4

Itération n°7 9

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�

10

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.

11

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.

12

1. Tracé de la solution en fonction des itérations

2. Zoom sur la crête

3. Nouveau zoom

On constate sur ces trois images que la solution n’est pas parfaitement stable à l’optimum. La dérivée l’est encore moins :

Dérivée numérique de la solution

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.

13

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.

14

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.

15

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đ?‘Ś 16

Ce qui revient à maximiser la fonction f aux points d’intersection avec la fonction c. L’intersection des deux surfaces est illustrÊe cidessous (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

17

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 :

18

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.

19

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.

20

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;

21

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

22

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

23

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

24

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*x1/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

25

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

26

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

27

Turn static files into dynamic content formats.

Create a flipbook
Issuu converts static files into: digital portfolios, online yearbooks, online catalogs, digital photo albums and more. Sign up and create your flipbook.