Methodes Inverses Var M2 Math PDF

Introduction à l’assimilation de données variationnelle
Eric Blayo, Maëlle Nodet
version du 3 février 2010

Table des matières
1 Introduction 4
1.1 Définitions, exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Un exemple simple mais fondamental . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Méthode naturelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Formalisation statistique . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.3 Méthodes d’assimilation de données . . . . . . . . . . . . . . . . . . 6
1.3 Vocabulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1 Modèle et vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Observations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.3 Statistiques d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.4 Fonction coût . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Historique de l’assimilation de données . . . . . . . . . . . . . . . . . . . . 9
1.4.1 Interpolation des observations . . . . . . . . . . . . . . . . . . . . . 9
1.4.2 Analyse de Cressman . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.3 Nudging (ou relaxation newtonienne) . . . . . . . . . . . . . . . . . 9
1.4.4 Méthodes variationnelles . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Rappels d’optimisation 10
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2.1 Produit scalaire, norme, espace de Hilbert . . . . . . . . . . . . . . 11
2.2.2 Définitions utiles en optimisation . . . . . . . . . . . . . . . . . . . 12
2.2.3 Dérivée directionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2.4 Dérivée au sens de Fréchet . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Minimisation sans contrainte : résultat théoriques . . . . . . . . . . . . . . 15
2.3.1 Existence d’un minimum (dimensions finie et infinie) . . . . . . . . 15
2.3.2 Théorème d’existence en dimension finie . . . . . . . . . . . . . . . 16
2.3.3 Théorème d’existence en dimension infinie . . . . . . . . . . . . . . 16
2.3.4 Conditions d’optimalité . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4 Minimisation d’une fonctionnelle quadratique en dimension finie . . . . . . 17
2.4.1 Inverse de Moore-Penrose . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.2 Lien avec l’assimilation de données variationnelle . . . . . . . . . . 18
2.4.3 Lien avec la vision statistique : BLUE . . . . . . . . . . . . . . . . 19
2.4.4 En pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.5 Optimisation sous contrainte . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.5.1 Minimisation avec contraintes d’égalité . . . . . . . . . . . . . . . . 20
2.5.2 Exemple 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Eric Blayo, Maëlle Nodet 1

Assimilation de données variationnelle 3 février 2010
2.5.3 Exemple 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6 Algorithmes d’optimisation : méthodes de descente . . . . . . . . . . . . . 22
2.6.1 Principe général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6.2 Méthodes à pas optimal, à pas constant . . . . . . . . . . . . . . . . 23
2.6.3 Méthodes de relaxation . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.6.4 Méthodes de gradient . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.6.5 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6.6 Méthodes de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6.7 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3 Méthode adjointe 27
3.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2 Un exemple simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 Ecriture générale dans le cas du contrôle de la condition initiale . . . . . . 29
3.3.1 Dérivée directionnelle de J . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.2 Modèle linéaire tangent . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.3.3 Modèle adjoint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.4 Calcul du gradient . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4 Exemple : l’équation de Bürgers . . . . . . . . . . . . . . . . . . . . . . . . 32
3.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4 Mise en œuvre de la méthode adjointe en pratique 35

4.1 Adjoint continu et adjoint discret . . . . . . . . . . . . . . . . . . . . . . . 35
4.2 Ecrire un adjoint pour faire de l’assimilation de données . . . . . . . . . . 36
4.2.1 Remarque introductive . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.2 Méthode adjointe discrète . . . . . . . . . . . . . . . . . . . . . . . 37
4.2.3 Autres remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.2.4 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3 Validation du code adjoint : tests du gradient . . . . . . . . . . . . . . . . 39
4.3.1 Premier test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3.2 Test dans le cas quadratique . . . . . . . . . . . . . . . . . . . . . . 40
5 Algorithmes d’assimilation de données variationnelle 41

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.2 Le 3D-Var . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.2.1 Fonction coût et algorithme . . . . . . . . . . . . . . . . . . . . . . 42
5.2.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3 Le 4D-Var . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3.1 Fonction coût et gradient . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3.2 Algorithme et remarques . . . . . . . . . . . . . . . . . . . . . . . . 44
5.3.3 Variante : 3D-FGAT . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.4 Compléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.4.1 En présence de non linéarités : algorithmes incrémentaux . . . . . . 46
5.4.2 Effet d’une seule observation . . . . . . . . . . . . . . . . . . . . . . 47
5.4.3 Préconditionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
Eric Blayo, Maëlle Nodet (Université de Grenoble) 2

6 Compléments 50
6.1 Analyse de sensibilté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
6.1.1 Assimilation de données . . . . . . . . . . . . . . . . . . . . . . . . 51
6.1.2 Lien avec l’analyse de sensibilité . . . . . . . . . . . . . . . . . . . . 52
6.2 Méthodes réduites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.2.1 Idée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.2.2 Choix de l’espace réduit . . . . . . . . . . . . . . . . . . . . . . . . 53
6.2.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.3 Modélisation des covariances d’erreur . . . . . . . . . . . . . . . . . . . . . 54
6.3.1 Remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.3.2 Opérateur de diffusion . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.3.3 EOF et bases réduites . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.3.4 Méthodes d’ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . 56
6.3.5 Autres méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
A Régles d’écriture d’un code adjoint 58

A.1 Ecriture d’un code adjoint : principes . . . . . . . . . . . . . . . . . . . . . 58
A.1.1 Dérivation d’une fonction composée . . . . . . . . . . . . . . . . . . 58
A.1.2 Lien avec le calcul de l’adjoint . . . . . . . . . . . . . . . . . . . . . 59
A.2 Checkpointing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
A.3 Règle d’écriture des codes adjoints . . . . . . . . . . . . . . . . . . . . . . . 62
A.3.1 Affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
A.3.2 Expressions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . 64
A.3.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
A.3.4 Blocs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
A.3.5 Appel à des subroutines et à des fonctions . . . . . . . . . . . . . . 66
A.3.6 Entrées / sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
A.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

Chapitre 1
Introduction
Sommaire
1.1 Définitions, exemples . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Un exemple simple mais fondamental . . . . . . . . . . . . . . 5
1.2.1 Méthode naturelle . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Formalisation statistique . . . . . . . . . . . . . . . . . . . . . . 5
1.2.3 Méthodes d’assimilation de données . . . . . . . . . . . . . . . 6
1.3 Vocabulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1 Modèle et vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.2 Observations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.3 Statistiques d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.4 Fonction coût . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4 Historique de l’assimilation de données . . . . . . . . . . . . . 9
1.4.1 Interpolation des observations . . . . . . . . . . . . . . . . . . . 9
1.4.2 Analyse de Cressman . . . . . . . . . . . . . . . . . . . . . . . 9
1.4.3 Nudging (ou relaxation newtonienne) . . . . . . . . . . . . . . 9
1.4.4 Méthodes variationnelles . . . . . . . . . . . . . . . . . . . . . . 9
1.1 Définitions, exemples

L’assimilation de données est la “science des compromis fructueux” : c’est l’ensemble
des méthodes qui permettent de combiner de manière optimale (dans un sens à définir)
les informations disponibles sur un système :
– équations mathématiques (décrivant le modèle physique)
– observations (mesures physiques de la réalité)
– statistiques d’erreurs (erreurs d’observation, du modèle...)
Ces informations sont souvent hétérogènes en nature, en quantité et en qualité.
Exemple 1.1 – météorologie

– océanographie
– sismique, pétrole
– fusion nucléaire (tokamak)
– médecine

– bâtiment
– glaciologie
– agronomie
– etc.
Quelques caractéristiques :
– les systèmes considéres sont complexes ;
– les observations sont parfois indirectes, partielles (en espace et/ou en temps), en-
tachées d’erreurs ;
– le problème est souvent mal posé (par exemple : pas assez d’observations ou obser-
vations contradictoires)
1.2 Un exemple simple mais fondamental

On se donne deux observations y1 = 1 et y2 = 2 d’une quantité x inconnue. On veut
estimer x.
1.2.1 Méthode naturelle

On cherche x qui minimise (x − 1)2 + (x − 2)2 , et on trouve l’estimateur x̂ = 3/2. On
a résolu ici un problème de moindres carrés.
Problèmes :
– Le résultat est sensible au changement d’unité : si on se donne y1 = 1 une mesure
de x et y2 = 4 une mesure de 2x, on est ramener à minimiser (x − 1)2 + (2x − 4)2 ,
et on trouve cette fois x̂ = 9/5.
→ Il faut sans doute normaliser, mais comment ?
– Le résultat n’est pas sensible à la précision de la mesure, on trouve le même résultat
si y1 est plus précise que y2 .
1.2.2 Formalisation statistique

On note yi = x + ei pour i = 1, 2. Les erreurs d’observations ei sont supposées :
– sans biais (= non biaisées) : E(ei ) = 0
– de variances connues : Var(ei ) = σi2
– non corrélées : E(e1 , e2 ) = 0
On cherche une estimation linéaire, sans biais et de variance minimum (BLUE - Best
Linear Unbiased Estimator) :
x̂ = α1 y1 + α2 y2
Pour déterminer les αi on remarque d’abord que “sans biais” signifie que E(x̂ − x) = 0 :
E(x̂) = (α1 + α2 )x + α1 E(e1 ) + α2 E(e2 ) = (α1 + α2 )x

On obtient donc α1 + α2 = 1, ou encore α2 = 1 − α1 .

Ensuite on calcule la variance de x̂ :
Var(x̂) = E((x̂ − x)2 ) = E((α1 y1 + α2 y2 )2 )
= α12 E(e21 ) + 2α1 α2 E(e1 e2 ) + α22 E(e22 )
= α12 σ12 + α22 σ22
= α12 σ12 + (1 − α1 )2 σ22
L’estimation x̂ cherchée doit minimiser cette variance. Cette fonction de α1 est minimum
lorsque sa dérivée par rapport à α1 s’annule, ce qui donne :
σ22
α1 =
σ12 + σ22
Puis :
1 1
y
σ12 1
+ y
σ22 y1 + σ12 y2
σ22 2
x̂ = 1 1 =
+
σ12 σ22
σ12 + σ22
−1
1 1
Var(x̂) = +
σ12 σ22
On obtient ce résultat lorsque l’on minimise la fonction :
1 (x − y1 )2 (x − y2 )2

J(x) = +
2 σ12 σ22
Remarques :
– Cette vision statistique permet de rationaliser le choix de la norme de la fonction-
nelle.
– Ça résout le problème de la sensibilité aux unités et d’insensibilité à la précision des
observations.
– La concavité de J donne une mesure de la précision de l’estimation :
1 1 1
J 00 (x) = 2
+ 2 =
σ1 σ2 Var(x̂)
– Si on considère que y1 = xb est une première estimation de x et y2 = y une nouvelle

observation indépendante, alors
σb 2
x̂ = xb + (y − xb )
σ 2 + σb 2
La valeur y − xb est appelée “innovation”, elle contient l’information supplémentaire

apportée par y par rapport à xb .
1.2.3 Méthodes d’assimilation de données

On a deux familles de méthodes d’assimilation de données :
– méthodes statistiques : on calcule le BLUE directement par des calculs algébriques ;
– méthodes variationnelles : on minimise J.

Points communs de ces méthodes :

– elles mènent à la même solution dans le cas linéaire ;
– elles sont optimales uniquement dans le cas linéaire ;
– difficultés communes :
– prise en compte des non-linéarités
– grandes dimensions
– méconnaissance des statistiques d’erreurs
1.3 Vocabulaire
1.3.1 Modèle et vecteurs
Les notations usuelles (internationales) en assimilation de données sont les suivantes.
– x vecteur d’état
– xt vecteur de l’état vrai
– xb vecteur de l’ébauche (information a priori, issue d’un modèle, d’une prévision,
d’une climatologie, etc.)
– xa vecteur de l’état analysé (que l’on cherche)
Les exposants désignent donc la nature du vecteur, tandis que les indices désignent le
temps ou l’espace.
Le modèle M fait évoluer l’état xi du temps i au temps i + 1 :
xi+1 = Mi,i+1 (xi )
1.3.2 Observations
Le vecteur contenant les observations est noté y o . Il est souvent de taille inférieure
à celle du vecteur d’état : l’espace des observations et l’espace d’état sont en général
différents, et donc de dimensions différentes. Le passage de l’espace d’état (où vit le
vecteur x) à l’espace des observations (où vit y) se fait grâce à un opérateur d’observation
H :
Hx = y
Exemple 1.2 1. Le vecteur d’état x = (T1 , T2 , . . . , Tn )T représente la température sur

n points de grille ; on observe la température au milieu des points de grille 3 et 4,
ce qui donne
T3 + T4
Hx =
2
ou encore
1 1
H = (0, 0, , , 0, . . . , 0)
2 2
Dans ce cas, l’opérateur H est un opérateur d’interpolation (partielle) du vecteur
d’état.
2. Tomographie : l’opérateur d’observation est une intégrale.
3. L’opérateur H peut aussi être non linéaire : Hx = αT β .

1.3.3 Statistiques d’erreurs

On s’intéresse aux erreurs par rapport à l’état vrai :
ε = x − xt
Les statistiqus des erreurs qui nous intéressent (et sont relativement accessibles) sont leurs
moyennes ε̄ (en général supposées nulles), et leurs moments d’ordre 2, c’est a dire leurs
covariances :
Cov(ε) = E (ε − ε̄)(ε − ε̄)T

Les diverses erreurs qui nous intéressent sont :

– Ebauche :
εb = xb − xt
On note B la matrice des covariances d’erreurs d’ébauche.
– Observations :
εo = y o − H(xt )
On note R la matrice des covariances d’erreurs d’observation (erreurs des instru-
ments de mesure, de discrétisation, etc.).
– Analyse :
εb = xb − xt
On note A la matrice des covariances d’erreurs d’analyse. On cherchera à minimiser
une “mesure” de cette erreur, à savoir la trace de la matrice A.
– Modèle :
ηi = xti+1 − Mi,i+1 (xti )
On note Qi la matrice des covariances d’erreurs modèle. Notez que cette matrice
dépend du temps, ou encore qu’il y a autant de matrices Qi que d’instants de calcul.
1.3.4 Fonction coût

La fonction coût mesure l’écart aux observations :
1
J o = kHx − y o k2
2
Malheureusement, le problème est souvent sous déterminé, il faut donc rajouter des
contraines.
Exemple 1.3 Trouver (x1 , x2 ) avec l’observation x1 + x2 = 2. Il existe une infinité de

solution. Si on rajoute la contrainte “norme minimale”, alors on trouve une solution
unique x1 = x2 = 1.
On va faire l’équivalent en utilisant toutes les informations possibles :

b
x ← ébauche I
y= H=
z ← “nouvelles” observations Hz
Alors
1 1 1
2
kHx − yk2 = 2
kHz x− zk2 + 2
kx − xb k 2
J = Jo + Jb

Si le modèle et l’opérateur d’observation sont linéaires, alors J est quadratique et son

minimum est unique. Sinon, il peut exister des minima locaux, ce qui crée des difficultés
pour les algorithmes de minimisation, d’où l’importance de l’ébauche xb pour régulariser
et ne pas partir trop loin du minimum).
Attention : Lorsque la fonctionnelle est choisie (ébauche, normes), le problème est

entièrement défini, et sa solution aussi. Toute la partie “physique” est donc dans la
définition de la fonctionnelle. Le reste, ie trouver le minimum, n’est “que” de la tech-
nique.
1.4 Historique de l’assimilation de données

1.4.1 Interpolation des observations
Richardson en 1922 propose sa “forecast factory”, qui interpole les observations dis-
ponibles au temps 0, puis lance le modèle de prévision (= le modèle d’évolution). Les
résultats étaient mauvais : l’interpolation ne respectant pas les contraintes physiques, des
modes instables se développaient et faisaient exploser le modèle.
1.4.2 Analyse de Cressman

Dans les années 50. L’idée cette fois est de pondérer entre lébauche et les observations.
Ceci introduit la notion de région d’influence : une observation n’influe que dans un petit
domaine autour du point d’observation, dans les zones non observées c’est l’ébauche qui
domine.
1.4.3 Nudging (ou relaxation newtonienne)

Années 70. On contraint les équations du modèle avec les observations, en leur ajoutant
un terme de rappel aux observations :
dX dX
= M (X) → = M (X) − K(H(x) − y o )
dt dt
1.4.4 Méthodes variationnelles

3D-Var et interpolation optimale dans les années 80, 90.
4D-Var dans les années 2000.

