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 chaque
 116     variable d'état optimisée. Les bornes doivent être données par une liste de
 117     liste de paires de bornes inférieure/supérieure pour chaque variable, avec
 118     une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes
 119     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", "CostFunctionJAtCurrentOptimum",
 167     "CostFunctionJbAtCurrentOptimum", "CostFunctionJoAtCurrentOptimum",
 168     "CurrentState", "CurrentOptimum", "IndexOfOptimum", "Innovation",
 169     "InnovationAtCurrentState", "OMA", "OMB",
 170     "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState",
 171     "SimulatedObservationAtOptimum", "SimulatedObservationAtCurrentOptimum"].
 172
 173     Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
 174
 175 *Astuce pour cet algorithme :*
 176
 177     Comme la commande *"BackgroundError"* est requise pour TOUS les algorithmes
 178     de calcul dans l'interface, vous devez fournir une valeur, malgré le fait
 179     que cette commande n'est pas requise pour cet algorithme, et ne sera pas
 180     utilisée. La manière la plus simple est de donner "1" comme un STRING.
 181
 182 Informations et variables disponibles à la fin de l'algorithme
 183 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 184
 185 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 186 variables issues du calcul. La description des
 187 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 188 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 189 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 190 l'écriture des procédures de post-processing, sont décrites dans
 191 l':ref:`subsection_r_o_v_Inventaire`.
 192
 193 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 194
 195   Analysis
 196     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 197     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 198     données.
 199
 200     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 201
 202   CostFunctionJ
 203     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 204     :math:`J`.
 205
 206     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 207
 208   CostFunctionJb
 209     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 210     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 211
 212     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 213
 214   CostFunctionJo
 215     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 216     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 217
 218     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 219
 220 Les sorties conditionnelles de l'algorithme sont les suivantes:
 221
 222   BMA
 223     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 224     l'ébauche et l'état optimal.
 225
 226     Exemple : ``bma = ADD.get("BMA")[-1]``
 227
 228   CurrentState
 229     *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
 230     au cours du déroulement de l'algorithme d'optimisation.
 231
 232     Exemple : ``Xs = ADD.get("CurrentState")[:]``
 233
 234   IndexOfOptimum
 235     *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
 236     obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
 237     nécessairement le numéro de la dernière itération.
 238
 239     Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
 240
 241   Innovation
 242     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 243     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 244     d'évolution.
 245
 246     Exemple : ``d = ADD.get("Innovation")[-1]``
 247
 248   InnovationAtCurrentState
 249     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
 250     courant.
 251
 252     Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
 253
 254   OMA
 255     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 256     l'observation et l'état optimal dans l'espace des observations.
 257
 258     Exemple : ``oma = ADD.get("OMA")[-1]``
 259
 260   OMB
 261     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 262     l'observation et l'état d'ébauche dans l'espace des observations.
 263
 264     Exemple : ``omb = ADD.get("OMB")[-1]``
 265
 266   SimulatedObservationAtBackground
 267     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 268     partir de l'ébauche :math:`\mathbf{x}^b`.
 269
 270     Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
 271
 272   SimulatedObservationAtCurrentOptimum
 273     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 274     partir de l'état optimal au pas de temps courant au cours du déroulement de
 275     l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations.
 276
 277     Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
 278
 279   SimulatedObservationAtCurrentState
 280     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 281     partir de l'état courant, c'est-à-dire dans l'espace des observations.
 282
 283     Exemple : ``hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]``
 284
 285   SimulatedObservationAtOptimum
 286     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 287     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 288
 289     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 290
 291 Voir aussi
 292 ++++++++++
 293
 294 Références vers d'autres sections :
 295   - :ref:`section_ref_algorithm_3DVAR`
 296
 297 Références bibliographiques :
 298   - [Byrd95]_
 299   - [Morales11]_
 300   - [Zhu97]_