Institut de la Francophonie pour
l’Informatique
Mémoire de fin d’études
Implémentation d’une copule mutilvariée
Réalisé par :
PHAM Van Trung
Superviseur :
Gildas MAZO
Projet Mistis
Centre de recherche
INRIA Grenoble Rhône-Alpes
29 novembre 2013

Remerciements
Je tiens à exprimer ma profonde gratitude à Gildas Mazo, mon directeur de stage. Il
était toujours prêt à m’avoir donné des aides pour que j’aie pu comprendre bien des
connaissances statistiques nécessaires. Ses commentaires utiles et ses judicieux conseils
m’ont souvent été d’un grand recours pour mener à bien les objectifs de mon stage.
Je tiens également à remercier les membres de l’équipe MISTIS. Grâce à leur soutien,
j’ai pu m’intégrer facilement à l’équipe.
Je voudrais adresser mes sincères remerciements aux professeurs de l’IFI. Leurs cours
m’ont permis d’approfondir mes connaissances sur des langages de programmation tels
que R et C++.
Enfin, je tiens à remercier ma famille, mes amis et notamment ma copine Truong Hong
Van qui m’ont supporté ces six mois de stage. Leurs encouragements m’ont permis d’être
toujours motivé et d’avoir pu remplir mon rôle.
i

Résumé
L’objectif de ce mémoire de fin d’études est d’implémenter une copule multivariée as-
sociée à un Cumulative Distribution Network (CDN). CDN est une fonction de répartition
d’un grand nombre de variables qui se factorise en produit de fonctions de répartition
bivariées. Ce modèle permet de décrire la dépendance entre plusieurs variables aléatoires
via un graphe où les arrêtes représentent les fonctions reliant les variables. La fonction de
vraisemblance est calculée grâce à un algorithme de message-passing. L’inférence dans
le CDN est alors mise en oeuvre via la maximisation de la vraisemblance en utilisant
une méthode d’optimisation.
Toutefois, l’implémentation délicate de ce modèle peut freiner l’utilisateur dans la pra-
tique. Nous nous proposons de l’implémenter et de le rendre disponible sous la forme
d’un paquet R. R est un logiciel de statistique très répandu et de plus en plus utilisé.
Avec ce paquet, il est très facile de construire le graphe et de choisir des familles de
copule paramétriques ainsi que de modéliser des données avec un CDN. Il permet aussi
de calculer la vraisemblance selon l’algorithme de message-passing et de faire l’inférence.
En outre, la vitesse de l’algorithme est augmentée grâce à l’écriture d’une partie du code
en C++.
Mots-clés : Cumulative Distribution Network, copule, vraisemblance, fonction de répartition
multivariée
ii

Abstract
The goal of the thesis aims at implementing a multivariate copula associated with a
Cumulative Distribution Network (CDN). CDN is a high-dimensional cumulative dis-
tribution function (CDF) defined as a product of bivariate CDFs. This model accounts
for dependencies between random variables via a graph where the edges represent the
functions linking the variables. The likelihood function is computed thanks to a message-
passing algorithm. The inference in CDN is performed by optimizing the likelihood
function.
However, the implementation of this model is not available for users in practice. Hence,
we propose to implement it and make it available as an R package. R is a statistical
software widely spread in pratice. Using this package, the users can build easily the
graph, choose parametric copula families and generate data with a CDN. It allows to
compute the likelihood function according to a message-passing algorithm and perform
inference in CDN. Moreover, the speed of the algorithm has been increased by integrating
C++ codes.
Keywords : Cumulative Distribution Network, copula, likelihood, multivariate distri-
bution function
iii

Table des matières
Remerciements i
Résumé ii
Abstract iii
Table des figures vi
Liste des tableaux viii
Contexte du stage 1
1 Introduction 3
1.1 Statistique théorique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1 Modèle statistique . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2 Estimation des paramètres d’un modèle statistique . . . . . . . . . 4
1.1.3 Copules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.4 Cumulative distribution networks . . . . . . . . . . . . . . . . . . . 6
1.1.5 La copule associée au CDN . . . . . . . . . . . . . . . . . . . . . . 8
1.2 Environnement de programmation . . . . . . . . . . . . . . . . . . . . . . 9
1.2.1 R . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.2 Structure d’un paquet R . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.3 Rcpp - Interface entre R et C++ . . . . . . . . . . . . . . . . . . 10
2 Algorithme de gradient-derivative-product 11
2.1 Initialisation de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Propagation des messages . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3 Calcul de la fonction de vraisemblance et son gradient . . . . . . . . . . . 13
3 Implémentation 17
3.1 Structure du paquet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.1.1 Code source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1.2 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.1.3 Tests et tutoriels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2 Fonctions du paquet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.1 Création d’un objet CDN . . . . . . . . . . . . . . . . . . . . . . . 20
3.2.2 Implémentation de l’algorithme de message-passing . . . . . . . . . 22
3.2.3 Estimation des paramètres . . . . . . . . . . . . . . . . . . . . . . 26
iv

Contents v
4 Expérimentations 28
4.1 Précision numérique de l’algorithme de message-passing . . . . . . . . . . 28
4.2 Simulation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.3 Temps d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.4 Application avec un jeu de données réelles . . . . . . . . . . . . . . . . . . 36
5 Conclusions et perspectives 40
Bibliographie 41
A mpAlgo 43
A.1 Initialisation de l’algorithme de message-passing . . . . . . . . . . . . . . 43
A.2 Propagation des messages . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
A.3 Calcul de la densité et du gradient . . . . . . . . . . . . . . . . . . . . . . 47
B cdnOptim 48
B.1 Calcul de la fonction de vraisemblance et son gradient . . . . . . . . . . . 48
B.2 Méthode de Broyden-Fletcher-Goldfarb-Shanno bfgs . . . . . . . . . . . . 49
B.3 Limited-memory BFGS with bounds lbfgsb . . . . . . . . . . . . . . . . . 50
C rCdn, pCdn et dCdn 51
C.1 Génération aléatoire des observations rCdn . . . . . . . . . . . . . . . . . 51
C.2 Calcul de la fonction de répartition pCdn . . . . . . . . . . . . . . . . . . 52
C.3 Calcul de la densité de plusieurs observations dCdn . . . . . . . . . . . . . 52

