13.4. Algorithme de calcul « DerivativeFreeOptimization »¶

13.4.1. Description¶

Cet algorithme réalise une estimation de l’état d’un système par minimisation sans gradient d’une fonctionnelle d’écart $J$ , en utilisant une méthode de recherche par approximation de type simplexe ou similaire. C’est une méthode qui n’utilise pas les dérivées de la fonctionnelle d’écart.

Elle entre dans la même catégorie que les Algorithme de calcul « DifferentialEvolution », Algorithme de calcul « ParticleSwarmOptimization », Algorithme de calcul « SimulatedAnnealing », Algorithme de calcul « TabuSearch ».

C’est une méthode d’optimisation mono-objectif permettant la recherche du minimum global d’une fonctionnelle d’erreur $J$ quelconque de type $L^1$ , $L^2$ ou $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.

13.4.2. Quelques propriétés notables des méthodes implémentées¶

Pour compléter la description on synthétise ici quelques propriétés notables, des méthodes de l’algorithme ou de leurs implémentations. Ces propriétés peuvent avoir une influence sur la manière de l’utiliser ou sur ses performances de calcul. Pour de plus amples renseignements, on se reportera aux références plus complètes indiquées à la fin du descriptif de cet algorithme.

Les méthodes d’optimisation proposées par cet algorithme effectuent une recherche non locale du minimum, sans pour autant néanmoins assurer une recherche globale. C’est le cas lorsque les méthodes d’optimisation de recherche locale présentent de plus des capacités permettant d’éviter de rester bloquées par le premier minimum local trouvé. Ces capacités sont parfois heuristiques.

Les méthodes proposées par cet algorithme ne requièrent pas de dérivation de la fonction objectif ou de l’un des opérateurs, permettant d’éviter ce temps de calcul supplémentaire dans le cas où les dérivées sont calculées numériquement par de multiples évaluations.

Les méthodes proposées par cet algorithme ne présentent pas de parallélisme interne ni de dérivation numérique d’opérateur(s), et ne peuvent donc profiter de ressources informatiques de répartition de calculs. Les méthodes sont séquentielles, et un usage éventuel des ressources du parallélisme est donc réservé aux opérateurs d’observation ou d’évolution, donc aux codes de l’utilisateur.

Les méthodes proposées par cet algorithme atteignent leur convergence sur un ou plusieurs critères de résidu ou de nombre. En pratique, il peut y avoir plusieurs critères de convergence actifs simultanément.

Le résidu peut être une mesure standard basée sur un écart (« écart calculs-mesures » par exemple), ou une valeur remarquable lié à l’algorithme (« nullité d’un gradient » par exemple).

Le nombre est fréquemment un élément remarquable lié à l’algorithme, comme un nombre d’itérations ou un nombre d’évaluations, mais cela peut aussi être par exemple un nombre de générations pour un algorithme évolutionnaire.

Il convient de régler soigneusement les seuils de convergence, pour limiter le coût calcul global de l’algorithme, ou pour assurer une adaptation de la convergence au cas physique traité.

13.4.3. Commandes requises et optionnelles¶

Les commandes générales requises, disponibles en édition dans l’interface graphique ou textuelle, sont les suivantes :

Background: Vecteur. La variable désigne le vecteur d’ébauche ou d’initialisation, usuellement noté $\mathbf{x}^b$ . Sa valeur est définie comme un objet de type « Vector » ou « VectorSerie ». Sa disponibilité en sortie est conditionnée par le booléen « Stored » associé en entrée.

BackgroundError: Matrice. La variable désigne la matrice de covariance des erreurs d’ébauche, usuellement notée $\mathbf{B}$ . Sa valeur est définie comme un objet de type « Matrix », de type « ScalarSparseMatrix », ou de type « DiagonalSparseMatrix », comme décrit en détail dans la section Conditions requises pour décrire des matrices de covariance. Sa disponibilité en sortie est conditionnée par le booléen « Stored » associé en entrée.