Chapitre 2
Rappels d’optimisation
Sommaire
2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2.1 Produit scalaire, norme, espace de Hilbert . . . . . . . . . . . . 11
2.2.2 Définitions utiles en optimisation . . . . . . . . . . . . . . . . . 12
2.2.3 Dérivée directionnelle . . . . . . . . . . . . . . . . . . . . . . . 13
2.2.4 Dérivée au sens de Fréchet . . . . . . . . . . . . . . . . . . . . 14
2.3 Minimisation sans contrainte : résultat théoriques . . . . . . . 15
2.3.1 Existence d’un minimum (dimensions finie et infinie) . . . . . . 15
2.3.2 Théorème d’existence en dimension finie . . . . . . . . . . . . . 16
2.3.3 Théorème d’existence en dimension infinie . . . . . . . . . . . . 16
2.3.4 Conditions d’optimalité . . . . . . . . . . . . . . . . . . . . . . 16
2.4 Minimisation d’une fonctionnelle quadratique en dimension
finie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4.1 Inverse de Moore-Penrose . . . . . . . . . . . . . . . . . . . . . 17
2.4.2 Lien avec l’assimilation de données variationnelle . . . . . . . . 18
2.4.3 Lien avec la vision statistique : BLUE . . . . . . . . . . . . . . 19
2.4.4 En pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.5 Optimisation sous contrainte . . . . . . . . . . . . . . . . . . . 20
2.5.1 Minimisation avec contraintes d’égalité . . . . . . . . . . . . . . 20
2.5.2 Exemple 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5.3 Exemple 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.6 Algorithmes d’optimisation : méthodes de descente . . . . . . 22
2.6.1 Principe général . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.6.2 Méthodes à pas optimal, à pas constant . . . . . . . . . . . . . 23
2.6.3 Méthodes de relaxation . . . . . . . . . . . . . . . . . . . . . . 23
2.6.4 Méthodes de gradient . . . . . . . . . . . . . . . . . . . . . . . 23
2.6.5 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.6.6 Méthodes de Newton . . . . . . . . . . . . . . . . . . . . . . . . 25
2.6.6.1 Idée de base . . . . . . . . . . . . . . . . . . . . . . . 25
2.6.6.2 Application à l’optimisation . . . . . . . . . . . . . . 26
2.6.7 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

2.1 Introduction
Soit V un espace vectoriel, et U une partie non vide de V . Soit J : V → R. On cherche
à résoudre el problème :
Problème 2.1 Trouver u ∈ U tel que
J(u) = min J(v)

v∈U
Vocabulaire :
– J est appelé “critère”, “fonctionnelle”, “fonction coût”, etc.
– U est l’espace des solutions admissibles, ou “èspace de contrôle”
– Si U = V le problème est sans contrainte, si U 6= V , le problème est avec contraintes.
Le problème, en assimilation de données, vient généralement du fait que J ne dépend

de v que de façon assez indirecte, via par exemple un modèle et un opérateur d’observation
plus ou moins complexes. D’où des difficultés d’optimisation.
2.2 Définitions
2.2.1 Produit scalaire, norme, espace de Hilbert
Définition 2.2 Soit E un espace vectoriel. Une application b : E ×E → R est un produit
scalaire si c’est une forme bilinéaire définie positive.
Exemple 2.3 1. Dans Rn , on a le produit scalaire euclidien usuel :

n
X
(x, y) = xi y i = xT y
i=1
2. Toujours dans Rn , si A est une matrice symétrique définie positive :

n
X
(x, y)A = aij xi yj = xT Ay
i,j=1
3. Dans L2 (Ω), où Ω est un ouvert de R, on a pour f et g deux fonctions de L2 (Ω) :

Z
(f, g) = f (x)g(x) dx
Ω
Exercice 2.1 Montrer que les formes bilinéaires définies à l’exemple 2.3 sont bien des
produits scalaires.
Définition 2.4 La norme induite par un produit scalaire (., .) est donnée par :
kuk2 = (u, u)
Exemple 2.5 On reprend les précédents

1. Dans Rn , on a la norme euclidienne :

n
X
kxk2 = x2i = xT x
i=1
2. Toujours dans Rn , si A est une matrice symétrique définie positive :

n
X
kxk2A = aij xi xj = xT Ax
i,j=1
3. Dans L2 (Ω), où Ω est un ouvert de R, on a pour f ∈ L2 (Ω) :

Z
2
kf k = |f (x)|2 dx
Ω
Exercice 2.2 Montrer que les applications définies à l’exemple 2.5 sont bien des normes.
Remarque 2.6 Toute norme n’est pas forcément induite par un produit scalaire.
Définition 2.7 Un espace de Hilbert est un espace vectoriel muni d’un produit scalaire,
qui est complet pour la norme induite.
2.2.2 Définitions utiles en optimisation

Soit f : E → R, où E n’est pas nécesairement de dimension finie.
Définition 2.8 On dit que x̄ est un minimum global de f si
f (x̄) ≤ f (x), ∀x ∈ E
Définition 2.9 On dit que x̄ est un minimum local de f si il existe un voisinage V de x̄

tel que
f (x̄) ≤ f (x), ∀x ∈ V
Définition 2.10 L’ensemble F est convexe si
∀x1 , x2 ∈ F, ∀α ∈ [0, 1] : αx1 + (1 − α)x2 ∈ F
Définition 2.11 La fonction f est convexe si E est convexe et si
∀x1 , x2 ∈ F, ∀α ∈ [0, 1] : f (αx1 + (1 − α)x2 ) ≤ αf (x1 ) + (1 − α)f (x2 )
f est dite strictement convexe si
∀x1 , x2 ∈ F, ∀α ∈ [0, 1] : f (αx1 + (1 − α)x2 ) < αf (x1 ) + (1 − α)f (x2 )

2.2.3 Dérivée directionnelle

Définition 2.12 Soit f : E → R. On appelle dérivée de Gâteaux, ou dérivée direction-
nelle, de f au point x dans la direction d ∈ E la limite, si elle existe :
f (x + αd) − f (x)
lim
α→0 α
∂f
Cette dérivée directionnelle sera notée (x), ou encore fd0 (x), ou encore fˆ(x)[d].
∂d
Exemple 2.13 1. Les dérivées partielles dans Rn sont les dérivées directionnelles dans
la direction des vecteurs de la base canonique :
∂f f (x + αei ) − f (x)
= lim
∂xi α→0 α
2. Soit f (x, y) = 4x2 − 2y et d = (1, 2) :
∂f f (x + α, y + 2α) − f (x, y)
(x) = lim = lim 4(2x + α) − 4 = 8x − 4
∂d α→0 α α→0
On peut remarquer que

∂f 8x 1
(x) = 8x − 4 = . = ∇f.d
∂d −2 2
(on reviendra sur ce point plus loin)
3. Considérons maintenant la fonctionnelle
Z
J (K) = (u − uobs )2
obs
Ω
où u dépend indirectement des paramètres K.
ˆ J(K + αk) − J(K)

J(K)[k] = limα→0
α
uK+αk − uK
Z
= limα→0 (uK+αk + uK − 2uobs )
Z Ω α
= 2 (u − uobs )û
Ω
où
uK+αk − uK
û = lim
α→0 α
Remarque : en pratique, le calcul d’une dérivée directionnelle peut être fait par taux
d’accroissement. On calcule ainsi
f (x + αd) − f (x)
T (α) =
α
pour différentes valeurs de α de plus en plus petites. En général, on a convergence quand
α devient suffisamment petit, jusqu’à ce qu’il devienne trop petit et qu’on observe une
divergence numérique due à la précision machine.
On reviendra là-dessus pour le “test du gradient”, qui permet de tester le modèle adjoint.

2.2.4 Dérivée au sens de Fréchet

Définition 2.14 Soit E un espace de Hilbert. On dit que f est Fréchet différentiable en
x s’il existe p ∈ E tel que
f (x + h) = f (x) + (p, h) + o(h), quad∀h ∈ E
Rappel : o(h) signifie que limh→0 ko(h)k

khk
= 0.
On dit alors que p est la dérivée, la différentielle, ou encore le gradient de f en x, noté
f 0 (x) ou ∇f (x).
Remarque : si le gradient existe, alors la dérivée directionnelle dans la direction d est

donné par
fd0 (x) = f 0 (x).d
(c’est immédiat d’après la défintion).
La Fréchet-différentiabilité implique la Gâteaux différentiabilité. La réciproque est

fausse. Par exemple
x6
f (x, y) = si (x, y) 6= (0, 0), et f (0, 0) = 0
(y − x2 )2 + x8
Remarque : si on revient à l’exemple de

Z
J (K) = (u − uobs )2
obs
Ω
la dérivée directionnelle Z
ˆ
J(K)[k] =2 (u − uobs )û
Ω
obs
ne s’écrit pas sous la forme (∇J , k) : le gradient n’est pas trivial ! On utilisera la méthode
adjointe pour l’obtenir.
Exercice 2.3 Soit A une matrice de taille (n, m), y un vecteur de Rn et d un vecteur
de Rm . On note k.k la norme euclidienne de Rn . On définit la fonction f de Rm dans
R de la façon suivante : pour tout x dans Rm , f (x) = kAx − yk2 . Calculer la dérivée
directionnelle de f dans la direction d. Puis en déduire le gradient de f en x.
Exercice 2.4 Soit X et Y deux espaces de Hilbert, k.kX et k.kY leurs normes respectives
et h., .iX , h., .iY les produits scalaires associés. Soit x ∈ X, y ∈ Y et d ∈ X. Soit g
une application de X dans Y différentiable. Soit f la fonction de X dans R définie par
f (x) = kg(x) − yk2X . Calculer la dérivée directionnelle de f en x dans la direction d, puis
le gradient de f en x.

2.3 Minimisation sans contrainte : résultat théoriques

2.3.1 Existence d’un minimum (dimensions finie et infinie)
On va illustrer ce problème par deux exemples.
Exemple 2.15 Droite des moindres carrés.

On se donne (xi , yi ), i = 1 . . . n, on cherche à minimiser
n
X
J(a, b) = (yi − axi − b)2
i=1
Le minimum (â, b̂) vérifie

∂J ∂J
= 0, =0
∂a ∂b
On obtient donc existence d’une unique solution, donnée par :
 X
1

 n
xi yi − x̄ȳ
â =
 σx2
b̂ = ȳ − âx̄

Exemple 2.16 En dimension infinie.

Considérons
V = {v ∈ L2 (]0, 1[), v 0 ∈ L2 (]0, 1[)} = H01 (]0, 1[)
et Z 1
J(v) = (|v 0 | − 1)2 + v 2
O
Posons maintenant
k k k 1

 x−
 si ≤x≤ +
un (x) = n n n 2n
k + 1 k 1 k+1
−x si + ≤x≤


n n 2n n
On a alors
k k 1

 1
 si ≤x≤ +
u0n (x) = n n 2n
 −1 k 1 k+1
si + ≤x≤

n 2n n
On a alors
1
J(un ) = ⇒ min J(v) = 0
12n2 v∈V
Si u réalise le minimum de J, alors J(u) = 0. Donc u = 0 et u0 = 1, ce qui est impossible,

donc le minimum n’est pas atteint.
La différence majeure entre ces deux exemples est le fait qu’on minimise en dimension
finie dans le premier exemple, et en dimension infinie dans le deuxième.

2.3.2 Théorème d’existence en dimension finie

Soit f : E → R, avec E ⊂ Rn fermé non vide, et f continue.
Théorème 2.17 Supposons que
lim f (x) = +∞
kxk→+∞
alors il existe au moins un minimum de f sur E.
Théorème 2.18 Si E est un convexe de Rn et si f est strictement convexe sur E, alors

il existe au plus un minimum de f sur E.
Théorème 2.19 Supposons que E est un convexe de Rn et que f est strictement convexe
sur E, et telle que
lim f (x) = +∞
kxk→+∞
alors il existe un minimum unique de f sur E.
2.3.3 Théorème d’existence en dimension infinie

Théorème 2.20 Soit f : E → R, avec E partie fermée convexe et non vide d’un espace
de Hilbert. Supposons que f est continue, convexe et telle que
lim f (x) = +∞
kxk→+∞
Alors il existe au moins un minimum de f sur E.
2.3.4 Conditions d’optimalité

Théorème 2.21 Soit f : E → R, où E est une partie d’un espace de Hilbert. Si x̂ est
un point intérieur de E, et s’il existe un ouvert Ω tel que x̂ ∈ Ω ⊂ E, si de plus f est
dérivable en x̂, alors :
x̂ est un minimum local de f ⇒ ∇f (x̂) = 0
C’est donc une condition nécessaire d’optimalité. Cette équation est aussi appelée équation
d’Euler.
Théorème 2.22 Soit f : E → R, où E est une partie convexe d’un espace de Hilbert. Si
x̂ est un point intérieur de E, et s’il existe un ouvert Ω tel que x̂ ∈ Ω ⊂ E, si de plus f
est convexe sur E et dérivable en x̂, alors :
x̂ est un minimum local de f ⇔ ∇f (x̂) = 0
Remarque : si on relâche la condition “x̂ point intérieur”, l’équation d’Euler se trans-

forme en inéquation d’Euler :
(∇f (x̂), x − x̂) ≥ 0, ∀x ∈ Ω (ou x ∈ E)

2.4 Minimisation d’une fonctionnelle quadratique en

dimension finie
2.4.1 Inverse de Moore-Penrose
Définition 2.23 Soit M une matrice de taille m × n. On appelle invers généralisé ou
pseudo-inverse de M une matrice, notée M + n vérifiant les propriétés suivantes :
M M + M = M, M +M M + = M +, (M M + )T = M M + , (M + M )T = M + M (2.1)
Cette matrice a été introduite par Moore (1920) et par Penrose (1955) de façon
indépendante, et on la désigne aussi sous le nom d’inverse de Moore-Penrose. On montre
à partir des relations (2.1) que l’inverse généralisé est unique et égale à M −1 si M est
inversible.
Théorème 2.24 Soit M une matrice de taille m × n. Si M est de rang n, alors
M + = (M T M )−1 M T
Démonstration. On vérifie les relations (2.1) avec M + = (M T M )−1 M T (qui est bien
définie car M T M est inversible pour M de rang n) :
M M + M = M (M T M )−1 M T M = M I = M
M + M M + = (M T M )−1 M T M (M T M )−1 M T = I(M T M )−1 M T = M +

(M M + )T = (M (M T M )−1 M T )T = M (M T M )−T M T = M (M T M )−1 M T = M M +
(M + M )T = ((M T M )−1 M T M )T = I = (M T M )−1 M T M = M + M
2
Théorème 2.25 On considère la fonctionnelle J suivante :
J(x) = kM x − bk2
pour x ∈ Rn , où M est une matrice de taille (m, n), de rang n et b ∈ Rn . La solution du
problème 2.1 est
x̂ = M + b
Démonstration. On a
kM x − bk2 = (M x − b)T (M x − b)
= x T M T M x − bT M x − x T M T b + bT b
= xT M T M x − 2bT M x + bT b
On a utilisé en particulier le fait que bT M x est un scalaire, il est donc égal à son transposé.
On calcule maintenant la dérivée directionnelle :
J(x + αδx) − J(x) = (x + αδx)T M T M (x + αδx) − 2bT M (x + αδx) + bT b
−xT M T M x + 2bT M x − bT b
= α(δxT M T M x + xT M T M δx − 2bT M δx) + α2 . . .
= α(2xT M T M δx − 2bT M δx) + α2 . . .

en utilisant de la même façon δxT M T M x = xT M T M δx. D’où
J(x + αδx) − J(x)

lim = 2(xT M T M − bT M )δx = 2(M T M x − M T b, δx)
α→0 α
D’où
∇J(x) = 2(M T M x − M T b)
Et finalement
∇J(x) = 0 ⇔ x = (M T M )−1 M T b = M + b
2
2.4.2 Lien avec l’assimilation de données variationnelle

Théorème 2.26 Posons
J1 (x) = kM x − bk2N = (M x − b)T N (M x − b)
pour x ∈ Rn , où M est une matrice de taille (m, n), de rang n et b ∈ Rn , et N est une
matrice symétrique définie positive. Le minimum de J est atteint pour
x̂ = (M T N M )−1 M T N b
Démonstration. On peut remarquer que
J1 (x) = (M x − b)T N (M x − b)
= (M x − b)T N 1/2 N 1/2 (M x − b)
= (N 1/2 M x − b)T (N 1/2 (M x − b))
On est donc ramené au cas précédent, en remplaçant M par N 1/2 M et b par N 1/2 b. On
obtient donc
x̂ = ((N 1/2 M )T N 1/2 M )−1 (N 1/2 M )T N 1/2 b
= (M T N M )−1 M T N b
2
On vient de résoudre le problème d’assimilation de données suivant :
Problème 2.27 Soit H un opérateur d’observation liéaire, de rang n. On veut trouver x̂

tel que
J o (x̂) = min J o (x) = min kHx − yk2
x x
Remarque : l’hypothèse “H de rang n” implique en particulier que n ≤ m : on a donc