Table des figures
1.1 Exemple d’un CDN à trois variables . . . . . . . . . . . . . . . . . . . . . 7
1.2 Exemple d’un CDN à sept variables . . . . . . . . . . . . . . . . . . . . . 8
2.1 Exemple d’un arbre de 5 variables . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Propagation des messages dans le CDN . . . . . . . . . . . . . . . . . . . 16
3.1 Composants principaux du paquet CDN . . . . . . . . . . . . . . . . . . . 17
3.2 Code source du paquet CDN . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.3 Documentation du paquet . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.4 Tests et démo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.5 Diagramme des fonctions du paquet . . . . . . . . . . . . . . . . . . . . . 20
3.6 Création d’un objet CDN . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.7 Exemple de transformation d’un graphe des variables en graphe CDN . . 22
3.8 Exemple de simplification du graphe. . . . . . . . . . . . . . . . . . . . . . 23
3.9 Algorithme de message-passing . . . . . . . . . . . . . . . . . . . . . . . . 23
3.10 Calculation de la fonction de répartition normale et ses gradients . . . . . 24
3.11 Appel des libraries/fonctions dans C/C++ . . . . . . . . . . . . . . . . . 25
3.12 Comparaison entre cdnOptim et optim. . . . . . . . . . . . . . . . . . . . 27
4.0 Précision de l’algorithme de message passing avec 5 modèles existants. . . 31
4.1 Précision de l’algorithme de message passing avec le modèle normal . . . . 32
vi