EvolutionError: Matrice. La variable désigne la matrice de covariance des erreurs a priori d’évolution, usuellement notée $\mathbf{Q}$ . Sa valeur est définie comme un objet de type « Matrix », de type « ScalarSparseMatrix », ou de type « DiagonalSparseMatrix », comme décrit en détail dans la section Conditions requises pour décrire des matrices de covariance. Sa disponibilité en sortie est conditionnée par le booléen « Stored » associé en entrée.

EvolutionModel: Opérateur. La variable désigne l’opérateur d’évolution du modèle, usuellement noté $M$ , qui décrit un pas élémentaire d’évolution dynamique ou itérative. 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 Conditions requises pour les fonctions décrivant un opérateur. Si un contrôle $U$ est inclus dans le modèle d’observation, l’opérateur doit être appliqué à une paire $(X,U)$ .

Observation: Liste de vecteurs. La variable désigne le vecteur d’observation utilisé en assimilation de données ou en optimisation, et usuellement noté $\mathbf{y}^o$ . Sa valeur est définie comme un objet de type « Vector » si c’est une unique observation (temporelle ou pas) ou « VectorSerie » si c’est une succession d’observations. Sa disponibilité en sortie est conditionnée par le booléen « Stored » associé en entrée.

ObservationError: Matrice. La variable désigne la matrice de covariance des erreurs a priori d’ébauche, usuellement notée $\mathbf{R}$ . Cette matrice est définie comme un objet de type « Matrix », de type « ScalarSparseMatrix », ou de type « DiagonalSparseMatrix », comme décrit en détail dans la section Conditions requises pour décrire des matrices de covariance. Sa disponibilité en sortie est conditionnée par le booléen « Stored » associé en entrée.

ObservationOperator: Opérateur. La variable désigne l’opérateur d’observation, usuellement noté $H$ , qui transforme les paramètres d’entrée $\mathbf{x}$ en résultats $\mathbf{y}$ qui sont à comparer aux observations $\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 Conditions requises pour les fonctions décrivant un opérateur. Si un contrôle $U$ est inclus dans le modèle d’observation, l’opérateur doit être appliqué à une paire $(X,U)$ .

Les commandes optionnelles générales, disponibles en édition dans l’interface graphique ou textuelle, sont indiquées dans la Liste des commandes et mots-clés pour un cas d’assimilation de données ou d’optimisation. 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 Description des options d’un algorithme par « AlgorithmParameters » pour le bon usage de cette commande.

Les options sont les suivantes :

Bounds

Liste de paires de valeurs réelles. Cette clé permet de définir des paires de 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. Si la liste est vide, cela équivaut à une absence de bornes.

Exemple : {"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}

CostDecrementTolerance

Valeur réelle. 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. La valeur par défaut est de 1.e-7, et il est recommandé de l’adapter aux besoins pour des problèmes réels. On peut se reporter à la partie décrivant les manières de Contrôler la convergence pour des cas de calculs et algorithmes itératifs pour des recommandations plus détaillées.

Exemple : {"CostDecrementTolerance":1.e-7}

EstimationOf

Nom prédéfini. Cette clé permet de choisir le type d’estimation à réaliser. Cela peut être soit une estimation de l’état, avec la valeur « State », ou une estimation de paramètres, avec la valeur « Parameters ». Le choix par défaut est « Parameters ».

Exemple : {"EstimationOf":"Parameters"}

MaximumNumberOfFunctionEvaluations

Valeur entière. 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}

MaximumNumberOfIterations

Valeur entière. Cette clé indique le nombre maximum d’itérations internes possibles en optimisation itérative. Le défaut est 15000, qui est très similaire à une absence de limite sur ce nombre d’itérations. Il est ainsi 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. On peut se reporter à la partie décrivant les manières de Contrôler la convergence pour des cas de calculs et algorithmes itératifs pour des recommandations plus détaillées.

Exemple : {"MaximumNumberOfIterations":100}

Minimizer

