..
- Copyright (C) 2008-2017 EDF R&D
+ Copyright (C) 2008-2021 EDF R&D
This file is part of SALOME ADAO module.
.. _section_ref_algorithm_DerivativeFreeOptimization:
Algorithme de calcul "*DerivativeFreeOptimization*"
-----------------------------------------------------
+---------------------------------------------------
-.. warning::
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo01.rst
- dans sa présente version, cet algorithme est expérimental, et reste donc
- susceptible de changements dans les prochaines versions.
-
-Description
-+++++++++++
-
-Cet algorithme réalise une estimation d'état d'un système par minimisation d'une
-fonctionnelle d'écart :math:`J` sans gradient. C'est une méthode qui n'utilise
-pas les dérivées de la fonctionnelle d'écart. Elle entre, par exemple, dans la
-même catégorie que l':ref:`section_ref_algorithm_ParticleSwarmOptimization`.
+Cet algorithme réalise une estimation d'état d'un système par minimisation
+d'une fonctionnelle d'écart :math:`J` sans gradient. C'est une méthode qui
+n'utilise pas les dérivées de la fonctionnelle d'écart. Elle entre, par
+exemple, dans la même catégorie que
+l':ref:`section_ref_algorithm_ParticleSwarmOptimization`,
+l':ref:`section_ref_algorithm_DifferentialEvolution` ou
+l':ref:`section_ref_algorithm_TabuSearch`.
C'est une méthode d'optimisation permettant la recherche du minimum global d'une
fonctionnelle d'erreur :math:`J` quelconque de type :math:`L^1`, :math:`L^2` ou
défaut est celle de moindres carrés pondérés augmentés, classiquement utilisée
en assimilation de données.
-Commandes requises et optionnelles
-++++++++++++++++++++++++++++++++++
-
-.. index:: single: AlgorithmParameters
-.. index:: single: Background
-.. index:: single: BackgroundError
-.. index:: single: Observation
-.. index:: single: ObservationError
-.. index:: single: ObservationOperator
-.. index:: single: Minimizer
-.. index:: single: MaximumNumberOfSteps
-.. index:: single: MaximumNumberOfFunctionEvaluations
-.. index:: single: StateVariationTolerance
-.. index:: single: CostDecrementTolerance
-.. index:: single: QualityCriterion
-.. index:: single: StoreSupplementaryCalculations
-
-Les commandes requises générales, disponibles dans l'interface en édition, sont
-les suivantes:
-
- Background
- *Commande obligatoire*. Elle définit le vecteur d'ébauche ou
- d'initialisation, noté précédemment :math:`\mathbf{x}^b`. Sa valeur est
- définie comme un objet de type "*Vector*" ou de type "*VectorSerie*".
-
- BackgroundError
- *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
- d'ébauche, notée précédemment :math:`\mathbf{B}`. Sa valeur est définie
- comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
- type "*DiagonalSparseMatrix*".
-
- Observation
- *Commande obligatoire*. Elle définit le vecteur d'observation utilisé en
- assimilation de données ou en optimisation, et noté précédemment
- :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de type "*Vector*"
- ou de type "*VectorSerie*".
-
- ObservationError
- *Commande obligatoire*. Elle définit la matrice de covariance des erreurs
- d'ébauche, notée précédemment :math:`\mathbf{R}`. Sa valeur est définie
- comme un objet de type "*Matrix*", de type "*ScalarSparseMatrix*", ou de
- type "*DiagonalSparseMatrix*".
-
- ObservationOperator
- *Commande obligatoire*. Elle indique l'opérateur d'observation, noté
- précédemment :math:`H`, qui transforme les paramètres d'entrée
- :math:`\mathbf{x}` en résultats :math:`\mathbf{y}` qui sont à comparer aux
- observations :math:`\mathbf{y}^o`. Sa valeur est définie comme un objet de
- type "*Function*" ou de type "*Matrix*". Dans le cas du type "*Function*",
- différentes formes fonctionnelles peuvent être utilisées, comme décrit dans
- la section :ref:`section_ref_operator_requirements`. Si un contrôle
- :math:`U` est inclus dans le modèle d'observation, l'opérateur doit être
- appliqué à une paire :math:`(X,U)`.
-
-Les commandes optionnelles générales, disponibles dans l'interface en édition,
-sont indiquées dans la :ref:`section_ref_assimilation_keywords`. De plus, les
-paramètres de la commande "*AlgorithmParameters*" permettent d'indiquer les
-options particulières, décrites ci-après, de l'algorithme. On se reportera à la
-:ref:`section_ref_options_Algorithm_Parameters` pour le bon usage de cette
-commande.
-
-Les options de l'algorithme sont les suivantes:
-
- Minimizer
- Cette clé permet de changer le minimiseur pour l'optimiseur. Le choix par
- défaut est "BOBYQA", et les choix possibles sont
- "BOBYQA" (minimisation avec ou sans contraintes par approximation quadratique [Powell09]_),
- "COBYLA" (minimisation avec ou sans contraintes par approximation linéaire [Powell94]_ [Powell98]_).
- "NEWUOA" (minimisation avec ou sans contraintes par approximation quadratique itérative [Powell04]_),
- "POWELL" (minimisation sans contraintes de type directions conjuguées [Powell64]_),
- "SIMPLEX" (minimisation avec ou sans contraintes de type simplexe ou Nelder-Mead, voir [Nelder65]_),
- "SUBPLEX" (minimisation avec ou sans contraintes de type simplexe sur une suite de sous-espaces [Rowan90]_).
- Remarque : la méthode "POWELL" effectue une optimisation par boucles
- imbriquées interne/externe, conduisant ainsi à un contrôle relaché du
- nombre d'évaluations de la fonctionnelle à optimiser. Si un contrôle précis
- du nombre d'évaluations de cette fonctionnelle est requis, il faut choisir
- un autre minimiseur.
-
- Exemple : ``{"Minimizer":"BOBYQA"}``
-
- Bounds
- Cette clé permet de définir des bornes supérieure et inférieure pour chaque
- variable d'état optimisée. Les bornes doivent être données par une liste de
- liste de paires de bornes inférieure/supérieure pour chaque variable, avec
- une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent
- toujours être spécifiées, mais seuls les optimiseurs sous contraintes les
- prennent en compte.
-
- Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}``
-
- MaximumNumberOfSteps
- Cette clé indique le nombre maximum d'itérations possibles en optimisation
- itérative. Le défaut est 15000, qui est une limite arbitraire. Il est ainsi
- fortement recommandé d'adapter ce paramètre aux besoins pour des problèmes
- réels. Pour certains optimiseurs, le nombre de pas effectif d'arrêt peut
- être légèrement différent de la limite à cause d'exigences de contrôle
- interne de l'algorithme.
-
- Exemple : ``{"MaximumNumberOfSteps":50}``
-
- MaximumNumberOfFunctionEvaluations
- Cette clé indique le nombre maximum d'évaluations possibles de la
- fonctionnelle à optimiser. Le défaut est de 15000, qui est une limite
- arbitraire. Il est ainsi recommandé d'adapter ce paramètre aux besoins pour
- des problèmes réels. Pour certains optimiseurs, le nombre effectif
- d'évaluations à l'arrêt peut être légèrement différent de la limite à cause
- d'exigences de déroulement interne de l'algorithme.
-
- Exemple : ``{"MaximumNumberOfFunctionEvaluations":50}``
-
- StateVariationTolerance
- Cette clé indique la variation relative maximale de l'état lors pour l'arrêt
- par convergence sur l'état. Le défaut est de 1.e-4, et il est recommandé
- de l'adapter aux besoins pour des problèmes réels.
-
- Exemple : ``{"StateVariationTolerance":1.e-4}``
-
- CostDecrementTolerance
- Cette clé indique une valeur limite, conduisant à arrêter le processus
- itératif d'optimisation lorsque la fonction coût décroît moins que cette
- tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé
- de l'adapter aux besoins pour des problèmes réels.
-
- Exemple : ``{"CostDecrementTolerance":1.e-7}``
-
- QualityCriterion
- Cette clé indique le critère de qualité, qui est minimisé pour trouver
- l'estimation optimale de l'état. Le défaut est le critère usuel de
- l'assimilation de données nommé "DA", qui est le critère de moindres carrés
- pondérés augmentés. Les critères possibles sont dans la liste suivante, dans
- laquelle les noms équivalents sont indiqués par un signe "=" :
- ["AugmentedWeightedLeastSquares"="AWLS"="DA", "WeightedLeastSquares"="WLS",
- "LeastSquares"="LS"="L2", "AbsoluteValue"="L1", "MaximumError"="ME"].
-
- Exemple : ``{"QualityCriterion":"DA"}``
-
- StoreSupplementaryCalculations
- Cette liste indique les noms des variables supplémentaires qui peuvent être
- disponibles à la fin de l'algorithme. Cela implique potentiellement des
- calculs ou du stockage coûteux. La valeur par défaut est une liste vide,
- aucune de ces variables n'étant calculée et stockée par défaut. Les noms
- possibles sont dans la liste suivante : ["BMA", "CostFunctionJ",
- "CostFunctionJb", "CostFunctionJo", "CostFunctionJAtCurrentOptimum",
- "CostFunctionJbAtCurrentOptimum", "CostFunctionJoAtCurrentOptimum",
- "CurrentOptimum", "CurrentState", "IndexOfOptimum",
- "InnovationAtCurrentState", "OMA", "OMB",
- "SimulatedObservationAtBackground", "SimulatedObservationAtCurrentOptimum",
- "SimulatedObservationAtCurrentState", "SimulatedObservationAtOptimum"].
-
- Exemple : ``{"StoreSupplementaryCalculations":["BMA", "Innovation"]}``
-
-Informations et variables disponibles à la fin de l'algorithme
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo02.rst
+
+.. include:: snippets/Background.rst
+
+.. include:: snippets/BackgroundError.rst
+
+.. include:: snippets/Observation.rst
+
+.. include:: snippets/ObservationError.rst
+
+.. include:: snippets/ObservationOperator.rst
+
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo03AdOp.rst
+
+.. include:: snippets/Minimizer_DFO.rst
-En sortie, après exécution de l'algorithme, on dispose d'informations et de
-variables issues du calcul. La description des
-:ref:`section_ref_output_variables` indique la manière de les obtenir par la
-méthode nommée ``get`` de la variable "*ADD*" du post-processing. Les variables
-d'entrée, mises à disposition de l'utilisateur en sortie pour faciliter
-l'écriture des procédures de post-processing, sont décrites dans
-l':ref:`subsection_r_o_v_Inventaire`.
+.. include:: snippets/BoundsWithNone.rst
-Les sorties non conditionnelles de l'algorithme sont les suivantes:
+.. include:: snippets/MaximumNumberOfSteps.rst
- Analysis
- *Liste de vecteurs*. Chaque élément est un état optimal :math:`\mathbf{x}*`
- en optimisation ou une analyse :math:`\mathbf{x}^a` en assimilation de
- données.
+.. include:: snippets/MaximumNumberOfFunctionEvaluations.rst
- Exemple : ``Xa = ADD.get("Analysis")[-1]``
+.. include:: snippets/StateVariationTolerance.rst
- CostFunctionJ
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`.
+.. include:: snippets/CostDecrementTolerance.rst
- Exemple : ``J = ADD.get("CostFunctionJ")[:]``
+.. include:: snippets/QualityCriterion.rst
- CostFunctionJb
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche.
+StoreSupplementaryCalculations
+ .. index:: single: StoreSupplementaryCalculations
- Exemple : ``Jb = ADD.get("CostFunctionJb")[:]``
+ *Liste de noms*. Cette liste indique les noms des variables supplémentaires
+ qui peuvent être disponibles au cours du déroulement ou à la fin de
+ l'algorithme, si elles sont initialement demandées par l'utilisateur. Cela
+ implique potentiellement des calculs ou du stockage coûteux. La valeur par
+ défaut est une liste vide, aucune de ces variables n'étant calculée et
+ stockée par défaut sauf les variables inconditionnelles. Les noms possibles
+ sont dans la liste suivante : [
+ "Analysis",
+ "BMA",
+ "CostFunctionJ",
+ "CostFunctionJb",
+ "CostFunctionJo",
+ "CostFunctionJAtCurrentOptimum",
+ "CostFunctionJbAtCurrentOptimum",
+ "CostFunctionJoAtCurrentOptimum",
+ "CurrentIterationNumber",
+ "CurrentOptimum",
+ "CurrentState",
+ "IndexOfOptimum",
+ "Innovation",
+ "InnovationAtCurrentState",
+ "OMA",
+ "OMB",
+ "SimulatedObservationAtBackground",
+ "SimulatedObservationAtCurrentOptimum",
+ "SimulatedObservationAtCurrentState",
+ "SimulatedObservationAtOptimum",
+ ].
- CostFunctionJo
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^o`, c'est-à-dire de la partie écart à l'observation.
+ Exemple :
+ ``{"StoreSupplementaryCalculations":["BMA", "CurrentState"]}``
- Exemple : ``Jo = ADD.get("CostFunctionJo")[:]``
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo04.rst
- CurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'état courant utilisé
- au cours du déroulement de l'algorithme d'optimisation.
+.. include:: snippets/Analysis.rst
- Exemple : ``Xs = ADD.get("CurrentState")[:]``
+.. include:: snippets/CostFunctionJ.rst
-Les sorties conditionnelles de l'algorithme sont les suivantes:
+.. include:: snippets/CostFunctionJb.rst
- CostFunctionJAtCurrentOptimum
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J`. A chaque pas, la valeur correspond à l'état optimal trouvé depuis
- le début.
+.. include:: snippets/CostFunctionJo.rst
- Exemple : ``JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]``
+.. include:: snippets/CurrentState.rst
- CostFunctionJbAtCurrentOptimum
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^b`, c'est-à-dire de la partie écart à l'ébauche. A chaque pas, la
- valeur correspond à l'état optimal trouvé depuis le début.
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo05.rst
- Exemple : ``JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]``
+.. include:: snippets/Analysis.rst
- CostFunctionJoAtCurrentOptimum
- *Liste de valeurs*. Chaque élément est une valeur de fonctionnelle d'écart
- :math:`J^o`, c'est-à-dire de la partie écart à l'observation. A chaque pas,
- la valeur correspond à l'état optimal trouvé depuis le début.
+.. include:: snippets/BMA.rst
- Exemple : ``JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]``
+.. include:: snippets/CostFunctionJ.rst
- CurrentOptimum
- *Liste de vecteurs*. Chaque élément est le vecteur d'état optimal au pas de
- temps courant au cours du déroulement de l'algorithme d'optimisation. Ce
- n'est pas nécessairement le dernier état.
+.. include:: snippets/CostFunctionJb.rst
- Exemple : ``Xo = ADD.get("CurrentOptimum")[:]``
+.. include:: snippets/CostFunctionJo.rst
- IndexOfOptimum
- *Liste d'entiers*. Chaque élément est l'index d'itération de l'optimum
- obtenu au cours du déroulement de l'algorithme d'optimisation. Ce n'est pas
- nécessairement le numéro de la dernière itération.
+.. include:: snippets/CostFunctionJAtCurrentOptimum.rst
- Exemple : ``i = ADD.get("IndexOfOptimum")[-1]``
+.. include:: snippets/CostFunctionJbAtCurrentOptimum.rst
- InnovationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur d'innovation à l'état
- courant.
+.. include:: snippets/CostFunctionJoAtCurrentOptimum.rst
- Exemple : ``ds = ADD.get("InnovationAtCurrentState")[-1]``
+.. include:: snippets/CurrentIterationNumber.rst
- OMA
- *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
- l'observation et l'état optimal dans l'espace des observations.
+.. include:: snippets/CurrentOptimum.rst
- Exemple : ``oma = ADD.get("OMA")[-1]``
+.. include:: snippets/CurrentState.rst
- OMB
- *Liste de vecteurs*. Chaque élément est un vecteur d'écart entre
- l'observation et l'état d'ébauche dans l'espace des observations.
+.. include:: snippets/IndexOfOptimum.rst
- Exemple : ``omb = ADD.get("OMB")[-1]``
+.. include:: snippets/Innovation.rst
- SimulatedObservationAtBackground
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'ébauche :math:`\mathbf{x}^b`.
+.. include:: snippets/InnovationAtCurrentState.rst
- Exemple : ``hxb = ADD.get("SimulatedObservationAtBackground")[-1]``
+.. include:: snippets/OMA.rst
- SimulatedObservationAtCurrentOptimum
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'état optimal au pas de temps courant au cours du déroulement de
- l'algorithme d'optimisation, c'est-à-dire dans l'espace des observations.
+.. include:: snippets/OMB.rst
- Exemple : ``hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]``
+.. include:: snippets/SimulatedObservationAtBackground.rst
- SimulatedObservationAtCurrentState
- *Liste de vecteurs*. Chaque élément est un vecteur observé à l'état courant,
- c'est-à-dire dans l'espace des observations.
+.. include:: snippets/SimulatedObservationAtCurrentOptimum.rst
- Exemple : ``Ys = ADD.get("SimulatedObservationAtCurrentState")[-1]``
+.. include:: snippets/SimulatedObservationAtCurrentState.rst
- SimulatedObservationAtOptimum
- *Liste de vecteurs*. Chaque élément est un vecteur d'observation simulé à
- partir de l'analyse ou de l'état optimal :math:`\mathbf{x}^a`.
+.. include:: snippets/SimulatedObservationAtOptimum.rst
- Exemple : ``hxa = ADD.get("SimulatedObservationAtOptimum")[-1]``
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo06.rst
-Voir aussi
-++++++++++
+- :ref:`section_ref_algorithm_ParticleSwarmOptimization`
+- :ref:`section_ref_algorithm_DifferentialEvolution`
+- :ref:`section_ref_algorithm_TabuSearch`
-Références vers d'autres sections :
- - :ref:`section_ref_algorithm_ParticleSwarmOptimization`
+.. ------------------------------------ ..
+.. include:: snippets/Header2Algo07.rst
-Références bibliographiques :
- - [Johnson08]_
- - [Nelder65]_
- - [Powell64]_
- - [Powell94]_
- - [Powell98]_
- - [Powell04]_
- - [Powell07]_
- - [Powell09]_
- - [Rowan90]_
+- [Johnson08]_
+- [Nelder65]_
+- [Powell64]_
+- [Powell94]_
+- [Powell98]_
+- [Powell04]_
+- [Powell07]_
+- [Powell09]_
+- [Rowan90]_
