ETUDE DE LA METHODE D'OPTIMISATION DE RACKWITZ - ISIMA

Institut Supérieur d’Informatique,
Polytech’ Clermont-Ferrand
de Modélisation et de leurs Applications
Complexe des Cézeaux
Complexe des Cézeaux
BP 125 BP 206
63173 Aubière Cedex 63174 Aubière Cedex
Rapport de projet de 3 ème année
Filière F4 - Calcul et modélisation scientifiques
________________________________________________________________________________
ETUDE DE LA METHODE D’OPTIMISATION
DE RACKWITZ
________________________________________________________________________________
Présenté par : Benoît GALLAND et Christophe MAETZ
Responsable : Michel FOGLI (Polytech' Clermont-Ferrand)
Durée : 100h
Octobre 2007 à mars 2008

Institut Supérieur d’Informatique,
Polytech’ Clermont-Ferrand
de Modélisation et de leurs Applications
Complexe des Cézeaux
Complexe des Cézeaux
BP 125 BP 206
63173 Aubière Cedex 63174 Aubière Cedex
Rapport de projet de 3 ème année
Filière F4 - Calcul et modélisation scientifiques
________________________________________________________________________________
ETUDE DE LA METHODE D’OPTIMISATION
DE RACKWITZ
________________________________________________________________________________
Présenté par : Benoît GALLAND et Christophe MAETZ
Responsable : Michel FOGLI (Polytech' Clermont-Ferrand)
Durée : 100h
Octobre 2007 à mars 2008

Remerciements
Nous remercions M. Michel Fogli, notre responsable de projet, pour son aide et ses
conseils pour la compréhension de l’algorithme principal et l’élaboration du projet. Nous
remercions également M. Jonas Koko, professeur à l’ISIMA, pour ses explications dans
l’utilisation de fonctions d’optimisation de Matlab.

Table des figures et illustrations
1.1 Représentation graphique de la fonction contrainte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Illustration de l’algorithme de Rackwitz (initialisation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3 Illustration de l’algorithme de Rackwitz (itération 1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4 Illustration de l’algorithme de Rackwitz (itération 2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 Illustration de l’algorithme de Rackwitz (solution) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.1 Exécution de l’algorithme de Rackwitz dans le cas d’un hyperplan en 2D . . . . . . . . . . . . . 21
3.2 Convergence en nombre d’itérations dans le cas d’un hyperplan . . . . . . . . . . . . . . . . . . . . . 22
3.3 Convergence en temps d’exécution dans le cas d’un hyperplan . . . . . . . . . . . . . . . . . . . . . . 22
3.4 Influence de l’initialisation sur le nombre d’itérations dans le cas d’un hyperplan . . . . . . . . 22
3.5 Intersections possibles entre une droite issue de l’origine et une parabole . . . . . . . . . . . . . . 23
3.6 Intersections possibles entre une droite issue de l’origine et une hyperbole . . . . . . . . . . . . . 23
3.7 Cas de non convergence de l’algorithme de Rackwitz avec une parabole. . . . . . . . . . . . . . . 24
3.8 Exécution de l’algorithme de Rackwitz avec un domaine non connexe . . . . . . . . . . . . . . . . 25
3.9 Exécution de l’algorithme de Rackwitz avec un domaine non connexe (zoom) . . . . . . . . . . 26
3.10 Convergence en nombre d’itérations dans le cas de paraboloïdes / hyperboloïdes . . . . . . . . 26
3.11 Exemple d’un domaine délimité par un cercle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.12 Convergence en nombre d’itérations dans le cas d’ellipsoïdes . . . . . . . . . . . . . . . . . . . . . . . 28
3.13 Convergence en nombre d’itérations pour des cas divers . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.14 Convergence en temps d’exécution pour des cas divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

Résumé
L’objet de ce projet est l’étude de la méthode d’optimisation de Rackwitz. Nous avons testé
cette méthode récente, principalement utilisée dans le domaine de la fiabilité, sur un problème
d’optimisation non linéaire : la minimisation, dans un espace à n dimensions, d’une norme d’un
vecteur avec une fonction contrainte non linéaire.
Notre travail a consisté tout d’abord à implémenter l’algorithme de Rackwitz, puis deux
autres algorithmes itératifs de type gradient projeté et lagrangien augmenté. La méthode de
Rackwitz a été analysée quant à sa convergence et comparée aux autres méthodes selon des critères
que nous avons sélectionnés.
L’implémentation des différentes méthodes d’optimisation ainsi que la visualisation des
résultats ont été faites dans l’environnement Matlab.
Mots-clés :
optimisation non linéaire, algorithme de Rackwitz, gradient projeté,
lagrangien augmenté, Matlab
Abstract
The purpose of this project is the study of the Rackwitz optimization method. We have tested
this recent method, principally used in the reliability domain, on a nonlinear optimization
problem: the minimization, in a n-dimensional space, of a vector’s norm with a nonlinear constraint
function.
We have first implemented the Rackwitz algorithm, then two other iterative algorithms,
projected gradient and augmented Lagrangian methods. We have analysed the Rackwitz method
about its convergence and compared it to the other methods with criteria we have selected.
The implementation of the different optimization methods and the visualization of results
have been realized in the Matlab environment.
Keywords :
nonlinear optimization, Rackwitz algorithm, projected gradient
augmented Lagrangian, Matlab

Table des matières
Remerciements
Table des figures et illustrations
Résumé / Abstract
Table des matières
Introduction 7
1. L’algorithme de Rackwitz 8
1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2 Convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Principe de l’algorithme et exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Le schéma de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.5 L’implémentation en Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2. Les algorithmes de comparaison 15
2.1 L’algorithme de type gradient projeté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 L’algorithme de type lagrangien augmenté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3 L’implémentation en Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3. Exemples d’application et résultats comparés 20
3.1 Critères de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.2 Cas où le graphe F(x) = 0 est un hyperplan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Cas où le graphe F(x) = 0 est un paraboloïde ou un hyperboloïde . . . . . . . . . . . . . . . . . 23
3.4 Cas où le graphe F(x) = 0 est un ellipsoïde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.5 Cas divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Conclusion 30
Bibliographie
Annexes

Introduction
Le problème que nous cherchons à traiter est un problème d’optimisation non linéaire contraint
du type :
où
est une fonction non linéaire
Nous utiliserons la norme euclidienne dans :
Nous allons présenter l’algorithme de Rackwitz, en l’illustrant graphiquement sur un exemple,
puis en présentant le schéma itératif utilisé pour son implémentation. Nous décrirons ensuite les deux
algorithmes de type gradient projeté et lagrangien augmenté, et nous verrons comment ils peuvent
s’appliquer au problème spécifique que nous voulons traiter. Enfin, dans une dernière partie, nous
allons comparer ces trois méthodes d’optimisation, plus précisément la méthode de Rackwitz par
rapport aux deux autres, au moyen de critères que nous choisirons.
7

1. L’algorithme de Rackwitz
1.1. Introduction
Rüdiger Rackwitz [1] est un chercheur de l’université technique de Munich (Allemagne). Il
travaille notamment sur la théorie de la fiabilité, mais également dans l’application de la théorie des
probabilités et des statistiques dans l’ingénierie du bâtiment, et l’optimisation des constructions.
En 1978, il développe l’algorithme qui porte aujourd’hui son nom, et qui est très largement
utilisé en fiabilité structurale. Cet algorithme se base notamment sur les notions de normale à une
courbe et de gradient, et il en existe plusieurs variantes, dont celle dite de Rackwitz-Fiessler [2] [3] .
1.2. Convergence
L’algorithme de Rackwitz est un algorithme non convergent. Par définition, cela signifie qu’il
existe au moins un exemple pour lequel il ne converge pas. Néanmoins, lorsqu’il y a convergence,
c’est l’un des algorithmes qui converge le plus rapidement. Nous allons vérifier cette proposition en
mettant en œuvre cet algorithme sur différents exemples assez représentatifs.
1.3. Principe de l’algorithme et exemple
Nous souhaitons donc résoudre le problème suivant, avec dans :
Minimiser
sous
Pour illustrer l’algorithme, nous avons choisi un exemple en 2D pour lequel il y a convergence,
avec pour contrainte la fonction F suivante :
Le vecteur solution de ce problème est la distance entre l’origine O du repère et le domaine
, colorié en vert sur la figure suivante (Fig. 1.1).
8

Fig. 1.1 - Représentation graphique de la fonction contrainte
Le point d’initialisation est choisi sur la courbe définie par . L’algorithme cherchera
ce point initial au moyen de la méthode de Newton. Pour cela, on cherche, s’il existe, le point sur la
courbe dont les (n-1) premières coordonnées sont fixées à 1, la dernière coordonnée étant le paramètre
de la méthode de Newton. Cette coordonnée x à trouver est telle que :
Sur notre exemple (Fig. 1.2), le point d’initialisation est dont le point :
9

Fig. 1.2 - Illustration de l’algorithme de Rackwitz (initialisation)
Ensuite, une itération de l’algorithme revient à chercher la normale au point courant et ensuite
trouver le point courant suivant en trouvant l’intersection entre la parallèle de la normale passant par
l’origine et la courbe définie par .
Sur notre exemple (Fig. 1.3), la droite rouge en pointillés est la normale en à la courbe
. La droite rouge est la parallèle à cette droite passant par l’origine et coupant, après calcul, la
courbe au point
10

Fig. 1.3 - Illustration de l’algorithme de Rackwitz (itération 1)
Fig. 1.4 - Illustration de l’algorithme de Rackwitz (itération 2)
11

L’algorithme consiste ensuite à réitérer ce calcul de la normale au point courant puis de la
recherche de l’intersection entre la courbe et la parallèle à cette normale passant par
l’origine. Ainsi la normale en est la droite rouge en pointillés (Fig. 1.4) et sa parallèle passant par
l’origine est la droite rouge, qui coupe, après calcul, la courbe au point
Il faut ainsi réitérer ces calculs jusqu’à ce que deux itérations successives vérifient la condition
suivante :
Sur notre exemple (Fig. 1.5), la solution trouvée par l’algorithme de Rackwitz est :
Fig. 1.5 - Illustration de l’algorithme de Rackwitz (solution)
Cette condition d’arrêt signifie que dès que la distance entre deux points successifs est
inférieure à la précision choisie, nous considérons que ces deux points sont confondus et forment donc
la solution recherchée.
12

1.4. Le schéma de l’algorithme
Nous avons implémenté l’algorithme de Rackwitz à partir du schéma suivant :
Initialisation :
Itération :
Condition d’arrêt :
1.5. L’implémentation en Matlab
1.5.1. Remarques générales
Tous les algorithmes du projet, dont celui de Rackwitz, ont été implémentés dans la version 7 du
logiciel Matlab. Tout le code de ce projet est exécutable sur les versions de Matlab équipées de la boîte
à outils Optimization Toolbox, car notre implémentation des algorithmes de comparaison nécessite
l’utilisation de fonctions de minimisation spécifiques.
L’instruction Matlab – format long – permet d’effectuer tous les calculs avec une grande
précision, avec jusqu’à 15 chiffres pour un nombre flottant.
Pour l’implémentation de l’algorithme de Rackwitz, nous avons au préalable écrit plusieurs
fonctions auxiliaires qui seront réutilisées pour les autres algorithmes.
13

1.5.2. Calcul des dérivées
Deux fonctions auxiliaires permettent de calculer une dérivée totale ou partielle ainsi que le
gradient, vecteur des dérivées partielles. Pour le calcul de la dérivée, nous utilisons l’approximation
par différences finies suivante :
si ,
alors
1.3.3. La méthode de Newton
Nous avons implémenté la méthode de Newton pour l’initialisation de l’algorithme de
Rackwitz. En effet, celui-ci nécessite de démarrer d’un point courant situé sur la courbe .
Comme nous traitons des fonctions
, nous appliquons la méthode de Newton sur
la dernière variable de , les valeurs des (n-1) premières variables étant fixées au préalable. Avec cette
hypothèse, il se peut que la méthode de Newton ne trouve pas de solution : dans ce cas, un nombre
d’itérations maximum étant fixé à l’avance, une erreur d’initialisation est prévue.
14

2. Les algorithmes de comparaison
Les méthodes existantes en programmation non linéaire sous contraintes se divisent en deux
grandes catégories, les méthodes primales et les méthodes duales. Nous allons présenter un algorithme
de chaque catégorie, et montrer comment on peut adapter chacun au problème général que nous
voulons traiter.
2.1. L’algorithme de type gradient projeté
2.1.1. Une méthode primale
Le premier algorithme que nous avons choisi de comparer à la méthode de Rackwitz est un
algorithme de type gradient projeté avec contraintes, d’après Rosen [4] (1960). Cet algorithme du
gradient projeté est une méthode dite primale, qui opère directement sur le problème à traiter. Les
méthodes primales engendrent une séquence itérative de solutions en assurant une décroissance
monotone de la fonction à minimiser. Leur principal avantage est, en cas d’interruption du processus
itératif, l’obtention d’une solution intermédiaire approchée vérifiant les contraintes.
2.1.2. Hypothèses
Cette méthode se base sur une idée simple : à chaque étape de l’algorithme, le nouveau point ne
vérifie peut-être pas certaines contraintes, on projette donc ce point obtenu sur l’ensemble induit par
les contraintes pour qu’il appartienne à l’ensemble des solutions réalisables. Le point est projeté sur la
frontière du domaine et l’algorithme n’est donc en réalité qu’un cheminement le long de la frontière,
jusqu’à obtention de la solution.
Cet algorithme s’applique, de manière générale, au problème suivant :
Minimiser
sous les contraintes
Dans notre problème, nous n’avons qu’une seule contrainte de type inégalité, ce que l’on peut
donc réécrire :
Minimiser
sous la contrainte
15

2.1.3. Déroulement
Une itération consiste à chercher depuis un point une direction de descente et à trouver dans
cette direction la meilleure solution.
La contrainte sera dite saturée pour si .
Pour appliquer l’algorithme de gradient projeté, il faudra suivre le schéma suivant :
Initialisation :
Tant que n’est pas acceptable :
Déterminer si la contrainte est saturée ou non
Si la contrainte est saturée,
Construction de
Sinon
Calcul de la matrice de projection
( ( est ici un scalaire)
Calcul de la direction de descente
Si alors
Calcul de
Calcul de tel que
Sinon
Poser
Si alors satisfait les conditions de Kuhn et Tucker, est acceptable
Sinon
La contrainte n’est plus considérée comme saturée
On retourne à l’étape de construction de
16

2.2. L’algorithme de type lagrangien augmenté
2.2.1. Une méthode duale
Le second algorithme que nous avons choisi est un algorithme de type lagrangien augmenté [5] ,
une méthode dite duale. Le principe général de ce type de méthode consiste à ramener le problème
initial à la résolution d’une suite de problèmes d’optimisations sans contrainte.
2.2.2. Hypothèses
Cet algorithme s’applique, de manière générale, au problème suivant :
Minimiser
sous les contraintes
Dans notre problème, nous n’avons qu’une seule contrainte de type inégalité, ce que l’on peut
donc réécrire :
Minimiser
sous la contrainte
2.2.3. Déroulement
Le schéma de l’algorithme, assez simple, est le suivant :
- Initialisation : et
- Minimisation du lagrangien augmenté
- Mise à jour du coefficient de Lagrange
- Augmentation de R
- S’il n’y a pas convergence, mettre à jour et réitérer
17

2.3. L’implémentation en Matlab
Ces deux algorithmes du gradient projeté et du lagrangien augmenté font eux-mêmes intervenir
des sous-problèmes d’optimisation. Ainsi, pour l’implémentation de ces deux méthodes, nous avons
fait appel à plusieurs fonctions de minimisation déjà programmées dans la boîte à outils Optimization
Toolbox de Matlab :
2.3.1. La fonction « fminbnd »
Cette fonction recherche le minimum d’une fonction dans un intervalle donné.
Cette instruction retourne une valeur qui est un minimum local de la fonction dans
l’intervalle , ainsi que la valeur de la fonction en ce point.
Nous utilisons cette fonction de minimisation pour calculer, dans l’algorithme du gradient
projeté :
2.3.2. La fonction « fmincon »
Cette fonction recherche le minimum d’une fonction soumis à des contraintes linéaires et/ou
non linéaires dans un intervalle donné.
Cette instruction retourne une valeur , ainsi que la valeur de la fonction en ce point,
solution approchée d’un problème de type :
Nous utilisons cette fonction de minimisation pour calculer, dans l’algorithme du gradient
projeté :
18

2.3.3. La fonction « fminunc »
Cette fonction recherche le minimum d’une fonction qui n’est soumise à aucune contrainte.
Cette instruction retourne une valeur , qui est un minimum local de la fonction fun.
Nous utilisons cette fonction de minimisation pour calculer, dans l’algorithme du lagrangien
augmenté :
Nous avons présenté en détail l’algorithme de Rackwitz, plus brièvement les méthodes de type
gradient projeté et lagrangien augmenté, et nous avons parlé des éléments nécessaires à leur
implémentation dans le langage Matlab.
L’ensemble du code Matlab du projet est présent en annexe.
Nous allons maintenant tester ces trois méthodes sur différents exemples et comparer celles-ci,
lorsque la comparaison est possible.
19

3. Exemples d’application et résultats comparés
Cette troisième et dernière partie regroupe les différents résultats comparés de l’exécution des
trois méthodes sur des exemples que nous avons choisis pour mettre en évidence des propriétés de
convergence et de rapidité d’exécution de l’une ou l’autre méthode.
Par hypothèse, dans tous les exemples que nous traiterons, l’origine O du repère de sera
située dans le domaine
. En effet, le problème étudié revenant à trouver la distance entre
le point O et le domaine
, prendre O dans ce domaine n’est pas un cas intéressant. Etant
donné que l’algorithme de Rackwitz cherche un point solution sur la frontière du domaine
, la solution triviale du point origine, si celui-ci n’est pas sur la frontière du domaine, ne
pourra être trouvée par cette méthode.
Nous n’évoquerons pas la complexité des algorithmes, le fait est que nous ne disposons que de
peu d’informations sur le fonctionnement intérieur des fonctions
de
l’Optimization Toolbox de Matlab.
3.1. Critères de comparaison
Dans cette troisième et dernière partie, nous allons essayer d’analyser les trois méthodes
d’optimisation, voir dans quels cas l’algorithme de Rackwitz converge, et le cas échéant comparer la
solution retournée avec celles des deux autres méthodes de type gradient projeté et lagrangien
augmenté.
Pour cela, il nous a fallu sélectionner des critères de comparaison comme le nombre
d’itérations et le temps d’exécution de chaque méthode.
3.1.1. Le nombre d’itérations
Comme les trois méthodes étudiées sont des méthodes itératives, un critère intéressant de
comparaison est le nombre d’itérations que chacun des algorithmes met, lors de son exécution avec
Matlab, pour arriver à la solution finale.
3.1.2. Le temps d’exécution
D’autre part, un autre critère que nous avons choisi est le temps d’exécution. La paire
d’instructions Matlab
permet d’afficher la durée écoulée en secondes entre deux instants.
Cette instruction mise au début et à la fin de l’exécution d’une méthode, nous donne sa durée
d’exécution. Cette durée dépendant du processeur de l’ordinateur, elle pourra être utilisée en terme de
rapport entre deux durées. D’autre part, dans le cas où la convergence se fait en moins d’une dizaine
d’itérations, le temps d’exécution très court peut parfois se relever insignifiant.
20

Nous allons maintenant essayer de donner des exemples assez représentatifs de fonctions. Nous
avons d’abord étudié certains cas de fonctions dont le graphe est assez particulier,
avant de donner divers exemples de fonctions non linéaires.
3.2. Cas où le graphe F(x)=0 est un hyperplan
Supposons tout d’abord que la fonction définit un hyperplan . Dans ce cas, il est
clair que l’algorithme de Rackwitz donne toujours en deux itérations maximum le résultat. En effet,
quelque soit le point, les normales sont toutes parallèles. Il y a donc le point initial de l’algorithme qui
est, a priori, un point différent de l’optimum. La première itération donne directement l’optimum. A
l’itération suivante, l’algorithme trouve donc le même point et s’arrête. Cela fait donc bien au plus
deux itérations.
Fig. 3.1 - Exécution de l’algorithme de Rackwitz dans le cas d’un hyperplan en 2D
Dans le cas du lagrangien augmenté, l’algorithme converge assez rapidement, en une dizaine
d’itérations maximum pour les cas traités, suivant que le point initial se situe plus ou moins loin de la
solution. Cependant, si on prend un point d’initialisation trop éloigné de la solution optimale, la
convergence ne peut se faire au moyen de cette méthode. L’algorithme ne nous donne pas la bonne
solution et l’appel de retourne à l’écran :
« »
Il y a aussi le cas très particulier de l’origine comme point initial : l’algorithme s’arrête
directement et considère l’origine comme solution.
21

En revanche, dans le cas du gradient projeté, la convergence semble se faire en trois ou quatre
itérations suivant que l’initialisation soit plus ou moins loin de la solution
Fonction contrainte
Dimension
Gradient Lagrangien
Rackwitz
du problème
projeté augmenté
x 1 - x 2 + 1 2 2 3 4 à 10
6 + x 1 - 3*x 2 - x 3 - 4*x 4 - 6*x 5 5 2 3 ou 4 8 ou 9
6 + x 1 - 3*x 2 - x 3 - 4*x 4 - 6*x 5
+ 3*x 6 - x 7 - x 8 - 2*x 9 + 2*x 10
10 2 3 ou 4 8 ou 9
Fig. 3.2 - Convergence en nombre d’itérations dans le cas d’un hyperplan
Fonction contrainte
Dimension du
Lagrangien
Rackwitz Gradient projeté
problème
augmenté
x 1 -x 2 +1 2 < 0.1 s 0.1 à 0.2 s 0.2 à 1 s
6 + x 1 - 3*x 2 - x 3 - 4*x 4 - 6*x 5 5 < 0.1 s 0.2 s 0.5 à 1.5 s
6 + x 1 - 3*x 2 - x 3 - 4*x 4 -6*x 5 +
3*x 6 - x 7 - x 8 - 2*x 9 + 2*x 10
10 < 0.1 s 0.2 à 0.3 s 0.8 à 2 s
Fig. 3.3 - Convergence en temps d’exécution dans le cas d’un hyperplan
Revenons sur l’exemple en dimension 10. La solution approchée du problème étudié est alors :
T
Les différents points d’initialisation ci-dessous convergent tous sur les deux algorithmes, donc
sont dans le domaine de contrainte . Le nombre d’itérations varie peu.
Point d’initialisation Gradient
projeté
Lagrangien
augmenté
(1;1;1;1;1;1;1;1;1;1) 4 8
(1;41;30;11;15;1;1;11;11;5) 3 8
(1;1;-3;1;5;10;1;11;11;5) 3 8
(1;1;-3;1;5;0;7;16;-11;-5) 4 9
(10;10;10;10;10;10;10;10;10;10) 4 9
(1;1;1;1;1;1;1;1;10;1) 4 8
Fig. 3.4 - Influence de l’initialisation sur le nombre d’itérations dans le cas d’un hyperplan
22

3.3. Cas où le graphe F(x)=0 est un paraboloïde ou un hyperboloïde
Nous avons choisi de regrouper dans une même sous-partie les cas des paraboloïdes et
hyperboloïdes cas car ils présentent des points communs quant aux situations de non-convergence de
la méthode de Rackwitz.
En effet, si on considère en dimension 2, une parabole ou une hyperbole, alors la parallèle
passant par l’origine, à la normale à un point situé sur le graphe , ne coupe pas, ou bien
coupe une ou deux fois la courbe. Ainsi, quand il n’y a pas d’intersection, l’algorithme s’arrête, et
quand l’intersection est double, le choix induit par la méthode de Newton peut faire entrer l’algorithme
dans un cycle infini.
La figure Fig. 3.5 (resp. Fig. 3.6) montre les cas où la parallèle à la normale à un point courant
situé sur une parabole (resp. hyperbole) ne coupe pas ou coupe deux fois la courbe.
Fig. 3.5 - Intersections possibles entre une droite issue de l’origine et une parabole
Fig. 3.6 - Intersections possibles entre une droite issue de l’origine et une hyperbole
23

3.3.1. Cas de non convergence pour une parabole
Dans le cas où la courbe est une parabole (ou plus généralement un paraboloïde en
dimension n), si la fonction contrainte prend des valeurs négatives pour les points situés dans la
partie non convexe, alors la convergence de l’algorithme de Rackwitz n’est pas obligatoirement
assurée.
Un tel exemple de non-convergence est celui où
. En effet, à chaque
itération, il est possible de choisir entre deux points, et l’algorithme, comme nous l’avons programmé,
ne peut pas chercher s’il y a plusieurs points et prend le premier qui arrive. Ce point n’est pas
forcément le plus judicieux. Dans notre exemple, l’algorithme fait un cycle entre les deux points :
La parallèle à la normale à la courbe au point , passant par l’origine, coupe la
courbe en deux points distincts dont l’un est , et inversement en échangeant les rôles de et .
Fig. 3.7 - Cas de non convergence de l’algorithme de Rackwitz avec une parabole
24

3.3.2. Cas de non convergence pour une hyperbole
Prenons l’exemple où délimite un domaine non connexe. C’est le cas par exemple
dans où le graphe correspond à une hyperbole.
Dans le cas des hyperboles, l’algorithme de Rackwitz ne convergera généralement pas car il
aura tendance à faire un cycle entre deux voire trois points situés sur l’hyperbole. La raison principale
est C’est un cas important de non convergence de l’algorithme de Rackwitz.
Pour illustrer ce cas, prenons la fonction contrainte
Considérons maintenant l’hyperbole définie par
courbe d’équation :
, c'est-à-dire le graphe (Fig. 3.1) de la
Fig. 3.8 - Exécution de l’algorithme de Rackwitz avec un domaine non connexe
Nous nous apercevons que l’algorithme de Rackwitz va très rapidement, en quelques itérations,
parvenir à ce cycle de trois points :
25

Le cycle est infini, mais nous nous apercevons que , le point plus proche de l’origine, est une
très bonne solution approchée de la solution. Nous pouvons le voir graphiquement en traçant (Fig. 3.2)
le cercle de centre 0 et de rayon .
Fig. 3.9 - Exécution de l’algorithme de Rackwitz avec un domaine non connexe (zoom)
3.3.3. Résultats en cas de convergence
Le tableau suivant donne les résultats trouvés en cas de convergence de l’algorithme de
Rackwitz dans le cas où le graphe est du type paraboloïde ou hyperboloïde. La quatrième
colonne indique l’initialisation choisie pour le gradient projeté et le lagrangien augmenté ; on rappelle
que pour la méthode de Rackwitz, l’initialisation, si elle est possible telle que nous l’avons
implémentée, est faite automatiquement. Le signe (-) dans la colonne du gradient projeté indique que
nous n’avons pas trouvé de point d’initialisation tel que cette méthode converge vers la bonne solution.
Fonction contrainte
Dimension
Gradient Lagrangien
Initialisation Rackwitz
du problème
projeté augmenté
x 1 ² - 4*x 1 - x 2 + 3 2 (0;1) 7 (-) 8
x 1 ² - 20*x 1 - x 2 + 20 2 (0;1) 3 (-) 9
x 1 ² - 2*x 2 - 3*x 2 + 2 3 (0;0;1) 13 4 8
Fig. 3.10 - Convergence en nombre d’itérations dans le cas de paraboloïdes / hyperboloïdes
Ce tableau montre que la méthode de Rackwitz donne en moyenne de meilleurs résultats que le
lagrangien augmenté, mais que le gradient projeté peut s’il converge arriver à un bon résultat.
26

3.4. Cas où le graphe F(x)=0 est un ellipsoïde
Etudions maintenant le cas où le graphe
ou un cercle en dimension 2.
est un ellipsoïde, en particulier une ellipse
Commençons tout d’abord par un exemple en dimension 2 avec la fonction contrainte :
Considérons maintenant le cercle défini par
centre et de rayon dont le graphe est le suivant :
, et le domaine défini par le disque de
Fig. 3.11 - Exemple d’un domaine délimité par un cercle
Dans ce cas, l’algorithme de Rackwitz converge en 16 itérations. Selon le point d’initialisation
de la méthode de type lagrangien augmenté, on a une convergence en 8 ou 9 itérations. Ainsi, dans ce
cas, on remarquera que le lagrangien augmenté donne de meilleurs résultats. Nous n’avons en
revanche trouvé aucun point d’initialisation pour lequel la méthode de type gradient projeté nous
donne la bonne solution pour cet exemple.
Le tableau suivant donne les résultats trouvés en cas de convergence de l’algorithme de
Rackwitz dans le cas où le graphe est du type ellipsoïde. Comme précédemment, la
quatrième colonne indique l’initialisation choisie pour le gradient projeté et le lagrangien augmenté, et
le signe (-) dans la colonne du gradient projeté indique que nous n’avons pas trouvé de point
d’initialisation tel que cette méthode converge vers la bonne solution.
27

Fonction contrainte
Dimension
Gradient Lagrangien
Initialisation Rackwitz
du problème
projeté augmenté
x 1 ² + x 2 ² + x 1 – 5*x 2 + 3 2 (1;1) 16 (-) 8
- x 1 ² - x 2 ² - x 1 + 5*x 2 + 18.5 2 (1;-3) 19 15 10
- x 1 ² - x 2 ² - x 1 + 5*x 2 + 18.5 2 (-5;5) 19 29 9
x 1 ² + x 2 ² + x 3 ² + 1 3 (1;1;1) 13 4 8
Fig. 3.12 - Convergence en nombre d’itérations dans le cas d’ellipsoïdes
Dans ce cas particulier où le graphe est un ellipsoïde, on peut noter que la méthode de Rackwitz
nous donne des résultats assez moyens par rapport à celle du lagrangien augmenté. Quant à celle du
gradient projeté, elle dépend beaucoup de l’initialisation.
3.5. Cas divers
L’étude de cas de graphes particuliers donne des résultats assez mitigés pour les différentes
méthodes. Nous allons maintenant voir si une méthode « l’emporte » sur une autre en testant des
exemples avec des fonctions de contraintes non linéaires.
Nous avons pris ces exemples de fonctions de manière totalement aléatoire, exemples que l’on
a testés à la fois en nombre d’itérations et en temps d’exécution.
Fonction contrainte
Dimension
Gradient Lagrangien
Initialisation Rackwitz
du problème
projeté augmenté
-(exp(x 1 - x 2 ) + x 1 - 3) 2 (-8;10) 5 (-) 7
2*x 1 ²*x 2 +3*x 2 + 1 2 (1;-3) 8 12 5
2*x 1 ²*x 2 +3*x 2 - x 3 +1 3 (1;-3;1) 8 10 5
2*x 1 ²*x 2 +3*x 2 - x 3 + x 4 +1 4 (0;0;5;0) 8 4 5
Fig. 3.13 - Convergence en nombre d’itérations pour des cas divers
Fonction contrainte
Dimension
Gradient Lagrangien
Initialisation Rackwitz
du problème
projeté augmenté
-(exp(x 1 - x 2 ) + x 1 - 3) 2 (-8;10) 0.2 s (-) 0.5 s
2*x 1 ²*x 2 +3*x 2 + 1 2 (1;-3) 0.2 s 0.6 s 0.3 s
2*x 1 ²*x 2 +3*x 2 - x 3 +1 3 (1;-3;1) 0.1 s 0.8 s 0.3 s
2*x 1 ²*x 2 +3*x 2 - x 3 + x 4 +1 4 (0;0;5;0) 0.1 s 0.3 s 0.3 s
Fig. 3.14 - Convergence en temps d’exécution pour des cas divers
28

L’étude de ces quelques exemples a permis de montrer que, dans le cas général, la méthode de
Rackwitz donne de meilleurs résultats que celle du gradient projeté et de moins bons résultats que celle
du lagrangien augmenté, en terme de nombre d’itérations effectuées. Cependant, dans tous les cas, la
méthode de Rackwitz l’emporte en terme de rapidité d’exécution. La méthode du gradient projeté
arrive quant à elle dernière au niveau performance.
29

Conclusion
Nous avons implémenté dans l’environnement Matlab l’algorithme de Rackwitz, et les deux
méthodes de type gradient projeté et lagrangien augmenté que nous avons adaptées au problème
d’optimisation non linéaire avec une unique fonction contrainte non linéaire dans .
Nous avons vu qu’il est assez facile de trouver des exemples de non convergence de
l’algorithme de Rackwitz. Cependant, cette méthode, lorsqu’elle converge, donne les meilleurs
résultats en terme de rapidité d’exécution, le nombre d’itérations effectuées étant légèrement plus
important que pour le lagrangien augmenté. En effet, contrairement aux algorithmes plus communs de
type gradient projeté et lagrangien augmenté, la méthode de Rackwitz ne fait pas intervenir d’autres
sous-problèmes d’optimisation.
Nous noterons enfin que l’algorithme du gradient projeté se prête assez mal au problème que
nous avons étudié, en particulier du fait de la présence d’une unique fonction contrainte, et de la nonlinéarité
de celle-ci, faisant de nombreux exemples étudiés des cas de non convergence.
30

Bibliographie
[1] Rüdiger Rackwitz, http://www.mb.bv.tum.de/index-d/mitarbeiter/rackwitz.htm
[2] Reliability based design optimization, http://www.iitk.ac.in/kangal/seminar/rbdo.ppt
[3] Introduction to reliability-based design, http://www.ippt.gov.pl/~arek/intr-reliab.ppt
[4] MINOUX M., Programmation mathématique, théorie et algorithmes, Tome 1,
éditions Dunod, 1983
[5] Optimisation sous contrainte, http://ycollette.free.fr/spip/IMG/pdf/02_AvecContraintes.pdf

ANNEXES

Table des annexes
A. Code Matlab pour la dérivée, le gradient et la méthode de Newton . . . . . . . . . . . . . . . . . . . . I
B. Code Matlab de la méthode de type gradient projeté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . II
C. Code Matlab de la méthode de type lagrangien augmenté . . . . . . . . . . . . . . . . . . . . . . . . . . . IV
D. Code Matlab de l’algorithme de Rackwitz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VI

A. Code Matlab pour la dérivée, le gradient et la méthode de Newton
function [dif] = deriv(f,i,x,eps)
%Approximation de la dérivée en un point par différences finies
% [dif] = deriv(f,i,x,eps)
% f : Rn -> R, fonction
% i, pour la i-ème derivée partielle (i=1 si dérivée)
% x, point de Rn
% eps, précisions des calculs
format long
n = length(x);
dif = feval(f,[x(1:i-1);x(i)+eps;x(i+1:n)])-...
feval(f,[x(1:i-1);x(i)-eps;x(i+1:n)]);
dif = dif/2/eps;
function [gradU,normU] = grad(f,x,n,eps)
%Calcul du gradient d'une fonction en un point
% [gradU,normU] = grad(f,x,n,eps)
% f : Rn -> R, fonction
% x, point de Rn
% n, dimension du problème
% eps, précisions des calculs
format long
for i=1:n
gradU(i) = deriv(f,i,x,eps);
end
normU = sqrt(gradU*gradU');
function [x,iter] = newton(f,eps,a,itermax)
%Méthode de Newton
% [x,iter] = newton(f,eps,a,itermax)
% f : R -> R, fonction
% eps, précision des calculs
% a, point d'initialisation
% itermax, nombre maximal d'itérations
format long
x = a;
for iter=1:itermax
if abs(deriv(f,1,x,eps)) < eps
disp('Méthode de Newton : division par 0');
return
end y = x - feval(f,x)/deriv(f,1,x,eps);
if abs(y-x) < eps
break
end
x = y;
end
I

B. Code Matlab de la méthode de type gradient projeté
function [] = gradient_projete(f,n,x0)
%Méthode du gradient projeté
% gradient_projete(f,n,x0)
% f : Rn -> R, contrainte F sur x
% n, dimension du problème
% x0, point d'initialisation dans Rn
stop = 0;
if feval(f,x0)>0
disp('Le point d initialisation doit etre dans le domaine F(x)

if alphamax>epsilon
[alphak,fxk] = fminbnd(@(alpha)norm(xk+alpha*yk),0,alphamax);
else
alphak = 0;
fxk = 0;
end
% Calcul du nouveau point courant
xk = xk+alphak*yk;
stopc = 1;
if norm(alphak*yk) < epsilon
stop = 1;
break
end
else
end
end
end
u = - 1/(dgdx*dgdx')*dgdx*2*xk;
if u >= -epsilon
stopc = 1;
stop = 1;
else
sat = 0;
end
x = xk
disp('Solution x calculée par l algorithme de type gradient projeté');
x
disp('Nombre d iterations');
iter
disp('Norme de x');
norm(x)
end
function [c,ceq] = constr(f,alpha,xk,yk)
c = feval(f,xk+alpha*yk);
ceq = [];
end
III

C. Code Matlab de la méthode de type lagrangien augmenté
function [] = lagrangien_augmente(f,n,x0)
%Méthode du lagrangien augmenté
% lagrangien_augmente(f,n,x0)
% f : Rn -> R, contrainte F sur x
% n, dimension du problème
% x0, point d'initialisation dans Rn
format long
itermax = 10000;
epsilon = 1e-6;
x = x0;
lambda = 0;
R = 0.1;
iter = 0;
stop = 0;
while (stop==0 & iter

% Calcul du lagrangien, avec gradient et hessien
function [L,gL,HL] = lagrangien(x,f,lambda,R,n,eps)
L = norm(x)+lambda*feval(f,x)+R*(feval(f,x)*feval(f,x))/2;
if nargout>1
for i=1:n
gL(i) = 2*x(i)+lambda*deriv(f,i,x,eps)+R*deriv(f,i,x,eps)*feval(f,x);
end
if nargout>2
HL(i,j) = 2+(lambda+R)*deriv(@(x)deriv(f,j,x,eps),i,x,eps)...
+R*deriv(f,i,x,eps)*deriv(f,j,x,eps);
if i~=j
HL(i,j) = HL(i,j)-2;
end
end
end
end
V

D. Code Matlab de l’algorithme de Rackwitz
function [] = rackwitz(f,n)
%Méthode de Rackwitz
% rackwitz(f,n)
% f : Rn -> R, fonction contrainte
% n, dimension du problème
format long
iter = 0;
itermax = 10000;
epsilon = 1e-6;
a = 1;
% Initialisation pour trouver x0 par la méthode de Newton
if nepsilon & iter

disp('Solution x calculée par l algorithme de Rackwitz');
x
disp('Nombre d iterations');
iter
disp('Norme de x');
norm(x)
VII