Discussion :

[Seabirds]

Bonjour à toutes et à tous

Je suis en train de coder un framework bayésien.
Le principe c'est ça : on a des modèles mathématiques qui sont des fonction paramétrées :
- Linéaire : y = a.x+b, => deux paramètres a et b
- Foo : y = m.x^d + c => trois paramètres m, d, c
- etc... pour une collection de fonctions.

On veut faire des simulations basées sur ces fonctions, en faisant varier les paramètres de chaque fonction à chaque simulation. Pour faire varier chaque paramètre, il faut faire un tirage dans un "prior", c'est à dire une distribution de probabilité bien précise, elle-même paramétrée. Par exemple une uniforme.

J'ai fait un arbre d'héritage qui me semblait cool (donc évidemment qui pose problème ) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class IMathematicalParametrizedFunction
{
    public:
 
    ...
    virtual double operator()() const = 0; // On peut rien dire sur quoi appliquer la fonction
    virtual void SetParameters() = 0; // On peut rien dire sur le nombre de paramètres
 
    protected:
        std::string _name;
        std::string _expression;
        std::map<std::string, double> _parameters;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class Linear : public IMathematicalParametrizedFunction
{
    public:
        ...
        double operator()(const double &x) const; // On applique la linéaire sur un réel
        void SetParameters(const double & a, const double & b); // Il y a deux paramètres à modifier
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class IPriorDistribution : public IMathematicalParametrizedFunction
{
    public:
        ...
        virtual double operator()(void) const = 0; // On sait ici qu'il n'y aura pas besoin d'argument, faut juste faire un tirage aléatoire.
        void SetParameters(); // On peut toujours rien dire sur le nombre de paramètres à prendre
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class Uniform : public IPriorDistribution
{
    public:
        ...
        double operator()(void) const;
        void SetParameters(const double & a, const double & b); // Signature différente.
}

Et bon vous vous en douterez il y a pas mal de soucis avec les signatures, et donc des fonction virtuelles pure non implémentées dans les classes dérivées. Comment faudrait-il que je m'y prenne ? J'ai lu ce fil là : http://www.developpez.net/forums/d13...ture-variable/
Il y a bien l'idée de faire un vector, mais (je crois que ?) je perds la transparence sur les paramètres. En effet, les paramètres ont une signification bien précise selon la place qu'ils ont dans l'expression de la fonction, ils ont également un nom "consacré" par la littérature (genre a et b pour la linéaire, ou lower/upper ou a/b pour l'uniforme, ou lambda pour la Poisson.).

Je m'étonne de pas pouvoir dire dans la classe ancestrale : "Mes filles ont besoin de ce comportement là pour fonctionner, mais je ne peux rien dire sur leur signature".

Des idées/contestations/suggestions ?
Merci d'avance !!!
Cordialement,

[Edit] : ici http://stackoverflow.com/questions/2...tual-functions ils proposent de stocker les paramètres au moment de la construction, ce que je fais déjà. Mais je n'avais pas envie de reconstruire l'objet de 0 à chaque ré-actualisation de ses valeurs de paramètres :/

[ternel]

A part que tu pars sur quelque chose de plus complexe que ca n'a l'air, tu peux utiliser des définitions par morceaux:

un begin/end sur la liste des parametres à définir
une fonction définir_parametre(nom, valeur).

Regarde tout de même du coté de boost::phoenix ou boost::je sais plus quoi qui parle de functional ou de high order.
Ils ont des choses toutes faites pour ca.
l'une des bibliothèques permet d'écrire directement les expressions mathématiques qu'il te faux.

[Seabirds]

Merci de ta réponse
En route pour les librairies, j'avais cherché une librairie proposant des classes pour le bayésien mais échec !

A part que tu pars sur quelque chose de plus complexe que ca n'a l'air, tu peux utiliser des définitions par morceaux:

Complexe par erreur de conception, ou complexe par nature ?

[Bousk]

Salut,

es-tu obligé de le faire en C++ ? C'est typiquement un truc pour lequel Python sera très bien.
Sinon ce que tu recherches c'est des variadic fonctions, ou les variadic templates. Mais c'est (quasi?) impossible de faire de l'héritage avec ces bestioles.
Sinon si tes paramètres sont tous du même type : tableau

[Seabirds]

Salut Bousk merci de ta réponse. C'est noté pour python le jour où je fais des projets plus légers, d'ailleurs on me l'a déjà conseillé. Mais là c'est sensé envoyer du lourd côté simulatoire, donc on m'a conseillé C++
Les paramètres sont tous du même type.

[Bousk]

Salut Bousk merci de ta réponse. C'est noté pour python le jour où je fais des projets plus légers, d'ailleurs on me l'a déjà conseillé. Mais là c'est sensé envoyer du lourd côté simulatoire, donc on m'a conseillé C++
Les paramètres sont tous du même type.

Je me méfierai de ce que veut dire "envoyer du lourd côté simulation", c'est souvent disproportionné comme énoncé. Et il vaut mieux avoir un résultat rapide, lentement, surtout quand on maitrise pas. Si c'est pour perdre 3 semaines à comprendre comment marche le C++ alors qu'un script Python peut les sortir en 24h..
Sinon ben y'a pas photo : tableau de double en paramètre et hop.
Tu peux même te risquer à un virtual double operator()(double[] args) const si t'es sur de ton coup (nombre et ordre des paramètres), sans avoir besoin de passer par un array ou vector.

[Iradrille]

Hello,

Je m'étonne de pas pouvoir dire dans la classe ancestrale : "Mes filles ont besoin de ce comportement là pour fonctionner, mais je ne peux rien dire sur leur signature".

Des idées/contestations/suggestions ?

Quelque chose du chose n'irait pas ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
struct Fct {
    virtual double operator()(double x) const = 0;
 
    virutal ~Fct( ) { };
 
    std::string const& name(unsigned i) const {
        return m_names[i];
    }
 
    void param(unsigned i, double p) {
        m_params[i] = p;
    }
 
    double param(unsigned i) const {
        return m_params[i];
    }
 
    unsigned nParams() const {
        return m_params.size();
    }
 
private:
    std::vector<double> m_params;
    std::vector<std::string> m_names;
}
 
struct LinearFct : Fct {
    LinearFct() { // 2 paramètres 'a' et 'b'
        m_params.emplace_back(0.0);
        m_params.emplace_back(0.0);
 
        m_names.emplace_back("a");
        m_names.emplace_back("b");
    }
 
    virtual double operator()(double x) const override {
        return x * param(0) + param(1);
    }
}
 
struct UniformFct : Fct {
    UniformFct() { // un paramètre 'x'
        m_params.emplace_back(0.0);
 
        m_names.emplace_back("x");
    }
 
    virtual double operator()(double) const override {
        return param(0);
    }
}
 
std::vector<Fct*> fcts;
fcts.emplace_back(new LinearFct);
fcts.emplace_back(new UniformFct);
 
// pour chaque fonction
for(auto fct: fcts) {
 
    // pour chaque paramètre
    for(unsigned i=0; i<fct->nParams(); ++i) {
 
        // lui donner une valeur et afficher son nom
        fct->param(i, 42.0);
        std::cout << fct->name(i) << std::endl;
    }
 
    // calculer f(x) pour 10 <= x < 20
    for(int x=10; x<20; ++x) {
        std::cout << (*fct)((double)x) << std::endl;
    }
}

[Seabirds]

Je me méfierai de ce que veut dire "envoyer du lourd côté simulation", c'est souvent disproportionné comme énoncé. Et il vaut mieux avoir un résultat rapide, lentement, surtout quand on maitrise pas. Si c'est pour perdre 3 semaines à comprendre comment marche le C++ alors qu'un script Python peut les sortir en 24h..

D'accord avec toi. Mais là c'est vraiment le cas. Le modèle est assez complexe, et c'est suffisamment lourd (grosses matrices et arbres recalculés des millions de fois pour explorer l'espace des paramètres) pour que les capacités actuelles de calcul soit considérées par la communauté scientifique comme le facteur limitant dans ce genre d'analyse stat.

Merci pour vos tuyaux
Cordialement,

[stendhal666]

Tout dépend de la façon dont tu appelles ces fonctions par la suite, je ne suis pas sûr de saisir exactement le contexte ni l'utilité exacte de cette belle hiérarchie que tu as construite. Au passage, pour les performances, les fonctions virtuelles ne sont pas le top. C++ n'est pas seulement un langage objet et il y a quelques bonnes raisons pour cela.

Les fonctions lambda sont disponibles en C++ aussi maintenant, et avec les templates variadiques (qui sont certes assez compliqués), C++ se rapproche assez bien de l'expressivité de Python. Même le typage est assez simplifié avec auto.

Il y a peut-être une piste du côté de la programmation fonctionnelle: on y considère qu'une fonction à deux arguments est en fait une fonction à un argument, qui renvoie une fonction à un argument. Par exemple, pour l'addition on ferait normalement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int plus(int x, int y) { return x+y; }

Mais on pourrait aussi écrire (à partir de C++14):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

auto plus(int x) { return [](int y) { x+y; }; }

et invoquer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

plus(2)(3);

En définissant ainsi les différents opérateurs mathématiques, tu peux composer les fonctions les plus compliquées.
Autrement dit la composition de fonction est une alternative à l'héritage des classes.

[Seabirds]

Tout dépend de la façon dont tu appelles ces fonctions par la suite, je ne suis pas sûr de saisir exactement le contexte ni l'utilité exacte de cette belle hiérarchie que tu as construite. Au passage, pour les performances, les fonctions virtuelles ne sont pas le top. C++ n'est pas seulement un langage objet et il y a quelques bonnes raisons pour cela..

Merci de ta réponse

En gros j'aimerais faire bouger un modèle mathématique paramétré dans l'espace de ses paramètres. Selon l'application qu'on en souhaite, le modèle est variable dans sa composition (fonctions, paramètres, prior), donc la dimension de l'espace et le nom des dimensions sont également variables, et la manière de se déplacer dans cet espace doit également pouvoir être choisie par l'utilisateur, et il faut évidemment parvenir à s'y retrouver automatiquement dans tout ça Du coup le but de cette hiérarchie c'est de rendre l'implémentation du modèle indépendant du choix des fonctions qui le définissent. Enfin ça c'est vu par le noob que je suis hein...

C'est noté pour les performances et les fonctions virtuelles. "Heureusement" cette partie là du code n'est pas attendue comme étant celle qui posera des problèmes de performances (ce sera plutôt le calcul matriciel).

Oui, la programmation fonctionnelle c'est ce que j'utilisais sur R pour répondre à cette problématique. Il y avait un moyen très facile de récupérer les paramètres/arguments d'une fonction sous forme de string, et donc d'itérer dessus, et aussi de récupérer sous forme de string le nom de la fonction... Merci !

[foetus]

Si tu veux coder rapidement (et si tu n'as pas beaucoup de fonctions à gérer), sans te prendre la tête et pas trop salement (avec l'utilisation de switch)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
typedef struct s_Linear_Params {
    double a;
    double b;
 
    s_Linear_Params() { clear(); }
 
    s_Linear_Params(const s_Linear_Params& other) { a = other.a; b = other.b; }
 
    /* ... */
 
    void clear() { a = 0.0; b = 0.0;  }
} Linear_Params;
 
 
typedef struct s_Foo_Params {
    int m;
    int d;
    int c;
 
    s_Foo_Params() { clear(); }
 
    s_Foo_Params(const s_Foo_Params& other) { m = other.m; d = other.d; c = other.c; }
 
    /* ... */
 
    void clear() { m = 0; d = 0; c = 0;  }
} Foo_Params;
 
 
class Function_Manager {
public:
 
    enum TYPE_ID {
        TYPE_LINEAR = 0,
        TYPE_FOO
    }
 
 
// Constructor
public:
 
    Function_Manager() { clear(); }
 
 
// Public Interface - Linear Functions
public:
 
    void clear() {
        linear_params.clear();
        foo_params.clear();
    }
 
 
// Public Interface - Linear Functions
public:
 
    void resolve_linear_function();
 
    void set_linear_params(double init_a, double init_b) {
        linear_params.a = init_a;
        linear_params.b = init_b;
    }
 
    void set_linear_params(const Linear_Params& params) {
        linear_params = params;
    }
 
 
// Public Interface - Foo Functions
public:
 
    void resolve_foo_function();
 
    void set_foo_params(int init_m, int init_d, int init_c) {
        foo_params.m = init_m;
        foo_params.d = init_d;
        foo_params.c = init_c;
    }
 
    void set_foo_params(const Foo_Params& params) {
        foo_params = params;
    }
 
 
// Attributes
private:
 
    Linear_Params linear_params;
 
    Foo_Params foo_params;
};

[Seabirds]

Si tu veux coder rapidement (et si tu n'as pas beaucoup de fonctions à gérer), sans te prendre la tête et pas trop salement (avec l'utilisation de switch)

Merci A vrai dire j'avais envie d'éviter cette solution (oui j'aime bien péter plus haut que mon cul et me prendre la tête pour rien)
La justification, c'est qu'on n'a pas encore vraiment idée du nombre de fonctions à embarquer...

[Seabirds]

Hello,



Quelque chose du chose n'irait pas ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
struct Fct {
    virtual double operator()(double x) const = 0;
 
    virutal ~Fct( ) { };
 
    std::string const& name(unsigned i) const {
        return m_names[i];
    }
 
    void param(unsigned i, double p) {
        m_params[i] = p;
    }
 
    double param(unsigned i) const {
        return m_params[i];
    }
 
    unsigned nParams() const {
        return m_params.size();
    }
 
private:
    std::vector<double> m_params;
    std::vector<std::string> m_names;
}
 
struct LinearFct : Fct {
    LinearFct() { // 2 paramètres 'a' et 'b'
        m_params.emplace_back(0.0);
        m_params.emplace_back(0.0);
 
        m_names.emplace_back("a");
        m_names.emplace_back("b");
    }
 
    virtual double operator()(double x) const override {
        return x * param(0) + param(1);
    }
}
 
struct UniformFct : Fct {
    UniformFct() { // un paramètre 'x'
        m_params.emplace_back(0.0);
 
        m_names.emplace_back("x");
    }
 
    virtual double operator()(double) const override {
        return param(0);
    }
}
 
std::vector<Fct*> fcts;
fcts.emplace_back(new LinearFct);
fcts.emplace_back(new UniformFct);
 
// pour chaque fonction
for(auto fct: fcts) {
 
    // pour chaque paramètre
    for(unsigned i=0; i<fct->nParams(); ++i) {
 
        // lui donner une valeur et afficher son nom
        fct->param(i, 42.0);
        std::cout << fct->name(i) << std::endl;
    }
 
    // calculer f(x) pour 10 <= x < 20
    for(int x=10; x<20; ++x) {
        std::cout << (*fct)((double)x) << std::endl;
    }
}

Désolé Iradrille je viens juste de m'apercevoir que j'avais loupé ton message. Je regarde ça