doc/fr/ref_algorithm_NonLinearLeastSquares.rst

   1 ..
   2    Copyright (C) 2008-2017 EDF R&D
   3
   4    This file is part of SALOME ADAO module.
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this library; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19
  20    See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21
  22    Author: Jean-Philippe Argaud, jean-philippe.argaud@edf.fr, EDF R&D
  23
  24 .. index:: single: NonLinearLeastSquares
  25 .. _section_ref_algorithm_NonLinearLeastSquares:
  26
  27 Algorithme de calcul "*NonLinearLeastSquares*"
  28 ----------------------------------------------
  29
  30 Description
  31 +++++++++++
  32
  33 Cet algorithme réalise une estimation d'état par minimisation variationnelle de
  34 la fonctionnelle :math:`J` d'écart classique de "Moindres Carrés" pondérés:
  35
  36 .. math:: J(\mathbf{x})=(\mathbf{y}^o-\mathbf{H}.\mathbf{x})^T.\mathbf{R}^{-1}.(\mathbf{y}^o-\mathbf{H}.\mathbf{x})
  37
  38 Il est similaire à l':ref:`section_ref_algorithm_3DVAR` privé de sa partie
  39 ébauche. L'ébauche, requise dans l'interface, ne sert que de point initial pour
  40 la minimisation variationnelle.
  41
  42 Dans tous les cas, il est recommandé de lui préférer
  43 l':ref:`section_ref_algorithm_3DVAR` pour sa stabilité comme pour son
  44 comportement lors de l'optimisation.
  45
  46 Commandes requises et optionnelles
  47 ++++++++++++++++++++++++++++++++++
  48
  49 .. index:: single: AlgorithmParameters
  50 .. index:: single: Background
  51 .. index:: single: Observation
  52 .. index:: single: ObservationError
  53 .. index:: single: ObservationOperator
  54 .. index:: single: Minimizer
  55 .. index:: single: Bounds
  56 .. index:: single: MaximumNumberOfSteps
  57 .. index:: single: CostDecrementTolerance
  58 .. index:: single: ProjectedGradientTolerance
  59 .. index:: single: GradientNormTolerance
  60 .. index:: single: StoreSupplementaryCalculations
  61
  62 Les commandes requises générales, disponibles dans l'interface en édition, sont
  63 les suivantes:
  64
  65   Background
  66     *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
  67     d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
  68     définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
  69
  70   Observation
  71     *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
  72     assimilation de données ou en optimisation, et noté précédemment
  73     :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
  74     ou de type "*VectorSerie*".
  75
  76   ObservationError
  77     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  78     d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
  79     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  80     type "*DiagonalSparseMatrix*".
  81
  82   ObservationOperator
  83     *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
  84     précédemment :math:`H`, qui transforme les paramètres d'entrée
  85     :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
  86     observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
  87     type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
  88     différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
  89     la section :ref:`section_ref_operator_requirements`. Si un contrôle
  90     :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
  91     appliqué à une paire :math:`(X,U)`.
  92
  93 Les commandes optionnelles générales, disponibles dans l'interface en édition,
  94 sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les
  95 paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les
  96 options particulières, décrites ci-après, de l'algorithme. On se reportera à la
  97 :ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette
  98 commande.
  99
 100 Les options de l'algorithme sont les suivantes:
 101
 102   Minimizer
 103     Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
 104     défaut est "LBFGSB", et les choix possibles sont "LBFGSB" (minimisation non
 105     linéaire sous contraintes, voir [Byrd95]_, [Morales11]_ et [Zhu97]_), "TNC"
 106     (minimisation non linéaire sous contraintes), "CG" (minimisation non
 107     linéaire sans contraintes), "BFGS" (minimisation non linéaire sans
 108     contraintes), "NCG" (minimisation de type gradient conjugué de Newton), "LM"
 109     (minimisation non linéaire de type Levenberg-Marquard). Il est fortement
 110     conseillé de conserver la valeur par défaut.
 111
 112     Exemple : ``{"Minimizer":"LBFGSB"}``
 113
 114   Bounds
 115     Cette clé permet de définir des bornes supérieure et inférieure pour
 116     chaque variable d'état optimisée. Les bornes doivent être données par une
 117     liste de liste de paires de bornes inférieure/supérieure pour chaque
 118     variable, avec une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les
 119     bornes peuvent toujours être spécifiées, mais seuls les optimiseurs sous
 120     contraintes les prennent en compte.
 121
 122     Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
 123
 124   MaximumNumberOfSteps
 125     Cette clé indique le nombre maximum d'itérations possibles en optimisation
 126     itérative. Le défaut est 15000, qui est très similaire à une absence de
 127     limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre
 128     aux besoins pour des problèmes réels. Pour certains optimiseurs, le nombre
 129     de pas effectif d'arrêt peut être légèrement différent de la limite à cause
 130     d'exigences de contrôle interne de l'algorithme.
 131
 132     Exemple : ``{"MaximumNumberOfSteps":100}``
 133
 134   CostDecrementTolerance
 135     Cette clé indique une valeur limite, conduisant à arrêter le processus
 136     itératif d'optimisation lorsque la fonction coût décroît moins que cette
 137     tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
 138     de l'adapter aux besoins pour des problèmes réels.
 139
 140     Exemple : ``{"CostDecrementTolerance":1.e-7}``
 141
 142   ProjectedGradientTolerance
 143     Cette clé indique une valeur limite, conduisant à arrêter le processus
 144     itératif d'optimisation lorsque toutes les composantes du gradient projeté
 145     sont en-dessous de cette limite. C'est utilisé uniquement par les
 146     optimiseurs sous contraintes. Le défaut est -1, qui désigne le défaut
 147     interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé
 148     de le changer.
 149
 150     Exemple : ``{"ProjectedGradientTolerance":-1}``
 151
 152   GradientNormTolerance
 153     Cette clé indique une valeur limite, conduisant à arrêter le processus
 154     itératif d'optimisation lorsque la norme du gradient est en dessous de cette
 155     limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le
 156     défaut est 1.e-5 et il n'est pas recommandé de le changer.
 157
 158     Exemple : ``{"GradientNormTolerance":1.e-5}``
 159
 160   StoreSupplementaryCalculations
 161     Cette liste indique les noms des variables supplémentaires qui peuvent être
 162     disponibles à la fin de l'algorithme. Cela implique potentiellement des
 163     calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
 164     aucune de ces variables n'étant calculée et stockée par défaut. Les noms
 165     possibles sont dans la liste suivante : ["BMA", "CostFunctionJ",
 166     "CostFunctionJb", "CostFunctionJo", "CurrentState", "OMA", "OMB",
 167     "Innovation", "SimulatedObservationAtCurrentState",
 168     "SimulatedObservationAtOptimum"].
 169
 170     Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
 171
 172 *Astuce pour cet algorithme :*
 173
 174     Comme la commande *"BackgroundError"* est requise pour TOUS les algorithmes
 175     de calcul dans l'interface, vous devez fournir une valeur, malgré le fait
 176     que cette commande n'est pas requise pour cet algorithme, et ne sera pas
 177     utilisée. La manière la plus simple est de donner "1" comme un STRING.
 178
 179 Informations et variables disponibles à la fin de l'algorithme
 180 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 181
 182 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 183 variables issues du calcul. La description des
 184 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 185 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 186 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 187 l'écriture des procédures de post-processing, sont décrites dans
 188 l':ref:`subsection_r_o_v_Inventaire`.
 189
 190 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 191
 192   Analysis
 193     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 194     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 195     données.
 196
 197     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 198
 199   CostFunctionJ
 200     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 201     :math:`J`.
 202
 203     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 204
 205   CostFunctionJb
 206     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 207     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 208
 209     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 210
 211   CostFunctionJo
 212     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 213     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 214
 215     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 216
 217 Les sorties conditionnelles de l'algorithme sont les suivantes:
 218
 219   BMA
 220     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 221     l'ébauche et l'état optimal.
 222
 223     Exemple : ``bma = ADD.get("BMA")[-1]``
 224
 225   CurrentState
 226     *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
 227     au cours du déroulement de l'algorithme d'optimisation.
 228
 229     Exemple : ``Xs = ADD.get("CurrentState")[:]``
 230
 231   Innovation
 232     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 233     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 234     d'évolution.
 235
 236     Exemple : ``d = ADD.get("Innovation")[-1]``
 237
 238   OMA
 239     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 240     l'observation et l'état optimal dans l'espace des observations.
 241
 242     Exemple : ``oma = ADD.get("OMA")[-1]``
 243
 244   OMB
 245     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 246     l'observation et l'état d'ébauche dans l'espace des observations.
 247
 248     Exemple : ``omb = ADD.get("OMB")[-1]``
 249
 250   SimulatedObservationAtCurrentState
 251     *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant,
 252     c'est-à-dire dans l'espace des observations.
 253
 254     Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]``
 255
 256   SimulatedObservationAtOptimum
 257     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 258     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 259
 260     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 261
 262 Voir aussi
 263 ++++++++++
 264
 265 Références vers d'autres sections :
 266   - :ref:`section_ref_algorithm_3DVAR`
 267
 268 Références bibliographiques :
 269   - [Byrd95]_
 270   - [Morales11]_
 271   - [Zhu97]_