doc/fr/ref_algorithm_ParticleSwarmOptimization.rst

   1 ..
   2    Copyright (C) 2008-2015 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: ParticleSwarmOptimization
  25 .. _section_ref_algorithm_ParticleSwarmOptimization:
  26
  27 Algorithme de calcul "*ParticleSwarmOptimization*"
  28 --------------------------------------------------
  29
  30 Description
  31 +++++++++++
  32
  33 Cet algorithme réalise une estimation de l'état d'un système dynamique par
  34 minimisation d'une fonctionnelle d'écart :math:`J` en utilisant un essaim
  35 particulaire. C'est une méthode qui n'utilise pas les dérivées de la
  36 fonctionnelle d'écart. Elle entre dans la même catégorie que
  37 l':ref:`section_ref_algorithm_DerivativeFreeOptimization`.
  38
  39 C'est une méthode d'optimisation permettant la recherche du minimum global d'une
  40 fonctionnelle d'erreur :math:`J` quelconque de type :math:`L^1`, :math:`L^2` ou
  41 :math:`L^{\infty}`, avec ou sans pondérations. La fonctionnelle d'erreur par
  42 défaut est celle de moindres carrés pondérés augmentés, classiquement utilisée
  43 en assimilation de données.
  44
  45 Commandes requises et optionnelles
  46 ++++++++++++++++++++++++++++++++++
  47
  48 .. index:: single: AlgorithmParameters
  49 .. index:: single: Background
  50 .. index:: single: BackgroundError
  51 .. index:: single: Observation
  52 .. index:: single: ObservationError
  53 .. index:: single: ObservationOperator
  54 .. index:: single: MaximumNumberOfSteps
  55 .. index:: single: NumberOfInsects
  56 .. index:: single: SwarmVelocity
  57 .. index:: single: GroupRecallRate
  58 .. index:: single: QualityCriterion
  59 .. index:: single: BoxBounds
  60 .. index:: single: SetSeed
  61 .. index:: single: StoreSupplementaryCalculations
  62
  63 Les commandes requises générales, disponibles dans l'interface en édition, sont
  64 les suivantes:
  65
  66   Background
  67     *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
  68     d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
  69     définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
  70
  71   BackgroundError
  72     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  73     d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie
  74     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  75     type "*DiagonalSparseMatrix*".
  76
  77   Observation
  78     *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
  79     assimilation de données ou en optimisation, et noté précédemment
  80     :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
  81     ou de type "*VectorSerie*".
  82
  83   ObservationError
  84     *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
  85     d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
  86     comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
  87     type "*DiagonalSparseMatrix*".
  88
  89   ObservationOperator
  90     *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
  91     précédemment :math:`H`, qui transforme les paramètres d'entrée
  92     :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
  93     observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
  94     type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
  95     différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
  96     la section :ref:`section_ref_operator_requirements`. Si un contrôle
  97     :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
  98     appliqué à une paire :math:`(X,U)`.
  99
 100 Les commandes optionnelles générales, disponibles dans l'interface en édition,
 101 sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les
 102 paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les
 103 options particulières, décrites ci-après, de l'algorithme. On se reportera à la
 104 :ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette
 105 commande.
 106
 107 Les options de l'algorithme sont les suivantes:
 108
 109   MaximumNumberOfSteps
 110     Cette clé indique le nombre maximum d'itérations possibles en optimisation
 111     itérative. Le défaut est 50, qui est une limite arbitraire. Il est ainsi
 112     recommandé d'adapter ce paramètre aux besoins pour des problèmes réels.
 113
 114     Exemple : ``{"MaximumNumberOfSteps":100}``
 115
 116   NumberOfInsects
 117     Cette clé indique le nombre d'insectes ou de particules dans l'essaim. La
 118     valeur par défaut est 100, qui est une valeur par défaut usuelle pour cet
 119     algorithme.
 120
 121     Exemple : ``{"NumberOfInsects":100}``
 122
 123   SwarmVelocity
 124     Cette clé indique la part de la vitesse d'insecte qui est imposée par
 125     l'essaim. C'est une valeur réelle positive. Le défaut est de 1.
 126
 127     Exemple : ``{"SwarmVelocity":1.}``
 128
 129   GroupRecallRate
 130     Cette clé indique le taux de rappel vers le meilleur insecte de l'essaim.
 131     C'est une valeur réelle comprise entre 0 et 1. Le défaut est de 0.5.
 132
 133     Exemple : ``{"GroupRecallRate":0.5}``
 134
 135   QualityCriterion
 136     Cette clé indique le critère de qualité, qui est minimisé pour trouver
 137     l'estimation optimale de l'état. Le défaut est le critère usuel de
 138     l'assimilation de données nommé "DA", qui est le critère de moindres carrés
 139     pondérés augmentés. Les critères possibles sont dans la liste suivante, dans
 140     laquelle les noms équivalents sont indiqués par un signe "=" :
 141     ["AugmentedWeightedLeastSquares"="AWLS"="DA", "WeightedLeastSquares"="WLS",
 142     "LeastSquares"="LS"="L2", "AbsoluteValue"="L1",  "MaximumError"="ME"].
 143
 144     Exemple : ``{"QualityCriterion":"DA"}``
 145
 146   BoxBounds
 147     Cette clé permet de définir des bornes supérieure et inférieure pour chaque
 148     incrément de  variable d'état optimisée (et non pas chaque variable d'état
 149     elle-même). Les bornes doivent être données par une liste de liste de paires
 150     de bornes inférieure/supérieure pour chaque incrément de variable, avec une
 151     valeur extrême chaque fois qu'il n'y a pas de borne (``None`` n'est pas une
 152     valeur autorisée lorsqu'il n'y a pas de borne). Cette clé est requise et il
 153     n'y a pas de valeurs par défaut.
 154
 155     Exemple : ``{"BoxBounds":[[-0.5,0.5], [0.01,2.], [0.,1.e99], [-1.e99,1.e99]]}``
 156
 157   SetSeed
 158     Cette clé permet de donner un nombre entier pour fixer la graine du
 159     générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est
 160     par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle
 161     utilise ainsi l'initialisation par défaut de l'ordinateur.
 162
 163     Exemple : ``{"SetSeed":1000}``
 164
 165   StoreSupplementaryCalculations
 166     Cette liste indique les noms des variables supplémentaires qui peuvent être
 167     disponibles à la fin de l'algorithme. Cela implique potentiellement des
 168     calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
 169     aucune de ces variables n'étant calculée et stockée par défaut. Les noms
 170     possibles sont dans la liste suivante : ["BMA", "CostFunctionJ",
 171     "CurrentState", "OMA", "OMB", "Innovation",
 172     "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentState",
 173     "SimulatedObservationAtOptimum"].
 174
 175     Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
 176
 177 Informations et variables disponibles à la fin de l'algorithme
 178 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 179
 180 En sortie, après exécution de l'algorithme, on dispose d'informations et de
 181 variables issues du calcul. La description des
 182 :ref:`section_ref_output_variables` indique la manière de les obtenir par la
 183 méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
 184 d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
 185 l'écriture des procédures de post-processing, sont décrites dans
 186 l':ref:`subsection_r_o_v_Inventaire`.
 187
 188 Les sorties non conditionnelles de l'algorithme sont les suivantes:
 189
 190   Analysis
 191     *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
 192     en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
 193     données.
 194
 195     Exemple : ``Xa = ADD.get("Analysis")[-1]``
 196
 197   CostFunctionJ
 198     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 199     :math:`J`.
 200
 201     Exemple : ``J = ADD.get("CostFunctionJ")[:]``
 202
 203   CostFunctionJb
 204     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 205     :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
 206
 207     Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
 208
 209   CostFunctionJo
 210     *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
 211     :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
 212
 213     Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
 214
 215 Les sorties conditionnelles de l'algorithme sont les suivantes:
 216
 217   BMA
 218     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 219     l'ébauche et l'état optimal.
 220
 221     Exemple : ``bma = ADD.get("BMA")[-1]``
 222
 223   CurrentState
 224     *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
 225     au cours du déroulement de l'algorithme d'optimisation.
 226
 227     Exemple : ``Xs = ADD.get("CurrentState")[:]``
 228
 229   Innovation
 230     *Liste de vecteurs*. Chaque élément est un vecteur d'innovation, qui est
 231     en statique l'écart de l'optimum à l'ébauche, et en dynamique l'incrément
 232     d'évolution.
 233
 234     Exemple : ``d = ADD.get("Innovation")[-1]``
 235
 236   OMA
 237     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 238     l'observation et l'état optimal dans l'espace des observations.
 239
 240     Exemple : ``oma = ADD.get("OMA")[-1]``
 241
 242   OMB
 243     *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
 244     l'observation et l'état d'ébauche dans l'espace des observations.
 245
 246     Exemple : ``omb = ADD.get("OMB")[-1]``
 247
 248   SimulatedObservationAtBackground
 249     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 250     partir de l'ébauche :math:`\mathbf{x}^b`.
 251
 252     Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
 253
 254   SimulatedObservationAtCurrentState
 255     *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant,
 256     c'est-à-dire dans l'espace des observations.
 257
 258     Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]``
 259
 260   SimulatedObservationAtOptimum
 261     *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
 262     partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
 263
 264     Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
 265
 266 Voir aussi
 267 ++++++++++
 268
 269 Références vers d'autres sections :
 270   - :ref:`section_ref_algorithm_DerivativeFreeOptimization`
 271
 272 Références bibliographiques :
 273   - [WikipediaPSO]_