From: Jean-Philippe ARGAUD Date: Thu, 4 May 2023 15:58:18 +0000 (+0200) Subject: Documentation review for mono-obj X-Git-Tag: V9_11_0b1~1 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=18b14d169f6eec5bb6ec654b8bfa9ecabf7319a3;p=modules%2Fadao.git Documentation review for mono-obj --- diff --git a/doc/en/ref_algorithm_3DVAR.rst b/doc/en/ref_algorithm_3DVAR.rst index b2023f1..bc0c530 100644 --- a/doc/en/ref_algorithm_3DVAR.rst +++ b/doc/en/ref_algorithm_3DVAR.rst @@ -57,17 +57,18 @@ It is highly recommended to use the original "3DVAR". The "3DVAR" and "3DVAR-Incr" algorithms (and not the others) explicitly allow the modification of the initial point of their minimization, even if it is not recommended. -This algorithm is naturally written for a single estimate, without any dynamic -or iterative notion (there is no need in this case for an incremental evolution -operator, nor for an evolution error covariance). In ADAO, it can also be used -on a succession of observations, placing the estimate in a recursive framework -similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is -made at each observation step on the state predicted by the incremental -evolution model, knowing that the state error covariance remains the background -covariance initially provided by the user. To be explicit, unlike Kalman-type -filters, the state error covariance is not updated. - -An extension of 3DVAR, coupling a 3DVAR méthod with a Kalman ensemble filter, +This mono-objective optimization algorithm is naturally written for a single +estimate, without any dynamic or iterative notion (there is no need in this +case for an incremental evolution operator, nor for an evolution error +covariance). In ADAO, it can also be used on a succession of observations, +placing the estimate in a recursive framework similar to a +:ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is made at each +observation step on the state predicted by the incremental evolution model, +knowing that the state error covariance remains the background covariance +initially provided by the user. To be explicit, unlike Kalman-type filters, the +state error covariance is not updated. + +An extension of 3DVAR, coupling a "3DVAR" method with a Kalman ensemble filter, allows to improve the estimation of *a posteriori* error covariances. This extension is obtained by using the "E3DVAR" variant of the filtering algorithm :ref:`section_ref_algorithm_EnsembleKalmanFilter`. diff --git a/doc/en/ref_algorithm_4DVAR.rst b/doc/en/ref_algorithm_4DVAR.rst index 39a2016..5b24352 100644 --- a/doc/en/ref_algorithm_4DVAR.rst +++ b/doc/en/ref_algorithm_4DVAR.rst @@ -39,8 +39,10 @@ assimilation: which is usually designed as the "*4D-Var*" functional (see for example [Talagrand97]_). The terms "*4D-Var*", "*4D-VAR*" and "*4DVAR*" are equivalent. -It is well suited in cases of non-linear observation and evolution operators, -its application domain is similar to the one of Kalman filters, specially the +This mono-objective optimization algorithm is naturally written for a single +estimate on a time window for the simulation. It is well suited in cases of +non-linear observation and evolution operators, its application domain is +similar to the one of Kalman filters, specially the :ref:`section_ref_algorithm_ExtendedKalmanFilter` or the :ref:`section_ref_algorithm_UnscentedKalmanFilter`. diff --git a/doc/en/ref_algorithm_Blue.rst b/doc/en/ref_algorithm_Blue.rst index 32c2b8e..9cc3a1a 100644 --- a/doc/en/ref_algorithm_Blue.rst +++ b/doc/en/ref_algorithm_Blue.rst @@ -40,15 +40,16 @@ linearity of the observation operator with the help of the :ref:`section_ref_algorithm_LinearityTest`. This algorithm is always the fastest of all the assimilation algorithms of ADAO. -This algorithm is naturally written for a single estimate, without any dynamic -or iterative notion (there is no need in this case for an incremental evolution -operator, nor for an evolution error covariance). In ADAO, it can also be used -on a succession of observations, placing the estimate in a recursive framework -partly similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard -estimate is made at each observation step on the state predicted by the -incremental evolution model, knowing that the state error covariance remains -the background covariance initially provided by the user. To be explicit, -unlike Kalman-type filters, the state error covariance is not updated. +This mono-objective optimization algorithm is naturally written for a single +estimate, without any dynamic or iterative notion (there is no need in this +case for an incremental evolution operator, nor for an evolution error +covariance). In ADAO, it can also be used on a succession of observations, +placing the estimate in a recursive framework partly similar to a +:ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is made at each +observation step on the state predicted by the incremental evolution model, +knowing that the state error covariance remains the background covariance +initially provided by the user. To be explicit, unlike Kalman-type filters, the +state error covariance is not updated. In case of non-linearity, even slightly marked, it will be easily preferred a :ref:`section_ref_algorithm_ExtendedBlue` or a diff --git a/doc/en/ref_algorithm_DerivativeFreeOptimization.rst b/doc/en/ref_algorithm_DerivativeFreeOptimization.rst index d41e506..753a32d 100644 --- a/doc/en/ref_algorithm_DerivativeFreeOptimization.rst +++ b/doc/en/ref_algorithm_DerivativeFreeOptimization.rst @@ -38,10 +38,11 @@ the derivatives of the cost function. It falls in the same category than the :ref:`section_ref_algorithm_DifferentialEvolution` or the :ref:`section_ref_algorithm_TabuSearch`. -This is an optimization method allowing for global minimum search of a general -error function :math:`J` of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`, -with or without weights. The default error function is the augmented weighted -least squares function, classically used in data assimilation. +This is a mono-objective optimization method allowing for global minimum search +of a general error function :math:`J` of type :math:`L^1`, :math:`L^2` or +:math:`L^{\infty}`, with or without weights. The default error function is the +augmented weighted least squares function, classically used in data +assimilation. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst diff --git a/doc/en/ref_algorithm_ExtendedBlue.rst b/doc/en/ref_algorithm_ExtendedBlue.rst index 5e83c61..f8ec2cb 100644 --- a/doc/en/ref_algorithm_ExtendedBlue.rst +++ b/doc/en/ref_algorithm_ExtendedBlue.rst @@ -41,15 +41,16 @@ help of a :ref:`section_ref_algorithm_LinearityTest`. In case of non-linearity, its results are close to a :ref:`section_ref_algorithm_3DVAR`, without being entirely equivalent. -This algorithm is naturally written for a single estimate, without any dynamic -or iterative notion (there is no need in this case for an incremental evolution -operator, nor for an evolution error covariance). In ADAO, it can also be used -on a succession of observations, placing the estimate in a recursive framework -partly similar to a :ref:`section_ref_algorithm_KalmanFilter`. A standard -estimate is made at each observation step on the state predicted by the -incremental evolution model, knowing that the state error covariance remains -the background covariance initially provided by the user. To be explicit, -unlike Kalman-type filters, the state error covariance is not updated. +This mono-objective optimization algorithm is naturally written for a single +estimate, without any dynamic or iterative notion (there is no need in this +case for an incremental evolution operator, nor for an evolution error +covariance). In ADAO, it can also be used on a succession of observations, +placing the estimate in a recursive framework partly similar to a +:ref:`section_ref_algorithm_KalmanFilter`. A standard estimate is made at each +observation step on the state predicted by the incremental evolution model, +knowing that the state error covariance remains the background covariance +initially provided by the user. To be explicit, unlike Kalman-type filters, the +state error covariance is not updated. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst diff --git a/doc/en/ref_algorithm_NonLinearLeastSquares.rst b/doc/en/ref_algorithm_NonLinearLeastSquares.rst index 4bd2150..ea78aab 100644 --- a/doc/en/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/en/ref_algorithm_NonLinearLeastSquares.rst @@ -39,12 +39,13 @@ It is similar to a :ref:`section_ref_algorithm_3DVAR`, without its background part. The background, required in the interface, is only used as an initial point for the variational minimization. -This algorithm is naturally written for a single estimate, without any dynamic -or iterative notion (there is no need in this case for an incremental evolution -operator, nor for an evolution error covariance). In ADAO, it can also be used -on a succession of observations, placing the estimate in a recursive framework -partly similar to a Kalman Filter. A standard estimate is made at each -observation step on the state predicted by the incremental evolution model. +This mono-objective optimization algorithm is naturally written for a single +estimate, without any dynamic or iterative notion (there is no need in this +case for an incremental evolution operator, nor for an evolution error +covariance). In ADAO, it can also be used on a succession of observations, +placing the estimate in a recursive framework partly similar to a Kalman +Filter. A standard estimate is made at each observation step on the state +predicted by the incremental evolution model. In all cases, it is recommended to prefer a :ref:`section_ref_algorithm_3DVAR` for its stability as for its behavior during optimization. diff --git a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst index 1e2c404..cc19b23 100644 --- a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst @@ -41,8 +41,8 @@ than the :ref:`section_ref_algorithm_DifferentialEvolution` or the :ref:`section_ref_algorithm_TabuSearch`. -This is an optimization method allowing for global minimum search of a general -error function :math:`J` of type :math:`L^1`, :math:`L^2` or +This is a mono-objective optimization method, allowing for global minimum search +of a general error function :math:`J` of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`, with or without weights, as described in the section for :ref:`section_theory_optimization`. The default error function is the augmented weighted least squares function, classically used in data assimilation. @@ -128,6 +128,8 @@ StoreSupplementaryCalculations Example : ``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}`` +.. include:: snippets/SwarmTopology.rst + .. include:: snippets/Variant_PSO.rst .. include:: snippets/VelocityClampingFactor.rst diff --git a/doc/en/ref_algorithm_QuantileRegression.rst b/doc/en/ref_algorithm_QuantileRegression.rst index a366fb5..00ea2ad 100644 --- a/doc/en/ref_algorithm_QuantileRegression.rst +++ b/doc/en/ref_algorithm_QuantileRegression.rst @@ -30,10 +30,11 @@ Calculation algorithm "*QuantileRegression*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -This algorithm allows to estimate the conditional quantiles of the state -parameters distribution, expressed with a model of the observed variables. These -are then the quantiles on the observed variables which will allow to determine -the model parameters that satisfy to the quantiles conditions. +This mono-objective optimization algorithm allows to estimate the conditional +quantiles of the state parameters distribution, expressed with a model of the +observed variables. These are then the quantiles on the observed variables +which will allow to determine the model parameters that satisfy to the +quantiles conditions. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst diff --git a/doc/en/ref_algorithm_TabuSearch.rst b/doc/en/ref_algorithm_TabuSearch.rst index 99762fb..079d7bd 100644 --- a/doc/en/ref_algorithm_TabuSearch.rst +++ b/doc/en/ref_algorithm_TabuSearch.rst @@ -38,10 +38,11 @@ the derivatives of the cost function. It falls in the same category than the :ref:`section_ref_algorithm_ParticleSwarmOptimization` or the :ref:`section_ref_algorithm_DifferentialEvolution`. -This is an optimization method allowing for global minimum search of a general -error function :math:`J` of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`, -with or without weights. The default error function is the augmented weighted -least squares function, classically used in data assimilation. +This is a mono-objective optimization method allowing for global minimum search +of a general error function :math:`J` of type :math:`L^1`, :math:`L^2` or +:math:`L^{\infty}`, with or without weights. The default error function is the +augmented weighted least squares function, classically used in data +assimilation. It works by iterative random exploration of the surroundings of the current point, to choose the state that minimizes the error function. To avoid diff --git a/doc/en/snippets/QualityCriterion.rst b/doc/en/snippets/QualityCriterion.rst index abb8688..a187c8c 100644 --- a/doc/en/snippets/QualityCriterion.rst +++ b/doc/en/snippets/QualityCriterion.rst @@ -4,11 +4,13 @@ QualityCriterion *Predefined name*. This key indicates the quality criterion, minimized to find the optimal state estimate. The default is the usual data assimilation criterion named "DA", the augmented weighted least squares. The possible - criteria has to be in the following list, where the equivalent names are + criterion has to be in the following list, where the equivalent names are indicated by the sign "<=>": ["AugmentedWeightedLeastSquares" <=> "AWLS" <=> "DA", - "WeightedLeastSquares" <=> "WLS", "LeastSquares" <=> "LS" <=> "L2", - "AbsoluteValue" <=> "L1", "MaximumError" <=> "ME" <=> "Linf"]. + "WeightedLeastSquares" <=> "WLS", + "LeastSquares" <=> "LS" <=> "L2", + "AbsoluteValue" <=> "L1", + "MaximumError" <=> "ME" <=> "Linf"]. Example: ``{"QualityCriterion":"DA"}`` diff --git a/doc/en/snippets/SwarmTopology.rst b/doc/en/snippets/SwarmTopology.rst new file mode 100644 index 0000000..007aa95 --- /dev/null +++ b/doc/en/snippets/SwarmTopology.rst @@ -0,0 +1,27 @@ +.. index:: single: SwarmTopology + +SwarmTopology + *Predefined name*. This key indicates how the particles (or insects) + communicate information to each other during the evolution of the particle + swarm. The most classical method consists in exchanging information between + all particles (called "gbest" or "FullyConnectedNeighborhood"). But it is + often more efficient to exchange information on a reduced neighborhood, as in + the classical method "lbest" (or "RingNeighborhoodWithRadius1") exchanging + information with the two neighboring particles in numbering order (the + previous one and the next one), or the method "RingNeighborhoodWithRadius2" + exchanging with the 4 neighbors (the two previous ones and the two following + ones). A variant of reduced neighborhood consists in exchanging with 3 + neighbors (method "AdaptativeRandomWith3Neighbors") or 5 neighbors (method + "AdaptativeRandomWith5Neighbors") chosen randomly (the particle can be drawn + several times). The default value is "FullyConnectedNeighborhood", and it is + advisable to change it carefully depending on the properties of the simulated + physical system. The possible communication topology is to be chosen from the + following list, in which the equivalent names are indicated by a "<=>" sign: + ["FullyConnectedNeighborhood" <=> "FullyConnectedNeighbourhood" <=> "gbest", + "RingNeighborhoodWithRadius1" <=> "RingNeighbourhoodWithRadius1" <=> "lbest", + "RingNeighborhoodWithRadius2" <=> "RingNeighbourhoodWithRadius2", + "AdaptativeRandomWith3Neighbors" <=> "AdaptativeRandomWith3Neighbours" <=> "abest", + "AdaptativeRandomWith5Neighbors" <=> "AdaptativeRandomWith5Neighbours"]. + + Example : + ``{"SwarmTopology":"FullyConnectedNeighborhood"}`` diff --git a/doc/fr/ref_algorithm_3DVAR.rst b/doc/fr/ref_algorithm_3DVAR.rst index c8cf19d..741d4cd 100644 --- a/doc/fr/ref_algorithm_3DVAR.rst +++ b/doc/fr/ref_algorithm_3DVAR.rst @@ -60,17 +60,17 @@ On recommande fortement d'utiliser le "3DVAR" d'origine. Les algorithmes modification du point initial de leur minimisation, même si ce n'est pas recommandé. -Cet algorithme est naturellement écrit pour une estimation unique, sans notion -dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur -d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO, -il peut aussi être utilisé sur une succession d'observations, plaçant alors -l'estimation dans un cadre récursif similaire à un -:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est -effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution -incrémentale, sachant que la covariance d'erreur d'état reste la covariance -d'ébauche initialement fournie par l'utilisateur. Pour être explicite, -contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états -n'est pas remise à jour. +Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une +estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin +dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs +d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession +d'observations, plaçant alors l'estimation dans un cadre récursif similaire à +un :ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard +"*3D-VAR*" est effectuée à chaque pas d'observation sur l'état prévu par le +modèle d'évolution incrémentale, sachant que la covariance d'erreur d'état +reste la covariance d'ébauche initialement fournie par l'utilisateur. Pour être +explicite, contrairement aux filtres de type Kalman, la covariance d'erreurs +sur les états n'est pas remise à jour. Une extension du 3DVAR, couplant en parallèle une méthode 3DVAR avec un filtre de Kalman d'ensemble, permet d'améliorer l'estimation des covariances d'erreurs diff --git a/doc/fr/ref_algorithm_4DVAR.rst b/doc/fr/ref_algorithm_4DVAR.rst index 4f34dbb..e28213d 100644 --- a/doc/fr/ref_algorithm_4DVAR.rst +++ b/doc/fr/ref_algorithm_4DVAR.rst @@ -39,7 +39,9 @@ classique en assimilation de données : qui est usuellement désignée comme la fonctionnelle "*4D-Var*" (voir par exemple [Talagrand97]_). Les dénominations "*4D-Var*", "*4D-VAR*" et "*4DVAR*" -sont équivalentes. Il est bien adapté aux cas d'opérateurs d'observation et +sont équivalentes. Cet algorithme d'optimisation mono-objectif est +naturellement écrit pour une estimation unique sur une fenêtre temporelle de +simulation. Il est bien adapté aux cas d'opérateurs d'observation et d'évolution non-linéaires, son domaine d'application est comparable aux algorithmes de filtrage de Kalman et en particulier l':ref:`section_ref_algorithm_ExtendedKalmanFilter` ou diff --git a/doc/fr/ref_algorithm_Blue.rst b/doc/fr/ref_algorithm_Blue.rst index 56ed87a..9f9d8be 100644 --- a/doc/fr/ref_algorithm_Blue.rst +++ b/doc/fr/ref_algorithm_Blue.rst @@ -40,17 +40,17 @@ non-linéaires. On peut vérifier la linéarité de l'opérateur d'observation l'aide d'un :ref:`section_ref_algorithm_LinearityTest`. Cet algorithme est toujours le plus rapide de l'ensemble des algorithmes d'assimilation d'ADAO. -Cet algorithme est naturellement écrit pour une estimation unique, sans notion -dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur -d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO, -il peut aussi être utilisé sur une succession d'observations, plaçant alors -l'estimation dans un cadre récursif en partie similaire à un -:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est -effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution -incrémentale, sachant que la covariance d'erreur d'état reste la covariance -d'ébauche initialement fournie par l'utilisateur. Pour être explicite, -contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états -n'est pas remise à jour. +Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une +estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin +dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs +d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession +d'observations, plaçant alors l'estimation dans un cadre récursif en partie +similaire à un :ref:`section_ref_algorithm_KalmanFilter`. Une estimation +standard est effectuée à chaque pas d'observation sur l'état prévu par le +modèle d'évolution incrémentale, sachant que la covariance d'erreur d'état +reste la covariance d'ébauche initialement fournie par l'utilisateur. Pour être +explicite, contrairement aux filtres de type Kalman, la covariance d'erreurs +sur les états n'est pas remise à jour. En cas de non-linéarité, même peu marquée, on lui préférera aisément un :ref:`section_ref_algorithm_ExtendedBlue` ou un diff --git a/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst b/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst index 3f7d1c0..6089801 100644 --- a/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst +++ b/doc/fr/ref_algorithm_DerivativeFreeOptimization.rst @@ -40,11 +40,11 @@ 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 -:math:`L^{\infty}`, avec ou sans pondérations. La fonctionnelle d'erreur par -défaut est celle de moindres carrés pondérés augmentés, classiquement utilisée -en assimilation de données. +C'est une méthode d'optimisation mono-objectif permettant la recherche du +minimum global d'une fonctionnelle d'erreur :math:`J` quelconque de type +:math:`L^1`, :math:`L^2` ou :math:`L^{\infty}`, avec ou sans pondérations. La +fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés +augmentés, classiquement utilisée en assimilation de données. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst diff --git a/doc/fr/ref_algorithm_ExtendedBlue.rst b/doc/fr/ref_algorithm_ExtendedBlue.rst index 0e47e61..0d7bdef 100644 --- a/doc/fr/ref_algorithm_ExtendedBlue.rst +++ b/doc/fr/ref_algorithm_ExtendedBlue.rst @@ -42,17 +42,17 @@ d'observation à l'aide d'un :ref:`section_ref_algorithm_LinearityTest`. En non-linéaire, ses résultats se rapprochent d'un :ref:`section_ref_algorithm_3DVAR`, sans lui être entièrement équivalent. -Cet algorithme est naturellement écrit pour une estimation unique, sans notion -dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur -d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO, -il peut aussi être utilisé sur une succession d'observations, plaçant alors -l'estimation dans un cadre récursif en partie similaire à un -:ref:`section_ref_algorithm_KalmanFilter`. Une estimation standard est -effectuée à chaque pas d'observation sur l'état prévu par le modèle d'évolution -incrémentale, sachant que la covariance d'erreur d'état reste la covariance -d'ébauche initialement fournie par l'utilisateur. Pour être explicite, -contrairement aux filtres de type Kalman, la covariance d'erreurs sur les états -n'est pas remise à jour. +Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une +estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin +dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs +d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession +d'observations, plaçant alors l'estimation dans un cadre récursif en partie +similaire à un :ref:`section_ref_algorithm_KalmanFilter`. Une estimation +standard est effectuée à chaque pas d'observation sur l'état prévu par le +modèle d'évolution incrémentale, sachant que la covariance d'erreur d'état +reste la covariance d'ébauche initialement fournie par l'utilisateur. Pour être +explicite, contrairement aux filtres de type Kalman, la covariance d'erreurs +sur les états n'est pas remise à jour. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst diff --git a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst index b60d063..4dcd194 100644 --- a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst @@ -39,13 +39,13 @@ Il est similaire à un :ref:`section_ref_algorithm_3DVAR` privé de sa partie ébauche. L'ébauche, requise dans l'interface, ne sert que de point initial pour la minimisation variationnelle. -Cet algorithme est naturellement écrit pour une estimation unique, sans notion -dynamique ou itérative (il n'y a donc pas besoin dans ce cas d'opérateur -d'évolution incrémentale, ni de covariance d'erreurs d'évolution). Dans ADAO, -il peut aussi être utilisé sur une succession d'observations, plaçant alors -l'estimation dans un cadre récursif en partie similaire à un filtre de Kalman. -Une estimation standard est effectuée à chaque pas d'observation sur l'état -prévu par le modèle d'évolution incrémentale. +Cet algorithme d'optimisation mono-objectif est naturellement écrit pour une +estimation unique, sans notion dynamique ou itérative (il n'y a donc pas besoin +dans ce cas d'opérateur d'évolution incrémentale, ni de covariance d'erreurs +d'évolution). Dans ADAO, il peut aussi être utilisé sur une succession +d'observations, plaçant alors l'estimation dans un cadre récursif en partie +similaire à un filtre de Kalman. Une estimation standard est effectuée à chaque +pas d'observation sur l'état prévu par le modèle d'évolution incrémentale. Dans tous les cas, il est recommandé de lui préférer un :ref:`section_ref_algorithm_3DVAR` pour sa stabilité comme pour son diff --git a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst index 47bad95..6af2b0d 100644 --- a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst @@ -42,12 +42,12 @@ Elle entre dans la même catégorie que les :ref:`section_ref_algorithm_DifferentialEvolution` ou :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 :math:`L^{\infty}`, avec ou sans pondérations, comme décrit dans -la section pour :ref:`section_theory_optimization`. La fonctionnelle d'erreur -par défaut est celle de moindres carrés pondérés augmentés, classiquement -utilisée en assimilation de données. +C'est une méthode d'optimisation mono-objectif, permettant la recherche du +minimum global d'une fonctionnelle d'erreur :math:`J` quelconque de type +:math:`L^1`, :math:`L^2` ou :math:`L^{\infty}`, avec ou sans pondérations, +comme décrit dans la section pour :ref:`section_theory_optimization`. La +fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés +augmentés, classiquement utilisée en assimilation de données. Il existe diverses variantes de cet algorithme. On propose ici les formulations stables et robustes suivantes : @@ -130,6 +130,8 @@ StoreSupplementaryCalculations Exemple : ``{"StoreSupplementaryCalculations":["CurrentState", "Residu"]}`` +.. include:: snippets/SwarmTopology.rst + .. include:: snippets/Variant_PSO.rst .. include:: snippets/VelocityClampingFactor.rst diff --git a/doc/fr/ref_algorithm_QuantileRegression.rst b/doc/fr/ref_algorithm_QuantileRegression.rst index 11e1848..1b60312 100644 --- a/doc/fr/ref_algorithm_QuantileRegression.rst +++ b/doc/fr/ref_algorithm_QuantileRegression.rst @@ -30,10 +30,11 @@ Algorithme de calcul "*QuantileRegression*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -Cet algorithme permet d'estimer les quantiles conditionnels de la distribution -des paramètres d'état, exprimés à l'aide d'un modèle des variables observées. Ce -sont donc les quantiles sur les variables observées qui vont permettre de -déterminer les paramètres de modèles satisfaisant aux conditions de quantiles. +Cet algorithme d'optimisation mono-objectif sur les paramètres de modèle permet +d'estimer les quantiles conditionnels de la distribution des paramètres d'état, +exprimés à l'aide d'un modèle des variables observées. Ce sont donc les +quantiles sur les variables observées qui vont permettre de déterminer les +paramètres de modèles satisfaisant aux conditions de quantiles. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst diff --git a/doc/fr/ref_algorithm_TabuSearch.rst b/doc/fr/ref_algorithm_TabuSearch.rst index 711bfb9..e8a2bb9 100644 --- a/doc/fr/ref_algorithm_TabuSearch.rst +++ b/doc/fr/ref_algorithm_TabuSearch.rst @@ -39,11 +39,11 @@ même catégorie que l':ref:`section_ref_algorithm_DerivativeFreeOptimization`, l':ref:`section_ref_algorithm_ParticleSwarmOptimization` ou l':ref:`section_ref_algorithm_DifferentialEvolution`. -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 -:math:`L^{\infty}`, avec ou sans pondérations. La fonctionnelle d'erreur par -défaut est celle de moindres carrés pondérés augmentés, classiquement utilisée -en assimilation de données. +C'est une méthode d'optimisation mono-objectif permettant la recherche du +minimum global d'une fonctionnelle d'erreur :math:`J` quelconque de type +:math:`L^1`, :math:`L^2` ou :math:`L^{\infty}`, avec ou sans pondérations. La +fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés +augmentés, classiquement utilisée en assimilation de données. Elle fonctionne par exploration aléatoire itérative du voisinage du point courant, pour en choisir l'état qui minimise la fonctionnelle d'écart. Pour diff --git a/doc/fr/snippets/QualityCriterion.rst b/doc/fr/snippets/QualityCriterion.rst index f052636..21b5109 100644 --- a/doc/fr/snippets/QualityCriterion.rst +++ b/doc/fr/snippets/QualityCriterion.rst @@ -4,11 +4,13 @@ QualityCriterion *Nom prédéfini*. 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 "<=>" : + carrés pondérés augmentés. Le critère possible est 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" <=> "Linf"]. + "WeightedLeastSquares" <=> "WLS", + "LeastSquares" <=> "LS" <=> "L2", + "AbsoluteValue" <=> "L1", + "MaximumError" <=> "ME" <=> "Linf"]. Exemple : ``{"QualityCriterion":"DA"}`` diff --git a/doc/fr/snippets/SwarmTopology.rst b/doc/fr/snippets/SwarmTopology.rst new file mode 100644 index 0000000..a598468 --- /dev/null +++ b/doc/fr/snippets/SwarmTopology.rst @@ -0,0 +1,29 @@ +.. index:: single: SwarmTopology + +SwarmTopology + *Nom prédéfini*. Cette clé indique la manière dont les particules (ou + insectes) se communiquent des informations lors de l'évolution de l'essaim + particulaire. La méthode la plus classique consiste à échanger des + informations entre toutes les particules (nommée "gbest" ou + "FullyConnectedNeighborhood"). Mais il est souvent plus efficace d'échanger + des informations sur un voisinage réduit, comme dans la méthode classique + "lbest" (ou "RingNeighborhoodWithRadius1") échangeant des informations avec + les deux particules voisines dans l'ordre de numérotation (la précédente et + la suivante), ou la méthode "RingNeighborhoodWithRadius2" échangeant avec les + 4 voisins (les deux précédents et les deux suivants). Une variante de + voisinage réduit consiste à échanger avec 3 voisins (méthode + "AdaptativeRandomWith3Neighbors") ou 5 voisins (méthode + "AdaptativeRandomWith5Neighbors") choisis aléatoirement (la particule pouvant + être tirée plusieurs fois). La valeur par défaut est + "FullyConnectedNeighborhood", et il est conseillé de la changer avec prudence + en fonction des propriétés du système physique simulé. La topologie de + communication possible est à choisir dans la liste suivante, dans laquelle + les noms équivalents sont indiqués par un signe "<=>" : + ["FullyConnectedNeighborhood" <=> "FullyConnectedNeighbourhood" <=> "gbest", + "RingNeighborhoodWithRadius1" <=> "RingNeighbourhoodWithRadius1" <=> "lbest", + "RingNeighborhoodWithRadius2" <=> "RingNeighbourhoodWithRadius2", + "AdaptativeRandomWith3Neighbors" <=> "AdaptativeRandomWith3Neighbours" <=> "abest", + "AdaptativeRandomWith5Neighbors" <=> "AdaptativeRandomWith5Neighbours"]. + + Exemple : + ``{"SwarmTopology":"FullyConnectedNeighborhood"}``