Guide de l`utilisateur Toolbox pour l`estimation de structures d

Transcription

Guide de l’utilisateur
Toolbox pour l’estimation
de structures d’indépendance conditionnelle
de processus multivariés gaussiens
(Matlab)
Fanny ROCHE, Aude COSTARD
Sommaire
1 Comment utiliser la Toolbox
1.1 Préparer l’environnement de travail . . . . . . . . . . . . . . . . . . . . . .
1.2 Comment appliquer les méthodes . . . . . . . . . . . . . . . . . . . . . . .
4
4
4
2 Description des méthodes d’estimation et des fonctions associées
2.1 Méthodes Asymptotic Bayesian initialized by Graphical Lasso (A. Costard)
2.1.1 Method_ABiGlasso . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1.2 Method_ABiGlasso_Max . . . . . . . . . . . . . . . . . . . . . . .
2.1.3 Method_ABiGlasso_Loop . . . . . . . . . . . . . . . . . . . . . . .
2.1.4 Method_ABiGlasso_MaxLoop . . . . . . . . . . . . . . . . . . . .
2.1.5 Method_ABiGlasso_RI . . . . . . . . . . . . . . . . . . . . . . . .
2.1.6 Fonctions associées . . . . . . . . . . . . . . . . . . . . . . . . . . .
ABiGlasso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
ABiGlasso_from_graph . . . . . . . . . . . . . . . . . . . . . . . .
distrib_normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
findLambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
kG_calc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
lambda_domain . . . . . . . . . . . . . . . . . . . . . . . . . . . .
lambdaMax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
log_distrib_normal . . . . . . . . . . . . . . . . . . . . . . . . . . .
Marrelec_fct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
neighbors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Méthode Bayesian Adaptive Graphical Lasso (H. Wang) . . . . . . . . . .
2.2.1 Method_BayesGLassoGDP . . . . . . . . . . . . . . . . . . . . . .
2.2.2 Fonctions associées . . . . . . . . . . . . . . . . . . . . . . . . . . .
BayesGlassoGDP . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bayesian_thresholding . . . . . . . . . . . . . . . . . . . . . . . . .
2.3 Méthode Graphical Lasso ADMM (Alternating Direction Method of Multipliers) (S. Boyd) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
covsel_from_mat . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.4 Méthodes GGMselect (C. Giraud) . . . . . . . . . . . . . . . . . . . . . . .
2.4.1 Method_GGMselect_R . . . . . . . . . . . . . . . . . . . . . . . .
2.4.2 Method_GGMselect_myFam_R . . . . . . . . . . . . . . . . . . .
2.5 Méthode SIN (M. Drton) . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.5.1 Method_sinUG_R . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.6 Méthodes de seuillages . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
edge_thresh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
par_corr_thresh . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
6
7
9
12
14
17
19
19
21
23
24
25
26
27
28
29
30
31
31
33
33
34
1
35
35
37
37
39
41
41
44
44
45
3 Description des fonctions d’évaluation des méthodes
3.1 Fonctions "Outils" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
comp_graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
MLEg_fct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
plotGraph . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
sorted_profile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.2 Simulation d’un processus multivarié gaussien dont la structure d’indépendance conditionnelle est connue . . . . . . . . . . . . . . . . . . . . . . . .
simu_data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
simu_mat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
significant_thresh . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
47
47
47
49
50
51
53
53
53
55
Introduction
Les domaines hétéroclites que sont la génétique, les neurosciences, les réseaux de capteurs,
les interactions sociales... ont pour point commun l’étude de phénomènes pouvant être
modélisés par des processus multivariés gaussiens. Pour comprendre ces différents phénomènes, une approche repose sur l’estimation de la structure d’indépendance conditionnelle
du processus étudié.
Nous avons rassemblé dans une Toolbox différentes méthodes d’estimation pour des
processus multivariés gaussiens. Cette Toolbox contient également une méthodes permettant de générer des processus multivariés gaussiens avec une structure d’indépendance
conditionnelle choisie pour évaluer les performances des différentes méthodes.
Ce guide explique comment utiliser les méthodes de cette Toolbox.
Ce guide rassemble les méthodes suivantes :
• la méthode de l’Asymptotic Bayesian initilized by Graphical Lasso (ABiGlasso) [1]
• la méthode du Bayesian Graphical Lasso (BAGlasso) [2]
• la méthode du Graphical Lasso [3, 4]
• la méthode GGMselect [5]
• la méthode SIN [6]
• deux méthodes de seuillage classiques : le seuillage par nombre d’arêtes et le seuillage
par valeur minimale en valeur absolue des valeurs de corrélation partielle.
3
Chapitre 1
Comment utiliser la Toolbox
1.1
Préparer l’environnement de travail
Premièrement, ajouter le dossier avec tous ses sous-dossiers sous Matlab. Pour ce faire, il
faut cliquer sur : file/Set Path... puis cliquer sur la case Add with Subfolders... et
ensuite sélectionner le dossier Toolbox.
Cliquer sur Save puis enfin sur Close.
Vous pouvez maintenant accéder aux fonctions de la Toolbox quelque soit le dossier
dans lequel vous travaillez.
Important : Pour appliquer certaines méthodes, il faut bien veiller à avoir le logiciel
R ainsi que les packages nécessaires (SIN et GGMSelect). Il faut également veiller à bien
posséder la Toolbox Statistics de Matlab.
1.2
Comment appliquer les méthodes
Il est vivement conseillé d’utiliser comme script le modèle : fichier Demo.m. Il suffit alors
de modifier le nom du fichier comportant le jeu de données ainsi que le paramètre dataInfo.
ATTENTION au format des données. Nous travaillons avec des données p × n dans
les exemples fournis ! Il est donc nécessaire de penser à calculer la transposée des données
afin de pouvoir calculer la matrice de covariance S. Il vous faut également bien penser à
renseigner le nombre d’échantillons n de votre jeu de données. Ce paramètre est facilement
récupérable en écrivant :
n = size(data,2) ;
Comment gérer les paramètres facultatifs : Par défaut, les méthodes présentant
des paramètres facultatifs vont s’exécuter avec les valeurs des paramètres par défaut sélectionnés. Cependant, vous pouvez modifier ces valeurs en indiquant le nom du paramètre
que vous souhaitez modifier entre ’quote’, puis la nouvelle valeur que vous lui affectez.
Par exemple si vous souhaitez modifier la valeur du paramètre e et choisir 5 au lieu de 3 dans
la méthode "Method_ABiGlasso_RI" (cette méthode a été choisie arbitrairement et ce
principe s’applique pour n’importe quelle fonction présentant des paramètres facultatifs),
ou encore si vous voulez modifier deux paramètres, il vous suffit d’écrire :
4
1
M et h o d_ A Bi G la s s o_ R I (S ,n , ’e ’ ,5) ; % modification d ’ un seul
paramètre , ici e
M et h o d_ A Bi G la s s o_ R I (S ,n , ’e ’ ,5 , ’ dataInfo ’ , ’ toto ’) ; % modifications
de 2 paramètres : e et dataInfo
Remarque : l’ordre des paramètres facultatifs n’est pas important.
Ceci ne s’applique que pour les méthodes possédant des paramètres facultatifs. Pour
toutes les autres, il vous suffit de modifier les valeurs renseignées directement dans l’appel
des fonctions en modifiant les codes que nous vous fournissons dans la Toolbox.
Une fois que tout cela a bien été pris en compte, vous pouvez alors appliquer la méthode
de votre choix parmi les différentes méthodes présentées dans cette Toolbox.
Remarque : il est possible d’accéder à une description de toutes les fonctions ainsi que
de leurs paramètres d’entrée et de sortie directement depuis Matlab en tapant :
help ma_fonction.
5
Chapitre 2
Description des méthodes d’estimation
et des fonctions associées
Pour toutes les méthodes dont le nom est sous la forme Method_nomDeLaMethode,
la sortie de la fonction est une structure matlab. Cette structure a un premier champ
input qui contient les paramètres d’entrée de la fonction et un deuxième champ output
qui contient les sorties (estimée de la structure d’indépendance conditionnelle, temps de
calcul, . . . ). Les temps de calcul se trouvent dans un sous champ time, les estimées des
structures et des matrices dans un sous champs results et les informations complémentaires
dans un sous champ info.
2.1
Méthodes Asymptotic Bayesian initialized by Graphical Lasso (A. Costard)
Cette méthode de l’Asymptotic Bayesian initialized by Graphical Lasso se compose de
plusieurs variantes (ou sous-méthodes) d’estimation de structures d’indépendance conditionnelle de processus gaussiens multivariés :
• la méthode de base Method_ABiGlasso dont l’identifiant est base
• la méthode avec comparaison des graphes du voisinage de la solution du Graphical
lasso la plus probable Method_ABiGlasso_Max dont l’identifiant est max
• la méthode itérative avec comparaison des graphes du voisinage du graphe le plus
probable à l’itération précédente Method_ABiGlasso_Loop dont l’identifiant est loop
• la méthode Method_ABiGlasso_Loop avec initialisation par la solution du Graphical
lasso la plus probable Method_ABiGlasso_MaxLoop dont l’identifiant est max_loop
• la méthode avec réduction d’intervalle Method_ABiGlasso_RI dont l’identifiant est
ri.
Les variantes ABiGlasso fournissent des scores sur les graphes comparés, ces scores sont
sauvegardés dans la structure de résultats dans le champ output.results
6
2.1.1
Method_ABiGlasso
Prototype de la fonction :
function [ data_base ] = Method_ABiGlasso (S , n )
Cette méthode génère un sous-ensemble de graphes à partir des voisinages de solutions
du Graphical Lasso. Ces solutions sont obtenues pour différentes valeurs du paramètre
de pénalisation allant de la valeur nulle jusqu’à la valeur au-delà de laquelle les graphes
solutions sont vides. La solution de cette méthode est le graphe le plus probable sur ce
sous-ensemble.
Les paramètres d’entrée :
S : matrice de covariance empirique.
n : nombre d’observations / nombre d’échantillons de chaque variable.
Paramètres facultatifs :
• e : paramètre de voisinage, i.e. le nombre maximal d’arêtes utilisé pour créer
le voisinage d’un graphe, c’est-à-dire l’ensemble des graphes qui diffèrent d’au
plus e arêtes par rapport au graphe d’origine. Par défaut, cette valeur vaut 3.
• lambda_step : pas entre deux lambdas consécutifs. Par défaut, cette valeur vaut
0.1.
• kG_read : entier permettant de déterminer si il y a des données à lire pour le
calcul des kG (car la lecture est plus rapide que de refaire les calculs à chaque
fois pour des petites valeurs de p (<6)). Par défaut, cette valeur vaut 1 (on lit
les données s’il y en a).
• dataInfo : identifiant du jeu de données traité utilisé dans les noms des fichiers
générés. Par défaut cette valeur vaut ’_base’ et si l’utilisateur donne son propre
identifiant ’Id’, la valeur devient ’Id_base’.
• Results_path : chemin permettant d’accéder à l’endroit où on stocke les résultats. Une valeur par défaut est fixée (.../Toolbox/Results/) mais l’utilisateur
est libre de la modifier à sa guise.
• verbose : entier permettant d’afficher ou non des informations à l’utilisateur tout
au long des calculs (étapes, avancement des étapes,...). Par défaut cette valeur
vaut 1 (on affiche les informations).
• save_struct : entier permettant de déterminer si on sauvegarde la structure solution ou pas. Par défaut, cette valeur vaut 0 (on ne sauvegarde pas la structure).
Le paramètre de sortie :
data_base : structure contenant l’ensemble des données calculées par la fonction (cf explications en début de chapitre).
Remarque sur les paramètres facultatifs : se reporter à l’explication dans le chapitre
1 pour savoir comment les modifier.
7
Fonctions appelées : Cette méthode fait appel aux fonctions suivantes :
• ABiGlasso
• lambda_domain
• MLEg_fct
Plus de détails sur la fonction : Cette fonction se compose des étapes suivantes :
1. initialisation de l’intervalle de lambdas à parcourir par calcul du lambda maximal
avec la fonction lambda_domain.
2. calcul des graphes les plus probables pour ces lambdas à l’aide de la fonction ABiGlasso.
3. sauvegarde des résultats si souhaité.
Exemple d’application :
Après avoir chargé un jeu de données et calculé la matrice de covariance associée, on peut
alors appliquer la méthode de l’Asymptotic Bayesian initialized by Graphical Lasso de la
manière suivante :
1
3
5
% chargement du jeu de données
data = load ( ’ dataset_demo . txt ’) ;
% mise en place des paramètres nécessaires à l ’ utilisation de la
méthode
S = cov ( data ’) ; % matrice de covariance empirique
n = size ( data ,2) ; % nombre d ’ échantillons du jeu de données
dataInfo = ’ dataset_demo ’;
7
% Méthode ABiGlasso
[ data_base ] = Method_ABiGlasso (S ,n , ’ dataInfo ’ , dataInfo , ’ verbose ’
9
,0) ;
11
13
graphId_base = data_base . output . results . best_graph . graphId ; % on
récupère le graphId obtenu
score_base = data_base . output . results . best_graph . score ; % on
récupère le score
plotGraph ( graphId_base ) ; % on trace le graphe
title ( ’ solution méthode de base ’) ;
Et on obtient alors le résultat suivant pour ce jeu de données en particulier :
8
Figure 2.1 – graphe obtenu avec la Method_ABiGlasso
2.1.2
Method_ABiGlasso_Max
1
function [ data_max ] = M e t h o d _ A B i G l a s s o _ M a x (S , n )
Cette méthode est une variante de l’Asymptotic Bayesian method initialized by Graphical Lasso. Elle génère un sous-ensemble de graphes qui est le voisinage de la solution
du Graphical Lasso la plus probable. La solution est le graphe le plus probable sur ce
sous-ensemble.
• e : paramètre de voisinage, i.e. le nombre maximal d’arêtes utilisé pour créer le
voisinage d’un graphe, c’est-à-dire l’ensemble des graphes qui diffèrent d’au plus
e arêtes par rapport au graphe d’origine. La valeur par défaut est fixée à 3.
• lambda_step : pas entre deux lambdas consécutifs. La valeur par défaut est fixée
à 0.1.
• kG_read : entier permettant de déterminer si on a des données à lire pour le
fois pour des petites valeurs de p (<6)). La valeur par défaut est fixée à 1 (on
lit les données s’il y en a).
9
générés.Par défaut cette valeur vaut ’_max’ et si l’utilisateur donne son propre
identifiant ’Id’, la valeur devient ’Id_max’.
data_max : structure contenant l’ensemble des données calculées par la fonction (cf explications en début de chapitre).
• ABiGlasso
• lambda_domain
• lambdaMax
• MLEg_fct
initial.
2. calcul de l’ensemble optimal des lambdas grâce à la fonction lambdaMax.
3. calcul des scores des graphes obtenus pour les lambdas optimaux et des scores de
leurs voisins à l’aide de la fonction ABiGlasso.
Après avoir chargé un jeu de données et calculé la matrice de covariance empirique associée,
on peut alors appliquer la méthode de l’Asymptotic Bayesian initialized by Graphical
Lasso avec comparaison des graphes du voisinage de la solution du Graphical lasso la plus
probable. On obtient un graphe avec un score maximal de la manière suivante :
10
1
3
5
% calcul des paramètres nécessaires à l ’ utilisation de la méthode
S = cov ( data ’) % la matrice de covariance empirique
n = size ( data ,2) ; % nombre d ’ échantillons
7
9
11
13
% Méthode ABiGlasso avec recherche d ’ intervalle
[ data_max ] = M e t h o d_ A B i G l a s s o _ M a x (S ,n , ’ dataInfo ’ , dataInfo ) ;
graphId_max = data_max . output . results . best_graph . graphId ; % on
score_max = data_max . output . results . best_graph . score ; % on
récupère le score
plotGraph ( graphId_max ) ; % on trace le graphe
title ( ’ solution méthode max ’) ;
On obtient alors le résultat suivant pour ce jeu de données en particulier :
Figure 2.2 – graphe obtenu avec Method_ABiGlasso_Max
11
2.1.3
Method_ABiGlasso_Loop
1
function [ data_loop ] = M e t h o d _ A B i G l a s s o _ L o o p (S , n )
Cette méthode est une variante de l’Asymptotic Bayesian method initialized by Graphical Lasso. C’est une méthode itérative. Elle est initialisée par le voisinage d’un graphe
solution du Graphical lasso ayant deux fois moins d’arêtes que le graphe complet. A chaque
itération, on cherche le graphe le plus probable sur le voisinage du graphe solution de l’itération précédente. La convergence est atteinte lorsque le graphe le plus probable de l’itération
courante est le même que celui de l’itération précédente. La solution est le graphe obtenu
lors de la dernière itération.
à 0.1.
générés.Par défaut cette valeur vaut ’_loop’ et si l’utilisateur donne son propre
identifiant ’Id’, la valeur devient ’Id_loop’.
data_loop : structure contenant l’ensemble des données calculées par la fonction (cf explications en début de chapitre).
12
• ABiGlasso_from_graph
• covsel_from_mat
• lambda_domain
• MLEg_fct
initial.
2. calcul de l’ensemble optimal des lambdas par méthode de dichotomie afin de pouvoir
calculer le graphe initial pour lequel on va chercher le voisinage (on cherche un graphe
avec deux fois moins d’arêtes que le graphe complet).
3. on calcule les scores du graphe initial et de son voisinage. Le graphe ayant le plus
fort score est utilisé comme le graphe initial dans l’itération suivante. Ceci est répété
jusqu’à obtenir que le graphe avec le score le plus élevé soit le graphe initial.
Exemple d’application : Après avoir chargé un jeu de données et calculé la matrice de
covariance associée, on peut alors appliquer la méthode de l’Asymptotic Bayesian initialized
by Graphical Lasso itérative avec comparaison des graphes du voisinage du graphe le plus
probable à l’itération précédente :
1
3
5
% calcul des paramètres nécessaires pour appliquer la méthode
7
9
11
13
% Méthode ABiGlasso avec bouclage
[ data_loop ] = M e t h o d _ A B i G l a s s o _ L o o p (S ,n , ’ dataInfo ’ , dataInfo ) ;
graphId_loop = data_loop . output . results . best_graph . graphId ; % on
score_loop = data_loop . output . results . best_graph . score ; % on
récupère le score
plotGraph ( graphId_loop ) ; % on trace le graphe
title ( ’ solution méthode loop ’) ;
13
Figure 2.3 – graphe obtenu avec Method_ABiGlasso_Loop
2.1.4
Method_ABiGlasso_MaxLoop
1
function [ data_max_loop ] = M e t h o d _ A B i G l a s s o _ M a x L o o p (S , n )
Cette méthode est une variante de l’Asymptotic Bayesian method initialized by Graphical Lasso. C’est une méthode itérative. Elle est initialisée par le voisinage de la solution du
Graphical Lasso la plus probable. A chaque itération, on cherche le graphe le plus probable
sur le voisinage du graphe solution de l’itération précédente. La convergence est atteinte
lorsque le graphe le plus probable de l’itération courante est le même que celui de l’itération
précédente. La solution est le graphe obtenu lors de la dernière itération.
à 0.1.
14
générés.Par défaut cette valeur vaut ’_max_loop’ et si l’utilisateur donne son
propre identifiant ’Id’, la valeur devient ’Id_max_loop’.
data_max_loop : structure contenant l’ensemble des données calculées par la fonction
(cf explications en début de chapitre).
• covsel_from_mat
• lambda_domain
• lambdaMax
• MLEg_fct
initial.
2. calcul de l’ensemble optimal des lambdas grâce à la fonction lambdaMax. La graphe
initial est le graphe solution du Graphical lasso pour le plus petit lambda optimal.
3. on calcule les scores du graphe initial et de son voisinage. Le graphe ayant le plus
fort score est utilisé comme le graphe initial dans l’itération suivante. Ceci est répété
jusqu’à obtenir que le graphe avec le score le plus élevé soit le graphe initial.
15
Exemple d’application : Après avoir chargé un jeu de données et calculé la matrice de
covariance associée, on peut alors appliquer la méthode de l’Asymptotic Bayesian initialized
by Graphical Lasso itérative avec comparaison des graphes du voisinage du graphe le plus
probable à l’itération précédente avec initialisation par le graphe solution du Graphical
lasso le plus probable :
1
3
5
% calcul des paramètres nécessaires pour appliquer la méthode
7
9
11
13
% Méthode ABiGlasso avec bouclage sur la solution du Graphical
lasso la plus probable
[ data_max_loop ] = M e t h o d _ A B i G l a s s o _ M a x L o o p (S ,n , ’ dataInfo ’ ,
dataInfo ) ;
graphId_loop = data_max_loop . output . results . best_graph . graphId ; %
on récupère le graphId obtenu
score_loop = data_max_loop . output . results . best_graph . score ; % on
récupère le score
plotGraph ( graphId_loop ) ; % on trace le graphe
title ( ’ solution méthode max loop ’) ;
Figure 2.4 – graphe obtenu avec Method_ABiGlasso_MaxLoop
16
2.1.5
Method_ABiGlasso_RI
1
function [ data_ri ] = M e th o d_ A B iG l as s o_ R I (S , n )
Cette méthode est une variante de l’Asymptotic Bayesian method initialized by Graphical Lasso. Elle réduit l’ensemble des paramètres de pénalisation (lambdas) utilisé pour
générer le sous-ensemble de graphes. Elle ne garde que les lambdas pour lesquels la différence d’arêtes entre la solution du Graphical lasso et son voisin le plus probable est
inférieure à e. La solution est le graphe le plus probable sur ce sous-ensemble.
• eRI : paramètre de voisinage pour la recherche de lambdas (i.e. le nombre maximal d’arêtes en plus ou en moins tolérées sur notre nouveau graphe par rapport
à notre graphe de départ lorsque l’on calcule l’intervalle de lambdas adapté au
problème). Par défaut, cette valeur vaut 3.
• e : paramètre de voisinage, i.e. le nombre maximal d’arêtes utilisé pour créer
le voisinage d’un graphe, c’est-à-dire l’ensemble des graphes qui diffèrent d’au
plus e arêtes par rapport au graphe d’origine. Par défaut, cette valeur vaut 3.
• lambda_step : pas entre deux lambdas consécutifs. Par défaut, cette valeur vaut
0.1.
• kG_read : entier permettant de déterminer si il y a des données à lire pour le
fois pour des petites valeurs de p (<6)). Par défaut, cette valeur vaut 1 (on lit
les données s’il y en a).
générés.Par défaut cette valeur vaut ’_ri’ et si l’utilisateur donne son propre
identifiant ’Id’, la valeur devient ’Id_ri’.
data_ri : structure contenant l’ensemble des données calculées par la fonction (cf explications en début de chapitre).
17
• ABiGlasso
• findLambda
• lambda_domain
• MLEg_fct
avec la fonction lambda_domain.
2. calcul de l’intervalle adapté des lambdas avec la fonction findLambda.
3. calcul des graphes les plus probables pour ces lambdas à l’aide de la fonction ABiGlasso.
Après avoir chargé un jeu de données et calculé la matrice de covariance associée, on peut
alors appliquer la méthode de l’Asymptotic Bayesian initialized by Graphical Lasso avec
réduction d’intervalle de la manière suivante :
1
3
5
méthode
7
% Méthode ABiGlasso avec recherche d ’ intervalle
[ data_ri ] = Me t ho d _A B i Gl a ss o _ RI (S ,n , ’ dataInfo ’ , dataInfo , ’ verbose ’
9
,0) ;
11
13
graphId_ri = data_ri . output . results . best_graph . graphId ; % on
score_ri = data_ri . output . results . best_graph . score ; % on récupère
le score
plotGraph ( graphId_ri ) ; % on trace le graphe
title ( ’ solution méthode RI ’) ;
Et on obtient alors le résultat suivant pour ce jeu de données en particulier :
18
Figure 2.5 – graphe obtenu avec la Method_ABiGlasso_RI
2.1.6
Fonctions associées
ABiGlasso
1
function [ graphs_star , score_max , lambda_star , other_graphs ,
list_scores ] = ABiGlasso (S ,n ,e , pen_parameters , kG_read ,W , dataInfo ,
Results_path , verbose )
Cette fonction a pour but de calculer à partir d’un jeu de données et de paramètres bien
définis quels sont le ou les graphes les plus probables ainsi que les scores d’un sous-groupe
de graphes.
e : paramètre de voisinage du graphe, i.e. le nombre maximal d’arêtes utilisé pour créer le
voisinage d’un graphe, c’est-à-dire un ensemble de graphes qui diffèrent d’au plus e
arêtes par rapport au graphe d’origine.
pen_parameters : ensemble des lambdas à tester.
kG_read : entier permettant de déterminer si on a des données à lire pour le calcul des
kG (car la lecture est plus rapide que de refaire les calculs à chaque fois pour des
petites valeurs de p (<6)).
W : matrice d’Isserlis de S.
19
dataInfo : identifiant du jeu de données traité utilisé dans les noms des fichiers générés.
Results_path : chemin permettant d’accéder à l’endroit où on stocke les résultats. Une
valeur par défaut est fixée (.../Toolbox/Results/) mais l’utilisateur est libre de la
modifier à sa guise.
verbose : entier permettant d’afficher ou non des informations à l’utilisateur tout au long
des calculs (étapes, avancement des étapes,...). Par défaut cette valeur vaut 1 (on
affiche les informations).
Les paramètres de sortie :
graphs_star : liste des graphes les plus probables.
score_max : le score maximal des graphes.
lambda_star : liste des lambdas associés aux graphes les plus probables.
other_graphs : liste de tous les graphes explorés sous forme de chaîne de caractères.
list_scores : liste des scores correspondants aux graphes explorés.
• covsel_from_mat
• Marrelec_fct
• neighbors
• plotGraph
Plus de détails sur la fonction : Cette fonction est composée des étapes suivantes :
1. calcul de la solution du Graphical Lasso pour tous les lambdas en paramètre à l’aide
de la fonction covsel_from_mat.
2. génération d’un ensemble de graphes contenant les graphes obtenus par le graphical
lasso et leurs voisins à l’aide de la fonction neighbors.
3. calcul du score de tous les graphes de l’ensemble généré à l’étape précédente grâce à
la fonction Marrelec_fct.
4. on stocke tous les graphes explorés dans other_graphs et leur score dans list_scores.
5. ensuite on sélectionne les graphes les plus probables.
Remarque : Cette fonction est appelée dans les fonctions suivantes :
• Method_ABiGlasso
• Method_ABiGlasso_Max
• Method_ABiGlasso_RI
20
ABiGlasso_from_graph
1
function [ graphs_star , graphs_scores , explored_graphs ] =
A B i G l a s s o _ f ro m _ g r a p h (S ,n ,e , given_graph , graphs_scores , explored_graphs ,
kG_read ,W , dataInfo , Results_path , verbose )
Cette fonction a pour but de calculer à partir d’un graphe donné quel est le graphe
voisin le plus probable.
e : paramètre de voisinage, i.e. le nombre maximal d’arêtes utilisé pour créer le voisinage
d’un graphe, c’est-à-dire l’ensemble des graphes qui diffèrent d’au plus e arêtes par
rapport au graphe d’origine.
given_graph : graphe dont on doit calculer le voisin le plus probable.
graphs_scores : dictionnaire contenant le score de tous les graphes explorés.
explored_graphs : dictionnaire contenant tous les graphes explorés.
faibles valeurs de p (<6)).
dataInfo : identifiant du jeu de données traité utilisé dans les noms des fichiers générés.
graphs_star : liste des graphes les plus probables.
graphs_scores : dictionnaire contenant les scores des graphes mis à jour.
explored_graphs : dictionnaire contenant tous les graphes explorés mis à jour.
• Marrelec_fct
• neighbors
21
Plus de détails sur la fonction : Cette fonction est composée des étapes suivantes :
1. calcul des voisins du graphe à l’aide de la fonction neighbors.
2. calcul du score de chaque voisin du graphe initial grâce à la fonction Marrelec_fct.
3. sélection du graphe le plus probable que l’on stocke dans un dictionnaire (graphs_star).
• Method_ABiGlasso_Loop
• Method_ABiGlasso_MaxLoop
22
distrib_normal
1
function [ res ] = distrib_normal ( mu , sigma , x0 , dim )
Cette fonction a pour but de calculer la fonction de densité pour une distribution
normale Np (µ, Σ) :
fv (x) =
1
p
1
(2π) 2 .|Σ| 2
exp(− 12 (x − µ)T Σ−1 (x − µ))
où V est l’ensemble des p noeuds du graphe, µ est la moyenne de la répartition et Σ
est la matrice de covariance.
mu : moyenne de la répartition.
Sigma : matrice de covariance.
x0 : vecteur variable de notre calcul. C’est une réalisation de la variable aléatoire X qui
suit la loi normale Np (µ, Σ) (dans notre cas x).
dim : nombre de lignes ou de colonnes de Σ, donc dans notre cas le nombre de noeuds p.
res : la fonction de densité correspondant à la distribution normale choisie, ie fv (x).
Remarque : Cette fonction est appelée dans la fonction suivante :
• Marrelec_fct
23
findLambda
1
function [ lambdaMinEnd , lambdaMaxEnd ,W , it_fl ] = findLambda (S ,n , eRI
, lambdaMaxInit , kG_read , verbose )
Cette fonction a pour but de calculer les bornes de l’intervalle de lambdas dans lequel
la solution ABiGlasso est proche de la solution du Graphical Lasso. Cela se fait par encadrement de la borne maximale et de la borne minimale de l’intervalle des lambdas par
dichotomie.
eRI : paramètre de voisinage pour la recherche de lambdas (i.e. le nombre maximal
d’arêtes en plus ou en moins tolérées sur notre nouveau graphe par rapport à notre
graphe de départ lorsque l’on calcule l’intervalle de lambdas adapté au problème).
lambdaMaxInit : le lambda maximal de départ renvoyé par la fonction lambda_domain.
valeurs de p faibles (<6)).
lambdaMinEnd : lambda minimum final (borne gauche de l’intervalle de lambdas).
lambdaMaxEnd : lambda maximum final (borne droite de l’intervalle de lambdas).
it_fl : le nombre d’itérations jusqu’à ce qu’il y ait convergence.
• covsel_from_mat
• Marrelec_fct
• neighbors
24
kG_calc
1
function kG = kG_calc ( kG ,p , graphs , kG_read , verbose )
Cette fonction a pour but de mettre à jour le dictionnaire contenant les kG. Pour cela,
soit des données existent déjà et on vient les lire (cela permettant d’économiser du temps),
soit il n’y a rien ou on ne veut pas lire les données, et on fait l’intégralité des calculs. Par
défaut, s’il y a des données à lire, on les lit plutôt que de refaire les calculs.
kG : dictionnaire contenant les kG.
p : nombre de variables.
graphs : dictionnaire contenant les graphes sous forme de vecteurs.
valeurs faibles de p (<6)).
des calculs (étapes, avancement des étapes,...). Par défaut cette valeur sera à 1 (on
kG : dictionnaire contenant les kG mis à jour.
• Marrelec_fct
25
lambda_domain
1
function [ lambda_max ] = lambda_domain (S , lambda_step )
Cette fonction a pour but de calculer le lambda maximal pour lequel il est encore utile
de mener à bien les calculs. Au-delà de ce lambda, les graphes sont vides.
lambda_step : pas entre deux lambdas consécutifs.
lambda_max : lambda maximal calculé.
Fonction appelée : Cette méthode fait appel à la fonction suivante :
• covsel_from_mat
• Method_ABiGlasso_Loop
26
lambdaMax
1
function [ pen_parameters ,W , lambdas_max ] = lambdaMax (S ,n ,
lambdaMaxInit , lambda_step , kG_read ,W , Results_path , verbose )
Cette fonction a pour but de calculer l’ensemble de lambdas nécessaires à notre étude.
Pour cela, on recherche les lambdas pour lesquels on obtient des graphes qui ont un score
maximal (score retourné par la fonction Marrelec_fct).
lambdaMaxInit : lambda maximal de départ renvoyé par la fonction lambda_domain.
lambda_step : pas entre deux lambdas consécutifs.
valeurs faibles de p(<6)).
W : la matrice d’Isserlis de S.
pen_parameters : ensemble des lambdas à tester.
lambdas_max : lambdas correspondant aux graphes avec un score maximal.
• covsel_from_mat
• Marrelec_fct
27
log_distrib_normal
function [ res ] = l og_ di st rib _n or mal ( mu , sigma , x0 )
1
Cette fonction a pour but de calculer le logarithme de la fonction de densité pour une
distribution normale Np (µ, Σ) :
fv (x) =
1
p
1
(2π) 2 .|Σ| 2
exp(− 12 (x − µ)T Σ−1 (x − µ))
où V est l’ensemble des p nœuds du graphe, µ est la moyenne de la répartition et Σ est
la matrice de covariance. Contrairement à la fonction , le ratio 1 p est ignoré (considéré
(2π) 2
égal à 1).
mu : moyenne de la répartition.
Sigma : matrice de covariance.
x0 : vecteur variable de notre calcul. C’est une réalisation de la variable aléatoire X qui
suit la loi normale Np (µ, Σ) (dans notre cas x).
dim : nombre de lignes ou de colonnes de Σ, donc dans notre cas le nombre de nœuds p.
res : le logarithme de la fonction de densité correspondant à la distribution normale choisie, i.e. log (fv (x)).
• Marrelec_fct
28
Marrelec_fct
1
function [ score , W ] = Marrelec_fct (S ,n , graphs ,W , kG_read , verbose )
Cette fonction a pour but de calculer le score de chaque graphe contenu dans le dictionnaire graphs indiqué en paramètre de la fonction.
graphs : dictionnaire contenant les graphes sous forme de vecteurs.
valeurs faibles de p(<6)).
score : dictionnaire contenant tous les scores des graphes.
Cette fonction fait appel à la fonction kG_calc
• kG_calc
• distrib_normal
• log_distrib_normal
• ABiGlasso
• findLambda
• lambdaMax
29
neighbors
1
function G = neighbors ( G_init ,e , verbose )
Cette fonction a pour but de calculer tous les graphes voisins du graphe mis en entrée
en fonction du nombre maximal d’arêtes en plus ou en moins tolérées, et renvoie tous les
voisins dans une matrice.
G_init : vecteur correspondant au graphe initial dont on veut chercher le voisinage.
e : paramètre de voisinage, i.e. le nombre maximal d’arêtes utilisé pour créer le voisinage
d’un graphe, c’est-à-dire l’ensemble des graphes qui diffèrent d’au plus e arêtes par
rapport au graphe d’origine.
G : matrice dont chaque ligne représente le support (matrice d’adjacence vectorisée) d’un
graphe voisin du graphe initial exprimé en paramètre d’entrée de la fonction.
• ABiGlasso
• findLambda
30
2.2
2.2.1
Méthode Bayesian Adaptive Graphical Lasso (H.
Wang)
Method_BayesGLassoGDP
1
function [ data_bayes ] = M e t h o d _ B a y e s G L a s s o G D P (S , n )
Cette méthode est celle proposée par H. Wang [2] pour estimer la structure d’indépendance conditionnelle d’un processus multivarié gaussien. Elle estime la matrice de précision
en utilisant une approche bayésienne pour estimer les paramètres de pénalisation du Graphical lasso puis la matrice des corrélations partielles associée est seuillée pour obtenir un
graphe. C’est ce graphe qui est l’estimée de la structure d’indépendance conditionnelle.
paramètres facultatifs :
• loop : nombre d’itérations. Cette valeur est fixée à 1000 par défaut mais est
modifiable.
• thresh : seuil pour le calcul de la matrice. Ce seuil est fixé à 0.5 par défaut mais
est modifiable.
générés. Par défaut cette valeur vaut ’_BAG’ et si l’utilisateur donne son
propre identifiant ’Id’, la valeur devient ’Id_BAG’.
• Results_path : chemin permettant d’accéder à l’endroit où on stocke les résultats. Une valeur par défaut est fixée mais (.../Toolbox/Results/) l’utilisateur
data_BAG : structure contenant l’ensemble des données calculées par la fonction.
Remarque sur les paramètres facultatifs : se reporter à l’explication en début de
chapitre pour savoir comment les modifier.
• BayesGlassoGDP
• bayes_thresholding
31
Remarque : Lors de l’appel de la fonction BayesGlassoGDP, les paramètres burnin
et nmc prennent les valeurs par défaut de, respectivement, 1000 et 2000. Ces valeurs
correspondent à celles prises par Hao Wang lors de l’utilisation de son code.
Exemple d’application : Après avoir chargé le jeu de données et calculé la matrice de
covariance correspondante, on peut appliquer la méthode du Bayesian Adaptive Graphical
Lasso comme pour l’exemple suivant :
1
3
5
7
9
11
% calcul des paramètres nécessaires pour l ’ application de la
méthode
n = size ( data ,2) ; % nombre d ’ échantillons
% % Méthode Bayesian Adaptive Glasso
[ data_BAG ] = Method_BAGlasso (S , n ) ;
graphId_GAG = data_BAG . output . graph ; % on récupère le graphId
obtenu
figure () ;
plotGraph ( graphId_BAG ) ; % on trace le graphe
title ( ’ Graphe le plus probable trouvé avec la méthode du Bayesian
Adaptive Graphical Lasso ’) ;
On obtient alors le résultat suivant :
Figure 2.6 – graphes obtenus avec la méthode du Bayesian Adaptive Graphical Lasso
Cette méthode fait intervenir des tirages aléatoires de matrices suivant une loi de Wishart. Il paraît donc logique que le résultat obtenu ne soit pas à 100% le même à chaque
fois. Il est donc possible d’obtenir la figure de droite (cf ci-dessus) avec une probabilité d’environ 6%. Cependant, le graphe le plus probable obtenu est bien celui de gauche (environ
70%).
32
2.2.2
Fonctions associées
BayesGlassoGDP
function [ Sig_save , C_save , lambda ] = BayesGLassoGDP (S ,n , Sig ,C ,
burnin , nmc )
Cette fonction est issue d’un article rédigé par Hao Wang [2] et a été récupérée et
utilisée comme telle. Aucune modification n’a été apportée.
S : matrice de covariance "pondérée" (multipliée par le nombre d’échantillons).
Sig : matrice de covariance empirique.
C : matrice de précision.
burnin : nombre d’itérations de "chauffe".
nmc : nombre d’itérations pour l’étape de Monte-Carlo.
Sig_save : matrices de covariance à chaque itération de l’étape de Monte-Carlo.
C_save : matrices de précision à chaque itération de l’étape de Monte-Carlo.
lambda : lambdas conservés.
Si vous voulez plus d’informations sur cette fonction, veuillez vous référer à l’article [2]
de la bibliographie (cf à la fin du document) ou directement au code https://www.msu.
edu/~haowang/RESEARCH/Bglasso/bglasso.html.
Remarque : ATTENTION : ici les matrices de concentration sont notées C alors que
dans nos notations, ces matrices sont notées K.
Pour notre part, nous l’utilisons dans la fonction Method_BAGlasso.
33
bayesian_thresholding
1
function gamma_est = b a y e s i a n _ t h r e s h o l d i n g ( Pi ,S ,n , loop , thresh )
Cette fonction a pour but de calculer une matrice dont les zéros correspondent aux
arêtes manquantes du graphe. Pour cela, on fait de nombreux tirages aléatoires de matrices de concentration K suivant une loi de Wishart pour lesquelles on calcule la matrice
des corrélations partielles associée. On calcule ensuite le rapport entre la matrice des corrélations partielles obtenue après utilisation de la fonction Bayes_GlassoGDP et la moyenne
des matrices des corrélations partielles issues des itérations que l’on a vues ; et on seuille
ce rapport pour obtenir la matrice en question.
Pi : matrice des corrélations partielles.
loop : nombre d’itérations. Cette valeur est normalement fixée à 1000 mais l’utilisateur
sera libre de la modifier.
thresh : seuil fixé à 0.5 normalement, mais ici aussi l’utilisateur est libre de le modifier.
G_est : la matrice de sortie de la fonction dont les zéros correspondent aux arêtes manquantes du graphe.
Remarque importante : Pour utiliser cette fonction, et donc mettre en place cette
méthode d’extraction de la structure d’indépendance d’un processus, il est nécessaire de
posséder la Toolbox Statistics de Matlab.
Cette fonction est appelée dans la méthode Method_BAGlasso
34
2.3
Méthode Graphical Lasso ADMM (Alternating Direction Method of Multipliers) (S. Boyd)
covsel_from_mat
1
function [K , ~] = covsel_from_mat (S , lambda , rho , alpha )
L’objectif de cette fonction est de déterminer quelle est la matrice parcimonieuse K
qui optimise l’expression suivante à partir de la matrice de covariance empirique et du
paramètre de pénalisation λ choisi.
K̂ = arg max{tr(SK) − log(det K) + λ.kKk1 }
K
lambda : λ choisi pour le calcul.
rho : paramètre lagrangien.
alpha : paramètre d’over-relaxation (entre 1.0 et 1.8).
K : matrice parcimonieuse permettant de maximiser l’expression voulue.
Plus de détails sur la fonction : Cette fonction a été établie à partir d’un code issu
d’un article de Stephen Boyd [4] que nous avons librement modifié afin de l’adapter à nos
paramètres. La fonction initiale se nomme covsel et son prototype est le suivant :
1
function [K , history ] = covsel (D , lambda , rho , alpha )
où lambda, rho et alpha sont les mêmes que pour notre fonction à nous covsel_from_mat
mais où D représente la matrice des données du problème. Pour plus d’informations sur la
fonction initiale et la démarche faite par Stephen Boyd, veuillez vous référer à ses travaux
[4] ou directement au code de la fonction : http://www.stanford.edu/~boyd/papers/
admm/covsel/covsel.html.
Remarque : il est également possible d’obtenir ce code directement sous Matlab en tapant :
1
grabcode ( ’ http :// www . stanford . edu /~ boyd / papers / admm / covsel / covsel
. html ’)
35
• ABiGlasso
• findLambda
• lambda_domain
• lambdaMax
Remarque générale : Lors de son utilisation comme méthode à part entière, nous
utilisons indifféremment covsel et covsel_from_mat. Les deux nous renvoient le même
résultat et sont totalement équivalentes. Pour obtenir ensuite le graphe associé à notre jeu
de données, il faut alors mettre K sous forme logique. Vous devez alors écrire ceci :
1
AdjMat = logical ( K ) ;
G = AdjMat - eye ( p ) ;
où G est la matrice correspondant au graphe résultat et eye(p) la matrice identité de taille
p.
Exemple d’application : Pour appliquer cette méthode, il est nécessaire de charger un
jeu de données, mais il n’est pas obligatoire de calculer la matrice de covariance. On peut
alors tester cette méthode de la manière suivante :
2
4
6
8
% % Méthode Glasso via ADMM
[K , history ] = covsel (D ’ ,0.2 ,1 ,1) ;
AdjMat = logical ( K ) ; % on calcule la matrice d ’ adjacence
% calcul du graphe correspondant
G_boyd = AdjMat - eye ( p ) ;
figure () ;
plotGraph ( G_boyd ) ; % on trace le graphe ( car on est dans le cas
où il y a 6 noeuds )
title ( ’ solution méthode du Graphical Lasso via ADMM pour un
lambda de 0.31 ’) ;
On obtient alors les résultats suivants :
Le graphe obtenu avec cette méthode dépend totalement du lambda choisi en paramètre
de la fonction. Si celui-ci n’est pas adapté, alors il sera impossible d’obtenir un résultat
correct (comme c’est le cas sur le graphe de droite de la figure par exemple). Afin de trouver
un lambda adapté, il existe des méthodes, comme par exemple la validation croisée, qui ne
sont pas développées ici.
36
(a) lambda = 0.31
(b) lambda = 0.01
Figure 2.7 – graphes obtenus avec la méthode du Graphical Lasso ADMM pour différentes
valeurs de lambda
2.4
Méthodes GGMselect (C. Giraud)
Cette méthode utilise le package GGMselect de R. Il est donc nécessaire de bien l’installer.
Pour cela, il vous suffit de taper : install.packages(’GGMselect’) sous le logiciel R. Il
faut au préalable avoir installé R.
2.4.1
Method_GGMselect_R
Prototype de la fonction
function [ data_GGMselect ] = Met ho d_ GGM se le ct_ R (X , chosen_family ,
varargin )
Cette méthode a pour but de calculer le graphe parmi une famille de graphes donnée
en paramètre le graphe qui minimise l’erreur quadratique moyenne de prédiction avec
pénalisation. Cette famille donnée en paramètre doit faire partie des familles traitées par
Giraud dans son article [5].
X : matrice p × n contenant les données que l’on souhaite étudier
chosen_family : chaîne de caractère identifiant la famille de graphes choisie (parmi C01,
LA, EW et QE).
générés. Par défaut cette valeur vaut ’_GGMselect’ et si l’utilisateur donne
son propre identifiant ’Id’, la valeur devient ’Id_GGMselect’.
37
data_GGMselect : structure contenant l’ensemble des données calculées et sauvegardées par la fonction.
Remarque : Cette méthode fait appel à un script R (comp_families.R) qui utilise la
fonction selectFast du package GGMselect du logiciel R. Si vous voulez plus d’information
sur cette fonction, vous pouvez vous référer au document [5] de la référence ou alors aller directement sur la documentation du package : cran.r-project.org/web/.../GGMselect/
GGMselect.pdf.
Exemple d’application : Si on s’intéresse à un graphe issue d’une famille en particulier,
par exemple ’C01’, on peut alors appliquer cette méthode de la manière suivante :
1
3
méthode
5
7
9
% Méthode utilisant GGMselect
[ data_GGMselect ] = Me th od _GG Ms el ect _R ( data , ’ C01 ’ , ’ dataInfo ’ ,
dataInfo , ’ verbose ’ ,0) ;
graph_GGMselect = data_GGMselect . output . results . graph ; % on
récupère le graphe obtenu
plotGraph ( graph_GGMselect ) ; % on trace le graphe
title ( ’ solution methode GGMselect pour famille C01 ’) ;
On obtient alors le résultats suivant pour cette famille en particulier (cf graphe de
gauche). Et si on choisit une autre famille, comme par exemple ’LA’, on obtient le résultat
suivant (cf graphe de droite).
38
(a) Graphe solution famille ’C01’
(b) Graphe solution famille ’LA’
Figure 2.8 – Graphes solution de la méthode GGMselect pour différentes familles
2.4.2
Method_GGMselect_myFam_R
Cette méthode utilise le package GGMselec de R. Il est donc nécessaire de bien l’installer.
Pour cela, il vous suffit de taper : install.packages(’GGMselect’) sous le logiciel R.
Prototype de la fonction
function [ d a t a _ G G M s e l e c t _m y F a m ] = M e t h o d _ G G M s e l e c t _ m y F a m _ R (X ,
myFam , varargin )
Cette méthode a pour but de calculer le graphe, parmi une famille de graphes que
l’on renseigne en paramètre, qui minimise l’erreur quadratique moyenne de prédiction avec
pénalisation. La famille renseignée en paramètre doit au préalable avoir été mise sous la
forme d’une matrice à 3 dimensions où la 3ème dimension représente le nombre de matrices
à 2 dimensions contenues dans notre famille.
X : matrice p × n contenant les données que l’on souhaite étudier
myFam : matrice à 3 dimensions contenant les matrices d’adjacences des graphes de notre
famille.
générés. Par défaut cette valeur vaut ’_GGMselect_myFam’ et si l’utilisateur donne son propre identifiant ’Id’, la valeur devient ’Id_GGMselect_myFam’.
39
Remarque : Cette méthode fait appel à un script R (my_family.R) qui utilise la fonction selectMyFam du package GGMselect de R. Si vous voulez plus d’information sur
cette fonction, vous pouvez vous référer au document [5] de la référence ou alors aller directement sur la documentation du package : cran.r-project.org/web/.../GGMselect/
GGMselect.pdf.
Exemple d’application : On peut par exemple choisir comme famille le voisinage d’un
graphe en particulier. On peut alors appliquer cette méthode sur un jeu de données en
particulier afin de trouver le graph associé parmi les graphes contenus dans notre famille
en écrivant ceci :
1
3
méthode
5
7
9
11
13
15
17
% creation de la famille
G_init = [0 0 0 1 1 1 1 0 0 1 0 0 1 0 1]; % on choisit un graphe
initial
G_mat = neighbors ( G_init ,3 ,1) ; % on calcule son voisinage
N = size ( G_mat ,1) ; % nombre de voisins
myFam = zeros (6 ,6 , N ) ; % on met en place notre matrice en 3
dimensions
idx = logical ( tril ( ones (6) , -1) ==1) ;
% on remplit la matrice
for i =1: N
mat = zeros (6) ;
mat ( idx ) = G_mat (i ,:) ;
mat = mat + mat ’;
myFam (: ,: , i ) = mat ;
end
19
21
23
% Méthode utilisant GGMselect
[ d a t a _ G G M s e l e c t _ m y F a m ] = M e t h o d _ G G M s e l e c t _ m y F a m _ R ( data , myFam , ’
dataInfo ’ , dataInfo , ’ verbose ’ ,0) ;
g r a p h _ G G M s e l e c t _ m y F a m = d a t a _ G G M s e l e c t _ m y F a m . output . results . graph
; % on récupère le graphe obtenu
plotGraph ( g r a p h _ G G M s e l e c t _ m y F a m ) ; % on trace le graphe
title ( ’ solution methode GGMselect_myFam ’) ;
On obtient alors le résultat suivant pour notre voisinage en particulier et notre jeu de
données :
40
Figure 2.9 – Graphe obtenu pour notre famille en particulier
2.5
2.5.1
Méthode SIN (M. Drton)
Method_sinUG_R
Cette méthode utilise le package ’SIN’ de R. Il est donc nécessaire de bien l’installer. Pour
cela, il vous suffit de taper : install.packages(’SIN’) sous le logiciel R.
1
function [ data_SIN ] = Method_sinUG_R (S ,n , varargin )
Cette méthode a pour fonction de calculer deux graphes qui correspondent à un encadrement du graphe correspondant exactement à nos données. Pour cela, on calcule la
matrice des p-valeurs associée à notre jeu de données puis on la seuille avec deux seuils
différents pour obtenir deux graphes : le premier correspond au graphe qui ne contient que
les arêtes significatives, et le deuxième correspond à un graphe pour lequel on ne retire
que les arêtes non-significatives, c’est-à-dire que l’on conserve les arêtes significatives et
indéterminées.
n : nombre d’observations que l’on considère / nombre d’échantillons de chaque variable.
41
générés. Par défaut cette valeur vaut ’_SIN’ et si l’utilisateur donne son propre
identifiant ’Id’, la valeur devient ’Id_SIN’.
• low_thresh : le seuil au-dessus duquel on considère que les arêtes ne sont plus
significatives. La valeur par défaut est de 0.01.
• high_thresh : le seuil au-dessus duquel on considère que les arêtes sont nonsignificatives. La valeur par défaut est fixée à 0.90.
Remarque sur les paramètres facultatifs : se reporter à l’explication plus haut pour
savoir comment les modifier.
Cette méthode se compose des étapes suivantes :
1. On écrit les données de notre problème dans le fichier texte qui va être lu par le script
R.
2. On exécute le script R qui calcule la matrice des p-valeurs (à l’aide de la méthode
sinUG de R).
3. On récupère la matrice obtenue et on la seuille de deux manières.
4. On récupère les deux graphes voulus.
Remarque : La fonction sinUG du package ’SIN’ de R ne s’applique que pour des graphes
non orientés. Elle prend en entrée la matrice de covariance ainsi que le nombre d’échantillons et retourne la matrice des p-valeurs associée.
Si vous voulez plus d’informations sur la fonction, vous pouvez vous référer au document
suivant : http://cran.r-project.org/web/packages/SIN/SIN.pdf.
Exemple d’application Cette méthode est toute simple à appliquer, il suffit de renseigner le jeu de données dont vous souhaitez approximer le graphe et appliquer la méthode.
On peut donc par exemple écrire :
42
n = size ( data ,2) ; % nombre d ’ échantillons du jeu de
1
3
données
5
% mise en place des paramètres nécessaires à l ’
utilisation de la méthode
7
% Méthode utilisant sinUG
[ data_SIN ] = Method_sinUG_R (S ,n , ’ dataInfo ’ , dataInfo , ’
9
verbose ’ ,0) ;
11
13
15
17
graph_S = data_SIN . output . results . graph . S ;
graph_SI = data_SIN . output . results . graph . SI ; % on
récupère les graphes obtenus
figure () ;
subplot (2 ,1 ,1) ;
plotGraph ( graph_S ) ; % on trace le graphe S
title ( ’ G_S : graphe avec aretes significatives ’) ;
subplot (2 ,1 ,2) ;
plotGraph ( graph_SI ) ; % on trace le graphe SI
title ( ’ G_SI : graphe avec aretes significatives et
indeterminees ’) ;
19
On obtient alors, pour cet exemple précis les résultats suivants :
(a) G_S
(b) G_SI
Figure 2.10 – graphes S et SI obtenus avec Method_sinUG_R
43
2.6
Méthodes de seuillages
edge_thresh
prototype de la fonction :
function [ G ] = edge_thresh (S , n_edges )
L’objectif de cette fonction est d’obtenir un graphe par seuillage du nombre d’arêtes.
Cette méthode va donc calculer la matrice des corrélations partielles et conserver les arêtes
dont le coefficient correspondant est le plus élevé. Le nombre d’arêtes que l’on conserve est
fixé à l’avance par l’utilisateur.
n_edges : nombre d’arêtes que l’on souhaite dans le graphe.
G : matrice correspondant au graphe solution.
Remarque : Cette méthode est utile quand on veut utiliser des métriques sensibles au
nombre d’arêtes pour comparer des graphes.
Exemple d’application : On peut tester la méthode après avoir chargé le jeu de données
et calculé la matrice de covariance correspondante. On peut alors faire le test de la manière
suivante :
1
3
5
% Méthode du nombre maximal d ’ arêtes
figure () ;
G_edge_number = edge_thresh (S ,7) ; % on récupère le graphe obtenu
plotGraph ( G_edge_number ) ; % on le trace
title ( ’ Graphe obtenu par la méthode du nombre d arêtes souhaitées
sur le graphe ( ici 7 arêtes ) ’) ;
On obtient alors les résultats suivants pour différents nombres d’arêtes sur ce jeu de
données en particulier.
44
(a) 7 arêtes
(b) 9 arêtes
Figure 2.11 – Graphes obtenus avec la méthode du nombre d’arêtes du graphe
par_corr_thresh
prototype de la fonction :
1
function [ G ] = par_corr_thresh (S , thresh )
L’objectif de cette fonction est d’obtenir un graphe en seuillant la matrice des corrélations partielles empirique.
thresh : seuil au dessous duquel on considère qu’une arête dans le graphe n’a pas lieu
d’être.
G : matrice correspondant au graphe solution.
Exemple d’application : Pour tester cette méthode, il nous faut charger le jeu de
données puis calculer la matrice de covariance correspondante. On peut alors appliquer la
méthode de la manière suivante :
1
3
figure () ;
G_thresh = par_corr_thresh (S ,0.1) ; % on récupère le graphe
résultat avec un seuil de 0.1 ( ici )
plotGraph ( G_thresh ) ; % on trace le graphe
title ( ’ graphe obtenu par méthode du seuillage de la matrice des
corrélations partielles pour un seuil de 0.1 ’) ;
On obtient alors les résultats suivants (pour différentes valeurs du seuil) :
45
(a) seuil de 0.1
(b) seuil de 0.02
Figure 2.12 – Graphes obtenus avec la méthode du seuillage direct de la matrice des
corrélations partielles pour différentes valeurs du seuil
46
Chapitre 3
Description des fonctions d’évaluation
des méthodes
3.1
Fonctions "Outils"
Ces fonctions permettent d’évaluer les performances des méthodes d’estimation ou de visualiser les résultats obtenus.
comp_graphs
function [ specificity , sensitivity , MCC , HD ] = scores ( G_test , G_ref )
Cette fonction fournit des mesures permettant de savoir si deux graphes sont proches
en terme de nombre d’arêtes et comment ils diffèrent.
G_test : graphe à tester.
G_ref : graphe de référence.
specificity : spécificité.
sensitivity : sensibilité.
MCC : Matthews Correlation Coefficient.
HD : distance de Hamming.
Toutes ces mesures permettent d’évaluer la ressemblance entre le graphe test et le graphe
de référence.
Remarque : Cette fonction n’est appelée dans aucune autre fonction mais peut être
utile à tout moment pour vérifier si notre graphe est bien adapté ou pourquoi il ne l’est
pas. Elle peut par ailleurs être applicable dans n’importe quelle méthode d’estimation de
structure d’indépendance, et non pas seulement dans la méthode ABiGlasso.
47
Exemple d’application : Cette méthode a pour but de calculer des mesures permettant
de déterminer si notre graphe est fidèle ou non au graphe de référence auquel il doit
"ressembler". Voici un exemple de cette fonction : dans un premier temps nous prenons
comme graphe test le graphe de référence et dans un deuxième temps un graphe ayant 2
arêtes de plus.
1
3
5
% creation des graphes
G_ref = [0 0 0 1 1 1 1 0 0 1 0 0 1 0 1];
G_test = [0 0 1 1 1 1 1 0 0 1 0 0 1 1 1];
% calcul des metriques
[ specificity_ref , sensitivity_ref , MCC_ref , HD_ref ] = comp_graphs (
G_ref , G_ref ) ; % calcul des métriques avec G_ref en graphe de test
[ specificity_test , sensitivity_test , MCC_test , HD_test ] =
comp_graphs ( G_ref , G_ref ) ; % calcul des métriques avec G_test en graphe
de test
7
9
11
% affichage des résultats
disp ([ ’ Specificity : ’ num2str ( specificity_ref ) ’ ’ num2str (
specificity_test ) ]) ;
disp ([ ’ Sensitivity : ’ num2str ( sensitivity_ref ) ’ ’ num2str (
sensitivity_test ) ]) ;
disp ([ ’ MCC : ’ num2str ( MCC_ref ) ’ ’ num2str ( MCC_test ) ]) ;
disp ([ ’ HD : ’ num2str ( HD_ref ) ’ ’ num2str ( HD_test ) ]) ;
(a) graphe référence
(b) graphe test
Figure 3.1 – Graphes comparés avec la fonction comp_graphs
On obtient alors les résultats suivants :
Pour un graphe identique au graphe de Pour un graphe différent du graphe de référéférence (graphe (a)) :
rence (ici le graphe (b)) :
• Specificity : 1
• Specificity : 0.75
• Sensitivity : 1
• Sensitivity : 1
• MCC : 1
• MCC : 0.7638
• HD :0
• HD : 2
48
MLEg_fct
function [ Sigma_est ]= MLEg_fct (S , Adj )
Cette fonction a pour but d’estimer la matrice de covariance dont l’inverse respecte la
structure d’indépendance conditionnelle donnée par Adj à partir de la matrice de covariance
empirique à l’aide de la méthode du maximum de vraisemblance.
Adj : la matrice d’adjacence du graphe.
Sigma_est : matrice de covariance estimée par la méthode du maximum de vraisemblance (MLE).
• Method_ABiGlasso_lambda_max
• Method_ABiGlasso_loop
49
plotGraph
1
function [] = plotGraph ( graph )
Cette fonction a pour but de tracer le graphe mis en paramètre de la fonction. Mais
cela n’est possible que pour des graphes à six noeuds.
Le paramètre d’entrée :
graph : graphe que l’on souhaite tracer. Ce dernier peut être sous la forme d’une matrice,
d’un vecteur ou d’une chaîne de caractères.
Les paramètres de sortie : ∅
Exemple d’application : Cette fonction est utilisée sur tous les exemples d’application des méthodes. Vous pouvez donc vous y reporter si vous voulez avoir un exemple
d’utilisation.
50
sorted_profile
1
function [ graphs_ord , list_ord ] = sorted_profile ( other_graphs ,
list_scores )
Cette fonction a pour but de classer les scores des graphes par ordre décroissant et
ensuite de tracer le profil des scores de chaque graphe en fonction de l’indice de celui-ci
une fois classé. Elle n’est utilisable qu’avec les résultats obtenus à partir des méthodes
ABiGlasso.
other_graphs : liste de tous les graphes explorés non classée.
list_scores : liste des scores correspondants à tous les graphes explorés non classée.
graphs_ord : liste des graphes explorés classée par scores décroissants.
list_ord : liste des scores des graphes classée par ordre décroissant.
Remarque : Cette fonction est utile pour visionner la répartition des scores et voir s’il
y a vraiment un graphe qui s’impose ou s’il y a de nombreux graphes similaires en terme
de probabilité.
Exemple d’application : Un exemple possible d’application est de comparer les différentes variantes de l’Asymptotic Bayesian method initialized by Graphical Lasso. On trace
alors les différents profils de scores pour les variantes de la façon suivante :
1
3
5
7
9
11
13
% calcul des profils de scores
figure () ;
subplot (4 ,1 ,1) ;
[ graphs_ord_base , scores_ord_base ]= sorted_profile ( data_base . output
. results . other_graphs . graphs , data_base . output . results . other_graphs .
scores ) ;
title ( ’ profil ordonne des scores des 100 graphes les plus probables pour
la methode de base ( cf . graphs_ ord_ base ) ’) ;
subplot (4 ,1 ,2) ;
[ graphs_ord_lmax , scores_ord_lmax ]= sorted_profile ( data_lmax . output
. results . other_graphs . graphs , data_lmax . output . results . other_graphs .
scores ) ;
la methode lambda max ( cf . graphs_ ord_ lmax ) ’) ;
subplot (4 ,1 ,3) ;
[ graphs_ord_loop , scores_ord_loop ]= sorted_profile ( data_loop . output
. results . other_graphs . graphs , data_loop . output . results . other_graphs .
scores ) ;
la methode loop ( cf . graphs_ ord_ loop ) ’) ;
51
15
17
subplot (4 ,1 ,4) ;
[ graphs_ord_ri , scores_ord_ri ]= sorted_profile ( data_ri . output .
results . other_graphs . graphs , data_ri . output . results . other_graphs . scores
);
la methode RI ( cf . graphs_ ord_ ri ) ’) ;
On obtient alors la figure suivante :
Figure 3.2 – Figure obtenue pour comparer les profils de scores des 4 variantes d’ABiGlasso
On peut donc voir qu’il y a vraiment des graphes qui s’imposent par rapport aux autres
pour ce jeu de données et que beaucoup ont un score nul, et ce pour les quatre variantes.
52
3.2
Simulation d’un processus multivarié gaussien dont
la structure d’indépendance conditionnelle est connue
Dans cette partie, nous allons voir comment simuler un processus multivarié gaussien ayant
une structure d’indépendance conditionnelle connue afin de vérifier que nos méthodes sont
efficaces et nous redonnent bien la structure d’indépendance conditionnelle attendue. Pour
cela, nous avons mis en place deux fonctions permettant d’une part de simuler des matrices
théoriques (matrices de covariance, de corrélations, des corrélations partielles, de précision)
à partir d’une structure d’indépendance conditionnelle donnée, et d’autre part, de simuler
un processus multivarié gaussien à partir de la matrice de covariance théorique.
simu_data
1
function [ X ] = simu_data (S , n )
Cette fonction a pour but de simuler un processus multivarié gaussien de n observations
à partir d’une matrice de covariance S. Ce processus est de moyenne nulle.
S : matrice de covariance.
X : processus multivarié gaussien (matrice de la forme n×p où p est le nombre de variables
du problème).
simu_mat
1
function [K ,S ,C , Pi ] = simu_mat ( AdjMat , thresh )
Le but de cette fonction est de simuler la matrice de covariance théorique ainsi que la
matrice de concentration, de corrélation et des corrélations partielles suivant une certaine
structure d’indépendance conditionnelle que nous renseignons en paramètre (AdjMat).
AdjMat : matrice donnant la structure de graphe à partir de laquelle on veut faire la
simulation de matrices.
thresh : valeur non nulle minimale en valeur absolue pour la corrélation partielle. Ce seuil
peut être fixé aléatoirement, mais on peut aussi calculer le seuil au-dessus duquel la
valeur de corrélation partielle est significativement non nulle en appliquant la fonction
significant_thresh.
53
K : matrice de concentration théorique.
S : matrice de covariance théorique.
C : matrice de corrélation théorique.
Pi : matrice des corrélations partielles théorique.
54
significant_thresh
1
function pi_max = si gn if ica nt _t hre sh ( alpha ,n , p )
Cette fonction a pour objectif de donner le seuil au-dessus duquel une corrélation partielle (en valeur absolue) est considérée comme significativement non nulle.
p : nombre de variables.
paramètre facultatif : alpha : risque de faux positif. Par défaut la valeur est fixée à 0.01
pi_max : corrélation partielle minimale (en valeur absolue) pour laquelle la corrélation
partielle (en valeur absolue) est significativement non nulle.
Remarque : Cette fonction n’est pas appelée lors de la simulation des matrices à l’aide
de la fonction simu_mat mais peut cependant être utile pour trouver le seuil le mieux
adapté lors de la simulation de matrices avec la fonction simu_mat.
55
Exemple pour simuler un processus gaussien multivarié dont la
structure d’indépendance conditionnelle est connue
Pour simuler un processus multivarié gaussien dont la structure d’indépendance conditionnelle est connue, il faut appliquer les fonctions présentées précédemment. Il faut tout
d’abord commencer par créer un graphe représentant la structure d’indépendance conditionnelle que l’on souhaite, puis générer des matrices correspondant à ce graphe avec la
fonction simu_mat. Ensuite, à partir de ces matrices, il faut générer, avec la fonction
simu_data, un processus que nous allons alors pouvoir utiliser pour tester les méthodes.
Exemple :
1
% % on veut simuler un jeu de donnees avec 2000 observations
n = 2000; % nombre d ’ observations
3
5
7
% % creation du graphe de reference a partir duquel on simule un
jeu de donnees
graph_ref = [ 0 0 0 0 1 1; 0 0 1 1 0 0 ; 0 1 0 1 0 0 ; 0 1 1 0 1
0 ; 1 0 0 1 0 1 ; 1 0 0 0 1 0];
% % simulation des matrices
[~ , S ] = simu_mat ( graph_ref ,0.2) ; % on prendra thresh = 0.2 par
defaut
9
11
% % simulation d ’ un jeu de donnees
X = simu_data (S , n ) ;
Remarque : On peut également tracer le graphe de référence afin de pouvoir le comparer
au graphe estimé avec une des méthodes pour une vérification visuelle.
56
Bibliographie
[1] A. Costard. Estimation de la structure d ?indépendance conditionnelle d ?un réseau de
capteurs. Application à l ?imagerie médicale. PhD thesis, Université de Grenoble, 2014.
[2] H. Wang. Bayesian graphical lasso models and efficient posterior computation. Bayesian
Analysis, 7 :771–790, 2012.
[3] J. Friedman, T. Hastie, and R. Tibshirani. Sparse inverse covariance estimation with
the Graphical lasso. Biostatistics, 9 :432–441, 2008.
[4] S. Boyd, N. Parikh, E. Chu, B. Peleato, and J. Eckstein. Distributed optimization and
statistical learning via the alternating direction method of multipliers. Foundations
and Trends in Machine Learning, 3 :1–122, 2010.
[5] C. Giraud, S. Huet, and N. Verzelen. Graph selection with ggmselect. Statistical
Applications in Genetics and Molecular Biology, 11 :1544–6115, 2012.
[6] M. Drton and M.D. Perlman. A sinful approach to gaussian graphical model selection.
Journal of Stastical planning and inference, 138 :1179–1200, 2008.
[7] G. Marrelec and H. Benali. Asymptotic Bayesian structure learning using graph supports for Gaussian graphical models. Journal of Multivariate Analysis, 97 :1451–1466,
2006.
57

Guide de l`utilisateur Toolbox pour l`estimation de structures d

Transcription

Documents pareils

Exercices

BTS SIO - 2015 - 11 - Ex 2 - Nouvelle Calédonie

WD Gestion Erreurs HFSQL Cet exemple présente de

TES GRAPHES feuille 34 Une grande ville a mis en

I Sim City II Matrice de transition

Proposition de stage M2 Informatique ENS Lyon 2015 Plongements

L`escalier du diable de Cantor Dans AlmaSoror

Quatre exercices d`initiation

MAT 3616 THEORIE DES GRAPHES Plan du cours : Hiver 2010

Masters Informatique et MIMSE Université de - dept