Nom prédéfini. 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, voir [Powell09]), « COBYLA » (minimisation, avec ou sans contraintes, par approximation linéaire, voir [Powell94] [Powell98]). « NEWUOA » (minimisation, avec ou sans contraintes, par approximation quadratique itérative, voir [Powell04]), « POWELL » (minimisation, sans contraintes, de type directions conjuguées, voir [Powell64]), « SIMPLEX » (minimisation, avec ou sans contraintes, de type Nelder-Mead utilisant le concept de simplexe, voir [Nelder65] et [WikipediaNM]), « SUBPLEX » (minimisation, avec ou sans contraintes, de type Nelder-Mead utilisant le concept de simplexe sur une suite de sous-espaces, voir [Rowan90]). Seul le minimiseur « POWELL » ne permet pas de traiter les contraintes de bornes, tous les autres en tiennent compte si elles sont présentes dans la définition du cas.

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 est requis, il faut choisir un autre minimiseur.

Exemple : {"Minimizer":"BOBYQA"}

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. 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 »]. On pourra se reporter à la section pour Approfondir l’estimation d’état par des méthodes d’optimisation afin de disposer de la définition détaillée de ces critères de qualité.

Exemple : {"QualityCriterion":"DA"}

StateVariationTolerance

Valeur réelle. Cette clé indique la variation relative maximale de l’état lors de 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}

StoreSupplementaryCalculations

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. Leur disponibilité implique, potentiellement, des calculs ou du stockage coûteux. La valeur par défaut est donc une liste vide, aucune de ces variables n’étant calculée et stockée par défaut (sauf les variables inconditionnelles). Les noms possibles pour les variables supplémentaires sont dans la liste suivante (la description détaillée de chaque variable nommée est donnée dans la suite de cette documentation par algorithme spécifique, dans la sous-partie « Informations et variables disponibles à la fin de l’algorithme ») : [ « Analysis », « BMA », « CostFunctionJ », « CostFunctionJb », « CostFunctionJo », « CostFunctionJAtCurrentOptimum », « CostFunctionJbAtCurrentOptimum », « CostFunctionJoAtCurrentOptimum », « CurrentIterationNumber », « CurrentOptimum », « CurrentState », « EnsembleOfSimulations », « EnsembleOfStates », « IndexOfOptimum », « Innovation », « InnovationAtCurrentState », « OMA », « OMB », « SimulatedObservationAtBackground », « SimulatedObservationAtCurrentOptimum », « SimulatedObservationAtCurrentState », « SimulatedObservationAtOptimum », ].

Exemple : {"StoreSupplementaryCalculations":["CurrentState", "Residu"]}

13.4.4. Informations et variables disponibles à la fin de l’algorithme¶

En sortie, après exécution de l’algorithme, on dispose d’informations et de variables issues du calcul. La description des Variables et informations disponibles en sortie indique la manière de les obtenir, par la méthode nommée get, depuis la variable « ADD » du post-processing en interface graphique, ou depuis le cas en interface textuelle. 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 un Inventaire des informations potentiellement disponibles en sortie.

Sorties permanentes (non conditionnelles)

Les sorties non conditionnelles de l’algorithme sont les suivantes :

Analysis

Liste de vecteurs. Chaque élément de cette variable est un état optimal $\mathbf{x}^*$ en optimisation, une interpolation ou une analyse $\mathbf{x}^a$ en assimilation de données.

Exemple : xa = ADD.get("Analysis")[-1]

CostFunctionJ

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $J$ choisie.

Exemple : J = ADD.get("CostFunctionJ")[:]

CostFunctionJb

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $J^b$ , c’est-à-dire de la partie écart à l’ébauche. Si cette partie n’existe pas dans la fonctionnelle, sa valeur est nulle.

Exemple : Jb = ADD.get("CostFunctionJb")[:]

CostFunctionJo

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $J^o$ , c’est-à-dire de la partie écart à l’observation.

Exemple : Jo = ADD.get("CostFunctionJo")[:]

CurrentState

Liste de vecteurs. Chaque élément est un vecteur d’état courant utilisé au cours du déroulement itératif de l’algorithme utilisé.

Exemple : xs = ADD.get("CurrentState")[:]

Ensemble des sorties à la demande (conditionnelles ou non)

L’ensemble des sorties (conditionnelles ou non) de l’algorithme, classées par ordre alphabétique, est le suivant :

Analysis