plus d’observations (y) que de quantités à estimer (x).
Avec les notations précédentes :

1
J o (x) = (Hx − y)T R−1 (Hx − y), x̂ = (H T R−1 H)−1 H T R−1 y
2

De la même façon on peut considérer

1 1
J(x) = J b (x) + J o (x) = (x − xb )T B −1 (x − xb ) + (Hx − y)T R−1 (Hx − y)
2 2
Pour cela il suffit de poser
B −1 0

I xb
M= , Y = , N=
H y 0 R−1
On obtient
M T N M = B −1 + H T R−1 H

M T N Y = B −1 xb + H t R−1 y
D’où
x̂ = (B −1 + H T R−1 H)−1 (B −1 xb + H t R−1 y)
= (B −1 + H T R−1 H)−1 ((B −1 + H T R−1 H)xb − H T R−1 Hxb + H t R−1 y)
= xb + (B −1 + H T R−1 H)−1 H T R−1 (y − Hxb )
La matrice (B −1 + H T R−1 H)−1 H T R−1 est appelée matrice de gain, le vecteur y − Hxb
est appelé innovation.
Remarque : la matrice de gain peut aussi s’écrire sous la forme

BH T (R + HBH T )−1
(formule de Sherman-Morrison-Woddburg)
2.4.3 Lien avec la vision statistique : BLUE

Cette formule peut aussi être établie à partir de la vision statistique du problème. On
cherche à estimer x ∈ Rn , on se donne des observations y ∈ Rm , telles que
y = Hx + e
où e est le vecteur d’erreurs, supposées sans biais (ie E(e) = 0), de matrice de covariances
connue R = E(eeT ). On cherche le BLUE (Best Linear Unbiased Estimator), estimateur
linéaire sans biais de variance minimum, ie on cherche x̂ tel que
– linéaire : x̂ = Ay
– sans biais : E(x̂ − x) = 0. Or x̂ − x = (AH − I)x + Ae, donc AH = I (possible si
Ker H = {0}, ce qui implique m ≥ n).
– de variance minimale : il faut minimiser
Tr(E((x̂ − x)(x̂ − x)T )) = Tr(AE(eeT )AT ) = Tr(ARAT )
sous la contrainte AH = I.
On obtient bien la même formule pour x̂ (cf cours sur le BLUE pour les détails).
Ceci donne donc une interprétation pour le choix des normes de J o et J b :

– quel que soit le choix des normes, le problème a du sens et un optimum ;
– cependant si on choisit les normes définies au moyen de R−1 et B −1 , l’optimum a
également des propriétés d’optimalité statistique.

Remarque : on voit aussi qu’un tel choix donne naturellement une normalisation de
J o et J b , et qu’il résout donc le problème de sensibilité au changement d’unité.
2.4.4 En pratique
Etant données les grandes tailles m et n, il est souvent impossible de former explicite-
ment les matrices B, H, R... Donc le calcul de la matrice de gain est imposible. Le calcul
de x̂ se fait alors par un algorithme d’optimisation, ou bien directement après réduction
d’ordre (cf cours sur la réduction d’ordre).
2.5 Optimisation sous contrainte

2.5.1 Minimisation avec contraintes d’égalité
Soit f : Rn → R différentiable. Soit K l’ensemble des contraintes :
K = {x ∈ Rn , h1 (x) = 0, h2 (x) = 0, . . . , hp (x) = 0}
où les fonctions hi : Rn → R sont au moins de classe C 1 . On cherche alors x̂ ∈ K tel que
f (x̂) = min f (x)

x∈K
Théorème 2.28 Si x̂ ∈ K est un minimum local de f sur K, si les vecteurs ∇h1 (x̂),
∇h2 (x̂), . . ., ∇hp (x̂) sont linéairement indépendants, alors il existe λ̂ = (λ̂1 , λ̂2 , . . . , λ̂p ) ∈
Rp tel que
p
X
∇f (x̂) + λ̂i ∇hi (x̂) = 0
i=1
On introduit le lagrangien L :
p
X
L(x, λ) = f (x) + λi hi (x)
i=1
Résoudre ∇f (x) = 0 dans K revient à résoudre ∇L = 0, donc à chercher un point selle

de L.
En effet, ∇L = 0 signifie
P
∇x L = ∇f + i λi ∇hi = 0
∇λ L = (h1 , h2 , . . . , hp )T = 0
La deuxième ligne ∇λ L = 0 donne les contraintes, et donc x ∈ K, la première donne la

condition du théorème.

2.5.2 Exemple 1
Supposons inconnues x et y, avec une observation x + y = 2, et cherchons la solution
de norme minimale. Le problème peut se voir comme celui de minimiser
f (x, y) = x2 + y 2 , sous la contrainte x + y = 2
Ecrivons le lagrangien :
L(x, y, λ) = x2 + y 2 + λ(x + y − 2)
La condition de point selle donne :

∂L


 = 0 = 2x + λ


 ∂x
 ∂L
= 0 = 2y + λ

 ∂y
 ∂L = 0 = x + y − 2



