1. Rapport de stage scientifique
R´solution num´rique
e e
de probl`mes d’optimisation dynamique
e
en ´conomie de l’environnement
e
a l’aide du logiciel scientifique SCILAB
`
Stage propos´ par le CIRED, r´alis´ avec le CEREVE, sous la direction
e e e
de :
– M. Michel Cohen de Lara et M. Jean-Philippe Chancelier (CEREVE) ;
– M. Jean-Charles Hourcade (CIRED).
S´bastien Berthaud
e
Juillet 2000
3. Remerciements
Je tiens tout d’abord a remercier M. Jean-Philippe Chancelier, enseignant-chercheur au
`
CEREVE, pour l’aide pr´cieuse qu’il m’a apport´ tout au long du stage, d`s que je me voyais
e e e
confront´ a des probl`mes techniques, ainsi que M. Pierre Carpentier, chercheur a l’ENSTA,
e` e `
qui m’a consacr´ de son temps pour me permettre de poser les bases des algorithmes utilis´s
e e
utilis´s par la suite.
e
Je remercie ´galement M. Cohen de Lara pour son encadrement attentif durant le stage,
e
et son aide salutaire quant a la r´daction de ce rapport.
` e
Je voudrais aussi attirer l’attention sur le fait que M. Franck Lecocq, chercheur au CI-
RED, a lui aussi pris sur son temps, alors qu’il se trouvait en pleine p´riode de soutenance
e
de th`se, pour me fournir des informations importantes sur les mod`les STARTS ainsi que
e e
des r´sultats de simulations num´riques.
e e
Je tiens aussi a remercier M. Jean-Charles Hourcade, M. Philippe Ambrosi, M. Vincent
`
Gitz, M. Thierry Lepesant, Mme Yasmina Rakem ainsi que toutes les ´quipes du CIRED,
e
et du CEREVE pour leur suivi tout au long du stage.
1
4. R´sum´
e e
Ce stage scientifique a pour but d’´tudier et de simuler num´riquement, avec le logiciel
e e
SCILAB, des mod`les de comportement de pays, face a des contraintes environnementales
e `
sur les ´missions de CO2 . Il se place dans le cadre d’une ´tude mise en place par le CIRED,
e e
financeur du stage.
Une description ´conomique pr´cise des mod`les a utiliser a ´t´ r´alis´e au CIRED, par
e e e ` ee e e
Franck Lecocq, pour aboutir aux mod`les STARTS. Dans un premier temps, il a fallu mettre
e
ces derniers sous une forme ¡¡math´matiquement correcte¿¿, c’est a dire sous une forme de
e `
probl`me d’optimisation dynamique.
e
Ensuite, des outils informatiques ont ´t´ d´velopp´s pour permettre a SCILAB de trai-
ee e e `
ter les probl`mes pos´s. Ces outils ont ´t´ voulus tr`s g´n´raux, afin d’ˆtre r´utilisables par
e e ee e e e e e
le CIRED pour tous les futurs mod`les ´conomiques. Il s’agit em l’occurence des macros
e e
dynoptim et dynoptimsc qui permettent de traiter des probl`mes d’optimisation dynamique.
e
Enfin, des comparaisons ont ´t´ r´alis´es entre les r´sultats fournis par le programme fonc-
ee e e e
tionnant avec SCILAB et ceux donn´s par un autre logiciel, GAMS, avec lequel Franck
e
Lecocq avait commenc´ a simuler les mod`les STARTS.
e` e
Mots-cl´s. Optimisation, syst`me dynamique, algorithme d’Uzawa, dualit´, Lagrangien
e e e
augment´, SCILAB, contrainte environnementale, coˆt-avantage, coˆts-efficacit´, effet de
e u u e
serre, optimisation dynamique.
2
8. Liste des tableaux
2.1 Fonctionnement de la fonction SCILAB optim . . . . . . . . . . . . . . . . 22
2.2 Fonctionnement de la primitive eval crit`re permettant de calculer la
e valeur
du crit`re J , ainsi que celle de son gradient J . . . . . . . . . . . .
e . . . . 23
2.3 Fonctionnement de la macro SCILAB dynoptim en tenant compte de la pri-
mitive d’interface setf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.1 R´sultats d’un exemple de p´nalisation de la contrainte . . . . . . . . . . . . 35
e e
3.2 Algorithme d’Uzawa, appliqu´ au Lagrangien augment´, avec contrainte d’in´galit´ 38
e e e e
4.1 D´finitions et valeurs par d´faut des param`tres utilis´s dans les mod`les
e e e e e
STARTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.2 Comparaison des valeurs de crit`re a l’optimum fournies par GAMS et par
e `
SCILAB, dans les cas o` il y avait une diff´rence sensible entre les trajectoires
u e
d’abattement obtenues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4
9. Introduction
Le CEREVE, centre d’enseignement et de recherche sur l’eau, la ville et l’environnement,
est issu de la fusion entre le CERGRENE et le LABAM. C’est a la fois un laboratoire de
`
recherche pluridisciplinaire, un centre d’expertise et un support de formations.
Plac´ sous la tutelle de l’ENPC, de l’ENGREF et de l’UPVM, ses objectifs sont triples :
e
faire progresser les connaissances scientifiques, participer a la mise en place d’instruments de
`
la gestion int´gr´e en environnement, et contribuer a la formation des praticiens et chercheurs
e e `
de demain.
Pour mener a bien ses recherches, le CEREVEcombine efficacement un savoir-faire dans
`
la mise en œuvre de campagnes et d’enquˆtes de terrain, des comp´tences analytiques et une
e e
maˆ ıtrise de la mod´lisation.
e
Le CIRED, pour Centre international de recherche sur l’environnement et le d´veloppement,
e
e e ee ` ´
a ´t´ cr´´ en 1973 par le professeur a l’Ecole des hautes ´tudes en sciences sociales, Ignacy
e
Sachs. Le but premier de ce laboratoire est d’´tudier les int´ractions entre l’environnement,
e e
la gestion des ressources naturelles et le d´veloppement ´conomique.
e e
En 1979, le CIRED est devenu une unit´ de recherche du CNRS, et depuis 1987, M.
e
Jean-Charles Hourcade en est le directeur.
Le CIRED est associ´ a de nombreux cours et partenariats, avec notamment l’EHESS,
e`
l’ENGREF, l’Universit´ Paris X, et l’Universit´ de Marne la Vall´e ainsi que l’ENPC.
e e e
Le logiciel SCILAB est un logiciel math´matique gratuit, librement distribu´, cr´´ a
e e ee `
l’initiative de l’INRIA. M Jean Philippe Chancelier, qui travaille actuellement au CEREVE,
fait partie de l’´quipe des d´veloppeurs de ce logiciel.
e e
SCILAB est tr`s ´volutif, chacun peut y rajouter ses travaux sous formes de ¡¡contribu-
e e
tions¿¿.
De plus, il est dot´ d’une interface tr`s facile d’utilisation, permettant un apprentissage
e e
ais´ et l’´criture de programmes tr`s lisibles.
e e e
e ee ´
SCILAB est utilis´ au CEREVE, mais aussi par les ´l`ves de l’Ecole nationale des ponts
et chauss´es.
e
5
10. Objectifs et encadrements du stage
Les probl`mes d’optimisation dynamique, i.e. des probl`mes d’optimisation o` le temps
e e u
apparaˆ sont tr`s nombreux en ´conomie, et le logiciel GAMS se prˆte relativement bien a
ıt, e e e `
la r´solution de ces probl`mes, tout du moins en ce qui concerne les petits mod`les.
e e e
Cependant ce logiciel n’est pas tr`s pratique d’utilisation, il n´cessite l’´criture et la
e e e
lecture de multiples fichiers a chaque utilisation. C’est pourquoi le CIRED cherchait un
`
logiciel plus souple, afin de pouvoir traiter de mani`re plus ais´e des probl`mes de plus en
e e e
plus complexes.
M Michel Cohen de Lara proposa donc au CIRED de se tourner vers le logiciel SCILAB,
afin de profiter de sa grande souplesse d’utilisation. En revanche, comme le logiciel SCILAB
ne poss´de pas d’outil pouvant ˆtre appliqu´ a la r´solution de probl`mes d’optimisation
e e e ` e e
dynamique, il y a un enjeu a en cr´er.
` e
Les objectifs de ce stage sont
– d’tiliser SCILAB pour mettre en place les mod´lisations informatiques des probl`mes
e e
´conomiques du CIRED ;
e
– de d´velopper des outils SCILAB pour l’optimisation dynamique, en vue de la r´solution
e e
num´rique de probl`mes d’´conomie de l’environnement.
e e e
L’encadrement de ce stage est assur´ par :
e
– M. Michel Cohen de Lara, enseignant-chercheur au CEREVE, tuteur du stage ;
– M. Jean-Philippe Chancelier, enseignant-chercheur au CEREVE ;
– M. Jean-Charles Hourcade, directeur du CIRED, responsable du stage.
Les mod`les ` ´tudier
e ae
Les mod`les STARTS (pour Sectoral Trajectories with Adaptation and Response Turnover
e
of Stocks) constituent une famille de mod`les d’optimisation des politiques de r´duction des
e e
´missions de gaz a effet de serre d´velopp´e au CIRED par Franck Lecocq et Jean-Charles
e ` e e
Hourcade avec l’aide technique de Naceur Ben Chaabane et Sylvain Cori.
Ces mod`les vont permettre de d´finir de ce que SCILAB devra ˆtre capable de r´soudre.
e e e e
De plus, certains mod`les STARTS ont d´j` ´t´ programm´s avec GAMS ; ils seront donc
e eaee e
utiles pour v´rifier le bon fonctionnement des programmes ´crits en SCILAB.
e e
Il existe aujourd’hui huit versions des mod`les STARTS qu’il est possible de regrouper
e
en deux cat´gories
e
– Optimisation partielle ou optimisation globale : dans le premier cas, nous ne disposons
comme variable de contrˆle que du niveau de r´duction des ´missions (ou abattement) ;
o e e
dans le second, nous contrˆlons l’ensemble de l’´conomie, et en particulier les d´cisions
o e e
d’´pargne des agents, et nous rajoutons donc une nouvelle variable de commande (la
e
consommation) et une nouvelle variable d’´tat (le capital).
e
– Coˆts-efficacit´ ou coˆts-b´n´fices : dans le premier cas, il s’agit de minimiser les coˆts
u e u e e u
(ou de maximiser l’utilit´) sous contrainte de non d´passement d’une contrainte envi-
e e
ronnementale ; dans le second, il existe un arbitrage explicite entre les coˆts de l’abat-
u
6
11. tement et les coˆts des impacts ; si la seconde mani`re est plus rationnelle pour un
u e
´conomiste, elle oblige par contre a aborder la question de la valorisation mon´taire
e ` e
des impacts du changement climatique.
La d´marche
e
Le stage est divis´ en quatre parties
e
– Mise en forme math´matique des probl`mes ´conomiques a ´tudier (probl`me d’opti-
e e e `e e
misation dynamique).
– D´veloppement d’une primitive g´n´rale d’optimisation dynamique sous SCILAB.
e e e
– Programmation sous SCILAB des probl`mes STARTS.
e
– R´solution num´rique des probl`mes STARTS.
e e e
7
12. Notations utilis´es
e
Notations math´matiques g´n´rales
e e e
F(E, H) l’ensemble des fonctions de E dans H ;
C 0 (E, H) l’ensemble des fonctions continues de E dans H ;
C n (E, H) l’ensemble des fonctions de E dans H d´rivables n fois,
e
et telles que leurs n premi`res d´riv´es soient continues sur E ;
e e e
J le gradient de J (on suppose J ∈ C 0 (E, H), diff´rentiable) ;
e
f la d´riv´e de la fonction f ;
e e
(cependant, dans certains cas, qui seront signal´s,
e
il faudra lire M comme ´tant la transpos´e de la matrice M
e e
et non la d´riv´e de la fonction M ).
e e
Dans les probl`mes de commande optimal, u et X d´signeront respectivement l’´tat et la
e e e
commande du syst`me. L’´tat a un instant donn´ sera suppos´ de taille n, et la commande
e e ` e e
de taille p.
Si a d´signe une suite d’´l´ments de Rn , alors at est le te terme de la suite.
e ee
Notations propres aux mod`les STARTS
e
Mt∈N ∈ R les concentrations en CO2 ;
at∈N ∈ R l’abattement des ´missions de CO2 ;
e
E t∈N ∈ R les ´missions de gaz a effet de serre de r´f´rence ;
e ` ee
κt∈N ∈ R le PIB.
8
13. Chapitre 1
Description math´matique des
e
mod`les STARTS
e
Cette partie a pour objet de faire un tour d’horizon des mod`les STARTS existants, en
` e
mettant l’accent sur la clarification de leur structure math´matique. Nous avons gard´ ici
e e
les d´nominations donn´es aux mod`les par le CIRED.
e e e
1.1 Optimisation partielle sous contrainte environnementale
Le probl`me pos´ consiste a mod´liser un pays qui doit mener une politique de r´duction
e e ` e e
des ´missions de gaz a effet de serre en de¸a d’un seuil pr´alablement fix´, tout en minimisant
e ` c` e e
les coˆts de cette politique.
u
1.1.1 Mod`le en temps continu
e
Nous supposons que les ´missions de r´f´rence Et , c’est a dire l’´volution des ´missions
e ee ` e e
si aucune mesure n’est prise, sont connues. On dispose de moyens pour r´duire a l’instant t
e `
les ´missions d’une fraction at Et : at sera appel´ abattement. On note Mt l’´mission r´elle de
e e e e
gaz a effet de serre a l’instant t.
` `
L’objectif consiste a minimiser la somme actualis´e (` un taux ρ > 0) des coˆts de r´duction
` e a u e
des ´missions de gaz a effet de serre
e `
+∞
J(a) = C(a(t), a (t), t)e−ρt dt, (1.1)
0
sous la contrainte environnementale de non-d´passement d’un seuil pr´alablement fix´
e e e
M (t) ≤ M . (1.2)
Le coˆt d’abattement s’´crit
u e
C(a(t)t, a (t), t) = αE(t)a(t)ν λ(t)γ(a (t)), (1.3)
et il est compos´ de trois facteurs
e
– un terme d´pendant de a(t) en αE(t)a(t)ν qui est le coˆt d’abattement ¡¡brut¿¿ ;
e u
9
14. – un terme de progr`s technique λ(t), o` λ est une fonction d´croissante v´rifiant λ(0) = 1
e u e e
et limt→∞ λ(t) = λ (0 < λ < 1) ;
– un terme γ(a (t)) qui traduit l’inertie du capital, par exemple de la forme
1 si a < γ
γ(a) = a
γ sinon.
Pour mod´liser l’ ´volution des concentrations en CO2 , nous utilisons la dynamique d’ac-
e e
cumulation du CO2 suivante :
M (0) = M0
. (1.4)
M (t) = βE(t)(1 − a(t)) − σ(M (t) − M−∞ )
Ici, β repr´sente une fraction (0 < β < 1) des ´missions de CO2 stock´e dans l’at-
e e e
mosph`re, et σ une fraction (0 < σ < 1) du CO2 exc´dentaire pr´-industriel M−∞ r´absorb´e
e e e e e
par le sol et les oc´ans. Nous supposons que la concentration initiale M0 en CO2 est sup´rieure
e e
a la concentration pr´-industrielle : M0 > M−∞ .
` e
Les ´missions de r´f´rence E(t) sont croissantes (´ventuellement a une vitesse elle aussi
e ee e `
croissante au d´part) avant de d´croˆ puis de tendre vers 0 quand t temps vers l’infini.
e e ıtre
Ici, a (t) est la variable de commande du probl`me, alors que a(t) et M (t) sont des va-
e
riables d’´tat du syst`me. En effet, il suffit de connaˆ le couple (a0 , M0 ) ainsi que l’ensemble
e e ıtre
des commandes a (t) pour d´crire compl`tement le syst`me via la dynamique (1.4).
e e e
1.1.2 Mod`le en temps discret
e
Du mod`le pr´c´dent nous pouvons d´duire un mod`le en temps discret en transformant
e e e e e
at − at−1
la quantit´ a (t) en
e ∆t o` ∆t est un pas de temps adapt´ ; la variable at est devenue
u e
variable de commande.
Bien entendu, le mod`le obtenu alors est tr`s proche du pr´c´dent. En ce qui concerne
e e e e
le coˆt, une somme discr`te vient remplacer l’int´grale, de sorte que le crit`re a minimiser
u e e e `
devient
T −1
1
J(a) = C(at , at−1 , t) , (1.5)
t=0
(1 + ρ)t
avec
C(at , at−1 , t) = αEt at ν λ(t)γ(at , at−1 ). (1.6)
La dynamique devient :
Mt|t=0 = M0
(1.7)
Mt = Mt−1 + ∆t βE t−1 (1 − at−1 ) − σ(Mt−1 − M−∞ ) .
10
15. Le mod`le obtenu alors est une discr´tisation possible du mod`le en temps continu
e e e
pr´sent´ plus haut, et il faut noter quelques petites modifications : dans le premier cas,
e e
a(t)
la variable de commande ´tait le vecteur a (t) et l’´tat ´tait
e e e , alors que dans le
M (t)
at−1
second cas, la variable de commande est at et l’´tat devient le vecteur xt =
e .
Mt
Dans le premier cas, si nous connaissons a (t) pour t < θ, ainsi que a(0) et M (0), alors
nous pouvons obtenir a(θ) ainsi que M (θ). Pour cela, il suffit d’int´grer
e
θ
– a (t) pour retrouver a(θ) = 0 a (t)dt + a(0),
– puis l’´quation diff´rentielle M˙(t) = βE(t)(1 − a(t)) − σ(M (t) − M−∞ ) .
e e
Dans le second cas, si nous connaissons at pour t ∈ {0, . . . , θ} , ainsi que a0 et M0 ,
alors nous pouvons obtenir aθ ainsi que Mθ . Pour cela, il suffit de partir de M0 de calculer
Mt pour t ∈ {0, . . . , θ} via la dynamique (1.7)pour enfin obtenir Mθ .
1.2 Optimisation partielle en analyse coˆ ts-avantages
u
Le probl`me pos´ consiste maintenant a mod´liser un pays qui doit mener une politique
e e ` e
de r´duction des ´missions de gaz a effet de serre, en minimisant a la fois, les coˆts
e e ` ` u
– des impacts futurs des changements climatiques ;
– de la politique de r´duction des ´missions.
e e
1.2.1 Mod`le en temps continu
e
Ce mod`le est tr`s proche de ceux ´tudi´s pr´c´demment, car les variables de commande
e e e e e e
et d’´tat restent identiques, ainsi que la dynamique. Cependant, la contrainte environnemen-
e
tale (1.2) a disparu, et maintenant le coˆt des impacts des dommages dus a la pollution est
u `
pris en compte dans la fonction objectif.
Ainsi, la dynamique reste inchang´e, a savoir
e `
M (0) = M0
(1.8)
M (t) = βE(t)(1 − a(t)) − σ(M (t) − M−∞ ),
et le crit`re a minimiser devient
e `
+∞
J(a, M ) = C(a(t), a (t), t) + d(M (t), t) e−ρt dt. (1.9)
0
Le terme C(a(t), a (t), t) du coˆt de l’abattement dans l’expression du crit`re est identique
u e
a l’expression (1.3), et le terme correspondant au coˆt des dommages s’´crit comme le produit
` u e
du PIB κ(t) de r´f´rence et d’un indicateur de dommage ξ(t) variant entre 0 et 1, soit :
ee
d(M (t), t) = κ(t)ξ(M (t)). (1.10)
On impose simplement a κ(t) et ξ(t) d’ˆtre croissantes.
` e
11
16. 1.2.2 Mod`le en temps discret
e
De la mˆme mani`re que pour le mod`le d’optimisation partielle sous contrainte envi-
e e e
ronnementale, nous allons d´finir un mod`le en temps discret en rempla¸ant encore a (t) par
e e c
at − at−1
∆t .
Nous sommes donc amen´s a consid`rer le probl`me suivant :
e ` e e
On minimise le crit`re
e
T −1
1
J(a, M ) = C(at , at−1 , t) + d(Mt , t) . (1.11)
t=0
(1 + ρ)t
Les ´tats sont li´s par la dynamique (1.7), a savoir :
e e `
Mt|t=0 = M0
Mt = Mt−1 + ∆t βEt−1 (1 − at−1 ) − σ(Mt−1 − M−∞ ) ,
et les hypoth`ses sur la fonction de dommage restent les mˆmes qu’au paragraphe (1.2.1).
e e
1.3 Synth`se
e
Tous les mod`les pr´sent´s ci-dessus – aussi bien en temps continu, qu’en temps discret
e e e
– ne sont que des cas particuliers de probl`mes plus g´n´raux et classiques en commande
e e e
optimale. En effet, tous les probl`mes ´tudi´s ci-dessus peuvent se mettre sous la forme
e e e
g´n´rale suivante (Culioli, 1994) :
e e
En temps continu
Soit T > 0 (´ventuellement T = +∞), on minimise en x ∈ C 0 [0, T ]; Rn
e
et en u ∈ C 0 [0, T ]; Rp le crit`re
e
J(x, u) = J1 (x, u) + J2 (x, u) avec, (1.12)
T
le coˆt int´gral
u e J1 (x, u) = l(x(t), u(t), t)dt , (1.13)
0
le coˆt final
u J2 (x, u) = Φ(x(T ), T ) , (1.14)
o` l’´tat x et la commande u sont li´s par la dynamique
u e e
x = F (x(t), u(t), t), t ∈ [0, T ] , (1.15)
12
17. avec des conditions aux limites (´ventuellement vides )
e
h0 (x(0), 0) = 0, hT (x(T ), T ) = 0 (1.16)
et des contraintes pouvant prendre des formes diverses (∀t ∈ [0, T ])
les contraintes d’´galit´ k1 (x(t), u(t), t) = 0,
e e (1.17)
les contraintes d’in´galit´ k2 (x(t), u(t), t) ≤ 0,
e e (1.18)
le domaine d’admissibilit´ e u(t) ∈ U (t), (1.19)
Il est a noter que l’on distingue traditionnellement les contraintes d’´tat, qui sont une
` e
forme particuli`re des contraintes instantan´es (1.17), et qui s’´crivent :
e e e
K1 (x(t), t) = 0, ou K2 (x(t), t) ≤ 0 .
En temps discret
Soit T > 0 (´ventuellement T = +∞), on minimise en x = (x0 , . . . , xT ) ∈ Rn(T +1) ainsi
e
qu’en u = (u0 , . . . , uT −1 ) ∈ RpT , le crit`re
e
J(x, u) = J1 (x, u) + J2 (x, u) avec, (1.20)
T −1
le coˆt int´gral
u e J1 (x, u) = l(xt , ut , t)dt , (1.21)
0
le coˆt final
u J2 (x, u) = Φ(xT , 1) , (1.22)
o` l’´tat x et la commande u sont li´s par la dynamique
u e e
xt+1 = F (xt , ut , t), t ∈ {0, . . . , T − 1} , (1.23)
avec des conditions aux limites (´ventuellement vides)
e
h0 (x0 , 0) = 0, hT (xT , T ) = 0 (1.24)
et des contraintes pouvant prendre des formes diverses (∀t ∈ {0, . . . , T − 1})
les contraintes d’´galit´ k1 (xt , ut , t) = 0,
e e (1.25)
les contraintes d’in´galit´ k2 (xt , ut , t) ≤ 0 ,
e e (1.26)
le domaine d’admissibilit´ e u t ∈ Ut . (1.27)
13
18. Toutes les fonctions intervenant dans les contraintes ainsi que dans le crit`re sont au
e
moins d´rivables par rapport a tous leurs arguments, et la borne T peut ˆtre laiss´e libre et
e ` e e
sera alors consid´r´e comme une commande.
ee
Il est a noter que pour le mod`le en temps discret, la commande u est d´finie sur 0, . . . , T
` e e
et l’´tat sur 0, . . . , T + 1, alors qu’en ce qui concerne le mod`le en temps continu, la com-
e e
mande u et l’´tat x sont tous deux d´finis sur [0, T ].
e e
Lorsque le crit`re comporte a la fois un coˆt int´gral (1.13), et un coˆt final (1.14), on
e ` u e u
parle de probl`me de Bolza. Si le crit`re ne comporte que le terme de coˆt int´gral, on parle
e e u e
de probl`me de Lagrange, et si le crit`re ne comporte que le terme de coˆt final, on parle de
e e u
probl`me de Meyer (Culioli, 1994).
e
1.4 Retour sur les mod`les d’optimisation STARTS
e
En ce qui concerne les mod`les STARTS expos´s pr´c´demment, nous avons vu que pour
e e e e
a(t)
les mod`les en temps continu, la commande ´tait a (t), l’´tat ´tait
e e e e , que dans le
M (t)
at−1
cadre des mod`les en temps discret, la variable de commande est at et l’´tat xt =
e e .
Mt
Nous allons maintenant ´tudier plus particuli`rement les deux mod`les STARTSen temps
e e e
discret, et ces deux mod`les peuvent effectivement se pr´senter sous la forme d’un probl`me
e e e
de Bolza.
Le mod`le d’optimisation partielle en analyse coˆts-avantages se pr´sente sous la forme
e u e
d’ un probl`me dynamique de Bolza en horizon fini sans contrainte instantan´e.
e e
Nous devons minimiser en a ∈ RT et en x ∈ R2(T +1) , le crit`re
e
T −1
(1) (2) 1
J(a, x) = C(at , xt , t) + d(xt , t) , (1.28)
t=0
(1 + ρ)t
o`
u
(1) (1)
C(at , xt , t) = αEt at ν λ(t)γ(at , xt ). (1.29)
et d est la fonction dommage d´finie en (1.11).
e
(1)
xT
Les ´tats xt =
e (2) sont li´s par la dynamique
e
xT
14
19.
x0 = a0
M0
xt = 1 0 0 0
at−1 + xt−1 +
−∆tβE t−1 0 1 − ∆tσ ∆t(βE t−1 + σM−∞ )
(1.30)
Le mod`le d’optimisation partielle sous contrainte environnementale est lui aussi un
e
probl`me dynamique de Bolza en horizon fini, mais contrairement au mod`le pr´c´dent,
e e e e
on y a introduit des contraintes d’´tat.
e
Le crit`re a minimiser se pr´sente sous la mˆme forme qu’en (1.28) mais sans le terme d
e ` e e
correspondant au coˆt des dommages
u
T −1
(1) 1
J(a, x) = C(at , xt , t) , (1.31)
t=0
(1 + ρ)t
o`
u
(1) (1)
C(at , xt , t) = αEt at ν λ(t)γ(at , xt ). (1.32)
Les ´tats sont toujours li´s par la dynamique (1.30), et ils doivent v´rifier la contrainte d’´tat
e e e e
suppl´mentaire
e
(1)
0 ≤ xT ≤ 1
(2) (1.33)
0 ≤ xT ≤ M
Cependant, dans aucun des deux mod`les, nous n’avons exprim´ de coˆt final, si bien que
e e u
dans le cas du probl`me d’optimisation en coˆts-avantages, nous ne prenons pas en compte le
e u
coˆt des dommages provoqu´s par les ´missions MT +1 : ainsi la commande aT sera toujours
u e e
nulle, ce qui peut parfois l´gerement fausser les trajectoires optimales mˆme pour t << T .
e e
Pour palier a cela, nous pouvons introduire un coˆt final
` u
(2)
Φ(x(T ), T ) = d(xT , T ),
o` d est la fonction de dommages utilis´e sous le signe somme (1.11).
u e
15
20. Mod`le STARTS d’optimisation sous contraintes environnementales
e
On cherche
min J(u, x),
u0 , . . . , uT −1 ∈ R
x0 , . . . , x T ∈ R 2
(1)
T −1 αEt ut ν λ(t)γ(ut , xt )
avec J(u, x) = ,
t=0
(1 + ρ)t
en tenant compte de la dynamique
(1) ut−1
xt
(2) = (2) (2)
xt xt−1 + ∆t βE t−1 (1 − ut−1 ) − σ(xt−1 − M−∞ )
et de la contrainte d’´tat
e
(1)
0 ≤ xT ≤ 1
(2)
0 ≤ xT ≤ M
Mod`le STARTS d’optimisation en coˆ ts-avantages
e u
On cherche
min J(u, x),
u0 , . . . , uT −1 ∈ R
x0 , . . . , x T ∈ R 2
(1) (2) (2)
T −1 αEt ut ν λ(t)γ(ut , xt ) + κ(t)ξ(xt ) κ(T )ξ(xT )
avec J(u, x) = +
t=0
(1 + ρ)t (1 + ρ)T
en tenant compte de la dynamique
ut−1
xt = (2) (2) .
xt−1 + ∆t βE t−1 (1 − ut−1 ) − σ(xt−1 − M−∞ )
16
21. Chapitre 2
D´veloppement d’une primitive
e
SCILAB pour la r´solution du
e
probl`me de Bolza sans contrainte
e
Nous allons tout d’abord traiter le cas du probl`me de Bolza, ( i.e. avec un crit`re
e e
comportant a la fois un coˆt int´gral et un coˆt final), sans contrainte, ce qui nous permettra
` u e u
de r´soudre des probl`mes du type optimisation partielle en analyse coˆts-avantages.
e e u
2.1 Mise en forme algorithmique du probl`me de Bolza
e
2.1.1 Le probl`me de Bolza
e
Nous allons nous int´resser a la r´solution du probl`me de Bolza sans contrainte, sans
e ` e e
condition aux limites, et avec des conditions d’admissibilit´ simples, i.e aux probl`mes de la
e e
forme suivante :
Soit T > 0 (´ventuellement T = +∞), on minimise en x0 , . . . , xT ∈ Rn ,
e
et en u0 , . . . , uT −1 ∈ Rp , le crit`re
e
J(x, u) = J1 (x, u) + J2 (x, u) avec, (2.1)
T −1
le coˆt int´gral
u e J1 (x, u) = l(xt , ut , t) (2.2)
0
le coˆt final
u J2 (x, u) = Φ(xT , T ) , (2.3)
en tenant compte de la dynamique
xt+1 = F (xt , ut , t), t ∈ {0, . . . , T − 1}, (2.4)
17
22. et ´ventuellement d’un domaine d’admissibilit´
e e
ut ∈ U pour tout t ∈ {0, . . . , T − 1}. (2.5)
2.1.2 Transformation du probl`me dynamique de Bolza ` horizon
e a
fini en un probl`me d’optimisation statique
e
L’id´e de la transformation est la suivante : x0 ´tant fix´, il suffit de connaˆ ut pour
e e e ıtre
t ∈ {0, . . . , T − 1} pour pouvoir ´valuer tous les xt . Nous pouvons donc voir le crit`re a
e e `
minimiser J(x, u) comme une fonction de u seulement.
Il ne reste alors qu’` minimiser ce crit`re en u pour obtenir la commande optimale, ce
a e
qui pourra se faire avec un algorithme de recherche de minimum classique (programm´ sous
e
SCILAB par exemple).
Il nous faut montrer ici, qu’` x0 fix´, il existe une fonction Ψx0 de R(p·T ) dans Rn·(T +1)
a e
telle que
xt = Ψx0 (u).
En effet, il suffit de consid´rer la suite de fonctions
e
ψ0 (u) = F (u0 , x0 , 0) ,
ψ1 (u) = F (u1 , F (u0 , x0 , 0), 1) ,
.
. .
. (2.6)
. .
ψT (u) = F (ut−1 , F (ut−2 , F (. . . F (u0 , x0 , 0) . . .), t − 2)t − 1) ,
et de poser
ψ0 (u)
ψ1 (u)
∈ Rn·(T +1)
Ψx0 (u) = .
. (2.7)
.
ψT (u)
afin d’obtenir
x0
x = . = Ψx0 (u) .
.
. (2.8)
xT
18
23. Nous pouvons donc d´finir
e
J (u) = J(u, Ψx0 (u)). (2.9)
La fonction J (u) ainsi d´finie sur RpT est continue, d´rivable a d´riv´e continue. En effet,
e e ` e e
la fonction F est C 1 par rapport a toutes ses variables, donc par composition, la fonction
`
Ψx0 est aussi C 1 , tout comme, pour les mˆmes raisons, la fonction J (u).
e
Le probl`me de Bolza peut donc maintenant ˆtre trait´ de mani`re ´quivalente comme
e e e e e
un probl`me d’optimisation statique en u. Dor´navant J d´signera aussi bien le crit`re sous
e e e e
sa forme statique (2.9), que sous sa forme dynamique (2.1).
2.1.3 L’algorithme de calcul de l’´tat adjoint
e
Nous allons tenter maintenant de r´soudre num´riquement le probl`me d’optimisation
e e e
statique
min J (u) (2.10)
u∈U
avec
– x0 fix´ ;
e
– J (u) = J(u, Ψx0 (u)) ;
T −1
– J(u, x) = l(ut , xt , t) + Φ(xT , T ).
t=0
Nous avons vu que la fonction J ´tait C 1 , ce qui est une condition suffisante pour pouvoir
e
rechercher des minima locaux, mais le gradient ne peut pas ˆtre exprim´ simplement.
e e
Nous pourrions utiliser le calcul de d´riv´e des fonctions compos´es
e e e
d
(f ◦ g(u)) = f (g(u)) ◦ g (u),
du
mais vue la forme de la fonction J , a savoir
`
J (u) = J(u, Ψx0 (u)),
cette mani`re de calculer le gradient risque d’ˆtre vraiment coˆteuse en temps.
e e u
En effet, conform´ment a l’expression (2.7), calculer le gradient de Ψx0 n´cessite le calcul
e ` e
de gradient de T fonctions qui sont encore des fonctions compos´es. Ainsi par exemple, la
e
derni`re composante de la fonction Ψx0 , c’est a dire la fonction ψT d´finie en (2.6), est com-
e ` e
pos´e de T fois la fonction dynamique F .
e
19
24. Cependant il existe une autre m´thode pour permettre des calculs de gradients beaucoup
e
plus rapides ; pour cela il faut revenir a la forme dynamique du crit`re
` e
T −1
J(u, x, t) = l(ut , xt , t) + Φ(xT , T ), (2.11)
t=0
avec
xt|t=0 = x0
xt+1 = F (ut , xt , t),
et il faut introduire une nouvelle variable, appel´e ´tat adjoint, de mˆme dimension que
e e e
l’´tat.
e
Cette nouvelle variable Λ, propre a chaque type de probl`mes, permet, grˆce a un algo-
` e a `
rithme simple, le calcul de gradients non explicites.
Ici nous voulons calculer le gradient en u d’une fonction de la forme (2.11), et nous allons
donc introduire l’´tat adjoint Λ v´rifiant l’´quation r´currente r´trograde
e e e e e
∀t ∈ {T − 1, . . . , 0}
ΛT = ( dΦ (xT )) ,
dx
(2.12)
Λt = ( ∂F (ut+1 , xt+1 , t + 1)) Λt+1 + ( ∂x (ut+1 , xt+1 , t + 1)) .
∂x
∂l
Le gradient de la fonction J s’´crit alors
e
T −1
dF dl
J = Λt (ut , xt , t) + ( (ut , xt , t)) Lt , (2.13)
t=0
du du
o` Lt est la matrice ligne dont tous les ´l´ments sont nuls, sauf le te qui vaut 1.
u ee
Les calculs sont alors beaucoup plus simples et surtout moins nombreux, donc le calcul
du gradient s’effectue beaucoup plus rapidement. En effet, pour le calcul d’un gradient en
un point u donn´, le nombre d’´valuations num´riques des fonctions donn´es (i.e. le nombre
e e e e
d’´valuation des fonctions l, F , et Φ ainsi que de leur d´riv´es respectives par rapport a la
e e e `
commande et a l’´tat) est en O(T 2 ) avec la m´thode de d´rivation des fonctions compos´es,
` e e e e
alors qu’en utilisant l’´tat adjoint ce mˆme nombre est en O(T ).
e e
2.2 La cr´ation de la macro SCILAB dynoptim
e
Par la suite, le terme
– primitive d´signera une fonction programm´e en C o` en FORTRAN, mais appelable
e e u
depuis SCILAB ;
– macro SCILAB d´signera une fonction programm´e en langage SCILAB.
e e
20
25. Pr´sentation d’optim
e
Le logiciel SCILAB dispose d’un outil adapt´ a la r´solution de probl`me d’optimisation
e` e e
statique. La fonction optim est un outil puissant pour proc´der a des recherches de minimum
e `
sans contrainte de fonction diff´rentiable, utilisant au choix (Culioli, 1994)
e
– l’algorithme de gradient conjugu´ ;
e
– l’algorithme du quasi Newton.
Il suffit de pr´ciser a cette fonction l’algorithme a utiliser, la fonction a minimiser, et le
e ` ` `
point de d´part de l’algorithme, (i.e. la valeur de la commande pour laquelle l’algorithme
e
doit s’initialiser).
La fonction optim se d´clare de la sorte :
e
[f,uopt]=optim(costf,u0) ;
Ici cette d´claration ne comporte que les deux arguments n´cessaires
e e
– u0 est le vecteur d’initialisation ;
– costf est une macro SCILAB, renvoyant la valeur du crit`re, ainsi que, si possible,
e
celle du gradient du crit`re par rapport a la commande.
e `
Si on ne pr´cise pas une expression du gradient du crit`re par rapport a la commande
e e `
en tout point du domaine d’admissibilit´, optim proc`de a une ´valuation num´rique de
e e ` e e
celui-l` ; cependant pour des raisons de rapidit´, et surtout pour assurer la convergence de
a e
l’algorithme dans les cas complexes, il est pr´f´rable de lui en fournir l’expression.
ee
Une nouvelle primitive : eval crit`re
e
Il nous faut donc fournir a la fonction optim le gradient de notre crit`re J , et nous allons
` e
pour cela faire appel a la m´thode bas´e sur l’´tat adjoint.
` e e e
Mˆme si cette m´thode de calcul de gradient est relativement facile a mettre en place,
e e `
elle est tr`s it´rative ; en effet, il faut tout d’abord proc´der a l’´valuation de l’´tat, puis a
e e e ` e e `
l’´valuation de l’´tat adjoint, puis enfin, au calcul du gradient au point voulu. De plus, cette
e e
op´ration va devoir ˆtre effectu´e des centaines de fois au cours d’une optimisation, a chaque
e e e `
fois que la fonction optim voudra ´valuer J (u).
e
Or, SCILAB est un langage interpr´t´, qui n’est pas optimis´ pour ce genre de tˆche
ee e a
tr`s r´p´titive ; il est donc n´cessaire de d´velopper une routine de calcul de gradient via le
e e e e e
calcul de l’´tat adjoint en langage C, et pour cela nous allons cr´er une primitive.
e e
Ainsi la fonction eval crit`re est une primitive ´crite en C, ´valuant le crit`re J ainsi que
e e e e
son gradient ; sous SCILAB, elle se pr´sente ainsi :
e
[J,grd,etat]=eval_critere(u,x0)
21
26. On fournit a eval crit`re le vecteur u ∈ Rp(T −1) comportant l’ensemble des commandes
` e
ut de dimension p, pour t ∈ {0, . . . , T − 1}, ainsi que x0 ∈ Rn l’´tat initial du syst`me, et
e e
eval crit`re renvoie la valeur J du crit`re, grd ∈ Rp(T −1) le gradient du crit`re au point u.
e e e
Cependant, mˆme si cela n’apparaˆ pas de mani`re explicite dans sa d´claration, la pri-
e ıt e e
mitive eval crit`re d´pend aussi des fonctions ¡¡donn´es ¿¿ du probl`me, a savoir les fonctions
e e e e `
coˆts et dynamique. Nous verrons plus loin comment transmettre ces fonctions a eval crit`re.
u ` e
Toute ces op´rations sont regroup´es dans une seule macro SCILAB, nomm´e dynoptim,
e e e
dont la structure SCILAB est
[Jopt,uopt,xopt]=dynoptim(u0,ub,uh,x0)
o`,
u
– u0, ub et uh sont des vecteurs de Rp(T −1) , correspondant respectivement a la valeur
`
initiale de la commande u utilis´e par l’algorithme de minimisation, a la borne inf´rieure
e ` e
du domaine d’admissibilit´ pour la commande u, et a la borne sup´rieure de ce mˆme
e ` e e
domaine ;
– x0 est un vecteur de Rn correspondant a l’´tat initial du syst`me ;
` e e
– Jopt est la valeur minimale du crit`re ;
e
– uopt ∈ Rp(T −1) est la commande optimale (i.e. permettant de minimiser le crit`re) ;
e
– xopt ∈ RnT est l’´tat du syst`me correspondant a la commande optimale uopt ainsi
e e `
qu’` l’´tat initial x0.
a e
´
Etape 1 optim initialise le vecteur u ∈ Rp(t−1) courant
avec la valeur u0 fournie.
´
Etape 2 eval crit`re calcule la valeur du crit`re,
e e
ainsi que le gradient du crit`re au point courant u.
e
´
Etape 3 optim r´cup`re la valeur du crit`re ainsi que celle du gradient,
e e e
puis d´cide du pas a suivre au cœur de l’algorithme utilis´e.
e ` e
Soit l’algorithme n’a pas encore converg´, et on retourne a l’´tape 2,
e ` e
soit l’algorithme a converg´, et on passe a l’´tape 4.
e ` e
´
Etape 4 Une fois que l’algorithme d’optimisation
a converg´, optim renvoie la commande optimale uopt.
e
Tab. 2.1 – Fonctionnement de la fonction SCILAB optim
22
27. ´
Etape 1 La primitive eval crit`re r´cup`re les arguments u et
e e e
x0 que lui transmet SCILAB. doc int.c
´
Etape 2 eval crit`re calcule l’´tat x = x0 , . . . , xT ∈ RnT
e e
correspondant a l’´tat initial x0 et a la commande u,
` e `
(en utilisant la dynamique F ). dynoptim.c
´
Etape 3 eval crit`re calcule la valeur du crit`re J (u) = J(u, x) correspondant
e e
a l’´tat x et a la commande u pr´c´demment calcul´s.
` e ` e e e dynoptim.c
´
Etape 4 eval crit`re calcule l’´tat adjoint Λ = Λ0 , . . . , ΛT ∈ RnT
e e
correspondant a l’´tat x et a la commande u.
` e ` dynoptim.c
´
Etape 5 eval crit`re calcule le gradient du crit`re au point u en utilisant
e e
l’´tat x et l’´tat adjoint Λ.
e e dynoptim.c
´
Etape 6 eval crit`re renvoie la valeur du crit`re J (u),
e e
ainsi que celle du gradient au point u, J (u). doc int.c
Tab. 2.2 – Fonctionnement de la primitive eval crit`re permettant de calculer la valeur du
e
crit`re J , ainsi que celle de son gradient J .
e
23
28. 2.3 La cr´ation d’une interface permettant l’utilisation
e
de macros SCILAB par l’algorithme de calcul de
l’´tat adjoint
e
Le choix entre le codage en dur des fonctions crit`res et dynamique, et l’inter-
e
facage avec SCILAB
Nous avons vu que pour des raisons de temps d’ex´cution, l’algorithme de calcul du
e
gradient du crit`re J a ´t´ programm´ en langage C, au sein de la primitive eval crit`re.
e ee e e
Cette primitive sert a calculer la valeur du crit`re, ainsi que son gradient en un point
` e
donn´, son fonctionnement ´tant rappel´ dans le tableau (2.2).
e e e
Pour mener ces calculs, la primitive eval crit`re doit connaˆ les fonctions n´cessaires
e ıtre e
a la d´finition du probl`me de Bolza, a savoir
` e e `
– la fonction dynamique F ∈ F (Rp × Rn × N, Rn ) ainsi que ses d´riv´es par rapport a
e e `
la commande u, et a l’´tat x ;
` e
– l ∈ F (Rp × Rn × N, Rn ), la fonction coˆt sous le signe somme (2.2), ainsi que ses
u
d´riv´es par rapport a la commande u, et a l’´tat x ;
e e ` ` e
– la fonction coˆt final Φ ∈ F (R × N, R ) ainsi que ses d´riv´es par rapport a la
u n n
e e `
commande u, et a l’´tat x.
` e
Pour pouvoir fournir ces fonctions a la primitive eval crit`re qui, rappelons-le est programm´e
` e e
avec le langage C, il y a deux solutions envisageables :
– le codage des fonctions ¡¡en dur¿¿ i.e. en langage C ;
– le codage des fonctions sous forme de macros SCILAB, qui seront ensuite transmises
a la fonction eval crit`re via une nouvelle interface entre SCILAB et C.
` e
La premi`re solution offre de gros avantages pour l’´criture des programmes car elle ne
e e
n´cessite pas d’interface ; c’est aussi cette absence d’interface entre SCILAB et le langage C
e
qui permet d’´normes gains de temps a l’ex´cution. En effet nous avons vu qu’au cours d’une
e ` e
optimisation toutes les fonctions d´finissant le probl`me de Bolza (le crit`re, la dynamique . . .)
e e e
pouvaient ˆtre appel´es des milliers de fois ; nous avons donc int´rˆt a limiter au maximum le
e e ee `
temps d’acc`s a ces fonctions ; le codage ¡¡en dur¿¿ est la meilleure r´ponse a cette exigence.
e ` e `
En revanche, la seconde solution, qui consiste a interfacer SCILAB et le code C, est
`
plus gourmande en temps. Cependant elle est beaucoup plus souple d’utilisation : en effet
lorsqu’il veut changer une donn´e du probl`me, l’utilisateur n’a pas a modifier le code C de
e e `
la fonction eval crit`re, il doit simplement red´finir une macro SCILAB, ce qui est quand
e e
mˆme beaucoup plus simple.
e
Les deux modes d’acc`s aux fonctions ont ´t´ impl´ment´s.
e ee e e
En ce qui concerne le premier mode d’acc`s, a savoir le codage en dur des fonctions, la
e `
structure interne des programmes utilis´s est celle qui est d´crite dans les tableaux (2.2) et
e e
(2.1), les fonctions ´tant d´finies comme de simples fonctions C, dans le fichier d´nomm´
e e e e
fonctions.c. Ainsi la fonction coˆt est d´finie de la mani`re suivante :
u e e
24
29. void L(double* cmd,double* etat,int* temps,double* res,
int* n_cmd,int* n_etat).
Comme nous pouvons le constater sur cet exemple la d´claration de la fonction crit`re l
e e
n’est pas une mince affaire car il faut non seulement d´clarer tous les param`tres et variables
e e
de la fonction, mais il faut aussi pr´ciser la dimension de tous ces ´l´ments ; c’est le rˆle des
e ee o
variables n_cmd, et n_para.
Une primitive permettant de fournir ` eval crit`re le nom des macros SCILAB
a e
` utiliser : setf
a
En revanche, pour permettre l’utilisation de macros SCILAB par la primitive eval crit`re,e
il a fallu modifier de mani`re cons´quente la structure des programmes. En effet les fonc-
e e
tions n´cessaires a la d´finition du probl`me de Bolza ne sont plus ´crites dans un fichier C
e ` e e e
comme auparavant, mais dans un fichier que seul SCILAB peut comprendre ; pour pouvoir
les appeler depuis des programmes ´crits en C, il faut utiliser la fonction interface scistring.
e
Cette fonction scistring permet d’utiliser des macros SCILAB charg´es en m´moire,
e e
depuis des primitives ´crites en C. Il suffit de lui fournir le nom de la macro que l’on veut
e
utiliser, ainsi que les arguments que SCILAB devra transmettre a cette macro, et on r´cup`re
` e e
les valeurs renvoy´es apr`s ex´cution de la macro.
e e e
Il se pose alors le probl`me de la transmission a la primitive eval crit`re des noms des
e ` e
fonctions qu’elle devra utiliser lors des calculs : en effet, pour une plus grande souplesse
d’utilisation, nous ne pouvons pas fixer d´finitivement les noms des fonctions a utiliser :
e `
la macro SCILAB repr´sentant le coˆt sous le signe somme (2.2) pourrait aussi bien se
e u
nommer l que j.
Il faut donc stipuler a la primitive eval crit`re le nom des macros SCILAB qu’elle est
` e
cens´e utiliser, et c’est a cela que sert la primitive setf.
e `
Elle s’utilise de la mani`re suivante
e
setf(nom_L,nom_L_cmd,nom_L_etat,nom_f,nom_f_cmd,
nom_f_etat,nom_phi,nom_phi_etat),
et sert a ´crire dans des variables connues de la primitive eval crit`re, les nom des fonctions
`e e
a utiliser.
`
Nous retrouvons donc huit arguments dans la d´claration de la primitive setf, a savoir les
e `
noms des huit fonctions n´cessaires a la d´finition du probl`me de Bolza :
e ` e e
– nom_L, nom_L_cmd, nom_L_etat sont respectivement les noms des macros SCILAB
∂l ∂l
repr´sentant l,
e et o` l d´signe le coˆt sous le signe somme (2.2) ;
u e u
∂u ∂x
– nom_phi, nom_phi_cmd, nom_phi_etat sont respectivement les noms des macros SCI-
∂Φ ∂Φ
LAB repr´sentant Φ,
e et o` Φ d´signe le coˆt final (2.3) ;
u e u
∂u ∂x
25
30. – et enfin, nom_f, nom_f_cmd, nom_f_etat sont respectivement les noms des macros
∂F ∂F
SCILAB repr´sentant F ,
e et o` F d´signe la dynamique (2.4).
u e
∂u ∂x
Pour une plus grande facilit´ d’utilisation, la macro SCILAB dynoptim regroupe toutes
e
les op´rations n´cessaires a la bonne marche de la proc´dure d’optimisation, et sa structure
e e ` e
SCILAB est maintenant :
[uopt,eopt]=dynoptim(nom_L,nom_L_cmd,nom_L_etat,nom_f,
nom_f_cmd,nom_f_etat,nom_phi,nom_phi_etat,ub,uh,u0,x0)
– les huit premiers param`tres ´tant d´finis ci-dessus ;
e e e
– u0, ub, et uh ´tant des vecteurs de Rp(T −1) , correspondant respectivement a la valeur
e `
initiale de la commande u utilis´e par l’algorithme de minimisation, a la borne inf´rieure
e ` e
du domaine d’admissibilit´ pour la commande u, et a la borne sup´rieure de ce mˆme
e ` e e
domaine ;
– x0 un vecteur de Rn correspondant a l’´tat initial du syst`me dynamique ;
` e e
– Jopt est la valeur minimale du crit`re ;
e
– uopt ∈ Rp(T −1) d´signant la commande optimale(i.e. permettant de minimiser le
e
crit`re) ;
e
– et xopt∈ RnT l’´tat correspondant a la commande uopt et a l’´tat initial x0 ;
e ` ` e
– eopt est l’´tat du syst`me dynamique a l’optimum.
e e `
Le fonctionnement de la macro dynoptim est r´sum´ dans le tableau suivant :
e e
´
Etape 1 L’utilisateur charge sous SCILAB les fonctions n´cessaires a la d´finition
e ` e
du probl`me de Bolza , au moyen de l’instruction getf.
e
´
Etape 2 setf fournit a la primitive eval crit`re
` e
les noms des macros SCILAB qu’elle devra utiliser.
´
Etape 3 Fonctionnement de l’algorithme d’optimisation d´crit dans le tableau 2.1.
e
´
Etape 4 Une fois que l’algorithme d’optimisation a converg´, la macro dynoptim
e
renvoie la valeur de la commande optimale uopt, le crit`re optimal Jopt,
e
et eopt l’´tat du syst`me, correspondant a la commande uopt et a l’´tat initial x0.
e e ` ` e
Tab. 2.3 – Fonctionnement de la macro SCILAB dynoptim en tenant compte de la primitive
d’interface setf.
26
31. D´finition des
e Ex´cution de la macro
e
fonctions et des dynoptim
variables du probl`me
e
deff(’y=f(u,x,t)’,’y=1/2*x^2’) [Uopt,Eopt]=dynoptim
deff(’y=f_cmd(u,x,t)’,’y=0’) (’L’,’L_cmd’,’L_etat’
deff(’y=f_etat(u,x,t)’,’y=x’) ’f’,’f_cmd’,’f_etat’,’phi’,
....
ub=zeros(1,12) ’phi_etat’,ub,uh,u0,e0)
uh=ones(1,12)
fonctions.sci SCILAB
On pr´cise ` eval crit`re
e a e On lance l’algorithme
les noms des macros
d’optimisation
SCILAB ` utiliser
a
setf(’L’,’L_cmd’,’L_etat’, [Uopt] =op tim(eval_critere
’f’,’f_cmd’,’f_etat’,’phi’,’phi_etat’) uob,uh,u0);
[Jopt,Eopt]=eval_critere(Uopt,x0)
dynoptim.sci dynoptim.sci
Les r´sultats
e
Uopt Eopt
Fig. 2.1 – Fonctionnement de la macro SCILAB dynoptim
27
32. Le code de la macro SCILAB dynoptim est pr´sent´ ci-dessous.
e e
################################ DYNOPTIM ###################################
//-----------------------------------------------------------------------------
// optimisation dynamique
// version sans contrainte
// avec primitives+
//-----------------------------------------------------------------------------
//nom_... sont les noms des fonctions utilisees par le probleme qui consiste
// a trouver min J(u) avec J(u)=somme( L(u[t],x[t],t))+phi(u[T],x[T],T)
// 0<u<1 t=0..T-1
// en tenant compte de la dynamique : x[t+1]=f(u[t],x[t],t)
//-----------------------------------------------------------------------------
function
[uopt,eopt]=dynoptim(nom_L,nom_L_cmd,nom_L_etat,nom_f,nom_f_cmd,
nom_f_etat,nom_phi,nom_phi_etat,xb,xh,x0,e0)
// on fixe les fonctions a utiliser
//ATTENTION l’odre est le suivant :
setf(nom_L,nom_L_cmd,nom_L_etat,nom_f,nom_f_cmd,
nom_f_etat,nom_phi,nom_phi_etat);
[fopt,uopt,gopt]=optim(dyn_ora,’b’,xb,xh,x0,’ar’,200,200);
[fopt,gopt,eopt]=eval_critere(uopt,e0);
//-----------------------------------------------------------------------------
// une fonction qui fait l’intermediaire entre J et optim
// raison de compatibilite d’ arguments et de retour
function [fo,go,ind]=dyn_ora(x,ind)
[fo,go,eo]=eval_critere(x,e0);
28
33. 2.4 Un petit exemple d’utilisation de la primitive dy-
noptim
Nous voulons ici r´soudre le probl`me suivant.
e e
On cherche
min J(u, x),
u0 , . . . , u11 ∈ R
x0 , . . . , x12 ∈ R2
1 11
avec J(u, x) = 2 t=0 x2 ,
en tenant compte de la dynamique
xt = ut−1 .
Il suffit alors de taper les instructions suivantes dans un fichier et de les ex´cuter sous
e
SCILAB.
//****************************************************
//* *
//* Un petit exemple *
//* *
//****************************************************
//-------------------------- L et ses gradients-------------------------------
deff(’y=L(u,x,t)’,’y=(0.5*x^2)’)
deff(’y=L_cmd(u,x,t)’,’y=0’)
deff(’y=L_etat(u,x,t)’,’y=x’)
// ------------------------f et ses gradients----------------------------------
deff(’y=f(u,x,t)’,’y=u’)
deff(’y=f_etat(u,x,t)’,’y=0’)
deff(’y=f_cmd(u,x,t)’,’y=1’)
29
34. // ------------------------phi et ses gradients--------------------------------
deff(’y=phi(x,t)’,’y=0’)
deff(’y=phi_etat(x,t)’,’y=0’)
// definition des parametres du probleme
e0=[1];
xb=zeros(1,12);
xh=zeros(1,12)+1;
x0=rand(1,12);
[Uopt,Eopt]=dynoptim("L","L_cmd","L_etat","f","f_cmd","f_etat","phi","phi_etat"
,xb,xh,x0,e0);
Apr`s ex´cution, SCILAB nous donne comme r´sultat :
e e e
-->Uopt
Uopt =
column 1 to 6
! 0. 3.331E-16 0. 0. 3.331E-16 3.331E-16 !
column 7 to 12
! 3.331E-16 3.331E-16 4.441E-16 0. 0. 0.6623569 !
-->Eopt
Eopt =
column 1 to 10
! 1. 0. 0. 0. 0. 0. 0. 0. 0. 4.441E-16 !
column 11 to 13
30
35. ! 0. 0. 0.6623569 !
Ce r´sultat est bien le r´sultat que nous pouvions esp´rer, car le probl`me revenait a
e e e e `
minimiser en u0 , . . . , u11 ∈ [0, 1] la fonction :
11
1
J(u) = x2 +
0 u2
t
2 t=0
et le minimum de cette fonction est bien atteint pour une commande u v´rifiant
e
∀t ∈ {0, . . . , 11} ut = 0
u12 ∈ [0, 1]
Ici la commande optimale donn´e par SCILAB v´rifie bien cette contrainte, et u12 est
e e
e
en fait ´gal a u012 qui est, rappelons le, le 12 de la commande initiale fournie a l’algorithme
e ` `
d’optimisation.
31
36. Chapitre 3
D´veloppement d’une primitive
e
SCILAB pour la r´solution du
e
probl`me de Bolza avec contraintes
e
d’´tat
e
3.1 Premier essai : une m´thode de p´nalisation ;
e e
probl`me d’instabilit´ de l’algorithme d’optimisa-
e e
tion
Cette premi`re partie du chapitre va nous familiariser avec les probl`mes d’optimisation
e e
de Bolza sous contrainte d’´tat.
e
Nous allons ´tudier le cas d’un probl`me de Bolza avec les mˆmes hypoth`ses de sim-
e e e e
plification qu’au paragraphe (2.1.1), mais avec une contrainte de borne sur l’´tat, i.e. un
e
probl`me de la forme :
e
Soit T > 0 ( ´ventuellement T = +∞), on minimise en x0 , . . . , xT ∈ Rn , et en u0 , . . . , uT −1 ∈
e
R , le crit`re
p
e
J(x, u) = J1 (x, u) + J2 (x, u) avec, (3.1)
T −1
le coˆt int´gral
u e J1 (x, u) = l(xt , ut , t), (3.2)
0
le coˆt final
u J2 (x, u) = Φ(xT , T ) , (3.3)
en tenant compte de la dynamique
x(t + 1) = F (xt , ut , t), t ∈ {0, . . . , T − 1}, (3.4)
32
37. ´ventuellement d’un domaine d’admissibilit´
e e
ut ∈ U pour tout t ∈ {0, . . . , T − 1}, (3.5)
et surtout de la contrainte de borne sur l’´tat
e
x ≤ x ≤ x. (3.6)
Le probl`me qui se pose a nous maintenant est de savoir comment traiter cette contrainte
e `
e ´
de borne sur l’´tat. Etant donn´ que, sans cette contrainte de borne sur l’´tat, nous savons
e e
parfaitement r´soudre le probl`me pos´, nous avons int´rˆt a nous ramener a un probl`me
e e e ee ` ` e
d’optimisation sans contrainte d’´tat.
e
Ainsi, pour traiter un probl`me d’optimisation dynamique, nous nous sommes ramen´
e e
a un probl`me d’optimisation statique, et maintenant pour traiter un probl`me d’optimisa-
` e e
tion avec contrainte, nous allons essayer de nous ramener a un probl`me d’optimisation sans
` e
contrainte.
3.1.1 Une id´e simple : la p´nalisation de la contrainte
e e
La p´nalisation de la contrainte est effectivement un moyen simple de ramener un probl`me
e e
d’optimisation sous contrainte a un probl`me d’optimisation sans contrainte.
` e
L’id´e est la suivante. Supposons que nous devons r´soudre le probl`me consistant a
e e e `
trouver
min J(u), (3.7)
u∈U
en tenant compte de la contrainte
u ≤ 0. (3.8)
Et bien nous allons r´soudre le probl`me qui consiste a trouver u permettant d’atteindre
e e `
min (J(u) + pu) , (3.9)
u∈U
o` p est un r´el choisi arbitrairement ¡¡grand¿¿.
u e
33
38. En effet si p est suffisamment ¡¡grand¿¿, la seule solution pour l’algorithme d’optimisation–
s’il veut minimiser correctement (J(u) + pu)– consiste a se placer dans les u n´gatifs.
` e
La contrainte sera automatiquement v´rifi´e : on aura bien u ≤ 0.
e e
Ainsi, nous avons trouv´ un moyen de se ramener a un probl`me d’optimisation sans
e ` e
contrainte, car la contrainte (3.8) a bien disparu dans le probl`me d’optimisation (3.9). Ce-
e
pendant, cette m´thode, bien qu’´tablie sous des hypoth`ses pr´cises (Culioli, 1994) , pr´sente
e e e e e
des probl`mes de mise en place, comme en t´moigne l’exemple suivant.
e e
Nous allons essayer de r´soudre par une m´thode de p´nalisation le probl`me suivant :
e e e e
min x2 − 2y 2 , (3.10)
x ∈ [−5, 5]
y ∈ [−5, 5]
sous la contrainte
x + y = 1. (3.11)
Ce probl`me est tr`s simple et le couple solution se calcule a la main : on trouve
e e `
xopt = 2
yopt = −1
Essayons maintenant de r´soudre ce probl`me avec SCILAB, en utilisant la fonction
e e
optim, et une p´nalisation de la contrainte : le crit`re a minimiser sera
e e `
j(x, y) = x2 − 2y 2 + p(1 − x − y)2 . (3.12)
On d´finit dans le code qui suit la fonction costf qui renvoie le crit`re (dans lequel nous
e e
avons d´j` inclu la p´nalit´ p de la contrainte), ainsi que son gradient, puis on demande a
ea e e `
SCILAB de minimiser ce crit`re en partant du point x0.
e
//------------------ definition du crit`re et de son gradient --------------
e
deff(’[f,g,ind]=costf(x,ind)’,’f=2*x(1)^2-x(2)^2+p*(1-x(1)-x(2))^2,g=zeros(1,2)
,g(1)=4*x(1)-2*p*(1-x(1)-x(2)),g(2)=-2*x(2)-2*p*(1-x(1)-x(2))’);
// le point initial
x0=10*rand(1,1);
//------------------- optimisation --------------------------------------------
34
39. [fopt,xopt]=optim(costf,x0)
Le probl`me de cette m´thode vient du fait qu’il faut parfaitement ajuster la valeur de
e e
la p´nalit´ p, les r´sultats obtenus sont regroup´s dans le tableau 3.1 :
e e e e
p=1 xopt = 1.0E+95 * ! - 10. 30. !
p = 10 xopt = ! - 1.25 2.5 !
p = 10 xopt = ! - 1.0204082 2.0408163 !
p = 1000 xopt = ! - 1.002004 2.004008 !
Tab. 3.1 – R´sultats d’un exemple de p´nalisation de la contrainte
e e
Il apparaˆ clairement que, pour que cette m´thode fonctionne, il faut que la p´nalit´ p ne
ıt e e e
soit pas trop petite. Cependant, nous n’avons pas non plus int´rˆt a prendre une p´nalit´ p
ee ` e e
trop grande, car, dans le cas de probl`mes compliqu´s, les gradients des fonctions en jeu ont
e e
des normes trop importantes, et donc les algorithmes d’optimisation ne fonctionnent plus
correctement.
Ainsi pour qu’une m´thode de p´nalisation de la contrainte soit efficace, il faut que la
e e
p´nalit´ soit ajust´e a la main en fonction du probl`me ´tudi´, ce qui peut ˆtre parfois tr`s
e e e ` e e e e e
ennuyeux : on ne peut pas cr´er, comme nous voulons le faire, un outil transposable a de
e `
nombreux probl`mes.
e
Il existe des m´thodes beaucoup plus souples, pouvant ˆtre transpos´es a des probl`mes
e e e ` e
diff´rents sans n´cessiter pour autant de phases de ¡¡r`glage¿¿ trop importantes. Ce sont des
e e e
m´thodes o` on introduit des crit`res plus complexes bas´s sur des multiplicateurs associ´s
e u e e e
aux contraintes : on parle alors de Lagrangien.
3.2 Les m´thode de Lagrangien
e
Les m´thodes de Lagrangien, ou m´thodes duales reposent sur la maximisation de la
e e
fonction duale H(p) dans R , o` H est d´finie de la fa¸on suivante :
m
u e c
On introduit le Lagrangien
L(u, p) = J (u) + p θ(u),
35