Liste de vecteurs. Chaque élément de cette variable est un état optimal $\mathbf{x}^*$ en optimisation, une interpolation ou une analyse $\mathbf{x}^a$ en assimilation de données.

Exemple : xa = ADD.get("Analysis")[-1]

BMA

Liste de vecteurs. Chaque élément est un vecteur d’écart entre l’ébauche et l’état optimal.

Exemple : bma = ADD.get("BMA")[-1]

CostFunctionJ

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $J$ choisie.

Exemple : J = ADD.get("CostFunctionJ")[:]

CostFunctionJb

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $J^b$ , c’est-à-dire de la partie écart à l’ébauche. Si cette partie n’existe pas dans la fonctionnelle, sa valeur est nulle.

Exemple : Jb = ADD.get("CostFunctionJb")[:]

CostFunctionJo

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $J^o$ , c’est-à-dire de la partie écart à l’observation.

Exemple : Jo = ADD.get("CostFunctionJo")[:]

CostFunctionJAtCurrentOptimum

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $J$ . A chaque pas, la valeur correspond à l’état optimal trouvé depuis le début.

Exemple : JACO = ADD.get("CostFunctionJAtCurrentOptimum")[:]

CostFunctionJbAtCurrentOptimum

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $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. Si cette partie n’existe pas dans la fonctionnelle, sa valeur est nulle.

Exemple : JbACO = ADD.get("CostFunctionJbAtCurrentOptimum")[:]

CostFunctionJoAtCurrentOptimum

Liste de valeurs. Chaque élément est une valeur de fonctionnelle d’écart $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.

Exemple : JoACO = ADD.get("CostFunctionJoAtCurrentOptimum")[:]

CurrentIterationNumber

Liste d’entiers. Chaque élément est l’index d’itération courant au cours du déroulement itératif de l’algorithme utilisé. Il y a une valeur d’index d’itération par pas d’assimilation correspondant à un état observé.

Exemple : cin = ADD.get("CurrentIterationNumber")[-1]

CurrentOptimum

Liste de vecteurs. Chaque élément est le vecteur d’état optimal au pas de temps courant au cours du déroulement itératif de l’algorithme d’optimisation utilisé. Ce n’est pas nécessairement le dernier état.

Exemple : xo = ADD.get("CurrentOptimum")[:]

CurrentState

Liste de vecteurs. Chaque élément est un vecteur d’état courant utilisé au cours du déroulement itératif de l’algorithme utilisé.

Exemple : xs = ADD.get("CurrentState")[:]

EnsembleOfSimulations

Liste de vecteurs ou matrice. Chaque élément est une collection ordonnée de vecteurs d’état physique ou d’état simulé éventuellement observé $\mathbf{y}$ . Ce sont des sorties d’opérateur $H$ , c’est-à-dire des états d’observation simulés (nommés « snapshots » en terminologie de bases réduites). A chaque index de pas, il y a 1 état par colonne si cette liste est sous forme matricielle, ou 1 état par élément si c’est effectivement une liste. Important : la numérotation du support ou des points, sur lequel ou auxquels sont fournis une valeur d’état dans chaque vecteur, est implicitement celle de l’ordre naturel de numérotation du vecteur d’état, de 0 à la « taille moins 1 » de ce vecteur.

Exemple : {"EnsembleOfSimulations":[y1, y2, y3...]}

EnsembleOfStates

Liste de vecteurs ou matrice. Chaque élément est une collection ordonnée de vecteurs d’état physique ou d’état paramétrique $\mathbf{x}$ . Ce sont des entrées d’opérateur $H$ , c’est-à-dire des états courants avant observation. A chaque index de pas, il y a 1 état par colonne si cette liste est sous forme matricielle, ou 1 état par élément si c’est effectivement une liste. Important : la numérotation du support ou des points, sur lequel ou auxquels sont fournis une valeur d’état dans chaque vecteur, est implicitement celle de l’ordre naturel de numérotation du vecteur d’état, de 0 à la « taille moins 1 » de ce vecteur.

Exemple : {"EnsembleOfStates":[x1, x2, x3...]}

IndexOfOptimum