List of Tables vii
4.2 Temps d’exécution du calcul direct et de la fonction mpAlgo (en millise-
condes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3 Plan de 9 sites aux États Unis où les précipitations sont utilisées pour
notre modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.4 Résultats de 6 modèles mutivariés . . . . . . . . . . . . . . . . . . . . . . 39

Liste des tableaux
3.1 Matrice binaire extraite du graphe CDN. . . . . . . . . . . . . . . . . . . . 22
3.2 Comparaison entre le temps du calcul via fonction R et celui du calcul
direct en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.1 Probabilité de l’événement (X1 ≤ x01, X2 ≤ x02, X3 ≤ x03, X4 ≤ x04, X5 ≤
x05) dans les données simulées et F(x0) = F(x01, x02, x03, x04, x05) . . . . 32
4.2 Résultats de l’estimation des paramètres . . . . . . . . . . . . . . . . . . . 34
4.3 Temps d’exécution du calcul direct (en rouge) et de la fonction mpAlgo
(en bleu) (en milisecondes) . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.4 Comparaison entre le temps d’exécution de la fonction optim et cdnOptim
(en secondes) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.5 Erreur quadratique moyenne selon deux modèles . . . . . . . . . . . . . . 37
viii

Contexte du stage
Problématique
Les copules [1, 2] jouent un rôle de plus en plus important dans la construction de
distributions en grande dimension et la description de la dépendance entre les variables
aléatoires. L’une des difficultés de la construction d’une copule mutilvariée réside dans
l’inférence de modèles paramétriques. Une copule multivariée associée à un Cumulative
Distribution Network (CDN) [3] a été proposée. L’intérêt de ce modèle est la capacité
de faire l’inférence via un algorithme de message-pasing [4]. L’estimation des paramètres
est alors mise en oeuvre par la maximisation de la vraisemblance. Toutefois, le code pour
utiliser le CDN ainsi que l’algorithme de message-passing n’est pas disponible. Cela peut
freiner l’utilisateur dans la pratique. C’est la raison pour laquelle nous nous proposons
d’implémenter cet algorithme dans mon stage.
Objectif de stage
L’objectif de mon stage est d’implémenter l’inférence de cette copule multivariée et de
la rendre disponible sous la forme d’un paquet R [5]. Ce paquet qui s’appelle CDN est
disponible pour l’utilisation. Je l’ai présenté dans une communication orale et un poster
en juin 2013 à Lyon lors des deuxièmes rencontres R [6]. Je prévois de le soumettre
sur le dépôt des paquets R (http://cran.r-project.org/) en décembre 2013 après la
publication de [3].
Environnement de stage
Mon stage est réalisé au centre de recherche INRIA Grenoble Rhône-Alpes dans le
cadre du projet MISTIS sous la direction de Mazo Gildas. Cette équipe a pour domaine
d’expertise la modélisation de phénomènes aléatoires complexes en grande dimension
1

List of Tables 2
et les statistiques des valeurs extrêmes, avec pour orientations applicatives privilégiées
le traitement d’images et de données spatiales et dans les domaines biomédicaux et
industriels. Mon stage s’inscrit à l’interface des statistiques des valeurs extrêmes et de
la modélisation statistique en grande dimension.
Plan de mémoire
Ce mémoire se compose des cinq chapitres suivants :
– Chapitre 1. Introduction. Dans ce chapitre, je vais présenter quelques notions
statistiques nécessaires telles que le modèle statistique, la copule, le Cumulative Dis-
tribution Network, l’inférence. L’environnement de programmation, y compris R et
C++, est aussi expliqué.
– Chapitre 2. Algorithme de gradient-derivative-product. Ce chapitre sert à
détailler un algorithme efficace qui permet de calculer la fonction de vraisemblance
dans le Cumulative Distribution Network.
– Chapitre 3. Implémentation. Ce chapitre présente les composants importants du
paquet CDN et comment ils sont installés dans R et C++.
– Chapitre 4. Expérimentations. Dans ce chapitre, je vais faire quelques expérimentations
pour démontrer la précision des résultats obtenus par le paquet CDN, ainsi que ses
avantages. Les applications sur les données simulées et réelles sont aussi montrées.
– Chapitre 5. Conclusion et perspectives. Dans la conclusion, je résume les contri-
butions et les perspectives qui découlent de mon paquet.

Chapitre 1
Introduction
Ce chapitre sert à introduire quelques notions nécessaires sur la statistique théorique
et computationnelle. Cela permet au lecteur de suivre facilement le rapport. Dans la
première partie, ce sont des concepts principaux concernant les modèles statistiques,
les copules, le Cumulative distribution networks (CDN) [7], l’inférence et l’optimisation.
Dans la deuxième, R [5] est présenté comme un langage de programmation afin de
développer des outils efficaces pour le traitement des données et l’analyse statistique.
1.1 Statistique théorique
1.1.1 Modèle statistique
Un modèle statistique se compose de deux ingrédients : une variable aléatoire X et une
fonction de répartition F(x). Cette fonction est définie via la probabilité d’un événement
associé à X comme suit :
F : R → [0, 1]
F(x) = Pr{X ≤ x}. (1.1)
F est une fonction croissante. Si elle est dérivable, la fonction de densité est donnée par :
f(x) =
dF(x)
dx
. (1.2)
Dans ce cas-là, la fonction de répartition s’écrit aussi :
F(x) =
Z x
−∞
f(u)du. (1.3)
3

Chapitre 1. Introduction 4
Dans le cas d’un vecteur aléatoires X = (X1, X2, . . . , Xk), la fonction de répartition
multivariée est donnée par :
F(x1, x2, . . . , xk) = Pr{X1 ≤ x1, X2 ≤ x2, . . . , Xk ≤ xk}. (1.4)
Si les variables Xi sont continues, la densité de probabilité multivariée est donnée par :
f(x1, x2, . . . , xk) =
∂kF(x1, x2, . . . , xk)
∂x1 . . . ∂xk
. (1.5)
La fonction de répartition est alors :
F(x1, x2, . . . , xk) =
Z x1
−∞
. . .
Z xk
−∞
f(u1, . . . , uk)du1 . . . duk. (1.6)
La densité marginale de Xi, i = 1, . . . , k est définie comme :
fXi (xi) =
Z ∞
−∞
. . .
Z ∞
−∞
f(u1, . . . , ui−1, xi, ui+1, . . . uk)du1 . . . dui−1dui+1 . . . duk. (1.7)
Dans le cas de plusieurs variables, par exemple X1 et X2, la marge est donnée par :
fX1,X2 (x1, x2) =
Z ∞
−∞
. . .
Z ∞
−∞
f(x1, x2, u3 . . . , uk)du3 . . . duk. (1.8)
1.1.2 Estimation des paramètres d’un modèle statistique
Soit X1, X2, . . . , Xn (indépendantes et identiquement distribuées) un échantillon d’une
population dont la densité de probabilité est f(.|θ) où θ est un vecteur de paramètres
inconnus de la population. L’objectif de l’estimation est de trouver la vraie valeur du
paramètre θ à partir de cet échantillon. La méthode du maximum de vraisemblance est
la plus efficace asymptotiquement [8]. La vraisemblance est donnée par :
f(X1, X2, . . . , Xn|θ) = f(X1|θ)f(X2|θ) . . . f(Xn|θ). (1.9)
En pratique, il faut donc trouver la valeur de θ qui maximise le log de la vraisemblance :
L(θ) =
n
X
i=1
logf(Xi|θ). (1.10)
Cela correspond à minimiser la fonction −L(θ). Le problème majeur est alors de mini-
miser −L(θ). Ce problème est traité en général de manière numérique. Les méthodes
de type Newton [9] sont très utilisées. Le principe de la méthode de Newton est de
trouver le point qui minimise la fonction −L(θ) à partir d’un point de départ. Après
chaque itération, ce point est mis à jour selon la direction de la descente du gradient

Chapitre 1. Introduction 5
∇θ(−L(θ)). L’algorithme s’arrête quand la valeur du gradient est suffisamment petite.
Basée sur l’idée de la méthode de Newton, les méthodes Broyden-Fletcher-Goldfarb-
Shanno (BFGS) et Limited-memory BFGS (L-BFGS) [9] ont été développées. L’avan-
tage de ces méthodes est leur implémentation pratique. C’est la raison pour laquelle je
les ai utilisées dans mon implémetation.
1.1.3 Copules
Les copules [1, 2] ont pour objectif de modéliser la dépendance de plusieurs variables
aléatoires. On va commencer d’abord une définition de la marge d’une fonction de
répartition.
Définition 1.1.3.1. Soit F une fonction de répartition à n dimensions, x = (x1, . . . , xn) ∈
Rn (n ≥ 2). Sa marge Fi (1 ≤ i ≤ n) est obtenue quand x1, x2, . . . , xi−1, xi+1, . . . , xn
tendent vers +∞ :
Fi(xi) = lim
xxi→+∞
F(x1, . . . , xn). (1.11)
Définition 1.1.3.2. Une copule C : [0, 1]n
→ [0, 1] est une fonction de répartition dont
les marges sont uniformes. Soit le vecteur u = (u1, . . . , un) ∈ [0, 1]n
, les marges de la
copule C sont données par :
Ck(uk) = lim
uuk→1
C(u1, . . . , un) = uk ∀k = 1, . . . , n. (1.12)
Théorème 1.1.3.1 (Sklar [1]). Soit H une fonction de répartition dont les marges F
et G sont continues. Il existe une unique copule C de sorte que ∀x, y ∈ R :
H(x, y) = C(F(x), G(y)). (1.13)
Quelques familles de copule standard [1, 10] sont montrées ci-après :
Cθ(u, v) = exp
−
h
(− ln u)θ
+ (− ln v)θ
i1/θ
, θ ∈ [1, +∞); (1.14)
Cθ(u, v) = uv(1 + θ(1 − u)(1 − v)), θ ∈ [−1, 1]; (1.15)
Cθ(u, v) = −
1
θ
ln
1 +
(e−θu − 1)(e−θv − 1)
(e−θ − 1)
, θ ∈ (0, +∞); (1.16)
Cθ(u, v) =
uv
1 − θ(1 − u)(1 − v)
, θ ∈ [0, 1); (1.17)
Cθ(u, v) = 1 −
h
(1 − u)θ
+ (1 − v)θ
− (1 − u)θ
(1 − v)θ
i1/θ
, θ ∈ [1, +∞); (1.18)

Chapitre 1. Introduction 6
Cθ(u, v) =
Z u
0
Z v
0
1
p
(1 − θ2)
exp
θ2q(x)2
+ θ2q(y)2
− 2θq(x)q(y)
2θ2 − 2
!
dxdy, θ ∈ (−1, 1);
(1.19)
où θ est un paramètre inconnu.
– (1.14) est la famille de copule de Gumbel.
– (1.15) est la famille de copule de Farlie-Gumbel-Morgenstern (FGM).
– (1.16) est la famille de copule de Frank.
– (1.17) est la famille de copule de Ali-Mikhail-Haq (AMH).
– (1.18) est la famille de copule de Joe.
– (1.19) est la famille de copule de Gauss (copule normale). q(x), q(y) sont des fonctions
de quantile :
q(x) =
√
2 erf−1
(2x − 1), x ∈ (0, 1), (1.20)
où erf est la fonction d’erreur :
erf(x) =
1
√
π
Z x
−x
e−t2
dt. (1.21)
1.1.4 Cumulative distribution networks
Cumulative distribution network (CDN) est un modèle statistique proposé dans la thèse
de Huang [7]. Dans ce modèle, la fonction de répartition s’écrit comme un produit
de fonction de répartition bivariées. On lui associe un graphe pour représenter les
dépendances.
Définition 1.4.1. Un graphe biparti G = (V, S, E) est construit à partir de trois en-
sembles : deux ensembles de sommets V et S, un ensemble d’arêtes E. Les arrêtes du
graphe ont une extrémité dans V et l’autre dans S.
Définition 1.4.2. Un Cumulative distribution network (CDN) est un modèle statistique
sous forme d’un graphe biparti G = (V, S, E), où V est un ensemble de noeuds de
variable et S indique un ensemble de noeuds de fonction, E se compose des arêtes entre
des noeuds de variable et de fonctions. Chaque fonction est représentée par φs(xs) :
R|N(s)| → [0, 1] où s ∈ S, N(s) = {s1, . . . , sd} est l’ensemble de voisins de la fonction s
et xs = xN(s) = (xs1, . . . , xsd) où d = |N(s)| est le nombre de voisins de s. Toutes les
fonctions φs doivent satisfaire les propriétés caractéristiques des fonctions de répartition.
La fonction de répartition sur toutes les variables dans le CDN s’écrit :
F(x) =
Y
s∈S
φs(xs), (1.22)

Chapitre 1. Introduction 7
et la densité de probabilité est définie comme suit :
f(x) = ∂x[F(x)], (1.23)
où x = (x1, . . . , xn) et ∂x [F(x)] =
∂F(x)
∂x1, . . . , ∂xn
avec n est le nombre de variables. Pour
faire l’inférence, on considère un CDN comme un modèle paramétrique F(x) = F(x|θ)
ou θ est un vecteur de paramètres. Il faut alors estimer θ comme mentionné dans la
section 1.2. D’abord, le log de vraisemblance est défini comme suit :
L(θ) = logf(x1, x2, . . . , xn|θ) =
n
X
k=1
logf(xk|θ). (1.24)
et son gradient est donné par :
∇θL(θ) =
n
X
k=1
∇θlogf(xk|θ) =
n
X
k=1
∇θf(xk|θ)
f(xk|θ)
. (1.25)
Dans notre cas, nous considérons un CDN avec les contraintes suivantes :
1. Le graphe ne contient aucun cycle. Autrement dit, c’est un arbre de n variables et
n - 1 fonctions.
2. Les feuilles sont des noeuds de variables.
3. Chaque noeud de fonction n’est relié qu’à deux noeuds de variable. En effet, les
fonctions de répartition φs sont bivariées. Cela veut dire que φs(xs) = φs(xα, xβ)
où α, β sont les variables voisines de la fonction s : N(s) = {α, β}.
Exemple 1.4.1. Sur la figure 1.1, c’est un exemple d’un CDN à trois variables. Les
cercles montrent des noeuds de variable et les diamants indiquent les noeuds de fonction.
Alors, la fonction de répartition sur trois variables X1, X2 et X3 dans le CDN est donnée
par :
F(x1, x2, x3) = φ1(x1, x2)φ2(x2, x3). (1.26)
Figure 1.1: Exemple d’un CDN à trois variables.
Exemple 1.4.2. Sur la figure 1.2, c’est un exemple d’un CDN à sept variables. La
fonction de répartition sur sept variables X1, X2, X3, X4, X5, X6, X7 dans le CDN

Chapitre 1. Introduction 8
s’écrit :
F(x1, x2, x3, x4, x5, x6, x7) =φ1(x1, x5)φ2(x2, x3)
φ3(x3, x4)φ4(x3, x5)φ5(x5, x6)φ6(x5, x7).
(1.27)
Figure 1.2: Exemple d’un CDN à sept variables.
1.1.5 La copule associée au CDN
Considérons φs comme une fonction paramétrique, on a : φs = φs(xα, xβ; θs) où θs est
un paramètre inconnu, α, β sont les voisins de s. Nous prenons la fonction φs en fonction
d’une copule :
φs(xα, xβ; θs) = Cs(x1/nα
α , x
1/nβ
β ; θs). (1.28)
où Cs est une copule à choisir ; nα et nβ sont respectivement les nombres de voisins des
variables α et β. Comme Cs est une copule, xα, xβ ∈ [0, 1]. La fonction de répartition
s’écrit alors :
F(x|θ) =
Y
s∈S
Cs(x1/ns
s ; θs), x1/ns
s = (x1/nα
α , x
1/nβ
β ). (1.29)
où x = (x1, . . . , xn) avec n est le nombre de variables, θ = (θs)s∈S. On note que F est
aussi une copule : F(x|θ) = F(x1, . . . , xn|θ) = C(x1, . . . , xn|θ). Cette copule multivariée
montre la dépendance entre toutes les variables x1, . . . , xn. Dans notre paquet, nous
avons implémenté le modèle (1.29) avec les familles de copule de Gumbel, Frank, FGM,
AMH, Joe, Gauss (voir section 1.1.3).
Pour la simulation des données de la fonction de répartition C(x1, . . . , xd|θ), on utilise
le lemme de Liebscher [11] :

Chapitre 1. Introduction 9
– Pour toutes les fonctions s ∈ S, il faut générer (U
(s)
α , U
(s)
β ) ∼ Cs où α, β sont des
variables de voisin de s.
– Il est nécessaire de calculer Uα = maxs∈N(α)
n
(U
(s)
α )
nα
o
, α = 1, . . . , d.
La fonction de répartition du vecteur (U1, U2, . . . , Ud) est C(x1, . . . , xd|θ).
1.2 Environnement de programmation
1.2.1 R
R [5] est un langage de programmation pour le développement des appilcations dans
le traitement des données et l’analyse statistique. Il est développé par GNU. R est
de plus en plus important et connu grâce à ses avantages. Premièrement, R est open
source. C’est libre à utiliser et à développer. Deuxièmement, il permet de faire de la
programmation de haut niveau orienté. Troisièmement, la programmation sous R est
disponible sur plusieurs systèmes d’opération populaires comme Unix, Windows et Ma-
cOS. Quatrièmement, R est associé à plusieurs langages de programmation tels que
C/C++, Fortan. En effet, il permet d’appeler directement le code dans C/C++, For-
tan. Dernièrement, R s’étend facilement via des paquets écrits par les développeurs. En
outre, il existe le dépôt CRAN pourque les développeurs puissent déposer leurs paquets.
1.2.2 Structure d’un paquet R
Normalement, un paquet R se compose des parties suivantes [12] :
– Un fichier Description qui décrit le paquet, l’auteur et la licence.
– Le répertoire man/ contient les fichiers de la documentation.
– Le répertoire R/ est le lieu pour déposer le code source en R.
– Le répertoire data/ fourni les données disponibles dans le paquet.
– Le répertoire src/ contient le code source en C/C++, Fortan.
– Le répertoire tests/ se compose des fichiers R qui sert à vérifier les fonctions fournies
par le paquet.
– Le répertoire exec/ comprend les fichiers exécutables (en Java ou Perl).
– Le répertoire demo/ montre quelques programmes d’exemples.
– Le répertoire vignettes/ donne quelques exemples et renseignements pour l’utilisation
du paquet.

Chapitre 1. Introduction 10
1.2.3 Rcpp - Interface entre R et C++
Les fonctionnalités de R peuvent être étendues avec du code dans un langage compilé
comme C++. La vitesse des programmes dans C++ est meilleure que celle dans R car
R est un langage de programmation interprété. De plus, il donne beaucoup de bonnes
librairies aux développeurs. Rcpp [13] est un paquet de R qui propose une intégration de
C++ très simple d’utilisation. Il fournit une interface efficace pour l’accès, l’extension
et la modification des objets de R en C++. Il peut aussi faciliter l’échange des données
entre R et C++ et la gestion des erreurs. En outre, avec Rcpp, le code peut devenir
plus propre et avec moins de bugs. C’est la raison pour laquelle Rcpp est utilisé pour
construire notre paquet.

Chapitre 2
Algorithme de
gradient-derivative-product
Comme mentionné dans la section 1.1.4, il faut calculer la densité de probabilité (1.23)
f(x) = ∂x[F(x)] avec F(x) =
Q
s∈S φs(xs) pour faire l’inférence dans un CDN. Toutefois,
c’est difficile si le nombre de variables est très grand. L’algorithme de gradient-derivative-
product (GDP) [4] qui a pour but de calculer la vraisemblance en tirant profit de la
structure d’arbre d’un CDN nous permet de le faire. L’idée de cet algorithme est de
séparer la dérivation multiple en une chaı̂ne des dérivées locales sous forme de messages.
En effet, on constate qu’une variable n’apparait que dans ses fonctions de voisin. Au lieu
de dériver la fonction de repartition par rapport à toutes les variables, il est nécessaire de
calculer les dérivées locales et les mettre sous forme des messages. Grâce à un processus
de propagation des messages, la fonction de vraisemblance est finalement obtenue :
f(x|θ) = ∂xα
hQ
s∈N(α) µs→α(x|θ)
i
où µ sont des fonctions de messages qu’on va définir
dans la section après, α est un noeud de variable arbitraire qu’on appelle la racine. Le
problème est comment choisir la racine α et calculer les messages.
Cet algorithme GDP se compose des trois étapes principales suivantes :
1. Initialisation de l’algorithme,
2. Propagation des messages, et ,
3. Calcul de la fonction de vraisemblance et son gradient.
2.1 Initialisation de l’algorithme
Les messages entre des noeuds de variable et de fonction sont représentés par les fonctions
µs→α, µα→s, λs→α, λα→s où s est un noeud de fonction et α est un noeud de variable. s
11

Chapitre 2. Algorithme de gradient-derivative-product 12
et α sont deux noeuds adjacents : α ∈ N(s), s ∈ N(α). µs→α et λs→α sont les messages
à partir des noeuds de fonction s aux noeuds de variable α. µα→s et λα→s sont les
messages à partir des noeuds de variable α aux noeuds de fonction s. D’abord, toutes
les fonctions de message et leur gradient sont initialisés à zéro sauf µα→s où α est une
feuille du graphe :
µs→α(x; θ) = λs→α(x; θ) = λα→s(x; θ) = 0.
µα→s(x; θ) =
(
1 si α est une feuille.
0 sinon.
∇θµs→α(x; θ) = ∇θµα→s(x; θ) = ∇θλs→α(x; θ) = ∇θλα→s(x; θ) = 0.
Chaque message µs→α, µα→s, λs→α, λα→s est une fonction du paramètre θ et de la
variable x = (xα, xβ)où α, β sont les variables voisines de la fonction s. ∇θ est le gradient
par rapport à θ.
2.2 Propagation des messages
La propagation des messages comprend deux processus de transmission : l’un à partir
des variables aux fonctions et l’autre à partir des fonctions aux variables.
• Les messages à partir des noeuds intérieurs de variable α aux noeuds de fonction de
voisin s ∈ N(α). Les fonctions de message sont mises à jour comme suit :
µα→s(x; θ) =
Y
s0∈N(α)s
µs0→α(x; θ),
λα→s(x; θ) = ∂xα [µα→s(x; θ)] = µα→s(x; θ)
X
s0∈N(α)s
λs0→α(x; θ)
µs0→α(x; θ)
,
∇θµα→s(x; θ) = µα→s(x; θ)
X
s0∈N(α)s
∇θµs0→α(x; θ)
µs0→α(x; θ)
,
∇θλα→s(x; θ) = ∇θµα→s(x; θ)
X
s0∈N(α)s
λs0→α(x; θ)
µs0→α(x; θ)
+ µα→s(x; θ)
X
s0∈N(α)s
∇θλs0→α(x; θ)µs0→α(x; θ) − λs0→α(x; θ)∇θµs0→α(x; θ)
µ2
s0→α(x; θ)
.

Chapitre 2. Algorithme de gradient-derivative-product 13
• Messages à partir des noeuds de fonction s aux noeuds de variable de voisin α ∈ N(s).
Les fonctions de message sont mises à jour comme suit :
µs→α(x; θ) = ∂xβ
[φs(xα, xβ; θ)]µβ→s(x; θ) + φs(xα, xβ; θ)λβ→s(x; θ),
λs→α(x; θ) = ∂xα,xβ
[φs(xα, xβ; θ)]µβ→s(x; θ) + ∂xα [φs(xα, xβ; θ)]λβ→s(x; θ),
∇θµs→α(x; θ) = ∇θ∂xβ
[φs(xα, xβ; θ)]µβ→s(x; θ) + ∂xβ
[φs(xα, xβ; θ)]∇θµβ→s(x; θ)
+ ∇θφs(xα, xβ; θ)λβ→s(x; θ) + φs(xα, xβ; θ)∇θλβ→s(x; θ),
∇θλs→α(x; θ) = ∇θ∂xα,xβ
[φs(xα, xβ; θ)]µβ→s(x; θ) + ∂xα,xβ
[φs(xα, xβ; θ)]∇θµβ→s(x; θ)
+ ∇θ∂xα [φs(xα, xβ; θ)]λβ→s(x; θ) + ∂xα [φs(xα, xβ; θ)]∇θλβ→s(x; θ).
À chaque itération de l’algorithme, les messages fonctions-variables sont d’abord mis
à jour. Après, c’est la mise à jour des messages variables-fonctions. Dans la première
itération, les messages entrant et sortant aux variables voisines des feuilles sont calculés.
La valeur de ces fonctions est fixée et ne change pas dans les itérations suivantes. Dans
la deuxième itération, les messages entrant et sortant aux variables à la hauteur de 2
sont mis à jour et fixés. Semblablement, à la k-ième itération, les messages entrant et
sortant aux variables à la hauteur de k sont calculés. Quand les fonctions de message
entrant la racine sont calculées et fixées, l’algorithme s’arrête alors.
2.3 Calcul de la fonction de vraisemblance et son gradient
Enfin, il faut calculer la dérivée f(x|θ) = ∂xα
hQ
s∈N(α) µs→α(x|θ)
i
et son gradient
∇θf(x|θ) par rapport à θ via des messages entrant à la racine choisie. La propaga-
tion des messages permet de calculer de manière récursive les messages à partir des
feuilles à la racine. f(x|θ) et ∇θf(x|θ) sont calculés via tous les messages entrant à la
racine. Leurs formules sont données ci-après :
U(x; θ) =
Y
s∈N(α)
µs→α(x; θ), ∇θU(x; θ) = U(x; θ)
X
s∈N(α)
∇θµs→α(x; θ)
µs→α(x; θ)
,
Z(x; θ) =
X
s∈N(α)
λs→α(x; θ)
µs→α(x; θ)
,
∇θZ(x; θ) =
X
s∈N(α)
∇θλs→α(x; θ)µs→α(x; θ) − λs→α(x; θ)∇θµs→α(x; θ)
µ2
s→α(x; θ)
,
f(x|θ) = U(x; θ)Z(x; θ), ∇θf(x|θ) = U(x; θ)∇θZ(x; θ) + ∇θU(x; θ)Z(x; θ).
Pour trouver la racine α, on va tout d’abord définir quelques notions et des propriétés
de l’arbre qui sont détaillées dans [14, 15]. Soit G un arbre :

Chapitre 2. Algorithme de gradient-derivative-product 14
• Si G a n arêtes, le nombre de sommets de G est alors n + 1.
• La distance entre deux noeuds de G est le nombre des arêtes dans le plus court chemin
entre eux.
• L’excentricité d’un sommet est sa distance maximale à tous les autres sommets de G.
• Le centre de G est un sommet dont l’excentricité est minimale. En outre, le centre du
graphe n’est pas unique. En effet, il existe un ensemble des centres.
• Les centres du graphe se trouvent au milieu du plus long chemin de G. L’excentricité
de centre est donc égale à la moitié de la longueur du plus long chemin.
On remarque que la dérivée f(x|θ) = ∂x[F(x|θ)] et son gradient ∇θf(x|θ) ne dépendent
pas de la racine choisie. Les résultats ne changent pas si on choisit autre racine. Cepen-
dant, le choix de la racine permet de déterminer le nombre d’itérations de l’algorithme.
En effet, en observant la propagation des messages, on trouve qu’il s’agit de n itérations
pour obtenir tous les messages entrant à la racine où n est l’excentricité de la racine.
C’est la raison pour laquelle on choisit un centre du graphe de variables comme la racine
puisque l’excentricité du centre est minimale. Le nombre d’itérations de l’algorithme est
alors défini comme l’excentricité du centre. Il faut donc trouver un plus long chemin du
graphe des variables. Le noeud au milieu de ce chemin est choisi comme la racine du
graphe CDN.
Exemple 2.3.1. Sur la figure 2.1, c’est un arbre de cinq variables et le graphe CDN
correspondant.
• La distance entre le sommet X1 et X4 est 3 puisque le plus court chemin entre ces
deux sommets est X1 - X2 - X3 - X4.
• Les distances entre le sommet X3 et les autres {X1, X2, X4, X5} sont {2, 1, 1, 1}.
L’excentricité de X3 est alors 2.
• Les excentricités des sommets {X1, X2, X3, X4, X5} sont {3, 2, 2, 3, 3}. Le centre du
graphe de variables est donc {X2, X3}.
• Dans le graphe de variable, il y a deux plus longs chemins : X1 - X2 - X3 - X4 et X1
- X2 - X3 - X5. Deux centres {X2, X3} se trouvent au milieu des plus longs chemins.
• La racine du graphe CDN est un des deux centres {X2, X3}.
Exemple 2.3.2 La figure 2.2 affiche la propagation des messages dans le CDN. Le
graphe CDN se compose de 6 variables (X1,X2,X3,X4,X5,X6) et 5 fonctions (Φ1, Φ2, Φ3, Φ4, Φ5).
Le plus long chemin est (X1 - X2 - X3 - X5 - X6). La racine du graphe de variables est
alors le sommet X3. Le nombre d’itération est 2. L’algorithme de message-passing est
détaillé comme suit :
• À l’étape d’initialisation, les messages sortant des feuilles sont initialisés. Ce sont des
messages variables-fonctions X1 − Φ1, X4 − Φ3, X6 − Φ5 .

Chapitre 2. Algorithme de gradient-derivative-product 15
Figure 2.1: Exemple d’un arbre de 5 variablese.
• Dans la première itération, les messages entrant et sortant pour X2, X3 et X5 sont
calculés. Pour la variable X2, c’est Φ1 − X2, puis X2 − Φ2. Pour la variable X3, c’est
Φ3 − X3. Pour la variable X5, c’est Φ5 − X5, puis X5 − Φ4.
• À la deuxième itération, les messages entrant à la variable X3 sont calculés. Ce sont
des messages fonctions-variables Φ4 − X3 et Φ2 − X3. On note que la figure 2.2
montre seulement les messages nécessaires pour le calcul f(x|θ) et ∇θf(x|θ). Ce sont
des messages tendant vers la racine X3. Pour les autres, on n’affiche pas. Par exemple,
dans la deuxième itération, les messages X3 − Φ2, X3 − Φ3, X3 − Φ4 sont aussi
calculés. Toutefois, ils ne servent pas à calculer f(x|θ) et ∇θf(x|θ).
• Enfin, f(x|θ) et ∇θf(x|θ) sont calculés à partir des messages entrant à la racine X3.
Par exemple,
f(x|θ) = (µφ2→X3 µφ3→X3 µφ4→X3 )
λφ2→X3
µφ2→X3
+
λφ3→X3
µφ3→X3
+
λφ4→X3
µφ4→X3
.

Chapitre 2. Algorithme de gradient-derivative-product 16
Figure 2.2: Propagation des messages dans le CDN.

Chapitre 3
Implémentation
Après avoir fait le point sur les connaissances importantes concernant le CDN (1.22), on
va se concentrer sur ce que j’ai fait dans mes travaux. C’est d’implémenter l’inférence de
la copule associée à un CDN présentée dans l’équation (1.29) et de le rendre disponible
sous forme d’un paquet R. En détail, je vais montrer ce qui est installé dans ce paquet
et comment ça fonctionne. En outre, quelques astuces servant à accélérer la vitesse des
fonctions du paquet sont présentées.
3.1 Structure du paquet
Dans cette section, je vais montrer des composants principaux du paquet CDN qui
sont affichés sur la figure 3.1. Le code source et la documentation sont deux parties
indispensables dans chaque paquet R. Les tests et le tutoriel ne sont pas nécessaires
mais appréciés.
Figure 3.1: Composants principaux du paquet CDN.
17

Chapitre 3. Implémentation 18
3.1.1 Code source
Dans le paquet CDN, le code source se sépare en deux types : code R et code C++
(Figure 3.2). D’une part, le code C++ est mis dans le répertoire /src. Il fournit quelques
fonctions importantes pour implémenter l’algorithme de message-passing (CDN.cpp,
Compute.cpp, Derivatives.cpp, Gradient.cpp, miwa.cpp) et l’inférence dans le CDN (Op-
tim.cpp, lbfgsb.cpp). Les fichiers de R se trouvent dans le répertoire /R. Ils ont pour
objectif de créer l’objet CDN qui est précisé dans la section 3.2.1 (CDN.R, cdnMo-
dels.R), d’appeler des fonctions C++ (cdnOptim.R, mpAlgo.R), de générer des données
aléatoires (rCdn.R). Le détail des fonctions du paquet est montré dans la section 3.2.
Figure 3.2: Code source du paquet CDN.
3.1.2 Documentation
La documentation du paquet (Figure 3.3) est mise dans deux répertoire : /man et /vi-
gnettes. Les fichiers dans /man décrivent le paquet (CDN-package.Rd) et les données
disponibles (JapanSeaLevel.Rd). Ils expliquent aussi comment créer l’objet CDN (CDN-
class.Rd, cdnModels.Rd), utiliser l’algorithme de message-passing (mpAlgo.Rd), faire
l’inférence (cdnOptim.Rd), générer des données aléatoires (CDN.Rd). En outre, les vi-
gnettes donnent quelques renseignements et exemples pour construire un modèle CDN
et l’utiliser pour résoudre des problèmes statistiques. Les fichiers de test et de tutoriel
sont montrés sur la figure 3.4.

Chapitre 3. Implémentation 19
Figure 3.3: Documentation du paquet.
3.1.3 Tests et tutoriels
Le répertoire /tests contient des fichiers qui testent quelques scénarios différents afin
d’assurer que toutes les fonctions du paquet marchent bien et donnent des résultats
corrects. En effet, on va vérifier la justesse d’implémentation de l’algorithme message-
passing (precision.R, testingFunctions.R), la simulation des données aléatoires (simula-
tion.R) et l’inférence dans le CDN (optim.R). De plus, il reste un fichier de description
qui présente généralement le paquet CDN et les paquets de dépendance tels que Rcpp
(l’interface R/C++), igraph et methodes (pour créer l’objet CDN), copula (pour simuler
des données), numDeriv (pour les tests).
Figure 3.4: Tests et démo.
3.2 Fonctions du paquet
Dans cette section, je vais montrer les fonctions fournies par le paquet CDN. La figure
3.5 décrit le fonctionnement général des fonctions importantes du paquet et les lieux où
elles sont installées. Le paquet se compose alors des trois étapes principales suivantes :
• Premièrement, c’est l’entrée des données utilisées pour les fonctions du paquet. Le
graphe créé par le paquet igraph montre la relation entre les variables. Les données
se composent des vecteurs d’observation et d’un vecteur de paramètres. La copule Cs
dans (1.28) est choisie par l’utilisateur. Tout est réalisé dans le code R.

Chapitre 3. Implémentation 20
• Deuxièmement, c’est l’appel des fonctions fournies par le paquet CDN qui sont implémentées
dans le code R ou C++.
– cdn sert à créer un objet CDN et a besoin d’un graphe et d’un modèle paramétrique.
– cdnPlot permet de visualiser l’objet CDN en représentant le graphe.
– rCdn (Annexe C.1) génère aléatoirement des observations et pCdn (Annexe C.2)
calcule la fonction de répartition.
– mpAlgo (Annexe A) implémente l’algorithme de message-passing gradient-derivative-
product. Son entrée est un objet CDN et un vecteur de variables. Sa sortie est la
densité de cette observation et la gradient par rapport au vecteur des paramètres.
– cdnOptim (Annexe B) utilise mpAlgo afin de construire la fonction de vraisemblance
et son gradient. Ensuite, une méthode d’optimisation est choisie pour trouver la
valeur du paramètre qui maximise la fonction de vraisemblance.
– dCdn (Annexe C.3) a pour objectif de calculer la densité de plusieurs observations
d’entrée via mpAlgo.
• Dernièrement, les résultats sont affichés dans R. La transmission des données et des
fonctions entre C++ et R est réalisée par l’interface Rcpp [13].
Dans les parties suivantes, je vais détailler l’implémentation des fonctions du paquet.
Figure 3.5: Diagramme des fonctions du paquet.
3.2.1 Création d’un objet CDN
Pour créer un objet CDN, il s’agit de choisir un graphe des variables et d’une famille de
copules Cs (1.28). Ces données d’entrées sont traitées avant d’assigner les valeurs aux
composants de l’objet (Figure 3.6).
Tải bản FULL (61 trang): https://bit.ly/3RzFKEb
Dự phòng: fb.com/TaiHo123doc.net

Chapitre 3. Implémentation 21
Figure 3.6: Création d’un objet CDN.
Pour le modèle, on peut choisir une des six familles existantes dans le paquet. Ce sont
des copules populaires qui sont mentionnées dans la section 1.1.3 : Gumbel (”gumbel”),
Farlie-Gumbel-Morgenstern (”fgm”), Frank (”frank”), Gauss (”normal”), Ali-Mikhail-
Haq (”amh”), Joe (”joe”). Un exemple pour créer un objet CDN à partir d’un graphe
des variables et d’un modèle choisi est montré ci-après.
1 ## Create the graph
2 g - graph.formula(X1 -X2 ,X2 -X3 ,X3 -X4 ,X3 -X5 ,X5 -X6 ,X5 -X7 ,simplify = FALSE)
3 ## Create the CDN object with a model chosen
4 cdnObj - cdn(g, model=amh)
Pour le graphe des variables, il faut trouver la racine et le nombre d’itération grâce à la
fonction diameter du paquet igraph. Ensuite, il est nécessaire de construire un graphe
CDN à partir du graphe des variables. Le graphe CDN obtenu est enregistré sous forme
d’une matrice binaire. Un exemple pour transformer un graphe des variables en graphe
CDN est montré sur la figure 3.7. La racine est X3, le nombre d’itération est 2 et le
graphe de CDN est obtenu en ajoutant des fonctions Φs entre deux variables adjacentes.
Pour obtenir la matrice binaire à partir du graphe dans ce cas, il s’agit de créer une
matrice avec six colonnes et sept lignes. Chaque colonne correspond à une fonction et
chaque ligne correspond à une variable. Si une variable i et une fonction s sont adjacentes,
la valeur de l’élément (i,s) est mise à 1 ; sinon à zéro. Sur le tableau 3.1, nous affichons
la matrice binaire extraite à partir du graphe CDN de la figure 3.7.
Concernant la création d’un graphe avec le paquet igraph, la façon la plus simple et pra-
tique pour l’utilisateur est d’utiliser la commande graph.formula. Cependant, il apparait
un problème à résoudre. C’est que cette commande fait par défaut simplifier le graphe
d’entrée. Par exemple, on crée un graphe avec la commande :
1 g - graph.formula(X3 -X4 ,X1 -X2 ,X2 -X3)
Tải bản FULL (61 trang): https://bit.ly/3RzFKEb
Dự phòng: fb.com/TaiHo123doc.net

Chapitre 3. Implémentation 22
Figure 3.7: Exemple de transformer un graphe des variables en graphe CDN.
Φ1 Φ2 Φ3 Φ4 Φ5 Φ6
X1 1 0 0 0 0 0
X2 1 1 0 0 0 0
X3 0 1 1 0 0 0
X4 0 0 1 1 0 0
X5 0 0 0 1 1 1
X6 0 0 0 0 1 0
X7 0 0 0 0 0 1
Table 3.1: Matrice binaire extraite du graphe CDN.
Après le lancer, l’ordre des arrêtes est modifié. En effet, la première arrête doit être
X3−X4, la deuxième est X1−X2 et la troisième est X2−X3. Toutefois, à cause de la
simplification de ce graphe, l’ordre des arrêtes est : X3−X4, X2−X3, X1−X2. L’ordre
des fonctions est donc changé. Cela peut provoquer des erreurs quand on entre des
paramètres des fonctions. Par exemple, si on a un vecteur de paramètre θ = (θ1, θ2, θ3),
il faut assigner θ1 pour X3 − X4, θ2 pour X1 − X2 et θ3 pour X2 − X3. En fait, le
résultat est : θ1 pour X3 − X4, θ2 pour X2 − X3 et θ3 pour X1 − X2. Pour éviter cette
erreur, il suffit d’ajouter une option dans la commande de création d’un graphe :
1 g - graph.formula(X3 -X4 ,X1 -X2 ,X2 -X3 ,simplify = FALSE)
On peut trouver la différence entre les résultats de ces deux commandes sur la figure
3.8.
3.2.2 Implémentation de l’algorithme de message-passing
Le diagramme de l’algorithme de message-passing est montré sur la figure 3.9. La racine,
le nombre d’itération, la matrice binaire, le modèle sont extraits à partir de l’objet CDN.
6814135