From 31b7f092f5770278bd5753bb71c7707dc6439136 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Tue, 17 May 2022 09:20:24 +0200 Subject: [PATCH] Minor documentation review corrections --- doc/en/ref_algorithm_InputValuesTest.rst | 6 ++--- doc/en/ref_algorithm_ObserverTest.rst | 15 +++++++------ doc/en/theory.rst | 7 +++--- doc/fr/gui_in_salome.rst | 4 ++-- doc/fr/ref_algorithm_InputValuesTest.rst | 12 +++++----- doc/fr/ref_algorithm_ObserverTest.rst | 19 ++++++++-------- doc/fr/ref_assimilation_keywords.rst | 4 ++-- doc/fr/snippets/InflationType.rst | 2 +- doc/fr/theory.rst | 21 +++++++++--------- doc/fr/tui.rst | 15 +++++++------ .../daAlgorithms/Atoms/lbfgsbhlt.py | 22 ++++++++++++++----- 11 files changed, 71 insertions(+), 56 deletions(-) diff --git a/doc/en/ref_algorithm_InputValuesTest.rst b/doc/en/ref_algorithm_InputValuesTest.rst index df9ec02..cfdc29f 100644 --- a/doc/en/ref_algorithm_InputValuesTest.rst +++ b/doc/en/ref_algorithm_InputValuesTest.rst @@ -50,11 +50,11 @@ if a variable is large in size, this can be difficult*). *Tips for this algorithm:* - Because *"ObservationOperator"* is a required command for ALL checking - algorithms in the graphical interface, you have to provide a value for it, + Because *"ObservationOperator"*, in the graphical interface, is a required + command for ALL checking algorithms, you have to provide a value for it, despite the fact that this command is not required for this test, and will not be used. The easiest way is to give "1" as a STRING, - *"ObservationOperator"* having to be of type *Matrix*. + *"ObservationOperator"* having to be of type sparse *Matrix*. .. ------------------------------------ .. .. include:: snippets/Header2Algo03Chck.rst diff --git a/doc/en/ref_algorithm_ObserverTest.rst b/doc/en/ref_algorithm_ObserverTest.rst index 357921c..fe19f34 100644 --- a/doc/en/ref_algorithm_ObserverTest.rst +++ b/doc/en/ref_algorithm_ObserverTest.rst @@ -31,9 +31,9 @@ Checking algorithm "*ObserverTest*" .. include:: snippets/Header2Algo01.rst This algorithm allows to verify an external function, given by the user, used as -an *observer*. This external function can be applied to every of the variables +an *observer*. This external function can be applied to each of the variables that can be potentially observed. It is activated only on those who are -explicitly associated with the *observer* in the interface. +explicitly associated with the *observer* in its declaration. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst @@ -45,8 +45,9 @@ indicated in :ref:`section_ref_assimilation_keywords`. *Tips for this algorithm:* - Because *"CheckingPoint"* and *"ObservationOperator"* are required commands - for ALL checking algorithms in the interface, you have to provide a value - for them, despite the fact that these commands are not required for this - test, and will not be used. The easiest way is to give "1" as a STRING for - both, *"ObservationOperator"* having to be of type *Matrix*. + Because *"CheckingPoint"* and *"ObservationOperator"*, in the graphical + interface, are required commands for ALL checking algorithms, you have to + provide a value for them, despite the fact that these commands are not + required for this test, and will not be used. The easiest way is to give + "1" as a STRING for both, *"ObservationOperator"* having to be of type + sparse *Matrix*. diff --git a/doc/en/theory.rst b/doc/en/theory.rst index 062d41e..80b540a 100644 --- a/doc/en/theory.rst +++ b/doc/en/theory.rst @@ -189,6 +189,7 @@ way the problem of joint estimation of states and parameters. Simple description of the data assimilation methodological framework -------------------------------------------------------------------- +.. index:: single: analysis .. index:: single: background .. index:: single: background error covariances .. index:: single: observation error covariances @@ -249,9 +250,9 @@ matrix of background error covariances by: The optimal estimation of the true parameters :math:`\mathbf{x}^t`, given the background :math:`\mathbf{x}^b` and the observations :math:`\mathbf{y}^o`, is -then the "*analysis*" :math:`\mathbf{x}^a` and comes from the minimisation of an -error function, explicit in variational assimilation, or from the filtering -correction in assimilation by filtering. +then called an "*analysis*", noted as :math:`\mathbf{x}^a`, and comes from the +minimisation of an error function, explicit in variational assimilation, or +from the filtering correction in assimilation by filtering. In **variational assimilation**, in a static case, one classically attempts to minimize the following function :math:`J`: diff --git a/doc/fr/gui_in_salome.rst b/doc/fr/gui_in_salome.rst index 3a5bdfe..5946458 100644 --- a/doc/fr/gui_in_salome.rst +++ b/doc/fr/gui_in_salome.rst @@ -113,9 +113,9 @@ le menu principal "*ADAO*") pour créer un nouveau cas ADAO, et on obtient : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Pour construire un cas en utilisant l'éditeur intégré, on doit passer par une -série de sous-étapes, en choisissant, à chaque étape, un mot-clé puis en +série de sous-étapes, en choisissant, à chaque sous-étape, un mot-clé puis en remplissant ses valeurs. On note que c'est dans cette étape qu'il faut, entre -autres, définir l'**appel au code de simulation** utilisé dans les opérateurs +autres, définir un **appel au code de simulation** utilisé dans les opérateurs d'observation ou d'évolution décrivant le problème [#]_. L'éditeur structuré indique des types hiérarchiques, des valeurs ou des diff --git a/doc/fr/ref_algorithm_InputValuesTest.rst b/doc/fr/ref_algorithm_InputValuesTest.rst index dff1a14..5ac0402 100644 --- a/doc/fr/ref_algorithm_InputValuesTest.rst +++ b/doc/fr/ref_algorithm_InputValuesTest.rst @@ -52,12 +52,12 @@ informatiquement problématique*). *Astuce pour cet algorithme :* - Comme la commande *"ObservationOperator"* est requise pour TOUS les - algorithmes de vérification dans l'interface graphique, vous devez fournir - une valeur, malgré le fait que cette commandes ne soit pas nécessaires pour - cet test, et ne soit donc pas utilisée. La manière la plus simple est de - donner "1" comme un STRING, l'*"ObservationOperator"* devant être de type - *Matrix*. + Comme la commande *"ObservationOperator"*, dans l'interface graphique, est + requise pour TOUS les algorithmes de vérification, il faut fournir une + valeur, malgré le fait que cette commandes ne soit pas nécessaires pour cet + test (et sa valeur n'est donc pas utilisée). La manière la plus simple est + de donner "1" comme un STRING, pour un *"ObservationOperator"* devant être + de type *Matrix* creuse. .. ------------------------------------ .. .. include:: snippets/Header2Algo03Chck.rst diff --git a/doc/fr/ref_algorithm_ObserverTest.rst b/doc/fr/ref_algorithm_ObserverTest.rst index 24cfdd6..973ce3c 100644 --- a/doc/fr/ref_algorithm_ObserverTest.rst +++ b/doc/fr/ref_algorithm_ObserverTest.rst @@ -32,9 +32,9 @@ Algorithme de vérification "*ObserverTest*" Cet algorithme permet de vérifier une fonction externe et fournie par l'utilisateur, utilisée comme un *observer*. Cette fonction externe peut être -appliquée à chacune des variables potentiellement observables. Elle n'est -activée que sur celles qui sont explicitement associées avec l'*observer* dans -l'interface. +appliquée pour chacune des variables potentiellement observables. Elle n'est +activée que sur celles qui sont explicitement associées avec cet *observer* +dans sa déclaration. .. ------------------------------------ .. .. include:: snippets/Header2Algo02.rst @@ -46,9 +46,10 @@ sont indiquées dans la :ref:`section_ref_checking_keywords`. *Astuce pour cet algorithme :* - Comme les commandes *"CheckingPoint"* et *"ObservationOperator"* sont - requises pour TOUS les algorithmes de vérification dans l'interface, vous - devez fournir une valeur, malgré le fait que ces commandes ne soient pas - nécessaires pour ce test, et ne sont donc pas utilisées. La manière la plus - simple est de donner "1" comme un STRING pour les deux, - l'*"ObservationOperator"* devant être de type *Matrix*. + Comme les commandes *"CheckingPoint"* et *"ObservationOperator"*, dans + l'interface graphique, sont requises pour TOUS les algorithmes de + vérification, il faut fournir une valeur, malgré le fait que ces commandes + ne soient pas nécessaires pour ce test (et que leurs valeurs ne sont donc + pas utilisées). La manière la plus simple est de donner "1" comme un STRING + pour les deux, avec un *"ObservationOperator"* devant être de type *Matrix* + creuse. diff --git a/doc/fr/ref_assimilation_keywords.rst b/doc/fr/ref_assimilation_keywords.rst index b26141f..7043b37 100644 --- a/doc/fr/ref_assimilation_keywords.rst +++ b/doc/fr/ref_assimilation_keywords.rst @@ -31,8 +31,8 @@ calcul en évitant les particularités de chaque algorithme. C'est donc un inventaire commun des commandes. Le jeu de commandes pour un cas d'assimilation de données ou d'optimisation est -lié à la description d'un cas de calcul, qui est une procédure d'*Assimilation -de Données*, de *Méthodes avec Réduction* ou de méthodes *Optimisation*. +lié à la description d'un cas de calcul, qui est une procédure en *Assimilation +de Données*, en *Méthodes avec Réduction* ou en méthodes *Optimisation*. Le premier terme décrit le choix entre un calcul ou une vérification. Dans l'interface graphique, chacun des trois types de calculs, individuellement diff --git a/doc/fr/snippets/InflationType.rst b/doc/fr/snippets/InflationType.rst index 1d27a29..90f77ba 100644 --- a/doc/fr/snippets/InflationType.rst +++ b/doc/fr/snippets/InflationType.rst @@ -6,7 +6,7 @@ InflationType L'inflation peut être appliquée de diverses manières, selon les options suivantes : multiplicative ou additive du facteur d'inflation spécifié, appliquée sur l'ébauche ou sur l'analyse, appliquée sur les covariances ou - sur les anomalies. L'*inflation multiplicative sur les anomalies*, qui sont + sur les anomalies. Une *inflation multiplicative sur les anomalies*, qui sont obtenues en retranchant la moyenne d'ensemble, est effectuée en multipliant ces anomalies par le facteur d'inflation, puis en reconstituant les membres de l'ensemble par ajout de la moyenne préalablement calculée. Un seul type diff --git a/doc/fr/theory.rst b/doc/fr/theory.rst index 1fd936d..68fee18 100644 --- a/doc/fr/theory.rst +++ b/doc/fr/theory.rst @@ -206,6 +206,7 @@ d'états et de paramètres. Description simple du cadre méthodologique de l'assimilation de données ----------------------------------------------------------------------- +.. index:: single: analyse .. index:: single: ebauche .. index:: single: covariances d'erreurs d'ébauche .. index:: single: covariances d'erreurs d'observation @@ -267,9 +268,9 @@ matrice :math:`\mathbf{B}` des covariances d'erreurs d'ébauche par : L'estimation optimale des paramètres vrais :math:`\mathbf{x}^t`, étant donné l'ébauche :math:`\mathbf{x}^b` et les observations :math:`\mathbf{y}^o`, est -ainsi "l'*analyse*" :math:`\mathbf{x}^a` et provient de la minimisation d'une -fonction d'erreur, explicite en assimilation variationnelle, ou d'une correction -de filtrage en assimilation par filtrage. +ainsi appelée une "*analyse*", notée :math:`\mathbf{x}^a`, et provient de la +minimisation d'une fonction d'erreur, explicite en assimilation variationnelle, +ou d'une correction de filtrage en assimilation par filtrage. En **assimilation variationnelle**, dans un cas statique, on cherche classiquement à minimiser la fonction :math:`J` suivante : @@ -579,10 +580,10 @@ méthodes sont un coût numérique souvent bien supérieur pour trouver les estimations d'états, et fréquemment aucune garantie de convergence en temps fini. Ici, on ne mentionne que quelques méthodes disponibles dans ADAO : -- l'*optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`), -- l'*optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`), -- l'*évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`), -- la *régression de quantile (Quantile Regression ou QR)* (voir :ref:`section_ref_algorithm_QuantileRegression`). +- *optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`), +- *optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`), +- *évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`), +- *régression de quantile (Quantile Regression ou QR)* (voir :ref:`section_ref_algorithm_QuantileRegression`). En second lieu, les méthodes d'optimisation cherchent usuellement à minimiser des mesures quadratiques d'erreurs, car les propriétés naturelles de ces @@ -634,9 +635,9 @@ sont un coût numérique souvent bien supérieur pour trouver les estimations d'états, et pas de garantie de convergence en temps fini. Ici encore, on ne mentionne que quelques méthodes qui sont disponibles dans ADAO : -- l'*optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`), -- l'*optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`), -- l'*évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`). +- *optimisation sans dérivées (Derivative Free Optimization ou DFO)* (voir :ref:`section_ref_algorithm_DerivativeFreeOptimization`), +- *optimisation par essaim de particules (Particle Swarm Optimization ou PSO)* (voir :ref:`section_ref_algorithm_ParticleSwarmOptimization`), +- *évolution différentielle (Differential Evolution ou DE)* (voir :ref:`section_ref_algorithm_DifferentialEvolution`). Le lecteur intéressé par le sujet de l'optimisation pourra utilement commencer sa recherche grâce au point d'entrée [WikipediaMO]_. diff --git a/doc/fr/tui.rst b/doc/fr/tui.rst index 7de90cd..cfbb2a5 100644 --- a/doc/fr/tui.rst +++ b/doc/fr/tui.rst @@ -550,13 +550,14 @@ Paramétrer le calcul, les sorties, etc. finale du calcul. On se reportera à la description des :ref:`section_ref_observers_requirements` pour avoir leur liste et leur format, et à la :ref:`section_reference` pour savoir quelles sont les - quantités observables. On définit comme un "*String*" le corps de - l'*observer*, en utilisant une chaîne de caractères incluant si nécessaire - des sauts de lignes. On recommande d'utiliser les patrons disponibles par - l'argument "*Template*". Dans le cas d'une définition par "*Script*", le - fichier indiqué doit contenir uniquement le corps de la fonction, comme - décrit dans les :ref:`section_ref_observers_requirements`. La variable - "*Info*" contient une chaîne de caractère d'information ou une chaine vide. + quantités observables. On définit comme un "*String*" le corps de la + fonction d'un *observer*, en utilisant une chaîne de caractères incluant si + nécessaire des sauts de lignes. On recommande d'utiliser les patrons + disponibles par l'argument "*Template*". Dans le cas d'une définition par + "*Script*", le fichier indiqué doit contenir uniquement le corps de la + fonction, comme décrit dans les :ref:`section_ref_observers_requirements`. + La variable "*Info*" contient une chaîne de caractère d'information ou une + chaine vide. .. index:: single: UserPostAnalysis .. index:: single: UserPostAnalysis Template diff --git a/src/daComposant/daAlgorithms/Atoms/lbfgsbhlt.py b/src/daComposant/daAlgorithms/Atoms/lbfgsbhlt.py index f59c1ec..426aecb 100644 --- a/src/daComposant/daAlgorithms/Atoms/lbfgsbhlt.py +++ b/src/daComposant/daAlgorithms/Atoms/lbfgsbhlt.py @@ -1,4 +1,4 @@ -# Modification de la version 1.1.0 +# Modification de la version 1.4.1 """ Functions --------- @@ -39,7 +39,7 @@ from __future__ import division, print_function, absolute_import import numpy as np from numpy import array, asarray, float64, int32, zeros from scipy.optimize import _lbfgsb -from scipy.optimize.optimize import (approx_fprime, MemoizeJac, OptimizeResult, +from scipy.optimize.optimize import (MemoizeJac, OptimizeResult, _check_unknown_options, wrap_function, _approx_fprime_helper) from scipy.sparse.linalg import LinearOperator @@ -219,8 +219,10 @@ def _minimize_lbfgsb(fun, x0, args=(), jac=None, bounds=None, Options ------- - disp : bool - Set to True to print convergence messages. + disp : None or int + If `disp is None` (the default), then the supplied version of `iprint` + is used. If `disp is not None`, then it overrides the supplied version + of `iprint` with the behaviour you outlined. maxcor : int The maximum number of variable metric corrections used to define the limited memory matrix. (The limited memory BFGS @@ -235,12 +237,20 @@ def _minimize_lbfgsb(fun, x0, args=(), jac=None, bounds=None, projected gradient. eps : float Step size used for numerical approximation of the jacobian. - disp : int - Set to True to print convergence messages. maxfun : int Maximum number of function evaluations. maxiter : int Maximum number of iterations. + iprint : int, optional + Controls the frequency of output. ``iprint < 0`` means no output; + ``iprint = 0`` print only one line at the last iteration; + ``0 < iprint < 99`` print also f and ``|proj g|`` every iprint iterations; + ``iprint = 99`` print details of every iteration except n-vectors; + ``iprint = 100`` print also the changes of active set and final x; + ``iprint > 100`` print details of every iteration including x and g. + callback : callable, optional + Called after each iteration, as ``callback(xk)``, where ``xk`` is the + current parameter vector. maxls : int, optional Maximum number of line search steps (per iteration). Default is 20. -- 2.39.2