Liste d’entiers. Chaque élément est l’index d’itération de l’optimum obtenu au cours du déroulement itératif de l’algorithme d’optimisation utilisé. Ce n’est pas nécessairement le numéro de la dernière itération.

Exemple : ioo = ADD.get("IndexOfOptimum")[-1]

Innovation

Liste de vecteurs. Chaque élément est un vecteur d’innovation, qui est en statique l’écart de l’optimum à l’ébauche, et en dynamique l’incrément d’évolution.

Exemple : d = ADD.get("Innovation")[-1]

InnovationAtCurrentState

Liste de vecteurs. Chaque élément est un vecteur d’innovation à l’état courant avant analyse.

Exemple : ds = ADD.get("InnovationAtCurrentState")[-1]

OMA

Liste de vecteurs. Chaque élément est un vecteur d’écart entre l’observation et l’état optimal dans l’espace des observations.

Exemple : oma = ADD.get("OMA")[-1]

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.

Exemple : omb = ADD.get("OMB")[-1]

SimulatedObservationAtBackground

Liste de vecteurs. Chaque élément est un vecteur d’observation simulé par l’opérateur d’observation à partir de l’ébauche $\mathbf{x}^b$ . C’est la prévision à partir de l’ébauche, elle est parfois appelée « Dry ».

Exemple : hxb = ADD.get("SimulatedObservationAtBackground")[-1]

SimulatedObservationAtCurrentOptimum

Liste de vecteurs. Chaque élément est un vecteur d’observation simulé par l’opérateur d’observation à 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.

Exemple : hxo = ADD.get("SimulatedObservationAtCurrentOptimum")[-1]

SimulatedObservationAtCurrentState

Liste de vecteurs. Chaque élément est un vecteur d’observation simulé par l’opérateur d’observation à partir de l’état courant, c’est-à-dire dans l’espace des observations.

Exemple : hxs = ADD.get("SimulatedObservationAtCurrentState")[-1]

SimulatedObservationAtOptimum

Liste de vecteurs. Chaque élément est un vecteur d’observation obtenu par l’opérateur d’observation à partir de la simulation d’analyse ou d’état optimal $\mathbf{x}^a$ . C’est l’observation de la prévision à partir de l’analyse ou de l’état optimal, et elle est parfois appelée « Forecast ».

Exemple : hxa = ADD.get("SimulatedObservationAtOptimum")[-1]

13.4.5. Exemples d’utilisation en Python (TUI)¶

Voici un ou des exemples très simple d’usage de l’algorithme proposé et de ses paramètres, écrit en [DocR] Interface textuelle pour l’utilisateur (TUI/API). De plus, lorsque c’est possible, les informations indiquées en entrée permettent aussi de définir un cas équivalent en interface graphique [DocR] Interface graphique pour l’utilisateur (GUI/EFICAS).

Cet exemple décrit le recalage des paramètres $\mathbf{x}$ d’un modèle d’observation $H$ quadratique. Ce modèle est représenté ici comme une fonction nommée QuadFunction. Cette fonction accepte en entrée le vecteur de coefficients $\mathbf{x}$ , et fournit en sortie le vecteur $\mathbf{y}$ d’évaluation du modèle quadratique aux points de contrôle internes prédéfinis dans le modèle. Le calage s’effectue sur la base d’un jeu initial de coefficients (état d’ébauche désigné par Xb dans l’exemple), et avec l’information $\mathbf{y}^o$ (désignée par Yobs dans l’exemple) de 5 mesures obtenues à ces mêmes points de contrôle internes. On se place en expériences jumelles (voir Pour tester une chaîne d’assimilation de données : les expériences jumelles) et les mesures sont parfaites. On privilégie les observations au détriment de l’ébauche par l’indication d’une très importante variance d’erreur d’ébauche, ici de $10^{6}$ .

L’ajustement s’effectue en affichant des résultats intermédiaires lors de l’optimisation itérative.

