14.8. Algorithme de vérification « ParallelFunctionTest »¶

Description¶

Cet algorithme permet de vérifier qu’un opérateur $F$ quelconque, dont en particulier celui d’observation, fonctionne correctement en parallèle et que son appel se déroule de manière compatible avec son usage dans les algorithmes d’ADAO. De manière pratique, il permet d’appeler une ou plusieurs fois l’opérateur en parallèle, en activant ou non le mode « debug » lors de l’exécution.

Une statistique sur les vecteurs en entrée et en sortie de chaque exécution de l’opérateur est indiquée, et une autre globale est fournie de manière récapitulative à la fin de l’algorithme de vérification. La précision d’affichage est contrôlable pour permettre l’automatisation des tests d’opérateur. Il peut être aussi utile de vérifier préalablement les entrées elles-mêmes avec le test prévu Algorithme de vérification « InputValuesTest ».

Commandes requises et optionnelles¶

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

CheckingPoint: Vecteur. La variable désigne le vecteur utilisé comme l’état autour duquel réaliser le test requis, noté $\mathbf{x}$ , similaire à l’ébauche $\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.

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 de vérification. 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 :

NumberOfPrintedDigits

Valeur entière. Cette clé indique le nombre de décimales de précision pour les affichages de valeurs réelles. La valeur par défaut est 5, avec un minimum de 0.

Exemple : {"NumberOfPrintedDigits":5}

NumberOfRepetition

Valeur entière. Cette clé indique le nombre de fois où répéter l’évaluation de la fonction. La valeur par défaut est 1.

Exemple : {"NumberOfRepetition":3}

SetDebug

Valeur booléenne. La variable conduit à l’activation, ou pas, du mode de débogage durant l’évaluation de la fonction ou de l’opérateur. La valeur par défaut est « True », les choix sont « True » ou « False ».

Exemple : {"SetDebug":False}

ShowElementarySummary

Valeur booléenne. La variable conduit à l’activation, ou pas, du calcul et de l’affichage d’un résumé à chaque évaluation élémentaire du test. La valeur par défaut est « True », les choix sont « True » ou « False ».

Exemple : {"ShowElementarySummary":False}

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 ») : [ « CurrentState », « SimulatedObservationAtCurrentState », ].

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

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, de la variable « ADD » du post-processing en interface graphique, ou du 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 l”Inventaire des informations potentiellement disponibles en sortie.

Sorties permanentes (non conditionnelles)

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

Aucune

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 :

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")[:]

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]

Exemples d’utilisation en Python (TUI)¶

Voici un exemple très simple d’usage de l’algorithme proposé et de ses paramètres, écrit en [DocR] Interface textuelle pour l’utilisateur (TUI/API), et dont les informations indiquées en entrée permettent de définir un cas équivalent en interface graphique.

Cet exemple décrit le test du bon fonctionnement d’un opérateur quelconque, et que son appel se déroule de manière compatible avec son usage courant en parallèle dans les algorithmes d’ADAO. Les information nécessaires sont minimales, à savoir ici un opérateur $F$ (décrit pour le test par la commande d’observation « ObservationOperator »), et un état $\mathbf{x}^b$ sur lequel le tester (décrit pour le test par la commande « CheckingPoint »).

Le test est répété un nombre paramétrable de fois, et une statistique finale permet de vérifier rapidement le bon comportement de l’opérateur. Le diagnostic le plus simple consiste à vérifier, à la toute fin de l’affichage, l’ordre de grandeur des valeurs indiquées comme la moyenne des différences entre les sorties répétées et leur moyenne, sous la partie titrée « Characteristics of the mean of the differences between the outputs Y and their mean Ym ». Pour un opérateur satisfaisant, ces valeurs doivent être proches du zéro numérique.

Note

Il peut être utile de s’assurer que l’évaluation de l’opérateur est réalisée réellement en parallèle, et par exemple qu’il n’y a pas d’utilisation forcée d’une accélération du parallélisme, qui éviterait ainsi un véritable test parallèle. Pour cela, il est recommandé d’utiliser systématiquement le paramètre booléen spécial « EnableMultiProcessingInEvaluation », exclusivement réservé à cet usage, de la commande de déclaration de l’opérateur. L’usage de ce paramètre est illustré dans l’exemple présent. Il n’est à utiliser dans aucun autre cas.

# -*- coding: utf-8 -*-
#
import numpy
from adao import adaoBuilder
#
def SomeOperator( x ):
    return numpy.dot(numpy.eye(x.size), numpy.ravel(x))
#
case = adaoBuilder.New('')
case.setAlgorithmParameters(
    Algorithm='ParallelFunctionTest',
    Parameters={
        'NumberOfRepetition' : 50,
        'NumberOfPrintedDigits' : 2,
        "ShowElementarySummary":False,
        },
    )
case.setCheckingPoint( Vector = range(30) )
case.setObservationOperator(
    OneFunction = SomeOperator,
    Parameters  = {
        "EnableMultiProcessingInEvaluation":True,
        "NumberOfProcesses":5,
        },
    )
case.execute()

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

     PARALLELFUNCTIONTEST
     ====================

     This test allows to analyze the (repetition of) launch of some given
     operator. It shows simple statistics related to its successful execution,
     or related to the similarities of repetition of its execution.

===> Information before launching:
     -----------------------------
     Characteristics of input vector X, internally converted:
       Type...............: <class 'numpy.ndarray'>
       Length of vector...: 30
       Minimum value......: 0.00e+00
       Maximum value......: 2.90e+01
       Mean of vector.....: 1.45e+01
       Standard error.....: 8.66e+00
       L2 norm of vector..: 9.25e+01

     ---------------------------------------------------------------------------

===> Beginning of repeated evaluation, without activating debug

     ---------------------------------------------------------------------------

===> Launching operator parallel evaluation for 50 states


===> End of operator parallel evaluation for 50 states

     ---------------------------------------------------------------------------

===> End of repeated evaluation, without deactivating debug

     ---------------------------------------------------------------------------

===> Launching statistical summary calculation for 50 states

     ---------------------------------------------------------------------------

===> Statistical analysis of the outputs obtained through parallel repeated evaluations

     (Remark: numbers that are (about) under 2e-16 represent 0 to machine precision)

     Characteristics of the whole set of outputs Y:
       Number of evaluations.........................: 50
       Minimum value of the whole set of outputs.....: 0.00e+00
       Maximum value of the whole set of outputs.....: 2.90e+01
       Mean of vector of the whole set of outputs....: 1.45e+01
       Standard error of the whole set of outputs....: 8.66e+00

     Characteristics of the vector Ym, mean of the outputs Y:
       Size of the mean of the outputs...............: 30
       Minimum value of the mean of the outputs......: 0.00e+00
       Maximum value of the mean of the outputs......: 2.90e+01
       Mean of the mean of the outputs...............: 1.45e+01
       Standard error of the mean of the outputs.....: 8.66e+00

     Characteristics of the mean of the differences between the outputs Y and their mean Ym:
       Size of the mean of the differences...........: 30
       Minimum value of the mean of the differences..: 0.00e+00
       Maximum value of the mean of the differences..: 0.00e+00
       Mean of the mean of the differences...........: 0.00e+00
       Standard error of the mean of the differences.: 0.00e+00

     ---------------------------------------------------------------------------

Voir aussi¶

Références vers d’autres sections :