14.11. Algorithme de vérification « ParallelFunctionTest »¶

14.11.1. Description¶

Cet algorithme permet d’analyser de manière simple la stabilité d’un opérateur $F$ lors de son exécution en parallèle. L’opérateur est quelconque, et il peut donc être celui d’observation $\mathcal{H}$ comme celui d’évolution $\mathcal{D}$ , pourvu qu’il soit fourni dans chaque cas selon les Conditions requises pour les fonctions décrivant un opérateur. L’opérateur $F$ est considéré comme dépendant d’une variable vectorielle $\mathbf{x}$ et restituant une autre variable vectorielle $\mathbf{y}$ .

L’algorithme vérifie que l’opérateur fonctionne correctement 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 activant ou non le mode « debug » lors de l’exécution.

Une statistique sur les vecteurs $\mathbf{x}$ en entrée et $\mathbf{y}$ en sortie est indiquée lors de chaque exécution de l’opérateur, et une autre statistique globale est fournie de manière récapitulative à la fin. 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 ».

14.11.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 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 présentent un parallélisme interne, et peuvent donc profiter de ressources informatiques de répartition de calculs. L’interaction potentielle, entre le parallélisme interne des méthodes, et le parallélisme éventuellement présent dans les opérateurs d’observation ou d’évolution intégrant les codes de l’utilisateur, doit donc être soigneusement réglée.

14.11.3. 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 « False », 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":["CurrentState", "Residu"]}

14.11.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 :

Aucune (messages ou statistiques sont néanmoins affichés)

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]

14.11.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 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 « EnableParallelEvaluations », 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.

# -*- 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  = {
        "EnableParallelEvaluations":True,
        "NumberOfProcesses":5,
        },
    )
case.execute()

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

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

     This test allows to analyze the (repetition of the) launch of some
     given simulation operator F, applied to one single vector argument x,
     in a parallel way.
     The output 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

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

     Appending the input vector to the agument set to be evaluated in parallel

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

===> 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)

     Number of evaluations...........................: 50

     Characteristics of the whole set of outputs Y:
       Size of each of the outputs...................: 30
       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

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

     End of the "PARALLELFUNCTIONTEST" verification

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

14.11.6. Voir aussi¶

Références vers d’autres sections :