# -*- coding: utf-8 -*-
#
from numpy import array, ravel
def QuadFunction( coefficients ):
    """
    Simulation quadratique aux points x : y = a x^2 + b x + c
    """
    a, b, c = list(ravel(coefficients))
    x_points = (-5, 0, 1, 3, 10)
    y_points = []
    for x in x_points:
        y_points.append( a*x*x + b*x + c )
    return array(y_points)
#
Xb   = array([1., 1., 1.])
Yobs = array([57, 2, 3, 17, 192])
#
print("Résolution du problème de calage")
print("--------------------------------")
print("")
from adao import adaoBuilder
case = adaoBuilder.New()
case.setBackground( Vector = Xb, Stored=True )
case.setBackgroundError( ScalarSparseMatrix = 1.e6 )
case.setObservation( Vector = Yobs, Stored=True )
case.setObservationError( ScalarSparseMatrix = 1. )
case.setObservationOperator( OneFunction = QuadFunction )
case.setAlgorithmParameters(
    Algorithm="DerivativeFreeOptimization",
    Parameters={
        "MaximumNumberOfIterations": 100,
        "StoreSupplementaryCalculations": [
            "CurrentState",
            ],
        },
    )
case.setObserver(
    Info="  État intermédiaire en itération courante :",
    Template="ValuePrinter",
    Variable="CurrentState",
    )
case.execute()
print("")
#
#-------------------------------------------------------------------------------
#
print("Calage de %i coefficients pour une forme quadratique 1D sur %i mesures"%(
    len(case.get("Background")),
    len(case.get("Observation")),
    ))
print("--------------------------------------------------------------------")
print("")
print("Vecteur d'observation.............:", ravel(case.get("Observation")))
print("État d'ébauche a priori...........:", ravel(case.get("Background")))
print("")
print("Coefficients théoriques attendus..:", ravel((2,-1,2)))
print("")
print("Nombre d'itérations...............:", len(case.get("CurrentState")))
print("Nombre de simulations.............:", len(case.get("CurrentState")))
print("Coefficients résultants du calage.:", ravel(case.get("Analysis")[-1]))
#
Xa = case.get("Analysis")[-1]
import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (10, 4)
#
plt.figure()
plt.plot((-5,0,1,3,10),QuadFunction(Xb),"b--",label="Simulation à l'ébauche")
plt.plot((-5,0,1,3,10),Yobs,            "kX", label="Observation",markersize=10)
plt.plot((-5,0,1,3,10),QuadFunction(Xa),"r-", label="Simulation à l'optimum")
plt.legend()
plt.title("Calage de coefficients", fontweight="bold")
plt.xlabel("Coordonnée arbitraire")
plt.ylabel("Observations")
plt.savefig("simple_DerivativeFreeOptimization.png")

Le résultat de son exécution est le suivant :