∂λ
Et on obtient
λ = −2, x = 1, y=1
2.5.3 Exemple 2
Remarque 2.29 Pour traiter cet exemple, il est recommandé d’attendre d’avoir traité le
chapitre “méthode adjointe” et plus précisément l’exemple de l’adjoint de l’équation de
Bürgers.
On considère l’équation de Bürgers en dimension 1 :


 ∂t u + 12 ∂x (u2 ) − ν∂xx u = f, x ∈]0, L[, t ∈ [0, T ]
u(x, 0) = u0 (x), x ∈]0, L[
u(0, t) = u(L, t) = 0, t ∈ [0, T ]

On souhaite contrôler la condition initiale u0 en minimisant la fonction coût :

1 T L
Z Z
J(u0 ) = (u − uobs )2 dx dt
2 0 0
sous la contrainte de valeur moyenne nulle :
Z L
u0 (x) dx = 0
0
Pour cela on écrit le lagrangien :
1 T L
Z Z Z L
2
L(u0 , µ) = (u − uobs ) dx dt + µ u0 (x) dx
2 0 0 0
Regardons maintenant les conditions de point selle :
∇u0 L = 0, ∇µ L = 0

Dérivons d’abord par rapport à µ :

L(u0 , µ + αδµ) − L(u0 , µ) RL
= δµ 0 u0 (x) dx
α
ce qui donne pour la deuxième condition de point selle :
Z L
∇µ L = u0 (x) dx = 0
0
(on retrouve bien la contrainte) Dérivons maintenant par rapport à u0 :

Z TZ L Z L
L(u0 + αδu0 , µ) − L(u0 , µ)
lim = û(u − uobs ) dx dt + µ δu0 dx
α→0 α 0 0 0
où û vérifie l’équation suivante :


 ∂t û + ∂x (uû) − ν∂xx û = 0, x ∈]0, L[, t ∈ [0, T ]
û(x, 0) = δu0 , x ∈]0, L[
û(0, t) = û(L, t) = 0, t ∈ [0, T ]

En intégrant par parties on trouve l’équation du modèle adjoint :

RT RT RL
0
∂t û + ∂x (uû) − ν∂xx û; p = 0 0 (∂t û + ∂x (uû) − ν∂xx û)p
RT RL RL
= 0 0 −∂t pû + 0 û(T, x)p(T, x) − δu0 p(0, x)
RT RL RT RL
+ 0 0 −uû∂x p − ν 0 0 û∂xx p
RT
+ 0 ∂x u(L, t)p(L, t) − ∂x u(0, t)p(0, t)
ce qui nous amène à poser comme équation du modèle adjoint :

 ∂t p + u∂x p + ν∂xx p = u − uobs , x ∈]0, L[, t ∈ [0, T ]
p(x, T ) = 0, x ∈]0, L[
p(0, t) = p(L, t) = 0, t ∈ [0, T ]

Grâce à cet adjoint, on peut réécrire le gradient du Lagrangien par rapport à u0 :

L(u0 + αδu0 , µ) − L(u0 , µ) RT RL RL
limα→0 = 0 0 û(u − uobs ) dx dt + µ 0 δu0 dx
α RT RL RL
= 0 0 û(∂t p + u∂x p + ν∂xx p) dx dt + µ 0 δu0 dx
RL RL
= − 0 δu0 (x)p(x,
0) dx + µ 0 δu0 dx
= ∇Lu0 ; δu0
D’où
∇Lu0 = −p(., 0) + µ
2.6 Algorithmes d’optimisation : méthodes de des-

cente
2.6.1 Principe général
On considère le problème suivant :

Problème 2.30 Trouver le minimum x̂ :
J(x̂) = minn J(x)

x∈R
On appelle méthode de descente tout algorithme du type
xk+1 = xk + αk dk , tel que J(xk+1 ) < J(xk )
où
– dk ∈ Rn est la direction de descente à l’itération k,
– αk ∈ R est le pas de descente à l’itération k.
Les méthodes de descente diffèrent dans le choix des αk et des dk .
2.6.2 Méthodes à pas optimal, à pas constant

On suppose que dk est choisi. Les méthodes à pas optimal choisissent αk tel que
J(xk + αk dk ) = min J(xk + αdk )

α∈R
Autrement dit on minimise J dans la direction dk .
Difficultés : ça peut être coùteux, et cela n’est pas forcément intéressant, dans la
mesure ou ce minimum n’est pas celui de J mais juste une valeur intermédaire.
Il existe également les méthodes à pas constant :
αk = α, ∀k
2.6.3 Méthodes de relaxation

L’idée est de choisir pour les dk successivement les vecteurs de la base canonique :
xk+1 = xk + αk ek
On modifie donc xi simplement composante par composante.
Difficultés : la méthode a l’avantage d’être simple, mais elle peut être lente à converger.
2.6.4 Méthodes de gradient

Par définition du gradient, on a
J(xk + h) = J(xk ) + (∇J(xk ), h) + o(h)
Donc, si ∇J(xk ) 6= 0, la partie principale de l’accroissement de J est (∇J(xk ), h), qui sera
la plus négative possible lorsque h = −α∇J(xk ), ce qui revient à poser
dk = −∇J(xk )

Dans le cas particulier où J(x) = 12 (Ax, x) − (b, x), avec A symétrique définie positive,
on peut utiliser l’algorithme du gradient conjugué :

k∇J(xk )k2
 dk = ∇J(xk ) + dk−1


k∇J(xk−1 )k2
(∇J(xk ), dk )
 αk = − (et ∇J(xk ) = Axk − b)


(Adk , dk )
Remarques :
– c’est une méthode à pas optimal ;
– elle converge en au plus n itérations ;
– son coùt est en O(n3 ) : ce n’est pas intéressant pour une matrice pleine, car chercher
le minimum de J revient à résoudre Ax = b et dans ce cas la méthode de Choleski
est plus intéressante. Cependant si la matrice est creurs, cet algorithme ne nécessite
pas le stockage de A, seulement les produits matrice-vecteurs Adk et Axk .
2.6.5 Exemples
1 7
J(x, y) = x2 − xy + 2y 2 = (x − y)2 + y 2
2 4
Le minimum de J est atteint pour (x, y) = (0, 0). Posons x1 = (1, 1) et comparons les
méthodes de relaxation et de gradient.
Relaxation :
x2 = x1 + αe1 = (1 + α, 1)
donc
1 7
J(x2 ) = (1 + α)2 − (1 + α) + 2 = (α + )2 +
2 4
1 1
ceci est minimum pour α = − 2 , et on obtient x2 = ( 2 , 1).
1
x3 = x2 + αe2 = ( , 1 + α)
2
1 1 7 7
J(x3 ) = − (1 + α) + 2(1 + α)2 = 2(α + )2 +
4 2 8 32
ce qui donne α = − 78 et x3 = ( 12 , 81 ). En poursuivant ainsi, on obtient x4 = ( 16
7 1
, 8 ), et les
valeurs successivement prises par J(xi ) au cours de la descente sont
J(x1 = 2, J(x2 ) = 1.75, J(x3 ) ' 0.21875, J(x4 ) ' 0.21484
Gradient :
2x − y
∇J(x, y) =
−x + 4y
Pour x1 = (1, 1), on obtient ∇J(x1 ) = (1, 3)T . On cherche ensuite
x2 = x1 + α∇J(x1 ) = (1 + α, 1 + 3α)

ce qui donne pour J(x2 ) :
J(x2 ) = (1 + α)2 − (1 + α)(1 + 3α) + 2(1 + 3α)2

= 16α2 + 10α + 2
= (4α + 54 )2 + 16
7
5
= 0 ⇒ α = − 16
Donc finalement, x2 = ( 11 , 1 ) et ∇J(x2 ) = ( 16

16 16
21 7
, − 16 ). On cherche ensuite x3 :
11 + 21α 1 − 7α
x3 = x2 + α∇J(x2 ) = ( , )
16 16
Puis
J(x3 ) = ( 11+21α
16
)2 − 11+21α
16
. 1−7α
16
+ 2( 1−7α
16
)2
1
= 256 (686α2 + 489α + 112)
686 489 2 68207
= 256 ((α + 1372 ) + 4∗686 2)
489
= 0 ⇒ α = − 1372
Et on a ainsi
J(x1 = 2, J(x2 ) ' 1.75, J(x3 ) ' 0.097
On constate que la méthode de gradient converge nettement plus vite que la relaxation...
2.6.6 Méthodes de Newton

2.6.6.1 Idée de base
En dimension 1 : on cherche à résoudre f (x) = 0. On suppose connu xk , on définit
xk+1 comme le point d’intersection de l’axe des abscisses avec la tangente à la courbe de
f en xk :
f (xk ) − 0 f (xk )
= f 0 (xk ) ⇒ xk+1 = xk − 0
xk − xk+1 f (xk )
x2 xk
Par exemple, pour f (x) = x2 , f 0 (x) = 2x et xk+1 = xk − 2xkk = 2
. Pour x0 = 1 on obtient
x1 = 1/2, x2 = 1/4, etc.
En dimension n :

 f1 (x1 , x2 , . . . , xn ) = 0
... = 0 (⇔ f (x) = 0)
fn (x1 , x2 , . . . , xn ) = 0

La généralisation de la méthode précédente est

−1
x(k+1) = x(k) − f 0 (x(k) ) f (x(k) )

où f 0 (x(k) ) est la matrice jacobienne ∂j fi (x(k) ) . A chaque

0 itération,
(k)il faut donc calcul
cette matrice jacobienne, et résoudre un système linéaire f (x ) δx = −f (x(k) ).
(k)

2.6.6.2 Application à l’optimisation

On applique la méthode de Newton à l’équation d’Euler ∇J(x) = 0, ce qui donne :
−1
xk+1 = xk − ∇2 J(xk )

∇J(xk )
où ∇2 J(xk ) est la Hessienne de J.

La différence majeure avec les problèmes de gradient est donc que la direction de descente
−1
n’est plus ∇J(xk ), mais [∇2 J(xk )] ∇J(xk ).
Inconvénient et remèdes : il faut calculer la hessienne ∇2 J(xk ) à chaque itération,

et résoudre un système linéaire de matrice ∇2 J(xk ). Pour des gros problèmes, c’est hors
de portée. Il existe donc des algorithmes comme ceux de Quasi-Newton qui fournissent des
approximations de la hessienne, qui s’améliorent au fil des itérations, à un coùt raisonnable
(par exemple M1QN3).
2.6.7 Exercice
Exercice 2.5 Soit J la fonctionnelle suivante, définie en dimension 2 par la formule :
J(x, y) = 3x2 + 3y 2 − 2xy
1. Vérifier que (0, 0) est l’unique minimum de f .

2. Mettre en œuvre à la main les premières étapes des méthodes de relaxation, gradient
et Newton, avec par exemple x0 = (1, 1), et comparer la vitesse de convergence.

Chapitre 3
Méthode adjointe
Sommaire
3.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.2 Un exemple simple . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.3 Ecriture générale dans le cas du contrôle de la condition
initiale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.3.1 Dérivée directionnelle de J . . . . . . . . . . . . . . . . . . . . 29
3.3.2 Modèle linéaire tangent . . . . . . . . . . . . . . . . . . . . . . 30
3.3.3 Modèle adjoint . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3.4 Calcul du gradient . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.4 Exemple : l’équation de Bürgers . . . . . . . . . . . . . . . . . 32
3.5 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.1 Motivation
Les méthodes d’optimisation précédentes requièrent le calcul de ∇J. Si la dépendance
de J vis à vis de la variable de contrôle est complexe et/ou indirecte, ce calcul peut être
difficile, comme on l’a vu au chapitre précédent avec
Z T
o
J (x0 ) = kH(x(t)) − y o (t)k2 dt
0
Numériquement, on peut toujours s’en sortir par un calcul de taux d’accroissement. Mais
pour avoir le gradient, il faut faire le calcul pour chaque direction de perturbation pos-
sible. Si x0 est la condition initiale du modèle, le gradient ∇x0 J o va demander plusieurs
simulations du modèle pour chaque composante du gradient, ce qui donne un nombre de
simulations supérieure à la taille de l’état initial, et ce à chaque itération de l’algorithme
de descente). En pratique c’est le plus souvent hors de portée. En météorologie ou en
océanographie, l’état initial vit dans un espace de dimension 106 à 107 .
Attention : cependant, si on contrôle un nombre très restreint de paramètres, c’est

alors faisable, et ç a évite de mettre en œuvre des méthodes plus lourdes comme l’adjoint.

Remarque : on verra également que le modèle adjoint peut servir à beaucoup d’autres
choses...
3.2 Un exemple simple

On considère l’équation différentielle ordinaire suivante :
−bu00 (x) + cu0 (x) = f (x), x ∈]0, 1[

u(0) = 0, u(1) = 0
avec f une fonction donnée de L2 (]0, 1[), b et c des paramètres inconnus, que l’on cherche
à identifier grâce à une mesure de u(x) sur ]0, 1[. La fonction coût s’écrit
Z 1
2
J(b, c) = u(x) − uobs (x) dx
0
Calculons son gradient :

R1 2 2
J(b + αδb, c + αδc) − J(b, c) = 0 ub+αδb,c+αδc − uobs − ub,c − uobs
R1
= 0 ub+αδb,c+αδc + ub,c − 2uobs (ub+αδb,c+αδc − ub,c )
En notant u
e = ub+αδb,c+αδc , u = ub,c , on a :
Z 1
e + u − 2uobs (e

J(b + αδb, c + αδc) − J(b, c) = u u − u)
0
En divisant par α et en passant à la limite quand α tend vers 0, on obtient :

Z 1
ˆ e−u
u
u − uobs û,

J[b, c](δb, δc) = 2 avec û = lim
0 α→0 α
Cherchons maintenant l’équation vérifiée par û. On a
u00 + (c + αδc)e
u0 = f

−(b + αδb)e
u
e(0) = 0, u e(1) = 0
−bu00 + cu0 = f

u(0) = 0, u(1) = 0
D’où
−bû00 − δbu00 + cû0 + δcu0 = 0

û(0) = 0, û(1) = 0
On obtient ainsi le modèle linéaire tangent :
−bû00 + cû0 = δbu00 − δcu0

û(0) = 0, û(1) = 0
R1
On veut pouvoir reformuler 0 (u − uobs )û, donc on multiplie le modèle linéaire tangent
par une variable p et on intègre :
Z 1 Z 1 Z 1
00 0
−b û p + c û p = (δb u00 − δc u0 )p
0 0 0

Calculons séparément :
R1 R1
0
û00 p = [û0 p]10 − 0 û0 p0
R1
= [û0 p − ûp0 ]10 + 0 ûp00
R1
= û0 (1)p(1) − û0 (0)p(0) + 0 ûp00
R1 0 1
R1 0
û p = [ûp] − ûp
0 R 01 0 0
= − 0 ûp
Ce qui donne :
R1 R R
1 1
−b û0 (1)p(1) − û0 (0)p(0) + 0 ûp00 + c − 0 ûp0 = 0 (δb u00 − δc u0 )p
R1 R1
⇔ 0 (−bp00 − cp0 )û = bû0 (1)p(1) − bû0 (0)p(0) + 0 (δb u00 − δc u0 )p
Posons maintenant
−bp00 − cp0 = 2(u − uobs )

p(0) = 0, p(1) = 0
(on appelle ces équations le modèle adjoint)
On a alors
Z 1 Z 1 Z 1 Z 1
obs 00 0 00 0
2 (u − u )û = (−bp − cp )û = δb pu + δc − pu
0 0 0 0
D’où Z 1 Z 1
00 0
∇J(b, c) = pu , − pu
0 0
On vient donc de calculer le gradient grâce au modèle adjoint.
3.3 Ecriture générale dans le cas du contrôle de la

condition initiale
On considère le modèle suivant :

 dX
= M (X), dans Ω × [0, T ]
dt
 X(t = 0) = U
avec la fonction coût Z T

1
J(U ) = kHX − Y o k2
2 0
3.3.1 Dérivée directionnelle de J

On perturbe U dans la direction u. On note X
e la trajectoire correspondante :

 dX e
= M (X)
e
dt
 e
X(t = 0) = U + αu

On a alors
1 T
Z
J(U + αu) − J(u) = kH Xe − Y k2 − kHX − Y k2
2 Z0
1 T e − Y, H Xe − HX + HX − Y ) − (HX − Y, HX − Y )
= (H X
2 Z0
1 T e − Y, H(X e − X)) + (H X
e − Y − (HX − Y ), HX − Y )
= (H X
2 Z0
1 T e − Y, H(X e − X)) + (H(Xe − X), HX − Y )
= (H X
2 0
On pose alors
e −X
X
X̂ = lim
α→0 α
et on calcule
ˆ ](u) = lim J(U + αu) − J(u)

J[U
α→0 α
1 T
Z
= (HX − Y, H X̂) + (H X̂, HX − Y )
Z2 T0
= (H X̂, HX − Y )
Z0 T
= (X̂, H T (HX − Y ))
0
3.3.2 Modèle linéaire tangent

En soustrayant les équations vérifiées par X
e et X on obtient :
 2
e − X)
 d(X ∂M 1 e T ∂ M

= M (X) − M X =
e (X − X) + (X − X)
e e − X) + . . .
(X
dt ∂X 2 ∂X 2

(X − X)(t = 0) = αu
 e
En divisant par α et en faisant tendre α vers 0, on obtient :


 dX̂ = ∂M X̂

dt ∂X

X̂(t = 0) = u

Ces équations sont appelés modèle linéaire tangent.

3.3.3 Modèle adjoint

Comme dans l’exemple précédent, on multiplie l’équation du modèle tangent par P et
on intègre par parties sur [0, T ] :
Z T ! Z T h
dX̂ dP iT
,P = − X̂, + (X̂, P )
0 dt 0 dt 0
Z T
dP
= − X̂, + (X̂(T ), P (T )) − (X̂(0), P (0))
0
Z T dt
dP
= − X̂, + (X̂(T ), P (T )) − (u, P (0))
0 dt
Z T Z T T !
∂M ∂M
X̂, P = X̂, P
0 ∂X 0 ∂X
D’où
Z T ! Z T T !
dX̂ ∂M dP ∂M
− X̂, P = 0 = X̂, − − P +(X̂(T ), P (T ))−(u, P (0))
0 dt ∂X 0 dt ∂X
En identifiant avec Z T
ˆ ](u) =
J[U (X̂, H T (HX − Y ))
0
On obtient les équations du modèle adjoint :
 T
 dP
 ∂M
+ P = H T (HX − Y )
dt ∂X

 P (t = T ) = 0
On remarque que le modèle adjoint est rétrograde : l’équation est intégrée de T jusqu’à
0.
3.3.4 Calcul du gradient

Le modèle adjoint permet de réécrire le gradient :
Z T
ˆ
J[U ](u) = (X̂, H T (HX − Y ))
0
Z T T
dP ∂M
= (X̂, + P)
0 dt ∂X
= −(u, P (0))
Or
ˆ ](u) = (∇JU , u)
J[U
D’où
∇JU = −P (0)

Remarque : le gradient se calcule dont en une intégration rétrograde du modèle ad-

joint. Ceci est à comparer avec le nombre gigantesque d’intégrations du modèle direct
requis pour calculer le gradient par la méthode des taux d’accroissement !
3.4 Exemple : l’équation de Bürgers

Dans ce paragraphe, on va traiter l’exemple de l’équation de Bürgers avec contrôle
de la condition initiale et des conditions aux limites. Soient L et T des réels strictement
positifs. On considère l’équation de Bürgers visqueuse suivante, pour x ∈]0, L[ et t ∈]0, T [ :
∂ 2u

∂u ∂u
+ u − ν =f


 ∂t ∂x ∂x2


u(x = 0, t) = ψ1 (t)
u(x = L, t) = ψ2 (t)




u(x, t = 0) = u0 (x)

Le vecteur de contrôle est (u0 , ψ1 , ψ2 ), et la fonction coût est donnée par

Z T Z L
1
J(u0 , ψ1 , ψ2 ) = (u − uobs )2
2 0 0
où u est la solution de l’équation de Bürgers ci-dessus associées aux conditions (u0 , ψ1 , ψ2 ).
On sait que la dérivée de J dans la direction de (hu , h1 , h2 ) est donnée par
Z T Z L
ˆ 0 , ψ1 , ψ2 )[hu , h1 , h2 ] =
J(u û(u − uobs )
0 0
où û est défini par
u(u0 + αhu , ψ1 + αh1 , ψ2 + αh2 ) − u(u0 , ψ1 , ψ2 )

û = lim
α→0 α
et û est solution de l’équation aux dérivées partielles du modèle linéaire tangent :
∂ 2 û

∂ û ∂(uû)
+ − ν =0


 ∂t ∂x ∂x2


û(x = 0, t) = h1 (t)
û(x = L, t) = h2 (t)




û(x, t = 0) = hu (x)


Cherchons maintenant l’équation du modèle adjoint. Pour cela, on multiplie l’équation du

modèle tangent par p et on intègre par parties sur [0, T ] :
Z T Z TZ L
∂ û ∂ û
,p = p
0 ∂t 0
Z L 0 ∂t Z LZ T
T ∂p
= [ûp]0 − û
Z0 L 0 0 ∂t Z LZ T
∂p
= (û(T )p(T, x) − hu p(0, x)) − û
0 0 0 ∂t
Z T Z TZ L
∂(uû) ∂(uû)
,p = p
0 ∂x Z0 T 0 ∂x Z Z
T L
L ∂p
= [uûp]0 − uû
Z0 T 0 0 ∂x Z TZ L
∂p
= (ψ2 h2 p(L, t) − ψ1 h1 p(0, t)) − uû
0 0 0 ∂x
Z T 2 Z TZ L 2
∂ û ∂ û
2
,p = p
0 ∂x ∂x2
Z0 T 0 L Z T Z L
∂ û ∂ û ∂p
= p −
∂x 0 0 0 ∂x ∂x
Z0 T L Z TZ L 2
∂ û ∂p ∂ p
= p − û + û 2
Z0 T ∂x ∂x 0 0 0 ∂x
∂ û ∂p ∂ û ∂p
= p(L, t) (L, t) − h2 (L, t) − p(0, t) (0, t) + h1 (0, t)
0Z ∂x ∂x ∂x ∂x
T Z L
∂ 2p
+ û 2
0 0 ∂x
Les conditions aux limites naturelles pour p sont alors :
p(x, t = T ) = 0, p(x = 0, t) = p(x = L, t) = 0
Et on obtient ainsi
T L
∂ 2 û
Z Z
∂ û ∂(uû)
0 = + −ν 2 p
0 0 ∂t ∂x ∂x
Z LZ T
∂ 2p

∂p ∂p
= û − − u −ν 2
0 0 ∂t ∂x ∂x
Z L Z T
∂p ∂p
+ −hu p(0, x) + νh2 (L, t) − νh1 (0, t)
0 0 ∂x ∂x
autrement dit
Z TZ L Z L Z T
∂ 2p

∂p ∂p ∂p ∂p
û +u +ν 2 =− hu p(t = 0) + νh2 (x = L) − νh1 (x = 0)
0 0 ∂t ∂x ∂x 0 0 ∂x ∂x
Posons donc pour le modèle adjoint :
∂ 2p

∂p ∂p
+ u + ν = u − uobs


 ∂t ∂x ∂x2


p(x = 0, t) = 0
p(x = L, t) = 0




p(x, t = T ) = 0


On peut ainsi réécrire le gradient de J sous la forme :

Z L Z T
ˆ ∂p ∂p
J(u0 , ψ1 , ψ2 )[hu , h1 , h2 ] = − hu p(0) − ν h2 (L) − h1 (0)
0 0 ∂x ∂x
Ce qui donne
∂p ∂p
∇u0 J = −p(x, t = 0), ∇ψ1 J = −ν (x = 0, t), ∇ψ2 J = ν (x = L, t)
∂x ∂x
3.5 Exercices
Exercice 3.1 Soient L et T des réels strictement positifs. On considère l’équation aux
dérivées partielles suivante, pour x ∈]0, L[ et t ∈]0, T [ :
∂u ∂u3 ∂ 2u


 + − ν =f
 ∂t ∂x ∂x2



u(x = 0, t) = ψ1 (t)
∂u
(x = L, t) = ψ2 (t)



 ∂x


u(x, t = 0) = u0 (x)
Où les fonctions ψ1 , ψ2 et u0 sont choisies de sorte que l’équation admette une solution
forte sur ]0, T [. Le vecteur de contrôle est (u0 , ψ1 , ψ2 ), et la fonction coût est donnée par
Z T Z L
1
J(u0 , ψ1 , ψ2 ) = (u − uobs )2
2 0 0
où u est la solution de l’équation ci-dessus associées aux conditions (u0 , ψ1 , ψ2 ).
Exercice 3.2 Reprendre l’exercice précédent avec
1 T L
Z Z
J(u0 , ψ2 ) = (u − uobs )2
2 0 0
Exercice 3.3 Reprendre l’exercice précédent avec
1 T L 1 L
Z Z Z
2
J(u0 , ψ1 , ψ2 ) = (u − uobs ) + (u0 − ub )2
2 0 0 2 0
où l’ébauche ub est une fonction de x ∈]0, L[.

Chapitre 4
Mise en œuvre de la méthode

adjointe en pratique
Sommaire
4.1 Adjoint continu et adjoint discret . . . . . . . . . . . . . . . . . 35
4.2 Ecrire un adjoint pour faire de l’assimilation de données . . . 36
4.2.1 Remarque introductive . . . . . . . . . . . . . . . . . . . . . . . 36
4.2.2 Méthode adjointe discrète . . . . . . . . . . . . . . . . . . . . . 37
4.2.3 Autres remarques . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.2.4 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3 Validation du code adjoint : tests du gradient . . . . . . . . . 39
4.3.1 Premier test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3.2 Test dans le cas quadratique . . . . . . . . . . . . . . . . . . . 40
4.1 Adjoint continu et adjoint discret

Il existe deux façons d’écrire en pratique le code adjoint :
– discrétiser le modèle direct continu, puis écrire l’adjoint du code direct discret, on
appelle ceci l’adjoint discret ;
– à partir du modèle continu, écrire le modèle adjoint continu (comme expliqué dans les
paragraphes précédents), puis discrétiser l’adjoint continu, on appelle ces équations
l’adjoint continu.
Les deux codes adjoints ne sont pas équivalents.
Exemple 4.1 donnons nous une équation linéaire non autonome

dc
= F (t).c
dt
où F (t) est un opérateur linéaire mais dépendant du temps. Choisissons maintenant de
discrétiser ce code par une équation d’Euler explicite :
cn+1 − cn
= F n cn ⇒ cn+1 = (I + ∆tFn )cn
∆t

Nous verrons plus tard que l’adjoint de ce code discret est

c∗n = (I + ∆tFn )T c∗n+1
où les variables adjointes sont dénotées avec des exposants étoilés.
Voici maintenant l’équation adjointe continue :
dc∗
− = F (t)T .c∗
dt
Si on discrétise avec la même méthode d’Euler explicite, on obtient pour l’adjoint continu :
c∗n − c∗n+1 T
= Fn+1 c∗n+1 ⇒ c∗n = (I + ∆tFn+1 )T c∗n+1
∆t
Et on constate que la non autonomie en temps implique que les deux adjoints obtenus sont
différents
(I + ∆tFn )T 6= (I + ∆tFn+1 )T
Remarques
– Si le code direct est codé de manière explicite, son adjoint devient implicite (et
vice-versa), il faut donc faire attention aux critères de stabilité numérique !
– Le problème ici est lié à la non symétrie de l’algorithme temporel discret, on peut
avoir le même genre de difficultés avec les algorithmes spaciaux, s’ils sont non
symétriques.
Deux bonnes raisons pour utiliser l’approche discrète (ie prendre l’adjoint du
code discret, et non discrétiser les équations adjoints continu)
1. La fonction coût est calculée par le code direct discret, son gradient est donc donné
par l’adjoint de ce même code discret. L’adjoint continu donne une approximation
de ce gradient qui peut être assez mauvaise...
2. L’approche discrète permet d’utiliser des dérivateurs automatiques de codes (logi-
ciels qui prennent en entrée le code, les variables, et rendent en sortie le code tangent
et le code adjoint).
Règles de construction de l’adjoint d’un code

Les règles d’écriture d’un code adjoint sont assez techniques, et ne sont pas nécessaires
pour les cas très simples que nous allons voir, puisque dans ces cas il suffit d’adapter la
méthode adjointe continue à une formulation discrète pour obtenir le code adjoint. Elles
sont néanmoins incluses dans ce cours, vous les trouverez dans l’annexe A, accompagnées
d’exercices élémentaires.
4.2 Ecrire un adjoint pour faire de l’assimilation de

données
4.2.1 Remarque introductive
Dans le cadre de l’assimilation de données par méthode adjointe, nous avons vu que le
second membre de l’état adjoint dépend de l’écart aux observations. Les règles présentées

en annexe A nous permettent d’écrire l’adjoint d’un code, mais ne nous disent pas com-
ment faire apparı̂tre l’écart aux observations, sous forme discrète. Nous allons voir ci-
dessous comment ceci apparaı̂t naturellement, lorsque l’on reprend la méthode adjointe et
qu’on l’adapte au cas discret. En pratique il est conseillé de procéder ainsi : schématiser
le modèle sous forme discrète comme nous allons le faire, afin d’identifier l’endroit ou va
intervenir l’écart aux observations, puis utiliser les règles présentées dans l’annexe A pour
écrire en détail les adjoints des routines mises en jeu.
4.2.2 Méthode adjointe discrète

Modèle direct. Dans ce paragraphe on considère une simple équation d’évolution
linéaire que l’on suppose écrite sous forme discrète implicite de la manière suivante :
(
u0 donné
uk+1 − uk
+ Buk+1 = Fk , pour k = 0 : M − 1
h
où uk est un vecteur contenant les valeurs de la fonction u sur la grille spatiale au temps
k, B est une matrice, Fk est un vecteur, h est le pas de temps.
Fonction coût et dérivée directionnelle. La fonction coût que l’on veut minimiser
par méthode de descente dans la direction du gradient est la suivante :
1 T
Z Z
J(u0 ) = (u − uobs )2 dx dt
2 0 Ω
que l’on écrit sous forme discrète de la manière suivante, en utilisant la méthode d’intégration
des rectangles :
M
1X
J(u0 ) = h(uk − uk,obs )(uk − uk,obs )T
2 k=1
Le gradient de J dans la direction hu est donné par
M
X M
X −1
ˆ 0 )[hu ] =
J(u T
hûk (uk − uk,obs ) = hûk+1 (uk+1 − uk+1,obs )T (4.1)
k=1 k=0
où û est donné par

u(u0 + αhu ) − u(u0 )
û = lim
α→0 α
Modèle tangent. La variable tangente û vérifie l’équation suivante :

(
û0 = hu
ûk+1 − ûk
+ B ûk+1 = 0, pour k = 0 : M − 1
h

Modèle adjoint. Pour obtenir le modèle adjoint, on multiplie l’équation tangente par
la variable adjointe pk et on intègre en temps et par parties (de manière discrète) :
M −1
X ûk+1 − ûk
0 = h + B ûk+1 pTk
k=0
h
M
X −1 M
X −1 M
X −1
T T
= ûk+1 pk − ûk pk + hB ûk+1 pTk
k=0 k=0 k=0
M −1 M −2 M −1 (4.2)
X X X
= ûk+1 pTk − ûk+1 pTk+1 − û0 pT0 + hûk+1 (B T pk )T
k=0 k=0 k=0
M −2
X T T
= ûk+1 pk − pk+1 + h(B T pk ) + ûM pM −1 + hB T pM −1 − hu pT0
k=0
en identifiant avec l’expression de la dérivée directionnelle de J, on obtient pour le modèle

adjoint :  p
 M −1 + B T pM −1 = uM − uM,obs
h
 pk − pk+1 + B T pk = uk+1 − uk+1,obs , pour k = 0 : M − 2
h
ce qui peut s’écrire encore sous la forme :
(
pM = 0
pk − pk+1
+ B T pk = uk+1 − uk+1,obs , pour k = 0 : M − 1
h
Gradient. En revenant à l’équation (4.1) et en utilisant l’équation (4.2) et le modèle

adjoint on obtient :
M
X −1
ˆ 0 )[hu ] =
J(u hûk+1 (uk+1 − uk+1,obs )T
k=0
M −1 T
X pk − pk+1
= hûk+1 + B T pk
k=0
h
M −2
X T T
= ûk+1 pk − pk+1 + h(B T pk ) + ûM pM −1 + hB T pM −1
k=0
= hu pT0
= hu (∇J(u0 ))T
donc en identifiant on obtient bien
∇J(u0 ) = p0
4.2.3 Autres remarques

1. La façon dont l’écart aux observations intervient dépend donc de l’implémentation
discrète de la fonction coût : si on avait choisi une autre méthode que celle des rectangles
pour calculer J, on aurait dû modifier le second membre de l’état adjoint.

2. Si au lieu de multiplier par pk dans (4.2) on avait multiplié par pk+1 on aurait trouvé
la même chose, à un décalage d’indice près pour p :
(
pM +1 = 0
pk − pk+1
+ B T pk = uk − uk,obs , pour k = 1 : M
h
∇J(u0 ) = p1
4.2.4 Exercice
Exercice 4.1 Soient L et T des réels strictement positifs. On considère l’équation aux
dérivées partielles suivante, pour x ∈]0, L[ et t ∈]0, T [ :
∂u ∂u3 ∂ 2u


 + − ν =f
 ∂t ∂x ∂x2



u(x = 0, t) = ψ1 (t)
∂u
(x = L, t) = ψ2 (t)



 ∂x


u(x, t = 0) = u0 (x)
Où les fonctions ψ1 , ψ2 et u0 sont choisies de sorte que l’équation admette une solution
forte sur ]0, T [. Le vecteur de contrôle est (u0 ), et la fonction coût est donnée par
1 T L 1 L
Z Z Z
2
J(u0 ) = (u − uobs ) + (u0 − ub )2
2 0 0 2 0
où u est la solution de l’équation ci-dessus associées aux conditions (u0 , ψ1 , ψ2 ) et l’ébauche
ub est une fonction de x ∈]0, L[.
1. Reprendre l’exercice en version continue (voir exercice 3.1).
2. Ecrire un schéma numérique implicite pour le modèle direct.
3. Ecrire les équations du modèles tangent et du modèle adjoint, lorsque la fonction
coût est discrétisée par la méthode des rectangles. En déduire le gradient de J.
4. Reprendre la question précédente lorsque J est discrétisé par une autre méthode
(trapèzes par exemple).
4.3 Validation du code adjoint : tests du gradient

4.3.1 Premier test
Le premier test de validation est élémentaire, puisqu’il s’agit de vérifier l’approximation
suivante, au premier ordre en α proche de 0 :
J(u + α.ei ) − J(u)
= ∇J, ei + o(1)
α
L’idée est donc de calculer, pour diverses valeurs de la direction de perturbation ei , et
pour diverses valeurs de α (tendant vers 0, par exemple α = 10−n , n = 1..8), d’une part
le quotient
J(u + α.ei ) − J(u)
τ (α, ei ) =
α
calculé avec le code direct et d’autre part le produit scalaire

δ(ei ) = ∇J, ei
où ∇J est donné par le modèle adjoint. Ensuite il suffit de mesurer l’erreur relative
|τ (α, ei ) − δ(ei )|
ε(α, ei ) =
|δ(ei )|
et de vérifier que ε(α, ei ) tend bien vers 0 avec α pour diverses directions ei .
4.3.2 Test dans le cas quadratique

Dans le cas où le modèle est linéaire (ainsi que l’opérateur d’observation), la fonction
coùt J est alors quadratique, autrement dit le développement de Taylor
α2
ei , ∇2 Jei

J(u + αei ) = J(u) + α ∇J, ei +
2
est exact. Pour ei fixé, le dernier terme est constant :
α2
J(u + αei ) = J(u) + α ∇J, ei + C(ei )
2
Dans ce cas, le test du gradient que l’on fait est le suivant. Soit τ (α, ei ) défini comme
précédemment
J(u + α.ei ) − J(u)
τ (α, ei ) =
α
et
δ(ei ) = ∇J, ei
La formule de Taylor donne
τ (α, ei ) − δ(ei ) 1
= C(ei )
α 2
Le deuxième test du gradient consiste donc à calculer la quantité r(α, ei )
τ (α, ei ) − δ(ei )
r(α, ei ) =
α
pour diverses directions ei et divers α et à vérifier que pour α → 0 cette quantité tend
vers une constante dépendant de ei .

Chapitre 5
Algorithmes d’assimilation de
données variationnelle
Sommaire
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
5.2 Le 3D-Var . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.2.1 Fonction coût et algorithme . . . . . . . . . . . . . . . . . . . . 42
5.2.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3 Le 4D-Var . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.3.1 Fonction coût et gradient . . . . . . . . . . . . . . . . . . . . . 43
5.3.2 Algorithme et remarques . . . . . . . . . . . . . . . . . . . . . 44
5.3.3 Variante : 3D-FGAT . . . . . . . . . . . . . . . . . . . . . . . . 46
5.4 Compléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
5.4.1 En présence de non linéarités : algorithmes incrémentaux . . . 46
5.4.2 Effet d’une seule observation . . . . . . . . . . . . . . . . . . . 47
5.4.2.1 3D-Var . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.4.2.2 4D-Var . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.4.3 Préconditionnement . . . . . . . . . . . . . . . . . . . . . . . . 48
5.1 Introduction
Rappel : l’estimation linéaire optimale (BLUE) donne les formules suivantes pour
calculer l’état analysé :
Algorithme 5.1 (BLUE)
1. Calcul de la matrice K, appelée matrice de gain de l’analyse :
K = BH T (HBH T + R)−1
2. Analyse
xa = xb + K(y − H(xb ))
Cet algorithme permet de calculer le minimum xa de la fonction coût suivante :
J(x) = (x − xb )T B −1 (x − xb ) + (y − H(x))T R−1 (y − H(x))

Idée des méthodes variationnelles : ne pas calculer la matrice de gain K (les

dimensions étant trop grandes, les matrices impliquées dans le calcul de K se sont ni
stockable ni manipulables), mais chercher directement le minimum de J, en utilisant un
algorithme de descente et la méthode adjointe :
– l’optimum est cherché par une méthode de descente dans la direction du gradient ;
– le gradient est calculé par la méthode adjointe (et donc avec le code adjoint).
5.2 Le 3D-Var
5.2.1 Fonction coût et algorithme
Le 3D-Var est un algorithme adpaté aux modèles qui ne dépendent pas du temps. La
fonction coût du 3D-Var est la suivante :
J(x) = (x − xb )T B −1 (x − xb ) + (y − H(x))T R−1 (y − H(x))
avec les notations usuelles. Lorsque H est linéaire, son gradient est donné par
∇J = 2B −1 (x − xb ) − 2H T R−1 (y − H(x))
L’algorithme itératif utilise comme critère d’arrêt soit le fait que ∇J est suffisamment
petit ou bien que le nombre maximal d’itérations est atteint :
Algorithme 5.2 (3D-Var)

– Initialisation : x = x0 , n = 0
– Tant que k∇Jk > ε ou n ≤ nmax , faire :
1. Calcul de J
2. Calcul de ∇J
3. Descente et mise à jour de x
4. n = n + 1
Au sujet de la matrice B : comme pour le BLUE, les dimensions de cette matrice font
que son stockage explicite est en général impossible : une modélisation de cette matrice est
nécessaire. Cependant, seul intervient des produits matrice-vecteur impliquant B 1 et ceci
autorise des modélisations complexes sous forme d’opérateur (ie on définit une fonction
complexe qui reçoit φ en entrée, et renvoie B −1 φ en sortie).
Au sujet de la dimension temporelle : cet algorithme est prévu a priori pour des
modèles qui ne dépendent pas du temps. Cependant, il est parfois utilisé pour des modèles
dépendant du temps, mais de grosse dimension. Dans ce cas, x représente l’état initial, et
les observations y o (pourtant réparties sur la fenêtre temporelle) sont ramenées à l’instant
initial. Ceci simplifie grandement le calcul du gradient car, contrairement au 4D-Var (cf
paragraphe suivant), l’algorithme du 3D-Var ne requiert ni l’intégration de l’adjoint du
modèle M T , ni même l’intégration du modèle M .

5.2.2 Exemple
On cherche x1 et x2 les températures à Grenoble et à Chambéry.
La climatologie nous
T 1 0.25
donne une ébauche xb = 10 5 , avec B = . On observe y o = 4 à
0.25 1
Chambéry, avec R = 0.25 , et donc H = 0 1 .
On a donc
−1
1 0.25 x1 − 10
J(x) = x1 − 10 x2 − 5 + R−1 (x2 − 4)2
0.25 1 x2 − 5
−1
16 1 −0.25 x1 − 10
= x1 − 10 x2 − 5 15 + 4(x2 − 4)2
−0.25 1 x2 − 5
16
= 15 ((x1 − 10)2 + (x2 − 5)2 − 0.5(x1 − 10)(x2 − 5)) + 4(x2 − 4)2
16
= 15 (x21 − 17.5x1 + 100 + x22 − 5x2 − 0.5x1 x2 ) + 4 (x22 − 8x2 + 16)
De sorte que le gradient de J est :
16
(2x1 − 0.5x2 − 17.5) 1 32x1 − 8x2 − 280
∇J(x) = 15
16 =
15
(2x2 − 5 − 0.5x1 ) + 4(2x2 − 8) 15 −8x1 + 152x2 − 560
Le minimum de J est donc atteint pour
∇J(x) = 0 ⇒ x1 = 9.8, x2 = 4.2
5.3 Le 4D-Var
5.3.1 Fonction coût et gradient
Le 4D-Var généralise le 3D-Var au cas dépendant du temps, les observations étant
obtenues à des instants différents. La fonction coût est toujours écrite en fonction de
l’état initial x, mais fait intervenir le modèle puisque l’observation yio au temps i est
comparée à Hi (xi ), où xi est l’état au temps i du modèle initialisé avec x.
ébauche
analyse
observation

La fonction coût est donc

J(x) = J b (x) + J o (x)
où le terme d’ébauche J b est le même que précédemment :
J b (x) = (x − xb )T B −1 (x − xb )
L’ébauche xb , comme x, est vue comme un vecteur au temps initial i = 0.

Le terme d’observation J o est plus complexe :
n
X
o
J (x) = (yio − Hi (xi ))T Ri−1 (yio − Hi (xi ))
i=0
avec
xi = M0→i (x)
= Mi−1,i Mi−2,i−1 . . . M1,2 M0,1 x
= Mi Mi−1 . . . M2 M1 x
en notant Mi,i−1 = Mi .
Le terme d’observation de la fonction coût du 4D-Var est alors, en fonction de x :
n
X
o
J (x) = (yio − Hi Mi Mi−1 . . . M1 x)T Ri−1 (yio − Hi Mi Mi−1 . . . M1 x)
i=0
Finalement, le gradient de J est donné par

n
X
∇J(x) = 2B −1 (x − xb ) − 2 M1T . . . Mi−1
T
MiT HiT Ri−1 (yio − Hi Mi Mi−1 . . . M1 x)
i=0
Notons di le vecteur innovation :
di = yio − Hi Mi Mi−1 . . . M1 x
On a alors
n
X
− 12 ∇J o (x) = M1T . . . Mi−1
T
MiT HiT Ri−1 di
i=0
= H0T R0−1 d0 + M1T H1T R1−1 d1 + M1T M2T H2T R2−1 d2 + . . . +
M1T . . . Mn−1
T
MnT HnT Rn−1 dn
H0T R0−1 d0 + M1T H1T R1−1 d1 + M2T H2T R2−1 d2 + . . . + MnT HnT Rn−1 dn

=
Cette factorisation permet de calculer J o puis ∇J o avec une intégration du modèle direct
et une du modèle adjoint (cf “chain rule, mode reverse”).
5.3.2 Algorithme et remarques

Algorithme 5.3 (4D-Var)

1. Calcul de J grâce au modèle direct M et à l’opérateur d’observation H :
n
X
b T −1
J = (x − x ) B (x − x ) + b
dTi Ri−1 di
i=0
2. Calcul de ∇J grâce au modèle adjoint M T et à l’adjoint H T de l’opérateur

d’observation (en mode reverse) :
∇J(x) = 2B −1 (x − xb ) − 2 H0T R0−1 d0 + M1T H1T R1−1 d1 +

M2T H2T R2−1 d2 + . . . + MnT HnT Rn−1 dn


4. n = n + 1
Estimation de paramètres. Si on souhaite optimiser un jeu de paramètres
α = (α1 , α2 , . . . , αp )
il suffit d’ajouter des variables de contrôle et des termes dans la fonction coût :
J(x, α) = J1b (x) + J2b (α) + J o (x, α)
Le terme d’observation fait alors intervenir la dépendance en α, et il est souvent nécessaire

d’ajouter un terme de régularisation pour α, comme par exemple :
J2b (α) = kα − αb k2 , ou = (α − αb )T Bα−1 (α − αb ), ou = k∇α − βk2 . . .
Pourquoi utiliser l’adjoint pour le calcul du gradient ? Une autre façon de faire
serait de revenir à la définition :
∇J = (∇J1 , ∇J2 , . . . , ∇Jm )T
avec
J(x1 , . . . , xj−1 , xj + h, xj+1 , . . . , xn ) − J(x1 , . . . , xn )
∇Ji = lim
h→0 h
On a alors deux problèmes :
1. Le calcul n’est pas exact, puisque la limite est calculée de manière approximative.
2. Il faut faire ce calcul pour tout j ∈ {1, . . . , n}
L’adjoint, lui, donne un résultat exact.
Non-linéarités. Comme pour le BLUE et le 3D-Var, tout ceci est valide lorsque les
opérateurs M et H sont linéaires. S’ils ne le sont pas, on peut essayer de les linéariser, et
espérer que le résultat soit correct, ou bien conserver les opérateurs non linéaires et faire
de l’optimisation non convexe.

5.3.3 Variante : 3D-FGAT

Une variante du 3D-Var et du 4D-Var est le 3D-FGAT. Dans le calcul du gradient de
J , les appels au modèle adjoint sont supprimés (autrement dit, les opérateurs MiT sont
o
remplacés par l’opérateur identité).
Algorithme 5.4 (3D-FGAT)

1. Calcul des vecteurs innovations grâce au modèle direct M et à l’opérateur d’ob-
servation H :
2. Calcul de J : n
X
b T −1
J = (x − x ) B (x − x ) + b
dTi Ri−1 di
i=0
3. Calcul de ∇J grâce à l’adjoint H T de l’opérateur d’observation :

n
X
∇J(x) = 2B −1 (x − xb ) − 2 HiT Ri−1 di
i=0

5. n = n + 1
Remarques. Comme le 3D-Var, cet algorithme ne nécessite pas le développement du

modèle adjoint M T . Cependant, il est plus satisfaisant que le 3D-Var, pour les raisons
suivantes :
1. les vecteurs innovations sont exacts, l’écart aux observations est donc calculé au bon
instant (d’où le nom de l’algorithme FGAT : First Guess at Appropriate Time) ;
2. la structure de l’algorithme est la même que celle du 4D-Var, il peut donc servir en
phase de développement, pour faire des premiers tests en attendant la mise en place
de l’adjoint.
5.4 Compléments
5.4.1 En présence de non linéarités : algorithmes incrémentaux
Dans le cas où le modèle et/ou l’opérateur d’observation sont faiblement non-linéaires,
on peut étendre les algorithmes des 3D- et D4-Var pour prendre en compte ces faibles
non-linéarités. Les hypothèses de “faibles non linéarités” sont les suivantes :
Mi . . . M1 (x) − Mi . . . M1 (xb ) ' Mi . . . M1 (x − xb )
où les Mj représentent les divers pas de temps du modèle non linéaire et les Mj en sont
une bonne approximation linéaire. De même, on impose
Hi Mi . . . M1 (x) − Hi Mi . . . M1 (xb ) ' Hi Mi . . . M1 (x) − Mi . . . M1 (xb )


où de la même façon, Hi est une bonne approximation linéaire de Hi . Alors on définit
l’incrément δx
δx = x − xb
et on réécrit la fonction coût en fonction de l’incrément δx :
J(δx) = J b (δx) + J o (δx)
J b (δx) = δxT B −1 δx
n
X
o
J (δx) = (di − Hi Mi . . . M1 δx)T Ri−1 (di − Hi Mi . . . M1 δx)
i=1
où di est le vecteur innovation :
di = yio − Hi Mi . . . M1 (xb )
La fonction coût incrémentale J(δx) est ainsi une approximation de la vraie fonction coût,
de plus elle est quadratique, donc facile à minimiser !
L’algorithme du 4D-Var incrémental permet de prendre en compte les faibles non-linéarités
en remettant périodiquement à jour les opérateurs linéarisés Mi et Hi .
Algorithme 5.5 (4D-Var incrémental) – Initialisation : xr0 = xg

(xr est appelé état de référence ; xg est le premier itéré).
début de la boucle externe

– Intégration du modèle non linéaire : xri = M0,i [xr ]
– Calcul du vecteur innovation di grâce à l’opérateur d’observation non linéaire
début de la boucle interne

– Calcul de la fonction coût incrémentale J o (δx) en utilisant les opérateurs M et
H linéarisés autour de xr
– Calcul du gradient ∇J o (δx) grâce aux opérateurs adjoints M T et H T
– Minimisation via l’algorithme M1QN3
fin de la boucle interne
– Mise à jour de l’incrément d’analyse δxa = δx

– Mise à jour de l’état de référence xr = xr + δxa
fin de la boucle externe
– Calcul de l’état analysé xa = xr , xai = M0,i [xa ].
5.4.2 Effet d’une seule observation

5.4.2.1 3D-Var
On suppose que l’on a une seule observation, en un seul point, correspondant au k-ème
élément du vecteur d’état. L’opérateur d’observation est alors très simple :

H = 0 ... 0 1 0 ... 0

Seule la k-ème colonne contient 1, les autres sont nulles. La gradient de J vaut
∇J(x) = B −1 (x − xb ) + H T R−1 (Hx − y o )
Il est nul au minimum xa , ie
B −1 (xa − xb ) + H T R−1 (Hxa − y o ) = 0 ⇒ xa − xb = BH T R−1 (y o − Hxa )
Ici, R = (σ 2 ) et Hxa = xak , et BH T est la k-ème colonne de B : (B1,k , B2,k , . . . , Bn,k )T , de

sorte que  
o a B1,k
y − xk 
xa − xb = ... 
σ2
Bn,k
L’incrément est donc proportionnel à une colonne de B ! Le choix de B est donc crucial,
il va détermnier comment cette observation va renseigner sur ce qui se passe autour pour
la même variable et pour d’autres variables.
5.4.2.2 4D-Var
De la même façon, on n’observe que le k-ème point du vecteur d’état, seulement au
temps ti . La fonction coût associée est
1 1
J(x0 ) = (x0 − xb )T B −1 (x0 − xb ) + (HM0→i x0 − y o )T R−1 (HM0→i x0 − y o )
2 2
Comme précédemment, en écrivant que son gradient s’annule en xa , et en utilisant les
valeurs particulières de H et R, on obtient :
 T

o a
y − xi,k (BM 0→i ) 1,k
xa − xb =  ... 
σ2 T
(BM0→i )n,k
Si on fait évoluer cette équation jusqu’au temps i, on obtient

 
o a
y − xi,k (M 0→i BM 0→i )1,k
xai − M0→i xb =  ... 
σ2
(M0→i BM0→i )n,k
L’incrément au temps i est alors proportionnel à une colonne de M BM T , qui décrit

les covariances d’erreur d’ébauche à l’instant d’observation i. La matrice B évolue donc
implicitement avec le temps dans l’algorithme du 4D-Var.
5.4.3 Préconditionnement
On rappelle que le conditionnement d’une matrice A est le produit kAk kA−1 k, qui est
proportionnel au quotient de la plus grande valeur propre de A par sa plus petite.
En général, les problèmes d’assimilation de données variationnelle sont mal condi-

tionnés. Le taux de convergence de l’algorithme de minimisation dépend du condition-
nement de la Hessienne de la fonction coût : plus le conditionnement est proche de 1,

meilleur est la convergence. En dimension finie, le conditionnement de la Hessienne peut

se voir géométriquement comme une mesure de l’inverse de la courbure du graphe de
J : plus le graphe est courbé, plus le conditionnement est petit, et plus la convergence
est rapide. Au contraire, quand le conditionnement est grand, la courbe est applatie au
niveau du minimum, et la convergence est lente.
Pour le 4D-Var, la hessienne vaut B −1 + H T R−1 H, et le conditionnement est grand en
général.
Le préconditionnement consiste à effectuer un changement de variable sur δx = x−xb ,

de sorte que la hessienne de la fonction coût (exprimée en la variable δx) ait un petit condi-
tionnement, afin de la minimiser plus vite.
Le changement de variable
w = L−1 δx, B −1 = LLT
est couramment utilisé en météorologie et océanographie. La fonction coût modifiée est

1 1
J(w)
e = wT w + (HLw − d)T R−1 (HLw − d)
2 2
et sa hessienne vaut
Je00 = I + LT H T R−1 HL
Elle est en général mieux conditionnée, et ce préconditionnement donne des résultats
spectaculaires dans bien des cas.

Chapitre 6
Compléments
Sommaire
6.1 Analyse de sensibilté . . . . . . . . . . . . . . . . . . . . . . . . 50
6.1.1 Assimilation de données . . . . . . . . . . . . . . . . . . . . . . 51
6.1.2 Lien avec l’analyse de sensibilité . . . . . . . . . . . . . . . . . 52
6.2 Méthodes réduites . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.2.1 Idée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
6.2.2 Choix de l’espace réduit . . . . . . . . . . . . . . . . . . . . . . 53
6.2.2.1 EOF . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.2.2.2 Autres bases . . . . . . . . . . . . . . . . . . . . . . . 53
6.2.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.3 Modélisation des covariances d’erreur . . . . . . . . . . . . . . 54
6.3.1 Remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.3.2 Opérateur de diffusion . . . . . . . . . . . . . . . . . . . . . . . 55
6.3.3 EOF et bases réduites . . . . . . . . . . . . . . . . . . . . . . . 56
6.3.4 Méthodes d’ensemble . . . . . . . . . . . . . . . . . . . . . . . . 56
6.3.5 Autres méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . 57
6.1 Analyse de sensibilté

Dans cette section, on va illustrer par un exemple la réponse à la question suivante :
Comment une caractéristique du système est-elle sensible un un paramètre du système ?

Autrement dit, comment une petite variation d’un paramètre d’entrée se repercute-t-elle
sur un critère de sortie du système ?
L’exemple que l’on va considérer est une équation de diffusion à coefficients non
constants, sur ]0, L[×]0, T [ :

∂u ∂ ∂u
= K(x)


∂t ∂x ∂x


 u(x = 0, t) = u(x = L, t) = 0
u(x, t = 0) = u0 (x)


6.1.1 Assimilation de données

Le problème classique d’assimilation de données pour ce système est de minimiser la
fonction coût :
1 T
Z Z
J(K) = L(u − uobs )2
2 0 0
Par méthode adjointe, le gradient de J par rapport à K dans la direction k est
Z TZ L
ˆ
J(K)[k] = û(u − uobs )
0 0
où û est
u(K + αk) − u(K)
û = lim
α→0 α
Le modèle linéaire tangent définissant û est

∂ û ∂ ∂ û ∂ ∂u
= K(x) + k(x)


∂t ∂x ∂x ∂x ∂x


 û(x = 0, t) = û(x = L, t) = 0
û(x, t = 0) = 0

On multiplie le modèle tangent par p puis on intègre, pour obtenir :

Z TZ L Z L Z LZ T
∂ û T ∂p
p = [ûp]0 − û
0 0 ∂t 0 0 0 ∂t
Z TZ L Z T L
∂ ∂ û ∂ û ∂p
K(x) p = K(x) p − ûK(x)
0 0 ∂x ∂x 0Z ∂x ∂x 0
T Z L
∂ ∂p
+ K(x) û
0 0 ∂x ∂x
Z TZ L Z TZ L
∂ ∂u ∂p ∂u
k(x) p = − k(x)
0 0 ∂x ∂x 0 0 ∂x ∂x
En posant
p(x = 0, t) = p(x = L, t) = 0, p(x, t = T ) = 0
on obtient Z L Z T Z T Z L
∂p ∂ ∂p ∂p ∂u
û + K(x) = k(x)
0 0 ∂t ∂x ∂x 0 0 ∂x ∂x
Le modèle adjoint est 
∂p ∂ ∂p
+ K(x) = u − uobs


∂t ∂x ∂x


 p(x = 0, t) = p(x = L, t) = 0
p(x, t = T ) = 0

Et on obtient pour la dérivée de J :

Z TZ L Z L
ˆ ∂p ∂u
J(K)[k] = k(x) = k(x)∇J(K)
0 0 ∂x ∂x 0
Ce qui donne pour le gradient de J :

Z T
∂p ∂u
∇J(K) =
0 ∂x ∂x

6.1.2 Lien avec l’analyse de sensibilité

On s’intéresse maintenant à quantifier l’influence de K sur ∂u ∂x
(t = T ) (par exemple),
ie on veut quantifier l’influence de K sur le critère J1 :
2
1 L ∂u
Z
J1 (K) = (t = T )
2 0 ∂x
RLRT
(plus généralement, on pourra considérer J(K) = 0 0 H(u) où H est un opérateur
d’observation de notre choix)
Cette fois on n’a plus d’observations, on étudie simplement le comportement du système.
La dérivée de J1 par rapport à K dans la direction k est
Z L Z L
ˆ ∂u ∂ û ∂ 2u
J(K)[k] = (T ) (T ) = − û(T ) 2 (T ) + 0
0 ∂x ∂x 0 ∂x
où û est défini comme précédemment. Tous les calculs précedents sont valables, seul change
le terme de forçage de l’équation adjointe :
∂ 2u

∂p ∂ ∂p
+ K(x) = − 2 δT (t)


∂t ∂x ∂x ∂x


 p(x = 0, t) = p(x = L, t) = 0
p(x, t = T ) = 0

où la fonction Dirac δT (t) vaut 1 si t = T et 0 sinon. On a encore

Z T
∂p ∂u
∇J(K) =
0 ∂x ∂x
L’adjoint est donc un outil précieux pour l’analyse de sensibilité.
6.2 Méthodes réduites

6.2.1 Idée
L’idée de la réduction d’ordre est de chercher un incrément optimal non pas dans
l’espace initial de grande dimension, mais dans un espace de dimension réduite. Plus
précisément, on va chercher x sous la forme
r
X
b
x=x + ci φi
i=1
où xb est un état de référence fixé, et (φ1 , . . . , φr ) est une base de l’espace réduit.
On minimise alors la fonction coût réduite
J(x) = J(c
e 1 , . . . , cr )
La minimisation a alors lieu dans un espace de dimension r, donc on gagne en temps de

calcul. En pratique, la dimension initiale des problèmes est de l’ordre de 106 à 108 en
météorologie et océanographie, alors que r vaut entre 30 et 100.

6.2.2 Choix de l’espace réduit

6.2.2.1 EOF
Les EOF (fonctions empiriques orthogonales) sont une base de vecteurs représentant
les modes de variabilité du système. Pour le calcul pratique de ces modes, on produit
d’abord une série de vecteurs x (grâce au modèle, par exemple pris à divers pas de temps
ou avec divers choix des paramètres), puis une série y qui vaut x moins sa moyenne. Avec
cette série y, on calcul une matrice de covariance
C = yy T
Cette matrice est symétrique et définie positive, on la diagonalise en rangeant ses valeurs
propres par ordre décroissant. Les EOF sont alors les premiers modes propres de C, as-
sociés aux plus grandes valeurs propres.
La méthode des EOF porte aussi d’autres noms : POD (proper orthogonal decompo-
sition), ACP (analyse en composante principales).
6.2.2.2 Autres bases

Il existe d’autres bases de vecteurs particuliers. Sans rentrer dans les détails, on peut
citer les modes de Fourier, les vecteurs singuliers, les ondelettes, etc.
6.2.3 Exemple
On considère le problème du contrôle du coefficient de diffusion K(x) dans l’équation

∂u ∂ ∂u


 = K(x) = x ∈]0, 1[, t ∈]0, T [
∂t ∂x ∂x


 u(x = O, t) = u(x = 1, t) = 0

u(x, t = 0) = u0 (x)
Le coefficient K est inconnu et on veut l’estimer à partir de l’observation uobs :
1 T 1
Z Z
J(K) = (uK − uobs )2
2 0 0
On suppose maintenant que les variations de K peuvent être représentées dans une base
(φ1 , . . . , φr ) :
Xr
K(x) = λi φi (x)
i=1
La fonction coût devient J(λ1 , . . . , λn ), et Jˆ devient

Z TZ 1
ˆ
J(λ1 , . . . , λn )[d1 , . . . , dn ] = û(u − uobs )
0 0
où û est solution du modèle linéaire tangent :

∂ û ∂ ∂ û ∂ ∂u
= K(x) + k(x)


∂t ∂x ∂x ∂x ∂x


 û(x = 0, t) = û(x = L, t) = 0
û(x, t = 0) = 0


Le modèle adjoint est également le même :


∂p ∂ ∂p
+ K(x) = u − uobs


∂t ∂x ∂x


 p(x = 0, t) = p(x = L, t) = 0
p(x, t = T ) = 0

Et on a r
Z T Z L
ˆ 1 , . . . , λn )[d1 , . . . , dn ] = ∂p ∂u
X
J(λ di φi (x)
0 0 i=1 ∂x ∂x
Z TZ L
Pr ∂p ∂u
= i=1 di φi (x)
0 0 ∂x ∂x
= ∇J(λ1 , . . . , λn ).[d1 , . . . , dn ]
Donc Z T Z L
∂p ∂u
∇Ji (λ1 , . . . , λn ) = φi (x)
0 0 ∂x ∂x
6.3 Modélisation des covariances d’erreur

6.3.1 Remarques
On rappelle que si εb représente l’erreur d’ébauche, alors la matrice B est définie ainsi :
B = (εb − εb )(εb − εb )T
Commençons par quelques remarques sur le rôle de cette matrice B :

– Rappelons l’algorithme du BLUE :
xa = xb + BH T (HBH T + R)−1 (y o − H(xb ))
La dépendance de la solution xa par rapport à B est très forte !

De la même façon, pour le 4D-Var :
xa = xb + BM T H T (HM BM T H T + R)−1 (y o − H(xb ))
– De plus, dans certains codes, on utilise B pour le préconditionnement, en effectuant

le changement de variable
χ = B −1/2 δx
– Si N est le nombre de variable du modèle multiplié par le nombre de points de
grille, alors B est de taille N 2 , avec N de l’ordre de 106 à 108 pour les applica-
tions géophysiques actuelles, de sorte que l’on ne stocke pas B, on code plutôt des
opérateurs acceptant x en entrée et donnant Bx ou B 1/2 x en sortie.
On rappelle le lien avec les variances et les corrélations. Si la matrice B a pour coeffi-
cients Bi,j alors on a
Bi,j = (εbi − εbi )(εbj − εbj )

Les variances sont alors définies comme les coefficients diagonaux Bi,i :
Bi,i = (εbi − εbi )2

Et les corrélations sont alors les coefficients Ci,j tels que :
Bi,j
Ci,j = 1/2 1/2
Bi,i Bj,j
De sorte que si on définit
1/2
Σ = diag(Bi,i )
on obtient
B = ΣCΣ
La matrice des écarts-types Σ peut être estimée par des statistiques sur des états du
modèle, elle n’a que N coefficients (alors que B en a N 2 ).
La matrice C est alors sans dimension, elle représente la corrélation entre les diverses
entrées du vecteur d’état : soit entre deux points de grille différents pour une même
variable (corrélations monovariées), soit entre deux variables prises en des points différents
(corrélations multivariées). On va voir diverses méthodes pour estimer B et/ou C.
6.3.2 Opérateur de diffusion

On donne ici un premier exemple qui permet de calculer des corrélations monovariées,
ie correspondant par exemple à une matrice C de la forme
 
Cu 0 0 0
 0 Cv 0 0 
C=  0 0 CT 0 

0 0 0 CS
où les Cφ sont des matrices de corrélations spatiables pour une variable φ donnée, par
exemple ici on a 4 variables u, v, T et S dans l’océan (vitesses, température, salinité), de
sorte que le vecteur d’état s’écrit
x = (u1 , . . . , uM , v1 , . . . , vM , T1 , . . . , TM , S1 , . . . , SM )
où M est le nombre de points de grille. Dans ce cas, par exemple, la matrice Cu =
(Cu;i,j )1≤i,j≤M représente les corrélations entre le points de grille i et j pour la variable de
vitesse u.
Une première méthode naı̈ve consiste à dire que les fonctions de corrélation sont des
gaussiennes dépendant de la distance entre deux points :

di,j
Ci,j = c1 exp −
c2
où c1 et c2 sont des coefficients de normalisation et di,j représente la disctance entre le
point repéré par l’indice i dans la grille et celui repéré par l’indice j, de sorte que l’influence
du point i sur le point j décroit avec la distance entre ces points.
La méthode de l’opérateur de diffusion améliore cette idée, en déformant les gaus-
siennes pour suivre les frontières du domaine, ou le flot. Ceci est réalisé grâce à un
opérateur de diffusion (dont les solutions sont justement des gaussiennes déformées).

6.3.3 EOF et bases réduites

On rappelle (voir le paragraphe 6.2.2.1) qu’avec une série temporelle d’états du système,
on calcule une matrice de covariance C dont les r premières valeurs propres sont appelées
EOF du système :
C = N ΛN T
où N est la matrice des vecteurs propres et Λ la matrice diagonale des valeurs propres
(classées par ordre décroissant). L’idée pour approcher B est de ne conserver que la partie
correspondant aux r EOF choisies :
B = Nr Λr NrT
où Nr est une matrice comportant r colonnes qui sont les r premières EOF, et Λr est une
matrice diagonale de taille r par r contenant les r plus grandes valeurs propres. De sorte
que B peut s’écrire
B = Sr SrT , avec Sr = Nr Λr1/2 de taille n × r
En général, r = 30, donc une telle formulation de B est stockable en mémoire et manipu-
lable aisément.
Un grand avantage de cette méthode est que la matrice produite est multivariée,
puisqu’elle fait apparaı̂tre naturellement des covariances non nulles entre les différentes
variables du modèle.
Cette technique peut s’appliquer avec n’importe quelle base réduite (voir le paragraphe
de réduction d’ordre 6.2).
6.3.4 Méthodes d’ensemble

Si on dispose d’un ensemble de p états possibles x1 , . . . , xp du système, on peut estimer
B par méthode de Monte-Carlo :
p
1X j T
x − x xj − x

B=
p j=1
où x est la moyenne des xj :

p
1X j
x= x
p j=1
Comme précédemment, on est ramené à des calculs moins coûteux :
p
1X j j T
B= L (L )
p j=1
avec Lj vecteur d’une seule colonne. Tout le problème est alors de calculer judicieusement
les vecteurs xj de l’ensemble. On se reportera aux méthodes de filtre d’ensemble pour voir
comment calculer ce éléments.
En général, p est de l’ordre de 80 à 100, de sorte que B est élémentaire à calculer.

Tout comme avec les EOF, B est naturellement multivariée.

6.3.5 Autres méthodes

Pour obtenir des matrices B multivariées, il est possible de tenir compte de lois phy-
siques liant 2 variables, par exemple une relation température / salinité dans l’océan, ou
encore la géostrophie (relation courants / hauteur d’eau). Ces méthodes sont encore peu
développées, du fait de leur complexité par rapport aux méthodes de réduction d’ordre
ou d’ensemble.

Annexe A
Régles d’écriture d’un code adjoint
A.1 Ecriture d’un code adjoint : principes

A.1.1 Dérivation d’une fonction composée
Un algorithme peut être défini comme une fonction H :
H : Rn → Rm
X 7→ Y
Les différentes étapes de l’algorithme sont :
Hl : Rnl−1 → Rnl
Z l−1 7→ Z l
de sorte que
H = HK ◦ HK−1 ◦ . . . ◦ H1 = K
l=1 H
l
Le jacobien de H :
∂Hi
(Aij (X0 ))1≤i≤m,1≤j≤n =
∂Xj X=X0
est donné par la chain-rule (règle de composition des différentielles) :
∂HK ∂HK−1 ∂H1

A(X0 ) = . .....
∂Z K−1 Z K−1 =Z K−1 ∂Z K−2 Z K−2 =Z K−2 ∂Z00 Z 0 =Z 0
0 0 0
où “.” représente la multiplication matricielle et où on a posé
Z K−1 = K−1 l
l=1 H (X), Z K−2 = K−2 l
l=1 H (X), ..., Z0 = X
Z0K−1 = K−1 l
l=1 H (X0 ), Z K−2 = K−2 l
l=1 H (X0 ), ..., Z 0 = X0
On a alors deux stratégies pour calculer le produit :
∂HK ∂HK−1
– −→ reverse mode : calculer de gauche à droite, ie commencer par le produit ∂Z K−1 . ∂Z K−2 ,
∂HK−2
puis multiplier le résultat par ∂Z K−3 , etc.
– ←− forward mode : calculer le produit dans le même sens que la composition des
2 ∂H1
fonctions, ie commencer par ∂H .
∂Z 1 ∂Z 0
et continuer de la droite vers la gauche.

Le coût de calcul n’est pas le même selon les méthodes :

– reverse mode : on manipule toujours des matrices de m lignes,
– forward mode : on manipule toujours des matrices de n colonnes.
Donc si m ou n st petit, une stratégie peut être meilleure que l’autre.
Une autre différence entre les méthodes est que les résultats intermédiaires Z p = pl=1 Hl (X0 )
sont nécessaires pour faire le calcul, mais pas dans le même ordre si on travaille en reverse
ou en forward.
Cas particulier de l’assimilation de données. On cherche à minimiser une fonction

scalaire J : Rn → R, ie m = 1. Le mode reverse est donc préféré, mais il requiert
les résultats des calculs dans l’ordre inverse. Autrement dit, on ne peut pas calculer en
parallèle le code direct et le code adjoint. Le mode reverse nécessite le stockage ou le
re-calcul des résultat intermédiaires (cf paragraphe “checkpointing”).
A.1.2 Lien avec le calcul de l’adjoint

On rappelle que les variables Z l sont définies comme suit :
Z l = Hl ◦ Hl−1 ◦ . . . ◦ H1 (X)
Les variables tangentes δZ l sont définies ainsi :

l ∂ l l−1

1
δZ = H ◦ H ◦ ... ◦ H δX
∂X X=X0
où δX est une petite variation de X. Le lien entre deux variables tangentes successives
est donné par :
∂Hl

l
δZ = δZ l−1
∂Z l−1 Z l−1 =Z l−1
0
avec Z0l l
=H ◦H l−1 1
◦ . . . ◦ H (X0 ).
Les variable adjointes sont définies ainsi :

δ ∗ Z l = ∇Z l (HK ◦ HK−1 ◦ . . . ◦ Hl+1 )Z l =Z l

0
On va maintenant utiliser cette définition pour en déduire le modèle adjoint, autrement

dit l’équation qui lit deux variables adjointes successives. On rappelle que H est donné
comme une composée :
H = HK ◦ HK−1 ◦ . . . ◦ Hl+1 ◦ Hl ◦ Hl−1 ◦ . . . ◦ H1
Voyons maintenant H comme la composée de deux fonctions :
H = HK ◦ HK−1 ◦ . . . ◦ Hl+1 ◦ Hl ◦ Hl−1 ◦ . . . ◦ H1

Quand on dérive cette composée de deux fonctions on obtient :

dH d HK ◦ HK−1 ◦ . . . ◦ Hl+1 d Hl ◦ Hl−1 ◦ . . . ◦ H1 (X)
= .
dX d Hl ◦ Hl−1 ◦ . . . ◦ H1 (X) dX
K K−1 l+1

d H ◦H ◦ ... ◦ H l
dZ
= l
.
dZ dX
De sorte que l’on a, en utilisant la définition des variables tangentes puis adjointes :
dH
δH = .δX
dX
d HK ◦ HK−1 ◦ . . . ◦ Hl+1 dZ l
= . .δX
dZ l dX
d HK ◦ HK−1 ◦ . . . ◦ Hl+1
= .δZ l
dZ l
= δ ∗ Z l .δZ l
Ceci vaut pour tout l, donc en particulier en écrivant ceci pour l = 0 on obtient :
δH = (∇X H, δX) = δ ∗ Z l , δZ l = δ ∗ Z l−1 , δZ l−1

Ceci nous permet d’en déduire δ ∗ Z l−1 en fonction de δ ∗ Z l :

δH = δ ∗ Z l−1 , δZ l−1 = δ ∗ Z l , δZ l

!
l

∂H
= δ∗Z l , δZ l−1
∂Z l−1 Z l−1 =Z l−1
" #0T 
l

∂H
=  l−1
δ ∗ Z l , δZ l−1 
∂Z
Z l−1 =Z l−1
0
ce qui donne finalement :

Z l = Hl (Z l−1 )


 ←− modèle direct
∂Hl


δZ l = δZ l−1


 ←− modèle tangent
∂Z l−1 Z l−1 =Z l−1
" 0 #T
 l

∂H


∗ l−1
 δ Z = δ ∗ Z l ←− modèle adjoint



∂Z l−1 Z l−1 =Z l−1
0
On remarque aussi que

δH = (∇X H, δX) = (δ ∗ X, δX) = (δ ∗ Z0 , δX)
donc ∇X H = δ ∗ Z0 est évalué en dernier.
A.2 Checkpointing
On a vu précédemment que le mode reverse (utilisé en assimilation de données)
nécessite les résultats intermédiaires dans l’ordre inverse. Il existe plusieurs stratégies
pour obtenir ces résultats intermédiaires :
– Stratégie 1 : on stocke tous les résultats intermédiaires lors du calcul du code direct.
Lorsque les dimensions du problèmes sont grandes, on a évidemment des problèmes
de mémoire.
– Stratégie 2 : on recalcule tout au fur et à mesure. De même, on peut avoir ici des
problèmes de temps de calcul.
– Stratégies intermédiaires : elles mélangent le stockage et le re-calcul. On appelle ça
le checkpointing.

Exemple de checkpointing à un niveau. On se donne un problème avec 1000 pas de

temps. Une stratégie de checkpointing à un niveau est de stocker les variables directes tous
les 100 pas de temps. Ainsi on aura en mémoire 10 vecteurs stockés, et on ne recalculera
jamais plus de 100 pas de temps successifs. Les 10 instants de stockage sont appelés les
checkpoints.
Direct
800 900 1000
899
999
898
... ... 998
Adjoint (reverse)
800 900 1000
Exemple de checkpointing à deux niveaux. On se donne comme précedemment

1000 pas de temps. On va décrire une stratégie de checkpointing à deux niveaux, avec 10
points de checkpoints de niveau 1, et 5 points de checkpoint de niveau 2.
L’algorithme commence avec le calcul du code direct et le stockage de 10 vecteurs (un tous
les 100 pas de temps, comme précédemment). Dans les 100 derniers pas de temps, on stcke
également 5 vecteurs (un tous les 20 pas de temps). Ensuite, pour obtenir le code adjoint
aux instant 1000, 999, jusqu’à 980, on utilise le vecteur stocké à 980 pour recalculer les
résultats intermédiaires. Pour le code adjoint des instant 979 à 960, on recalcule à partir
du checkpoint 960, etc. Arrivé à 900, on reprend le checkpoint 800, on relance le code
direct pendant 100 pas de temps, et on stocke 5 vecteurs entre 800 et 900 (en écrasant les
5 vecteurs 900, 920, 940, 960 et 980 précédents), et on poursuit ainsi.

Direct
800 900 1000
960 980
860 880
...
Adjoint (reverse)
800 900 1000
On a ainsi en mémoire 10+5=15 vecteurs stockés au maximum, et on ne recalcule jamais

plus de 20 pas de temps successifs.
De la même façon on peut définir des stratégies de checkpointing à 3 ou 4 niveaux.

On ajuste la taille des niveaux en fonction des difficultés spécifiques du problème (place
mémoire, accès disque et/ou temps de calcul).
A.3 Règle d’écriture des codes adjoints

Définition A.1 On appelle variables actives les variables qui dépendent du contrôle et
qui ont une influence sur la fonction coût. Les autres variables sont dites passives. Seules
les variables actives ont des variables adjointes associées.
Par exemple, les variables d’état sont en général actives, tandis que les paramètres phy-
siques et numériques sont passifs.
Composition d’un code :

– affectations ;
– expressions conditionnelles ;
– boucles ;
– suites d’instructions (blocs) ;
– appel à des subroutines ou à des fonctions ;
– entrées / sorties (I/O).
On va voir comment écrire l’adjoint de chacun de ces éléments.

A.3.1 Affectation
On va appliquer la formule vue précédemment, ie on va dériver, puis transposer. Tra-
vaillons sur un exemple. Soit le code direct
Z = X sin(Y 2 ) + aX 2 + bY + c
où les variables X, Y et Z sont actives et a, b, et c sont passives. Avec les notations
précédentes, ceci est l’étape l :

l l−1 l−1 2 2
Z = X sin Y + aX l−1 + bY l−1 + c
(sous entendu : à cette étape Y l = Y l−1 et X l = X l−1 sont inchangés)

La première étape est d dériver par rapport aux variables actives de l’étape l − 1 :
2
2

δZ l = δX l−1 sin Y l−1 + 2X l−1 Y l−1 δY l−1 cos Y l−1 + 2aX l−1 δX l−1 + bδY l−1
(sous entendu : δY l = δY l−1 et δX l = δX l−1 )

Sous forme matricielle on obtient :
   1 0

0  δX l−1 
δX l
 δY l  =   0 1 0 
  δY l−1 
2 2
δZ l sin Y l−1 + 2aX l−1 2X l−1 Y l−1 cos Y l−1 + b 0 δZ l−1
On transpose ensuite pour obtenir le code adjoint :

 
l−1 2
+ 2aX l−1
l−1 l
∗ 1 0 sin Y ∗
 
δX   δX
 δY ∗  =    δY ∗ 

2
0 1 2X l−1 Y l−1 cos Y l−1 + b
δZ ∗ δZ ∗
 
0 0 0
Ce qui donne finalement les trois lignes de code suivantes :


ADX = ADX + (sin(Y 2 ) + 2aX)ADZ
 ADY = ADY + (2XY cos(Y 2 ) + b)ADZ
ADZ = 0
Remarque : la valeur Z l−1 n’intervient pas dans le calcul de Z l , c’est pour cela qu’on
a ADZ = 0. C’est important de mettre cette ligne en dernier ! Réciproquement, si Z l−1
intervient, alors ADZ 6= 0. Par exemple :

ADY = ADY + ADZ
direct : Z = ZX + Y → adjoint :  ADX = ADX + Z ADZ
ADZ = X ADZ
Conflits : lorsqu’on ne voit pas qu’une variable du membre de droite est la même que
celui de gauche. Par exemple :
X(i) = X(10 − i) + Y (i)

Pour i 6= 5, on a trois variables différentes X(i), X(10 − i) et Y (i). Pour i = 5, on a

seulement 2 variables distinctes X(5) et Y (5). Le code n’est donc pas le même pour tout
i.
La résolution de ce confit consiste soit à traiter différemment les cas i = 5 et i 6= 5, soit
plus systématiquement à introduire une variable intermédiaire :

H(i) = X(10 − i)
X(i) = H(i) + Y (i)
A.3.2 Expressions conditionnelles

Voilà comment écrire l’adjoint :
direct −→ adjoint
if (condition D1 ) then if (condition D1 ) then
bloc A adjoint bloc A
else if (condition D2 ) then else if (condition D2 ) then
bloc B adjoint bloc B
else else
bloc C adjoint bloc C
end end
Remarque : on doit être capable d’évaluer les conditions D1 et D2 (à stocker ou à

recalculer...).
A.3.3 Boucles
On distingue les boucles parallèles, lorsqu’il n’existe pas de dépendance entre les étapes
de la boucle, des boucles séquentielles. La règle est la suivante :
direct −→ adjoint (b. parallèle) adjoint (b. séquentielle)
do i = start, end, step do i = start, end, step do i = end, start, -step
bloc A adjoint bloc A adjoint bloc A
end end end
Conflits. Peuvent arriver si des variables actives sont écrasées durant la boucle. Voyons
un exemple. 
F =1
 do i = 1, N

 F = F.X(i)
end
L’adjoint du bloc dans la boucle est

adX(i) = adX(i) + F adF
adF = X(i) adF
Il fait intervenir F (tel qu’il était à l’étape i de la boucle !).

Pour la résolution, on présente trois stratégies :

1. Stocker F sur le disque, puis le lire (au bon moment !).

2. Stocker F dans un vecteur dépendant de i.
3. Recalculer F à chaque étape.
Pour notre exemple, on obtient :
1.  
F =1 do i = N, 1, −1

 write(1, F )  read(i, F )

 do i = 1, N  adX(i) = adX(i) + F adF
direct :  , adjoint : 

 F = F.X(i)  adF = X(i) adF

 write(i, F )  end
end adF = 0
2. 
H(1) = 1
 do i = 1, N

direct :  H(i + 1) = H(i).X(i)
 end
F = H(N + 1)

adH(N + 1) = adH(N + 1) + adF
 adF = 0

 do i = N, 1, −1

 adX(i) = adX(i) + H(i) adH(i + 1)
adjoint : 
 adH(i) = adH(i) + X(i) adH(i + 1)

 adH(i + 1) = 0
end
3. 
do i = N, 1, −1
 F =1

  do l = 1, i
F =1 
 do i = 1, N

 F = F.X(i)
direct : 
 F = F.X(i) , adjoint : 
 end
 adX(i) = adX(i) + F adF
end 
 adF = X(i) adF

 end
adF = 0
Les inconvénients pour chacune des stratégies sont :
1. multiplie les entrées ;
2. augmente la taille mémoire nécessaire ;
3. augmente le temps de calcul.
Il faut donc faire le choix adéquat, en fonction du code, de la machine de calcul, etc.
A.3.4 Blocs
Le code adjoint de
A→B→C

est
A∗ ← B ∗ ← C ∗
La difficulté est que, parfois, certaines variables sont requises pour faire les calculs. Par
exemple, C ∗ requiert les variables directes telles qu’elles étaient après avoir effectué A
puis B.
Comme précédemment, on peut trouver trois solutions pour gérer cette difficulté :
1. stocker les variables requises sur le disque ;
2. les stocker en mémoire ;
3. tout recalculer, de sorte que l’adjoint de A B C devient 0 A B C ∗ 0 A B ∗ 0 A∗ , où 0
signifie “revenir aux variables initiales” (telles qu’elles étaient avant l’évaluation de
A).
Par exemple, considérons le code direct

 (A) Y = F.X 2

 (B) X = 4X + C

y (C) Z = F. sin(X)
Les blocs adjoints sont les suivants :

x

 (A )∗ adX = adX + 2F.X.adY

 adY = 0
∗

 (B ) adX = 4.adX


 (C ∗ )
 adX = adX + F. cos(X).adZ
 adZ = 0
On peut remarquer que X intervient deux fois : dans le bloc C ∗ , c’est la valeur de X telle
qu’elle était après B qui est requise ; dans le bloc A∗ , c’est sa valeur initiale (avant A) qui
est requise.
On laisse en exercice au lecteur l’implémentation des trois stratégies présentées plus haut.
A.3.5 Appel à des subroutines et à des fonctions

Voici les principes.
– Les procédures qui modifient ou calculent des variables actives sont dites actives et
doivent être transposées.
– L’adjoint de l’appel à une subroutine est l’appel à la subroutine adjointe.
– Pour écrire la subroutine adjointe, on transpose les blocs qui la compose.
– Les variables dans les blocs “common” doivent être incluses, et pour les variables
actives il faut ajouter des blocs “common” pour les variables adjointes associées.
– Les arguments de la subroutine adjointe sont les variables requises parmi les variables
arguments de la routine directe pour calculer la procédure adjointe, ainsi que les
variables adjointes des variables actives arguments de la routine directe.
Il est recommandé de procéder de la manière suivante :
1. Identifier les variables actives (globales, locales, arguments).
2. Ecrire l’adjoint du bloc procédure.
3. Le précéder des déclarations et de la mise à zéro des variables adjointes locales.
4. Enfin, voir les arguments.

Exemple. Dans l’exemple suivant, les variables actives sont X, Y et Xnorm.
subroutine sub(X,Y,A)
implicit none
integer n,i,j
parameter n=100
real X(n),Y(n),A
real sumX,sumY,fac
real Xnorm
common /com1/ Xnorm
sumX = 0.
sumY = 0.
do i=1,n
sumX = sumX+X(i)
sumY = sumY+Y(i)
enddo
fac = sumX*sumY*Xnorm/A
do i=1,n
j = n+1-i
X(i) = fac*(X(i)^2+Y(j)^2)
enddo
end
On procède comme indiqué précédemment.

1. Variables actives : arguments X, Y, common Xnorm, locales sumX, sumY, fac.
2. Adjoint du bloc procédure. Pour cela, on appelle A le bloc :
sumX = 0.
sumY = 0.
do i=1,n
sumX = sumX+X(i)
sumY = sumY+Y(i)
enddo
On appelle B le bloc :
fac = sumX*sumY*Xnorm/A
Et enfin C :
do i=1,n
j = n+1-i
X(i) = fac*(X(i)^2+Y(j)^2)
enddo
On commence par C ∗ . Les variables requises sont X et Y (arguments) et fac (à
recalculer). Le bloc C ∗ doit donc être précédé des blocs A et B :

A
B
do i=n,1,-1
j = n+1-i
adfac = adfac + adX(i)*(X(i)^2+Y(j)^2)
adY(j) = adY(j)+2*Y(j)*fac*adX(i)
adX(i) = 2*X(i)*fac*adX(i)
enddo
Ensuite on passe au bloc B ∗ . Il nécessite sumX et sumY, qui ont déjà été recal-
culés avant le bloc C ∗ , et pas modifiés, donc on peut passer directement à B ∗ sans
recalculer le bloc A :
adsumX = adsumX + adfac*sumY*Xnorm/A
adsumY = adsumY + adfac*sumX*Xnorm/A
adXnorm = adXnorm + adfac*sumX*sumY/A
adfac = 0
Et enfin, pour A∗ on a :
do i=n,1,-1
adX(i) = adX(i) + adsumX
adY(i) = adY(i) + adsumY
enddo
adsumX = 0.
adsumY = 0.
3. Pour les déclarations, on conserve les variables requises de la routine directe, on
ajoute les adjoints des arguments actifs X et Y, on ajoute les adjoints des variables
locales actives sumX, sumY et fac, et enfin les adjoints des variables de common
actives Xnorm.
integer n,i,j
parameter n=100
real X(n),Y(n),A
real sumX,sumY,fac
real Xnorm
common /com1/ Xnorm
real adX(n),adY(n)
real adsumX,adsumY,adfac
real adXnorm
common /adcom1/ adXnorm
La mise à zéro des variables acitves locales est immédiate :
adsumX = 0
adsumY = 0
adfac = 0
4. Enfin, on identifie les arguments à conserver : les variables X, Y et A sont requises,
et adX et adY sont les variables adjointes des arguments actifs X et Y.
5. Il suffit maintenant de tout remettre en ordre :

subroutine adsub(X,Y,A,adX,adY)
declarations
mise a zero des variables actives locales
A, B, C*, B*, A*
end
L’adjoint d’une fonction est l’appel à une subroutine construite selon les mêmes règles
que précédemment, au détail près que l’on ajoute un argument suppémentaire à la su-
broutine adjointe, qui est l’adjoint du résultat de la fonction. Par exemple, le code
Z = fct(X,Y)
function fct(X,Y)
real X,Y,fct
fct = X^2+2*Y^2
end
a pour adjoint le code
call adfct(X,Y,adX,adY,adZ)
real X,Y,adX,adY,adZ
adX = adX + 2*X*adZ
adY = adY + 4*Y*adZ
end
adZ = 0
A.3.6 Entrées / sorties

Les entrées et sorties peuvent être vues comme des affectations selon la correspondance
suivante :
– write X ⇔ affecter X à une variable hypothétique : Xh = X
– read Z ⇔ affecter une valeur lue à Z : Z = Xh
Si des variables actives sont lues ou écrites, des variables adjointes doivent l’être aussi.
Les fichiers “actifs” sont donc doublés de fichiers adjoints.
Grâce à la correspondance ci-dessus, on peut donc écrire l’adjoint d’un bloc d’entrée /
sortie. Par exemple pour le bloc direct
open(1)
write(1) X
read(1) Z
close(1)
on peut écrire le bloc direct hypothétique associé :
local Xh
Xh = X
Z = Xh
Xh = 0
Doù l’adjoint hypothétique :

local adXh
adXh = 0
adXh = adXh + adZ
adZ = 0
adX = adX + adXh
adXh = 0
Que l’on peut simplifier en :
local adXh
adXh = adZ
adZ = 0
adX = adX + adXh
adXh = 0
Ce qui donne avec des entrées / sorties :
open(2)
write(2) adZ
adZ = 0
read(2) adXh
adX = adX + adXh
adXh = 0
close(2)
A.4 Exercices
Ecrire les adjoints des codes suivants
1. (x, y et z sont actives)
z = 2x^2+3*y/x+cos(y)*x
2. (x, y et z sont actives)
z = x*z + a*x*z
Vérifier que c’est équivalent à
h = x*z
z = h + a*x*y
3. (x et y actives)
do i =0,4
x(i) = y(i)*x(4-i)
enddo
Comparer à
do i =0,4
z(i) = y(i)*x(4-i)
enddo
do i =0,4
x(i) = z(i)
enddo

4. (x, y et z actives)
y = a/x^2
x = b*x+c*y
z = x*y
5. (x et u actives)
do i=1,n
x(i) = x(i-1) + h*f(x(i-1),u(i))
enddo
function f(y,v)
integer parameter n=3
real v(n)
real y
real a,b,c
a=0
b=1
c=2
f = v(1)*(y-b)*(y-c)/((a-b)*(a-c)) + ...
v(2)*(y-a)*(y-c)/((b-a)*(b-c)) + ...
v(3)*(y-a)*(y-b)/((c-a)*(c-b))
end

Methodes Inverses Var M2 Math PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Methodes Inverses Var M2 Math PDF

Transféré par

Droits d'auteur :

Formats disponibles

Introduction à l’assimilation de données variationnelle

Eric Blayo, Maëlle Nodet

version du 3 février 2010

Eric Blayo, Maëlle Nodet 1

4 Mise en œuvre de la méthode adjointe en pratique 35

5 Algorithmes d’assimilation de données variationnelle 41

Eric Blayo, Maëlle Nodet (Université de Grenoble) 2

A Régles d’écriture d’un code adjoint 58

Eric Blayo, Maëlle Nodet (Université de Grenoble) 3

1.1 Définitions, exemples

Exemple 1.1 – météorologie

Eric Blayo, Maëlle Nodet 4

1.2 Un exemple simple mais fondamental

1.2.1 Méthode naturelle

1.2.2 Formalisation statistique

E(x̂) = (α1 + α2 )x + α1 E(e1 ) + α2 E(e2 ) = (α1 + α2 )x

Eric Blayo, Maëlle Nodet (Université de Grenoble) 5

On obtient donc α1 + α2 = 1, ou encore α2 = 1 − α1 .

– Si on considère que y1 = xb est une première estimation de x et y2 = y une nouvelle

La valeur y − xb est appelée “innovation”, elle contient l’information supplémentaire

1.2.3 Méthodes d’assimilation de données

Eric Blayo, Maëlle Nodet (Université de Grenoble) 6

Points communs de ces méthodes :

Le modèle M fait évoluer l’état xi du temps i au temps i + 1 :

xi+1 = Mi,i+1 (xi )

Exemple 1.2 1. Le vecteur d’état x = (T1 , T2 , . . . , Tn )T représente la température sur

Eric Blayo, Maëlle Nodet (Université de Grenoble) 7

1.3.3 Statistiques d’erreurs

Les diverses erreurs qui nous intéressent sont :

1.3.4 Fonction coût

Exemple 1.3 Trouver (x1 , x2 ) avec l’observation x1 + x2 = 2. Il existe une infinité de

On va faire l’équivalent en utilisant toutes les informations possibles :

Eric Blayo, Maëlle Nodet (Université de Grenoble) 8

Si le modèle et l’opérateur d’observation sont linéaires, alors J est quadratique et son

Attention : Lorsque la fonctionnelle est choisie (ébauche, normes), le problème est

1.4 Historique de l’assimilation de données

1.4.2 Analyse de Cressman

1.4.3 Nudging (ou relaxation newtonienne)

1.4.4 Méthodes variationnelles

Eric Blayo, Maëlle Nodet (Université de Grenoble) 9

Eric Blayo, Maëlle Nodet 10

Problème 2.1 Trouver u ∈ U tel que

J(u) = min J(v)

Le problème, en assimilation de données, vient généralement du fait que J ne dépend

Exemple 2.3 1. Dans Rn , on a le produit scalaire euclidien usuel :

2. Toujours dans Rn , si A est une matrice symétrique définie positive :

3. Dans L2 (Ω), où Ω est un ouvert de R, on a pour f et g deux fonctions de L2 (Ω) :

Exemple 2.5 On reprend les précédents

Eric Blayo, Maëlle Nodet (Université de Grenoble) 11

1. Dans Rn , on a la norme euclidienne :

2. Toujours dans Rn , si A est une matrice symétrique définie positive :

3. Dans L2 (Ω), où Ω est un ouvert de R, on a pour f ∈ L2 (Ω) :

2.2.2 Définitions utiles en optimisation

Définition 2.8 On dit que x̄ est un minimum global de f si

Définition 2.9 On dit que x̄ est un minimum local de f si il existe un voisinage V de x̄

Définition 2.10 L’ensemble F est convexe si

∀x1 , x2 ∈ F, ∀α ∈ [0, 1] : αx1 + (1 − α)x2 ∈ F

Définition 2.11 La fonction f est convexe si E est convexe et si

∀x1 , x2 ∈ F, ∀α ∈ [0, 1] : f (αx1 + (1 − α)x2 ) ≤ αf (x1 ) + (1 − α)f (x2 )

f est dite strictement convexe si

∀x1 , x2 ∈ F, ∀α ∈ [0, 1] : f (αx1 + (1 − α)x2 ) < αf (x1 ) + (1 − α)f (x2 )

Eric Blayo, Maëlle Nodet (Université de Grenoble) 12

2.2.3 Dérivée directionnelle