Résolution du problème de calage
--------------------------------

  État intermédiaire en itération courante : [1. 1. 1.]
  État intermédiaire en itération courante : [2. 1. 1.]
  État intermédiaire en itération courante : [1. 2. 1.]
  État intermédiaire en itération courante : [1. 1. 2.]
  État intermédiaire en itération courante : [0. 1. 1.]
  État intermédiaire en itération courante : [1. 0. 1.]
  État intermédiaire en itération courante : [1. 1. 0.]
  État intermédiaire en itération courante : [1.82475484 1.96682811 1.18582936]
  État intermédiaire en itération courante : [1.89559338 0.54235283 1.17221593]
  État intermédiaire en itération courante : [ 1.90222657 -0.20823061  1.83295831]
  État intermédiaire en itération courante : [ 1.94478151 -0.55541624  2.76978872]
  État intermédiaire en itération courante : [ 2.04021458 -1.49397981  2.43813988]
  État intermédiaire en itération courante : [ 2.26677171 -0.58498556  2.84248383]
  État intermédiaire en itération courante : [ 1.9902328  -1.04021448  2.88338819]
  État intermédiaire en itération courante : [ 1.98695318 -0.92116383  2.47695648]
  État intermédiaire en itération courante : [ 1.99320312 -1.02368518  2.64731215]
  État intermédiaire en itération courante : [ 1.79473809 -0.96379959  2.44856121]
  État intermédiaire en itération courante : [ 1.98630908 -0.91207212  2.5394595 ]
  État intermédiaire en itération courante : [ 1.99262279 -0.97073591  2.4801914 ]
  État intermédiaire en itération courante : [ 1.99434434 -0.99814626  2.51840027]
  État intermédiaire en itération courante : [ 1.98838712 -0.93500739  2.44986416]
  État intermédiaire en itération courante : [ 1.99080633 -0.94768294  2.46780354]
  État intermédiaire en itération courante : [ 2.01588592 -0.97086338  2.47667529]
  État intermédiaire en itération courante : [ 1.99098142 -0.96519905  2.48111896]
  État intermédiaire en itération courante : [ 1.99157918 -0.97086422  2.47290017]
  État intermédiaire en itération courante : [ 1.9929175  -0.98359308  2.45753186]
  État intermédiaire en itération courante : [ 1.99550241 -1.01497755  2.43286745]
  État intermédiaire en itération courante : [ 1.99505414 -1.00691754  2.44681334]
  État intermédiaire en itération courante : [ 1.97993261 -1.01100857  2.43408454]
  État intermédiaire en itération courante : [ 1.99503312 -1.0022575   2.42298652]
  État intermédiaire en itération courante : [ 1.99337049 -0.98139127  2.3984825 ]
  État intermédiaire en itération courante : [ 1.99387512 -0.97303786  2.33457311]
  État intermédiaire en itération courante : [ 1.99742055 -0.99371791  2.20738214]
  État intermédiaire en itération courante : [ 2.0002882  -0.98541744  1.96740743]
  État intermédiaire en itération courante : [ 2.00047429 -0.99646137  2.01501424]
  État intermédiaire en itération courante : [ 2.0009106  -1.00072301  2.00881512]
  État intermédiaire en itération courante : [ 1.9909278  -1.00127001  2.00860374]
  État intermédiaire en itération courante : [ 2.0009174  -1.00688459  2.01669134]
  État intermédiaire en itération courante : [ 1.99994608 -1.00029476  2.00923274]
  État intermédiaire en itération courante : [ 2.00031465 -1.00202777  1.98931137]
  État intermédiaire en itération courante : [ 1.99389877 -1.00336389  2.01658192]
  État intermédiaire en itération courante : [ 2.00003478 -1.00017674  1.99950089]
  État intermédiaire en itération courante : [ 1.99970222 -0.99882654  1.99924329]
  État intermédiaire en itération courante : [ 2.00000228 -0.99960552  1.99820757]
  État intermédiaire en itération courante : [ 2.00103142 -1.0000571   1.9985047 ]
  État intermédiaire en itération courante : [ 1.99925894 -1.0009752   1.9986288 ]
  État intermédiaire en itération courante : [ 1.99998604 -0.99994926  2.00089583]
  État intermédiaire en itération courante : [ 2.00000344 -0.99996363  1.9994818 ]
  État intermédiaire en itération courante : [ 1.99980383 -0.99996386  1.9994693 ]
  État intermédiaire en itération courante : [ 1.99998362 -0.99985392  1.99931575]
  État intermédiaire en itération courante : [ 2.00000605 -1.00001563  1.9996749 ]
  État intermédiaire en itération courante : [ 2.00000343 -1.00002045  1.99987483]
  État intermédiaire en itération courante : [ 2.00000165 -1.0000257   2.00006119]
  État intermédiaire en itération courante : [ 2.00000167 -1.00001085  1.99996478]

Calage de 3 coefficients pour une forme quadratique 1D sur 5 mesures
--------------------------------------------------------------------

Vecteur d'observation.............: [ 57.   2.   3.  17. 192.]
État d'ébauche a priori...........: [1. 1. 1.]

Coefficients théoriques attendus..: [ 2 -1  2]

Nombre d'itérations...............: 54
Nombre de simulations.............: 54
Coefficients résultants du calage.: [ 2.00000167 -1.00001085  1.99996478]

Les graphiques illustrant le résultat de son exécution sont les suivants :

_images/simple_DerivativeFreeOptimization.png

13.4.6. Voir aussi¶

Références vers d’autres sections :

Références bibliographiques :