Sélection de variables à grande échelle à partir de forêts aléatoires

École Centrale de Marseille
Département d’Électricité,
Électronique & Informatique
Université de Liège
Travail de Fin d’Études
du 01/04/15 au 11/09/15
Sélection de variables à grande échelle à
partir de forêts aléatoires
Célia Châtel
Tuteur ECM :
François Brucker
Tuteur Entreprise :
Pierre Geurts
Option OMIS
Promo 2015
Remerciements
Je tiens à remercier mon encadrant de stage, Pierre Geurts, pour le temps
qu’il m’a consacré et sa sympathie.
Je voudrais également remercier tous les doctorants et membres de l’équipe
pour leur accueil chaleureux et plus particulièrement :
— Jean-Michel Begon pour sa bonne humeur,
— Vân Anh Huynh-Thu pour sa sympathie au quotidien,
— Arnaud Joly pour ses conseils techniques et sa disponibilité,
— et Antonio Sutera avec qui j’ai eu l’occasion de travailler, pour son aide
et sa présence.
Enfin, j’aimerais remercier Sandrine Anthoine, François Brucker et Liva Ralaivola qui m’ont donné le goût de la recherche et l’envie de m’y consacrer.
1
Résumé
La classification a pour but l’apprentissage d’un modèle permettant de prédire une sortie (représentant des classes) à partir de données. Dans ce domaine,
les arbres de décision sont des modèles d’apprentissage simples et très utilisés.
Construire des ensembles d’arbres appelés forêts permet en général d’obtenir de
bons résultats de classification. La façon de construire les arbres étant intrinsèquement liée à la sélection de variables, qui consiste à retrouver les variables
apportant de l’information sur la sortie, de nombreuses méthodes de sélection
de variables sont basées sur ces modèles. Nous nous intéressons en particulier à
résoudre ce problème à grande échelle, ne permettant pas de mettre en mémoire
toutes les données simultanément et obligeant ainsi à n’étudier qu’un certain
nombre de variables à la fois. Nous chercherons à identifier toutes les variables
ayant une influence sur la sortie.
Nous décrivons une méthode naïve et proposons et justifions un nouvel algorithme de sélection de variables reposant en partie sur des résultats théoriques
montrés dans l’article ’Understanding variable importances in forests of randomized trees’ (Louppe et al., 2013). Ces résultats utilisent une mesure d’importance des variables calculée à partir de forêts d’arbres aléatoires et basée
sur l’information mutuelle entre les variables et la sortie conditionnellement à
d’autres variables. Notre étude se divise ensuite en deux parties. Une simulation du comportement des algorithmes est réalisée dans un premier temps avec
diverses formes d’arbres et hypothèses sur les données afin de mesurer les performances des deux méthodes dans différents cas et montrer la pertinence de
la méthode proposée. Dans un second temps, nous testons la méthode naïve
ainsi que notre algorithme sur l’ensemble très utilisé de données générées Madelon afin de comparer les différentes méthodes et de mesurer les performances
obtenues sur un ensemble de données.
Mots clés big data, apprentissage automatique, arbres de décision, sélection
de variables, forêts d’arbres aléatoires
2
Summary
In classification, one wants to build a statistical model able to predict an
output based on some data. In machine learning, decision trees are a really
easy and wide spread method. Constructing several trees and thus, building a
forest, leads to good classification results. The way of building these trees is
intrinsically linked to feature selection which consists in identifying the features
impacting the value of the output. Hence many feature selection methods are
based on decision trees. In this work, we focus on feature selection at a large
scale, without being able to study all the features at once. We aim at identifying
each feature that has an impact on the output.
We describe a naive algorithm and propose a new one based on the results from ’Understanding variable importances in forests of randomized trees’
(Louppe et al., 2013). This paper proposes a measure of importance for the
features using the mutual information between some features and the output
conditioning by other features. Our work is then divided into two parts. First,
we study by performing simulations, the speed of convergence of the naive method and of our algorithm. We test our idea on different tree models and data
hypothesis by simulating their behaviour, in order to measure our algorithms
performances and compare them. Secondly, we use the well known Madelon
dataset to compare our methods and performances on a dataset.
Key words big data, machine learning, decision trees, feature selection, random forests
3
Table des matières
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1 Contexte
7
9
1.1
Contexte de travail . . . . . . . . . . . . . . . . . . . . . . . . . .
9
1.2
Contexte théorique . . . . . . . . . . . . . . . . . . . . . . . . . .
10
1.2.1
Apprentissage supervisé . . . . . . . . . . . . . . . . . . .
10
1.2.2
Entropie et information mutuelle . . . . . . . . . . . . . .
10
1.2.3
Pertinence et sélection de variables . . . . . . . . . . . . .
11
1.2.4
Arbres de décision . . . . . . . . . . . . . . . . . . . . . .
13
2 Contributions
17
2.1
Objectif général . . . . . . . . . . . . . . . . . . . . . . . . . . . .
17
2.2
Algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
2.2.1
Algorithme naïf . . . . . . . . . . . . . . . . . . . . . . . .
18
2.2.2
Algorithme intelligent . . . . . . . . . . . . . . . . . . . .
20
Simulations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
23
2.3.1
Arbres utilisés . . . . . . . . . . . . . . . . . . . . . . . .
23
2.3.2
Hypothèses sur les données . . . . . . . . . . . . . . . . .
25
Mise en pratique . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
2.4.1
Modifications des algorithmes . . . . . . . . . . . . . . . .
26
2.4.2
Arbres utilisés . . . . . . . . . . . . . . . . . . . . . . . .
27
2.4.3
Données . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
2.3
2.4
3 Résultats
3.1
30
Simulations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30
3.1.1
Cas d’une infinité d’arbres . . . . . . . . . . . . . . . . . .
31
3.1.2
Comparaison des deux algorithmes . . . . . . . . . . . . .
31
3.1.3
Impact des données . . . . . . . . . . . . . . . . . . . . .
33
3.1.4
Impact des paramètres . . . . . . . . . . . . . . . . . . . .
37
4
3.1.5
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . .
40
Données simulées : Madelon . . . . . . . . . . . . . . . . . . . . .
40
3.2.1
Méthodologie . . . . . . . . . . . . . . . . . . . . . . . . .
40
3.2.2
Comparaison des algorithmes et résultats généraux . . . .
41
3.2.3
Impact des données . . . . . . . . . . . . . . . . . . . . .
43
3.2.4
Impact des paramètres . . . . . . . . . . . . . . . . . . . .
49
3.2.5
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . .
52
Discussion et perspectives . . . . . . . . . . . . . . . . . . . . . . . . .
54
3.2
Annexe A Comparaison théorique des algorithmes pour le cas de
variables marginalement pertinentes
57
Annexe B Impact de α dans le cas K =
"Base"
5
1
q
sur l’ensemble Madelon
59
Nomenclature
α
Paramètre de l’algorithme intelligent : pourcentage de variables à éliminer de la mémoire pour l’itération suivante
β
Paramètre de l’algorithme intelligent : pourcentage de remplissage de la
mémoire avant de commencer l’élimination
∆i
Décroissance en impureté
ˆ
Imp (Xm ) Importance de Xm estimée sur des données
A (V, Y ) Résultat de l’algorithme appliqué à l’ensemble de variables V et la
sortie Y
B
Sous-ensemble de variables désignant un conditionnement
deg (V ) Degré d’interaction maximal de V
deg (Xm ) Degré d’interaction de la variable Xm
F
Sous-ensemble de V renvoyé par les algorithmes : résultat de la sélection
de variables
H (A) Entropie de la variable aléatoire A
I (A; B) Information mutuelle entre les variables aléatoires A et B
Imp (Xm ) Importance de Xm calculée à partir d’une infinité d’exemples et de
manière indifférente à partir d’une infinité d’arbres ou d’un nombre fini
Imp∞ (Xm ) Importance de Xm calculée à partir d’une infinité d’arbres et d’une
infinité d’exemples
ImpNT (Xm ) Importance de Xm calculée à partir de NT arbres et d’une infinité
d’exemples
K
Paramètre de construction des arbres : pourcentage de variables à utiliser
lors de la division en chaque nœud de l’arbre
k
Nombre de variables pertinentes
n
Nombre d’exemples dans la base de données
p
Nombre de variables
q
Taille de la mémoire
V
Ensemble des variables
Xi
Variable particulière
Y
Variable de sortie
6
Introduction
Lors de ma troisième année à l’École Centrale de Marseille, j’ai eu l’occasion de réaliser mon travail de fin d’études au sein de l’Institut Montefiore,
département d’électricité, électronique et informatique de l’université de Liège
en Belgique. J’ai été amenée à travailler dans le domaine de l’apprentissage
automatique, sur la sélection de variables.
L’apprentissage supervisé consiste à inférer une fonction à partir de données
étiquetées. On dispose d’exemples de points auxquels sont attribuées une classe
ou une valeur et le but est de trouver une fonction permettant de prédire à
partir des valeurs des points, la valeur de la sortie. Parmi les méthodes d’apprentissage supervisé, on trouve notamment les modèles de type forêts d’arbres
aléatoires [6, 3] qui permettent d’obtenir de bonnes performances en prédiction
et se distinguent des autres méthodes par leur grande facilité d’utilisation et
leurs bonnes performances en termes de temps de calcul.
Un problème sous-jacent à l’apprentissage supervisé est le problème de la
sélection de variables [5] qui peut consister en deux tâches différentes. La première est de trouver un sous-ensemble F de V = {X1 , X2 , ...Xp }, l’ensemble
des variables, le plus petit possible permettant de prédire la sortie Y sans perte
d’information significative tandis que la seconde consiste à trouver toutes les
variables influençant la sortie, seules ou en combinaison avec d’autres variables.
Les intérêts de la sélection de variables sont divers. Elle peut être une fin en
soi pour l’information qu’elle apporte à l’utilisateur sur le lien entre les entrées
et la sortie. Elle permet de simplifier les modèles et donc de les rendre plus
faciles à interpréter. Elle permet également de réduire les temps d’apprentissage en se focalisant sur les variables identifiées. Enfin, elle permet d’éviter le
sur-apprentissage, c’est-à-dire la construction de modèles ayant de très bonnes
performances sur l’ensemble d’apprentissage mais inefficaces sur de nouvelles
données issues de la même distribution. Ce travail se concentre sur la sélection
de variables comme méthode d’identification de toutes les variables influant sur
la sortie. Les méthodes de forêts aléatoires sont particulièrement intéressantes
pour résoudre ce problème. D’abord, parce que la construction des arbres au
sein de ces méthodes se fait selon une approche gloutonne, en choisissant à
chaque nœud une variable minimisant un certain critère ce qui rend ces modèles
étroitement liés à la sélection de variables. Ensuite, parce qu’il est possible de
tirer a posteriori de ces modèles une mesure d’importance de variables, dont
l’intérêt pratique pour la sélection de variables a été prouvé dans de nombreux
travaux. Bien qu’utile, les propriétés de cette mesure ont cependant été très peu
étudiées théoriquement. Dans [10], Louppe et al. ont montré la pertinence de
7
cette mesure pour la sélection de variables mais leurs résultats sont cependant
limités à des forêts de taille infinie et n’apportent donc pas d’éclairage sur les
capacités de ces méthodes à identifier les variables les plus influentes dans le cas
d’un ensemble fini d’arbres aléatoires.
Dans ce travail, nous nous proposons d’étudier et d’améliorer la convergence
de ces algorithmes en fonction du nombre d’arbres introduits dans la forêt. Pour
cette étude, nous nous placerons dans un cadre plus contraint où on suppose
qu’il n’est pas possible de construire un modèle sur la totalité des variables mais
seulement sur un sous-ensemble d’entre elles de taille fixée a priori. Ce cadre
théorique est motivé par le besoin de plus en plus fréquent en apprentissage de
pouvoir traiter des problèmes à très grande dimension, pour lesquels il n’est pas
possible d’étudier toutes les variables simultanément à cause d’une limitation de
mémoire. Ce type de problèmes apparaît dans de nombreux domaines. C’est le
cas par exemple dans le domaine de la génomique où il n’est pas rare de devoir
traiter des millions, voire des dizaines de millions de variables.
Dans ce contexte, nous proposons et étudions essentiellement deux algorithmes de sélection : (1) une approche naïve dérivée de travaux existants [7, 9],
et consistant simplement à apprendre chaque arbre de la forêt sur un sousensemble de variables choisies uniformément au hasard parmi toutes les variables
et (2) une approche nouvelle, plus intelligente, exploitant les arbres précédemment construits pour améliorer la convergence. Une étude théorique de ces deux
algorithmes est réalisée qui précise les conditions exactes dans lesquelles ces deux
méthodes sont consistantes par rapport au problème de sélection de variables.
Leurs vitesses de convergence sont ensuite étudiées et comparées dans différents
contextes grâce à des simulations numériques qui supposent le cas asymptotique
d’une infinité de données. Enfin, afin de confirmer l’intérêt des méthodes proposées, nous testons leurs performances dans le cas d’un ensemble de données
générées artificiellement très utilisé et dont un certain nombre de paramètres
sont maîtrisables.
Le présent rapport est structuré de la manière suivante. Nous présentons le
laboratoire dans lequel le travail a été réalisé dans le chapitre 1.1, le contexte
théorique lié au problème dans le chapitre 1.2 puis décrivons la méthode proposée et les études réalisées sur celle-ci et sur la méthode naïve dans le chapitre
2 en terme de simulation et de mise en pratique. Enfin, nous donnons dans le
chapitre 3 les résultats obtenus par les simulations réalisées ainsi que par la mise
en pratique et concluons.
8
Chapitre 1
Contexte
1.1
Contexte de travail
Ce travail, ancré dans le domaine de l’apprentissage automatique a été réalisé
au sein de l’université de Liège, en Belgique et plus précisément au département
d’Électricité, Électronique et Informatique, situé à l’institut Montefiore. Le laboratoire comprend divers groupes de recherche :
— Applied and Computational Electromagnetics (ACE)
— Computer Networks (RUN)
— Electronics, Microsystems, Measurements, and Instrumentation (EMMI)
— Power Transmission and Distribution (TDEE)
— Signal and Image Exploitation (INTELSIG)
— Software Reliability
— Systems and Modeling
J’ai plus précisément été intégrée à l’équipe "Systems and Modeling" (SystMod) comprenant plus de soixante membres permanents et doctorants travaillant sur des sujets aussi variés que l’apprentissage automatique, les systèmes
dynamiques, les statistiques, le contrôle et l’optimisation, les réseaux d’énergie
électrique, la biologie des systèmes et la bioinformatique. L’équipe est impliquée
dans différents réseaux d’excellence nationaux et internationaux en particulier
le réseau "Pattern analysis, statistical modeling and computational learning"
et le pôle d’attraction inter-universitaire DYSCO (Dynamical systems, control
and optimization).
J’ai eu l’occasion de travailler avec Pierre Geurts et d’être intégrée à son
équipe et au groupe de doctorants qu’il encadre. Leur recherche porte plus précisément sur les méthodes de type forêts aléatoires et leurs applications dans
différents domaines tels que la bioinformatique. J’ai par exemple été amenée à
travailler plus avant avec Antonio Sutera dont la thèse porte sur la caractérisation et l’extension des mesures d’importances de variables dérivées des forêts
aléatoires. D’autres sujets étudiés dans ce groupe sont par exemple la classification dans le cas multi-label (c’est-à-dire avec plusieurs sorties), l’inférence de
réseaux ou encore l’exploitation de la structure de données structurées telles que
les images.
9
L’unité de recherche organise un séminaire bimensuel afin de donner l’occasion à des chercheurs étrangers invités ou des membres de l’unité de présenter
leurs recherches. Certains membres de l’équipe travaillent également dans le
centre GIGA-R (Groupe Interdisciplinaire de Genoprotéomique Appliquée) au
CHU de Liège où ils participent à la recherche en biologie systémique et biologie
chimique.
Durant mon stage, j’ai pu également bénéficier du CECI (Consortium des
Équipements de Calcul Intensif) qui réunit les super-ordinateurs de calcul de
l’université libre de Bruxelles, de l’université catholique de Louvain, de l’université de Liège, de celle de Mons et enfin de celle de Namur. Ceci m’a permis
d’utiliser des ressources de calculs adaptées à mes besoins.
1.2
Contexte théorique
Cette section introduit les concepts théoriques importants tels que la mesure
d’information sur laquelle est basée la notion de variable pertinente, les méthodes de forêts aléatoires et les mesures d’importance de variables qui peuvent
leur être associées et sont très largement utilisées dans ce travail.
1.2.1
Apprentissage supervisé
L’apprentissage supervisé [6] consiste à inférer une fonction à partir de données étiquetées. On dispose d’un échantillon de paires LS = {(x1 , y1 ) , ... (xn , yn )}
⊆ (X × Y)n , appelé ensemble d’apprentissage, tirées de manière indépendante
d’une distribution P (X, Y ) sur X × Y inconnue. L’objectif est alors de trouver
une fonction f : X → Y qui minimise l’espérance d’un coût EX,Y {L (Y, f (X))}.
On parle de classification lorsque Y est une variable discrète et de régression
lorsque Y est une variable continue. Dans le cas de la classification, la fonction
de coût peut être par exemple : L(y, f (x)) = 1{(y,y0 )∈Y×Y|y6=y0 } ((y, f (x))) qui
consiste tout simplement à compter le nombre d’erreurs de classification faites
par le modèle.
Dans ce travail, nous nous concentrerons sur les problèmes de classification
binaire avec des variables discrètes dans la partie théorique.
1.2.2
Entropie et information mutuelle
En théorie de l’information [4], l’entropie d’une variable aléatoire A discrète
est définie par
X
H (A) = −
p (a) log p (a)
a∈A
et l’entropie conditionnelle de A sachant la variable aléatoire discrète B par
H (A|B) =
X
p (a, b) log
a∈A,b∈B
10
p (b)
p (a, b)
en notant p (a) la probabilité de a. L’information mutuelle entre deux variables
aléatoires A et B est alors définie par :
I (A; B) =
P
a∈A,b∈B
p (a, b) log
p(a,b)
p(a)p(b)
= H (A) − H (A|B)
= H (B) − H (B|A)
L’information mutuelle est symétrique et ne prend que des valeurs positives.
Cette quantité permet de mesurer la dépendance entre les deux variables. Par
exemple, A et B sont indépendantes si et seulement si I (A; B) = 0. Dans le
cas de la sélection de variables, l’idée est d’utiliser I (Xi ; Y ) pour mesurer la
pertinence de la variable Xi quant à la prédiction de Y (la variable de sortie) et I (Xi ; Xj ) pour mesurer la redondance entre les variables Xi et Xj . On
utilise également l’information mutuelle conditionnelle afin de capturer des relations plus complexes entre les variables. Celle-ci peut s’écrire grâce à la règle
de chaînage pour trois variables aléatoires X, Y et Z :
I (X; Y |Z) = I (X; Y, Z) − I (X; Z)
Dans le cas de deux variables binaires X1 et X2 qui définissent un XOR (Y =
X1 ⊕ X2 ), par exemple, seules les deux variables prises ensemble fournissent de
l’information sur la sortie. Il faudra donc regarder I (X1 ; Y |X2 ) et non I (X1 ; Y )
pour prendre en compte la relation entre X1 et la sortie.
1.2.3
Pertinence et sélection de variables
L’information mutuelle permet de définir formellement la pertinence d’une
variable. En effet, dans [8], la pertinence d’une variable est définie à partir de
la notion d’indépendance ce qui est équivalent à une information mutuelle nulle
comme nous l’avons dit précédemment.
Définition 1. Une variable Xm est pertinente pour Y si et seulement si il existe
un ensemble de variables B ⊆ {X1 , X2 , ...Xp } \Xm tel que I (Xm ; Y |B) > 0.
Intuitivement, une variable est donc pertinente si et seulement si elle apporte
de l’information sur la sortie dans au moins un contexte (représenté par le
conditionnement B). A l’inverse, une variable est non pertinente si et seulement
si pour tout contexte B, I (Xm ; Y |B) = 0. Dans ce cas, quelles que soient les
variables avec lesquelles on l’étudie, Xm n’apporte pas d’information sur la
valeur de la sortie.
Cette notion de pertinence permet de définir formellement le problème de
sélection de variables que nous voulons résoudre.
Définition 2. La sélection de variables consiste, étant donnés un ensemble de
variables V et une sortie Y à trouver toutes les variables Xm dans V telles que
Xm est pertinente. On s’intéresse donc aux fonctions A : V × Y → 2V telles que
A (V, Y ) = {Xm ∈ V |Xm est pertinente}.
11
Nous cherchons à développer des méthodes de sélection de variables qui
convergent vers une solution à ce problème et que nous qualifierons de consistantes.
Définition 3. Une méthode de sélection de variables A est dite consistante
si, pour un ensemble d’apprentissage de taille infinie et après un temps infini,
Xm ∈ A (V, Y ) si et seulement si Xm est pertinente.
Nous définissons de plus certaines propriétés relatives aux données.
Définition 4. On appelle conditionnement minimal pour Xm un ensemble B ⊆
{X1 , X2 , ...Xp } \Xm tel que :
I (Xm ; Y |B) > 0
∀B 0 ⊆ {X1 , X2 , ...Xp } \Xm , I (Xm ; Y |B 0 ) > 0 ⇒ |B| ≤ |B 0 |
Pour un tel B, on appellera degré d’interaction la taille de l’ensemble B qu’on
notera deg (Xm ).
On notera deg (V ) = maxXm ∈V deg (Xm ) le degré d’interaction maximal de
l’ensemble de variables V .
On peut de plus définir un type particulier de variables et certaines propriétés.
Définition 5. Une variable Xm est dite marginalement pertinente si et seulement si I (Xm ; Y ) > 0 i.e si et seulement deg (V ) = 0.
Définition 6. Deux variables Xi et Xj sont dites parfaitement redondantes si

 ∃B ⊆ {X1 , X2 , ...Xp } \Xi , I (Xi ; Y |B) > 0
∃B 0 ⊆ {X1 , X2 , ...Xp } \Xj , I (Xj ; Y |B 0 ) > 0

∀C ⊆ {X1 , X2 , ...Xp } , I (Xj ; Y |C ∪ Xi ) = I (Xi ; Y |C ∪ Xj ) = 0
Dans ce cas, intuitivement, les deux variables contiennent exactement la
même information sur la sortie. Connaître les deux variables n’apporte rien de
plus sur la sortie que de n’en connaître qu’une. Cela se généralise à des groupes
de variables.
Il convient d’étudier les variables avec des conditionnements adéquats. En
effet, les conditionnements minimaux de variables pertinentes ne sont pas quelconques.
Lemme 1. Soient Xi une variable non pertinente pour Y , Xm ∈ V et B ⊆
{X1 , X2 , ...Xp }.
I (Xm ; Y |B) = I (Xm ; Y |B ∪ Xi ) .
Preuve. D’après la règle de chaînage sur l’information mutuelle [4], on a :
I (Xm , Xi ; Y |B) = I (Xm ; Y |B) + I (Xi ; Y |B ∪ Xm )
et
I (Xm , Xi ; Y |B) = I (Xi ; Y |B) + I (Xm ; Y |B ∪ Xi )
Or Xi est non pertinente donc I (Xi ; Y |B) = I (Xi ; Y |B ∪ Xm ) = 0.
Donc I (Xm ; Y |B) = I (Xm ; Y |B ∪ Xi )
12
X1
X2 = 0
X1 = 0
X1 = 1
X2
X3
X2 = 1
X3
X3 = 0
0
X3 = 0
1
X4
1
X3 = 1
X3 = 1
X4 = 0
1
X4 = 1
0
1
Figure 1.1 – Exemple d’arbre de décision
On en déduit immédiatement le théorème suivant qui nous sera utile par la
suite :
Théorème 1. Tout conditionnement minimal d’une variable pertinente Xm ne
contient que des variables pertinentes.
1.2.4
Arbres de décision
Définitions
Les méthodes d’arbres (introduites par [1]) étant efficaces en terme de prédiction dans de nombreuses situations, elles sont largement utilisées pour les
problèmes de classification et de régression. De plus, la façon dont les arbres
sont construits est liée à la sélection de variables, ce qui en fait un outil intuitif
et efficace pour la résolution de ce problème.
Quand un arbre de décision a été construit, afin de prédire la classe d’un point
à partir des valeurs de ses variables, on parcourt l’arbre en prenant à chaque
noeud, la branche adaptée à la valeur de la variable considérée. La feuille dans
laquelle on arrive indique la classe attribuée au point. Chaque noeud de l’arbre
représente donc une division effectuée sur une variable (par exemple, sur l’arbre
de la Figure 1.1 si X1 = 0, l’exemple continue son chemin dans le fils gauche
de la racine, sinon il va dans le fils droit). Les feuilles de l’arbre quand à elles,
sont des nœuds purs et indiquent la classe des exemples qui y arrivent. Le point
(X1 = 0, X2 = 0, X3 = 1, X4 = 0) sera par exemple attribué à la classe 1.
Pour construire un arbre de décision, il convient donc de choisir en chaque
nœud, sur quelle variable sera effectuée la division des données. Ce choix peut
être fait de manière arbitraire mais la méthode la plus répandue consiste à
maximiser la décroissance d’un certain critère d’impureté des exemples propagés
dans chaque noeud : ∆i (st , t) = i (t) − pL i (tL ) − pR i (tR ) avec pR et pL les
proportions d’exemples propagés à droite et à gauche respectivement et tR et
tL les fils droit et gauche. L’Algorithme 1 détaille la construction de tels arbres
pour des variables discrètes. Le critère que nous utiliserons dans tout ce travail
est l’entropie de Shannon. Chercher à maximiser la décroissance en entropie de
13
Shannon revient à maximiser l’information mutuelle entre la variable choisie
et la sortie conditionnellement aux variables utilisées précédemment dans la
branche de l’arbre.
Algorithme 1 : Algorithme de création d’un arbre de décision
Données : V = {X1 , ..., Xp } l’ensemble de variables, Y la variable sortie,
n exemples
Résultat : Arbre de décision
1 si Tous les exemples ne sont pas de la même classe et toutes les variables
ne sont pas constantes alors
2
pour Xm ∈ V faire
3
IXm = gain en information si on divise le noeud sur Xm
4
fin
5
Xbest = arg maxXm ∈V IXm
6
Créer un nœud qui divise sur Xbest
7
Rappeler la fonction sur les sous-ensembles d’exemples obtenus par la
division et ajouter les nœuds en tant que fils du nœud créé
8 fin
Au lieu d’un arbre seul, on construit souvent un ensemble d’arbres afin de
réduire la variance. On introduit donc un paramètre aléatoire lors de la construction des arbres afin d’obtenir des modèles différents. On peut par exemple
construire chaque arbre sur un sous-ensemble (avec remise) des exemples (bagging, [2]), des variables (random subspace, [7]), des deux à la fois (random
patches, [9]) ou encore décider de la variable sur laquelle effectuer la division en
un nœud de l’arbre parmi un sous-ensemble de variables tirées aléatoirement à
chaque nœud (random forest, [3]), ou de façon totalement aléatoire. Une partie
de l’étude se concentrera sur la méthode "random forests" qui est l’une des plus
utilisées en pratique.
Dans la méthode des random forests, on fixe un paramètre K. A chaque
noeud, on sélectionne de manière uniforme dK × pe variables (avec p le nombre
total de variables) et on utilise la variable maximisant la décroissance d’impureté
parmi ces variables uniquement. En prenant par exemple K = 1, on construit
alors l’arbre de manière déterministe. A l’inverse, si on prend K = p1 , l’arbre
sera construit en choisissant de manière totalement aléatoire les variables sur
lesquelles effectuer les divisions. La seule modification à faire dans l’Algorithme
1 est donc au début de chaque appel récursif de choisir un ensemble V 0 ⊆ V de
taille dK × pe de manière uniforme et d’effectuer la suite de l’algorithme sur cet
ensemble à la place de V.
Il est possible de définir certaines propriétés sur les arbres, notamment :
Définition 7. Un arbre est dit totalement aléatoire si la variable sur laquelle
effectuer la division à chaque nœud est choisie de manière uniforme parmi l’ensemble des variables.
Définition 8. Un arbre est dit complètement développé si chaque nœud est
divisé en autant de fils qu’il y a de valeurs de la variable choisie et que toutes
les variables sont utilisées une fois par branche ou que toutes les feuilles sont
pures.
14
Mesure d’importance associée aux arbres
A partir d’arbres appris sur des données quelconques, il est possible de définir une mesure d’importance pour les variables sur lesquelles les données sont
exprimées.
Définition 9. L’ importance estimée d’une variable Xm dans le cas d’un ensemble fini de NT arbres construits avec une perturbation aléatoire est définie
par :
X
X
ˆ (st , t)
ˆ N (Xm ) = 1
p̂ (t) ∆i
Imp
T
NT
T
t∈T :v(st )=Xm
avec v (st ) la variable choisie lors de la division st , p̂ (t) la probabilité d’arriver
au nœud t c’est-à-dire le rapport entre le nombre d’exemples arrivant à ce nœud
ˆ (st , t) = i (t) − pL i (tL ) − pR i (tR ) où i est
et le nombre total d’exemples et ∆i
une mesure d’impureté comme l’entropie de Shannon, tL (resp. tR ) est le fils
gauche (resp. droit) de t, et pL (resp. pR ) est la probabilité qu’un exemple arrive
dans le nœud tL (resp. tR ).
Cela revient à identifier dans chaque arbre de la forêt les nœuds dans lesquels
la variable Xm a été utilisée et à quel point elle a permis de réduire l’impureté.
On estime ici la valeur de l’importance de la variable grâce aux données avec
lesquelles les arbres ont été construits.
Si on dispose d’un nombre infini d’exemples, les valeurs d’impureté calculées
sont exactes et non plus estimées. On note alors ImpNT (Xm ).
Dans le cas d’un ensemble infini d’arbres totalement aléatoires et complètement développés construits sur un ensemble d’exemples supposé infini, on notera
l’importance d’une variable :
Imp∞ (Xm ) =
lim
NT →+∞
ImpNT (Xm )
Dans ce cas, l’importance n’est plus estimée mais calculée de manière exacte :
tous les conditionnements sont testés pour chaque variable et toutes les informations mutuelles sont calculées exactement. Plusieurs résultats concernant la
sélection de variables dans ce cas ont été démontrés dans [10].
Dans la suite, quand Imp∞ (Xm ) ou ImpNT (Xm ) peuvent être utilisées
indifféremment, on notera simplement Imp (Xm ).
En utilisant comme mesure d’impureté l’entropie de Shannon, l’importance
d’une variable Xm peut s’exprimer de la manière suivante :
Imp∞ (Xm ) =
p−1
X
1
p
k=0
k
1
p−k
X
B∈Pk (V
I (Xm ; Y |B)
−m )
avec Pk (V −m ) l’ensemble des sous-ensembles de variables ne contenant pas Xm
et contenant k éléments. Ceci revient donc à mesurer pour la variable Xm la
valeur de son information mutuelle avec la sortie conditionnellement à tous les
sous-ensembles de variables possibles et à effectuer une moyenne des résultats.
On tire le résultat suivant de [10] :
15
Théorème 2. Une variable Xm est non pertinente pour Y si et seulement si son
importance Imp∞ (Xm ) calculée grâce à un ensemble infini d’arbres totalement
aléatoires et complètement développés est nulle.
L’importance d’une variable et sa pertinence sont donc étroitement liées
et cette mesure d’importance peut être utilisée pour résoudre un problème de
sélection de variables de manière consistante. Notons cependant que ce théorème
n’est plus vrai dans le cas d’arbres non totalement aléatoires [10].
16
Chapitre 2
Contributions
2.1
Objectif général
Les algorithmes de forêts aléatoires ont la propriété de permettre de trouver
toutes les variables pertinentes dans l’hypothèse d’un nombre infini d’arbres
et d’une taille d’ensemble d’apprentissage infinie. Étant donnés les résultats
rappelés dans le chapitre 1.2.4, il est aisé de se convaincre que pour un NT
fini fixé, la condition ImpNT (Xi ) > 0 reste suffisante pour qu’une variable soit
pertinente mais elle n’est cependant plus nécessaire. Plus l’algorithme dispose
d’un nombre important d’arbres et plus il détecte de variables pertinentes. Sa
vitesse de convergence, mesurée par exemple par le nombre moyen d’arbres
nécessaire pour trouver toutes les variables pertinentes, n’a cependant jamais
été étudiée à notre connaissance.
Dans ce travail, notre objectif est d’étudier, et de tenter d’améliorer, la
convergence de ces algorithmes dans un cadre plus contraint où on suppose
qu’il n’est pas possible de construire un arbre sur la totalité des variables, mais
seulement sur un sous-ensemble d’entre elles de taille fixée q (le cadre classique
non contraint correspondant donc à q = p). Ce cadre particulier est motivé par
le désir de traiter des problèmes de sélection de variables à très grande dimension
pour lesquels on ne peut pas supposer qu’il est possible de stocker en mémoire
la totalité des données.
Pour simplifier nos développements, nous ne ferons par contre pas d’hypothèse particulière sur le nombre d’échantillons qui peuvent être exploités simultanément pour construire nos modèles. Il est cependant intéressant de noter que
lorsqu’il s’agit de construire des arbres, le nombre de variables exploitées par le
modèle dépend directement de la taille de la base de données. En effet, étant
donnée la division récursive de l’ensemble d’apprentissage du haut vers le bas
de l’arbre, plus la taille de l’échantillon d’apprentissage est grande et plus il est
possible de construire des arbres profonds, en particulier si on veut maintenir
un nombre d’échantillons en chaque nœud suffisant pour pouvoir estimer correctement les informations mutuelles conditionnelles. Il y a donc une certaine
forme d’équivalence entre travailler à nombre de variables contraint et travailler
à nombre d’échantillons contraint.
17
Notre approche pour aborder cette problématique est la suivante. Dans le
chapitre 2.2, nous présentons deux algorithmes basés sur les forêts d’arbres permettant de résoudre le problème de sélection de variables en tenant compte de la
contrainte de mémoire. Le premier, plus naïf, consiste simplement à construire
les arbres sur des sous-ensembles de variables de taille q choisis aléatoirement
et de manière uniforme parmi toutes les variables. Le second est une méthode
alternative originale dont l’objectif est d’améliorer la convergence de la méthode naïve. Dans cette même section, nous étudions en détails les conditions
de consistance de ces deux méthodes. Ensuite, afin d’évaluer dans un premier
temps les idées et performances des algorithmes, nous mettons en place des simulations numériques (c’est-à-dire en supposant un échantillon de taille infinie
et sans calculer effectivement les importances ni utiliser de données) afin d’évaluer le nombre d’itérations nécessaires aux différents algorithmes pour retrouver
toutes les variables pertinentes de l’ensemble. Les modèles théoriques d’arbres
et de données que nous utilisons pour ces simulations sont présentés dans les
chapitres 2.3.1 et 2.3.2 respectivement. Nous discutons ensuite des modifications à apporter à ces algorithmes afin de les rendre utilisables en pratique et
présentons les modèles d’arbres utilisés dans le chapitre 2.4.
2.2
Algorithmes
Ci-dessous, nous donnons les deux idées d’algorithmes sur lesquels nous avons
réalisé une étude théorique, des simulations et enfin une mise en pratique.
2.2.1
Algorithme naïf
L’algorithme le plus simple de sélection de variables à partir de forêts d’arbres
aléatoires consiste à construire NT arbres à partir d’ensembles de q variables
choisies uniformément parmi l’ensemble des variables V et à calculer ImpNT (Xm )
pour tout Xm ∈ V . Nous reformulons légèrement cet algorithme dans l’Algorithme 2 en calculant les importances des variables après chaque arbre appris
afin d’extraire les variables pertinentes au fur et à mesure des itérations. On
peut également envisager de construire à chaque itération une forêt d’arbres et
d’en extraire les importances des variables. En pratique, il n’est pas possible de
savoir si toutes les variables pertinentes ont été trouvées à moins de les avoir
toutes identifiées comme pertinentes ou d’avoir testé tous les conditionnements
possibles.
Cet algorithme est dérivé des méthodes random subspace [7] et random
patches [9] qui ont montré qu’il offrait de bonnes performances en terme de
précision de classification.
Variante théorique A la place de construire un unique arbre à chaque itération et pour évaluer la capacité de l’algorithme à identifier les variables pertinentes, on peut également supposer qu’on construit un nombre infini d’arbres
à chaque itération. Cela revient donc, pour chaque variable de l’ensemble Q
choisi, à calculer son information mutuelle avec la sortie conditionnellement à
18
Algorithme 2 : Algorithme naïf
Données : V = {X1 , ..., Xp } l’ensemble de variables, Y la variable sortie,
n exemples, N le nombre d’itérations maximum, q la taille de
la mémoire
Résultat : Ensemble F ⊆ {X1 , ..., Xp } des variables pertinentes
identifiées
1 F =∅
2 pour t de 1 à N faire
3
Q = choix (q, V ) // On tire aléatoirement q variables dans V
4
Construire un arbre sur Q
5
pour Xm ∈ Q faire
6
Calculer Imp (Xm ) à l’aide de l’arbre construit // On calcule
l’importance avec l’arbre construit
7
si Imp (Xm ) > 0 alors
8
Ajouter Xm à F
9
fin
10
fin
11 fin
tous les sous ensembles possibles de Q. On suppose donc que pour toute variable
Xm ∈ Q et pour tout Q0 ⊆ Q\Xm , on sait si Imp(Xm |Q0 ) > 0.
Dans la suite, on note Atnaïf (V, Y ) l’ensemble des variables renvoyé par l’algorithme naïf à partir des variables V et de la sortie Y après t itérations.
Lemme 2. Soit V un ensemble de variables et Y une variable aléatoire discrète.
L’algorithme naïf utilisant des arbres totalement aléatoires vérifie :
lim Atnaïf (V, Y ) = {Xm ∈ V |Xm pertinente et deg (Xm ) < q}
t→∞
Preuve. Pour un ensemble infini d’arbres complètement développés et totalement aléatoires construits sur des sous-espaces de q variables, [10] montre que :
Imp∞ (Xm ) =
q−1
X
k=0
p−k−1
q−k−1
p
q
1
q
k
1
q−k
X
I (Xm ; Y |B)
(2.1)
B∈Pk (V −m )
avec Pk (V −m ) les sous-ensembles de V \Xm de taille k.
Soit Xm ∈ Atnaïf (V, Y ) quand t tend vers +∞. L’algorithme a donc trouvé
lors d’une itération Imp (Xm ) > 0. L’information mutuelle étant positive, l’un
des termes de la deuxième somme de l’équation (2.1) au moins est positif. Donc
Xm est pertinente avec deg (Xm ) < q.
De même, si Xm est pertinente et deg (Xm ) < q alors l’un des termes de la
somme est positif. En effet quand t tend vers +∞, tous les conditionnements
possibles de tailles inférieures ou égales à q − 1 sont testés pour la variable
Xm .
Théorème 3. L’algorithme naïf utilisant des arbres totalement aléatoires est
consistant si et seulement si deg (V ) < q.
19
Preuve. Si deg (V ) < q, alors : ∀Xm , Xm pertinente ⇒ deg (Xm ) < q. Le
Lemme 2 donne alors le résultat.
Si l’algorithme naïf est consistant, alors il a pu identifier toutes les variables
pertinentes et uniquement celles-ci. Il a donc pu mettre en mémoire une variable
Xm telle que deg (Xm ) = deg (V ) et tout son conditionnement. On a donc
1 + deg (Xm ) ≤ q. Donc deg (V ) < q.
Corollaire 1. Soit k le nombre de variables pertinentes. L’algorithme naïf utilisant des arbres totalement aléatoires est consistant pour k ≤ q.
Preuve. On déduit du Théorème 1 que k ≤ q ⇒ deg(V ) < k car il n’y a que des
variables pertinentes dans un conditionnement minimal.
2.2.2
Algorithme intelligent
L’algorithme naïf semble améliorable dans la mesure où les arbres précédemment construits ne sont pas pris en compte. De plus, le conditionnement minimal
d’une variable pertinente n’étant composé que de variables pertinentes comme
énoncé par le Théorème 1, il paraît naturel de conserver les variables pertinentes
identifiées pour les utiliser dans les conditionnements servant à trouver les suivantes. Ceci constitue l’idée générale de l’algorithme proposé (Algorithme 3) que
nous appellerons algorithme intelligent. L’idée est d’éviter de tester des conditionnements composés uniquement de variables non pertinentes par exemple et
de se concentrer sur les variables qui ont plus de chances d’être dans le conditionnement d’une variable pertinente.
Algorithme 3 : Algorithme intelligent
Données : V = {X1 , ..., Xp } l’ensemble de variables, Y la variable sortie,
n exemples, N le nombre d’itérations maximum, q la taille de
la mémoire
Résultat : Ensemble F ⊆ {X1 , ..., Xp } des variables pertinentes
identifiées
1 F =∅
2 pour t de 1 à N faire
3
f = |F |
4
R = choix (q − f, V \F )
5
Q=R∪F
6
Construire un arbre sur Q
7
pour Xm ∈ Q faire
8
Calculer Imp (Xm ) à l’aide de l’arbre construit
9
si Imp (Xm ) > 0 alors
10
Ajouter Xm à F
11
fin
12
fin
13 fin
La différence avec le précédent se fait donc uniquement aux lignes 4 et 5 lors
de la construction de l’ensemble utilisé pour apprendre les arbres. On utilise
20
ici à chaque fois dans cet ensemble les variables déjà identifiées. Cette méthode
augmente les chances de trouver certaines variables en permettant de tester
des conditionnements potentiellement plus intéressants que s’ils étaient tirés au
hasard.
L’algorithme est toujours consistant pour k ≤ q avec k le nombre de variables
pertinentes. L’un des inconvénients de cette version brute est que sa consistance
n’est plus garantie pour k > q même si le degré d’interaction maximal est inférieur à q. En effet, s’il y a plus de variables pertinentes que ne peut en contenir
la mémoire, une fois que l’algorithme aura trouvé q variables, sa mémoire sera
remplie et il s’arrêtera sans pouvoir trouver les k − q restantes.
Une variation envisageable de l’algorithme peut être d’éliminer un certain
nombre de variables identifiées, lors du tirage, afin d’éviter de remplir la mémoire et ainsi de redonner plus de poids à l’exploration (qui consiste à aller
chercher de nouvelles variables à étudier) face à l’exploitation (qui consiste à
utiliser les variables déjà utilisées et identifiées comme pertinentes). On peut
choisir par exemple, de n’utiliser que 50 % des variables pertinentes identifiées
lors de l’itération suivante au lieu de l’ensemble F entier. Il paraît plus judicieux
de commencer à éliminer aléatoirement ces variables une fois que la mémoire
est déjà proche d’être pleine afin d’éviter à l’algorithme de faire de nombreuses
itérations quasiment identiques au début. La méthode obtenue est alors l’Algorithme 4 prenant deux nouveaux paramètres en entrée :
— Le premier, α, représente le pourcentage de variables identifiées qui ne
sera pas utilisé pour la prochaine itération et permet de définir l’importance de l’exploration face à l’exploitation. α = 1 revient à exécuter
l’Algorithme 2 tandis que α = 0 équivaut à l’Algorithme 3. Une valeur
intermédiaire permet de ne pas bloquer la mémoire inutilement et de
renouveler les variables utilisées dans les conditionnements testés.
— Le second, β, indique le pourcentage de remplissage de la mémoire à
partir duquel l’algorithme doit commencer à ne pas utiliser toutes les
variables identifiées pour l’itération suivante. Par exemple, si q = 20 et
β = 0.25, l’algorithme s’exécutera de la même manière que l’Algorithme
3 jusqu’à avoir trouvé 5 variables. Une fois ces cinq variables identifiées,
il commencera à éliminer α% des variables identifiées pour l’ensemble de
variables utilisé lors de l’itération suivante. Ce paramètre fixe donc la
place accordée à une phase d’exploration pure.
Ces deux paramètres permettent ainsi de compenser certaines difficultés que
l’algorithme peut rencontrer selon les paramètres du problème et d’autoriser la
convergence dans le cas q < k (avec k le nombre de variables pertinentes) mais
aussi de l’accélérer dans d’autres cas.
Le théorème suivant précise les conditions de consistance de cet algorithme.
Théorème 4. L’algorithme intelligent utilisant des arbres totalement aléatoires
est consistant pour :
— k≤q
— k > q, deg (V ) < q et α ≥ deg(Vq )+1
Preuve. Pour k ≤ q, la même preuve que pour l’algorithme naïf s’applique.
21
Algorithme 4 : Algorithme intelligent amélioré
Données : V = {X1 , ..., Xp } l’ensemble de variables, Y la variable sortie,
n exemples, N le nombre d’itérations maximum, q la taille de
la mémoire, α le pourcentage d’abandon de variables, β le
pourcentage de remplissage de la mémoire à partir duquel
commencer à abandonner des variables
Résultat : Ensemble F ⊆ {X1 , ..., Xp } des variables pertinentes
identifiées
1 F =∅
2 pour t de 1 à N faire
3
f = |F |
4
b = β × q // b représente le nombre de variables en mémoire
à partir duquel on commence à libérer de l’espace
5
si f > b alors
6
a = α × f // a, le nombre de variables à enlever de la
mémoire
7
G = choix (f − a, F )
8
R = choix (q − f + a, V \G)
9
Q=R∪G
10
fin
11
sinon
12
R = choix (q − f, V \F )
13
Q=R∪F
14
fin
15
Construire un arbre sur Q
16
pour Xm ∈ Q faire
17
Calculer Imp (Xm ) à l’aide de l’arbre construit
18
si Imp (Xm ) > 0 alors
19
Ajouter Xm à F
20
fin
21
fin
22 fin
22
Pour k > q, l’idée est de considérer le pire cas. Si l’algorithme a déjà identifié
q variables et qu’il lui reste une variable Xm ainsi que toutes les variables de son
conditionnement à trouver, il doit libérer dans sa mémoire au moins deg (Xm )+1
places.
On doit donc avoir α × q ≥ deg (Xm ) + 1 ⇐⇒ α ≥
2.3
deg(Xm )+1
.
q
Simulations
L’étude effectuée dans un premier temps est une simulation du comportement des algorithmes décrits précédemment. Il s’agit de tester la vitesse de
convergence des différentes méthodes sans calculer effectivement les importances
des variables ni construire d’arbres. On simule uniquement l’ordre dans lequel
les variables seraient choisies.
Nous ne générons ou n’utilisons dans cette section aucun ensemble de données mais nous contentons de simuler des liens entre des variables de manière
aléatoire. Sur un ensemble de p variables, on pourra par exemple supposer que
pour que la variable X1 apporte de l’information sur la valeur de sortie, on a
besoin de connaître la valeur de la variable X2 .
Ces expériences partent de l’idée que la structure des données est le facteur le plus influent pour les résultats de nos algorithmes. Étudier le problème
en simulant simplement le comportement des algorithmes permet donc de se
concentrer sur l’aspect combinatoire du problème. On suppose alors qu’on dispose d’un nombre d’échantillons infini et qu’il suffit de savoir si Imp (Xm ) > 0
pour déterminer la pertinence d’une variable. La valeur de l’importance en ellemême n’a aucun impact et c’est pourquoi nous ne construisons ici aucun arbre
de décision. L’accent est mis sur la structure des données.
2.3.1
Arbres utilisés
On considère deux cas différents de construction d’arbres pour identifier les
variables pertinentes : simuler la construction d’une infinité d’arbres ou d’un
arbre particulier.
Dans le premier cas, lorsque l’algorithme tire aléatoirement l’ensemble Q des
variables qu’il peut mettre en mémoire, on suppose qu’il trouve n’importe quelle
variable Xm ∈ Q telle qu’il existe un B ⊆ Q \ Xm tel que I (Xm ; Y |B) > 0. Ceci
revient à construire un ensemble infini d’arbres complètement aléatoires. En
effet, grâce à une telle forêt, tous les conditionnements possibles seraient testés
pour le calcul de l’importance de chaque variable et toute variable pertinente
serait identifiée.
Cette configuration est peu réaliste 1 mais permet d’évaluer rapidement l’intérêt des méthodes proposées et est facile à étudier théoriquement.
Le second cas, plus réaliste, consiste à construire à chaque itération un seul
arbre. On applique alors l’idée des random forests présentée dans le chapitre
1.2.4. A chaque nœud, un ensemble de K × q variables est tiré au sort parmi
1. Elle pourrait se justifier pratiquement en construisant plusieurs arbres en parallèle.
23
(a) Exemple de relations de pertinence
entre trois variables.
Une flèche de X1 vers
X2 indique que X1
est dans un conditionnement minimal de
X2 .
X1
(b) Exemple d’arbre obtenu
X1
X2
X3
X1 = 0
X1 = 1
X2
X2
X2 = 0
X2 = 1
X3
X3
X2 = 0
X3
X2 = 1
X3
Figure 2.1 – Dans la simulation, les variables X2 et X3 peuvent être choisie
indifféremment au deuxième niveau. X1 sera toujours choisie au premier niveau.
les variables mises en mémoire pour choisir la variable sur laquelle diviser le
nœud. Pour la construction d’un arbre de décision classique avec un critère
d’information mutuelle, on choisit la variable Xk servant à diviser un nœud
telle que :
p
k = arg max I (Xm ; Y |B = b)
m=1
avec B l’ensemble des variables choisies dans les nœuds situés sur la branche
entre la racine et le nœud et b leurs valeurs le long de la branche. La variable
sélectionnée est donc celle qui apporte le plus d’information sur la sortie en
prenant en compte les variables déjà sélectionnées.
La forme d’arbre étudiée dans un soucis de simplification de la simulation
est un cas particulier. Au lieu de sélectionner une variable à chaque nœud, on
choisit une unique variable par niveau de l’arbre. De plus, afin de pouvoir simuler le comportement des algorithmes sans estimer en pratique les importances,
la variable est choisie aléatoirement parmi celles identifiées comme pertinentes
étant données les variables choisies précédemment. On choisira donc au premier niveau une variable marginalement pertinente au hasard parmi les K × q
variables, puis une variable pertinente étant donnée la précédente et ainsi de
suite. Dans le cas où aucune variable ne remplit les contraintes données, un
tirage aléatoire parmi toutes les variables restantes est effectué. Un exemple de
construction d’un tel arbre est illustré par la Figure 2.1 pour le cas où K vaut
100%.
Un arbre est construit ici à chaque itération ce qui permet de tester pour
chaque variable Xm le conditionnement constitué de toutes les variables sélectionnées avant Xm (et les conditionnements inclus dans cet ensemble). Ce cas
est donc plus réaliste que le précédent. Sa consistance n’est pas assurée pour
K > p1 mais il est intéressant vu sa pertinence pratique.
24
(a) Hypothèse de chaînage
1
2
3
(b) Hypothèse de cliques
4
5
1
2
5
6
4
3
8
7
Figure 2.2 – Représentation graphique des hypothèses sur les données. Une
flèche de 1 à 2 indique que 1 est dans le conditionnement minimal de 2.
2.3.2
Hypothèses sur les données
La nature des données utilisées et des relations de dépendances entre les
variables va nécessairement influencer la vitesse de convergence des algorithmes
proposés. Pour ces simulations, nous proposons, en plus d’un cas général, deux
cas particuliers :
— hypothèse de chaînage : le conditionnement minimal qui rend pertinente
la variable Xi est {X1 , X2 , ...Xi−1 }. Ce cas est a priori le plus avantageux
pour l’algorithme de sélection de variables intelligent. En effet, toutes les
variables identifiées comme pertinentes sont dans le conditionnement des
variables qu’il reste à trouver. Un exemple de graphe de relations entre
les variables sous cette hypothèse est représenté sur la Figure 2.2a.
— hypothèse de cliques : les variables sont réparties en sous-ensembles au
sein desquels chaque variable est pertinente uniquement si elle est observée avec les autres. Ce cas est la généralisation d’un XOR et est a priori
le plus défavorable à l’algorithme proposé puisque trouver une nouvelle
variable pertinente implique de tirer lors de la même itération, toutes les
variables contenues dans la même clique qu’elle. La Figure 2.2b
U donne
U
un exemple de ce cas. Plus formellement, dans ce cas, V = V1 ... Vc
et :
∀Xm ∈ Vi , Vi \Xm est le seul conditionnement minimal de Xm
— le cas général où le conditionnement de chaque variable est généré aléatoirement. On fixe alors deg (V ) le degré d’interaction maximal des variables. Pour chaque variable, on tire de manière aléatoire et uniforme
son degré dans {0, .., deg (V )} puis les variables constituant un conditionnement minimal.
La génération aléatoire des conditionnements ne prend pas en compte l’existence possible de contraintes quant aux conditionnements rencontrés. Une étude
théorique pourrait permettre de dégager des cas impossibles et d’ajouter certaines contraintes de génération si elles existent. Dans le cas de variables binaires
par exemple, nous ne sommes pas parvenus à créer un exemple respectant l’hypothèse de cliques sans utiliser des cliques strictement identiques.
Nous avons également voulu étudier l’impact de la redondance entre les
variables et plus précisément le cas où plusieurs variables fournissent exactement
la même information sur la sortie mais aussi celui où des cliques de variables sont
redondantes. Intuitivement, la redondance complique l’identification de toutes
25
les variables pertinentes. En effet si l’une d’entre elle est conservée dans la
mémoire par l’algorithme intelligent, les arbres construits risquent de conserver
cette variable dans les premiers niveaux et ainsi d’empêcher l’identification d’une
variable complètement redondante qui apparaîtrait plus bas.
Les résultats des simulations sont disponibles dans la Section 3 et confirment
l’intérêt de l’algorithme intelligent par rapport à la version naïve. Le passage à
la pratique paraît donc pertinent.
2.4
Mise en pratique
La manière dont nous avons défini la pertinence d’une variable ne permet
pas de s’appliquer en pratique. En effet, sur des données réelles, il est extrêmement rare voire impossible d’observer des importances de variables nulles.
L’information mutuelle théoriquement nulle est toujours surestimée à cause du
nombre fini d’échantillons. Toutes les variables seraient alors identifiées comme
pertinentes, ce qui ne correspond évidemment pas au problème posé.
2.4.1
Modifications des algorithmes
Nous avons donc besoin d’une nouvelle méthode pour identifier les variables
jugées pertinentes parmi l’ensemble de celles utilisées à chaque itération lors de
la construction de l’arbre. L’idée est de remplacer le test Imp (Xm ) > 0 par un
test statistique.
Dans [11], il est rappelé que :
Proposition 1. Sous hypothèse d’indépendance statistique, 2n ln (2) I (X; Y )
suit une loi du χ2 à (CX − 1) (CY − 1) degrés de liberté avec CX la cardinalité de
la variable X (c’est-à-dire le nombre de valeurs différentes qu’elle peut prendre),
CY la cardinalité de la variable Y de sortie et n le nombre d’échantillons utilisés
pour estimer l’information mutuelle.
Nous nous intéressons ici à des problèmes de classification binaire, on aura
donc toujours CY = 2. Les arbres utilisés effectuant des divisions binaires et les
tests statistiques étant locaux, on aura également CX = 2. 2
On réalisera donc après la construction de chaque arbre un test du χ2 en
chaque nœud afin de déterminer si la variable est pertinente ou non. Cette méthode est couramment utilisée en sélection de variables. L’Algorithme 5 résume
le processus utilisé.
Le seuil choisi pour le test du χ2 est évidemment déterminant pour les résultats de l’algorithme. En effet, si dans les simulations, seules des variables
effectivement pertinentes étaient retournées, ici, il est possible que l’algorithme
2. Néanmoins, dans l’implémentation utilisée pour les tests, nous avons utilisé comme
cardinalité le nombre de valeurs que peut prendre la variable en tout, c’est à dire, dans le
cas de variables continues, le nombre d’intervalles dans lesquels peuvent se trouver les valeurs
de la variable selon les divisions réalisées dans l’arbre de décision (c’est à dire le nombre de
fois où la variable a été sélectionnée dans la branche plus un). Ceci n’a pas pu être corrigé
afin d’avoir des résultats à temps et n’impacte que très peu les résultats obtenus.
26
Algorithme 5 : Algorithme de sélection de variable par test du χ2
Données : Un arbre de décision construit sur un ensemble
Q ⊆ V = {X1 , ..., Xp } de variables, y la cardinalité de la
sortie, error le seuil d’erreur du test du χ2
Résultat : Ensemble F ⊆ Q des variables pertinentes identifiées
1 F =∅
2 pour chaque noeud t de l’arbre faire
3
f = variable sur laquelle le noeud a été divisé
4
si f ∈
/ F alors
5
c=2
6
d = (c − 1)(y − 1)
7
s = seuil(error, d)
8
si 2n ln 2∆i (t) ≥ s alors
// avec ∆i (t) le gain au noeud considéré i.e
l’information mutuelle entre la variable et la
sortie conditionnellement à la branche
9
Ajouter f à F
10
fin
11
fin
12 fin
retourne de faux positifs et identifient des variables comme pertinentes alors
qu’elles ne le sont pas en réalité. Nous n’avons plus de garantie sur la pertinence
des variables retournées par l’algorithme.
2.4.2
Arbres utilisés
Pour la mise en pratique, nous avons choisi d’utiliser des arbres de décision
de classification classique et non plus la version simplifiée utilisée pour les simulations. Les arbres sont donc construits en utilisant comme critère d’impureté
l’entropie de Shannon, en utilisant le paramètre K mentionné dans la Section
1.2.4 et en optimisant à la fois sur la variable et sur le seuil à chaque nœud.
D’un point de vue pratique, ce sont les arbres de décision de la librairie
python "scikit-learn" 3 qui ont été utilisés. Certaines modifications ont été effectuées dans le code de cette librairie afin de parcourir les arbres pour les tests
statistiques et réunir les données nécessaires à ces tests.
Ceci nous permet donc d’arriver à l’algorithme intelligent final et utilisé en
pratique dont le pseudo-code se trouve dans l’Algorithme 6. Cette version se
décline aisément en l’algorithme naïf final en fixant α = 1 et β = 0.
3. https://github.com/scikit-learn/scikit-learn,http://scikitlearn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html
27
Algorithme 6 : Algorithme de mise en pratique
Données : V = {X1 , ..., Xp } l’ensemble de variables, Y la variable sortie,
n exemples, N le nombre d’itérations maximum, q la taille de
la mémoire, α le pourcentage d’abandon de variables, β le
pourcentage de remplissage de la mémoire à partir duquel
commencer à abandonner des variables, error le seuil d’erreur
du test du χ2
Résultat : Ensemble F ⊆ {X1 , ..., Xp } des variables pertinentes
identifiées
1 F =∅
2 pour t de 1 à N faire
3
f = |F |
4
b = β × q // b représente le nombre de variables en mémoire
à partir duquel on commence à libérer de l’espace
5
si f > b alors
6
a = α × f // a, le nombre de variables à enlever de la
mémoire
7
G = choix (f − a, F )
8
R = choix (q − f + a, V \G)
9
Q=R∪G
10
fin
11
sinon
12
R = choix (q − f, V \F )
13
Q=R∪F
14
fin
15
Construire un arbre sur Q
16
F = chi2(arbre, CY , error) ∪ F // avec chi2 l’Algorithme 5
17 fin
28
Figure 2.3 – Exemple de données "madelon" en trois dimensions
2.4.3
Données
L’ensemble de données utilisé dans les tests de nos algorithmes, appelé "Madelon" provient d’un challenge de sélection de variables proposé lors de NIPS 4
2003. C’est un problème généré artificiellement, de classification binaire. Les
données sont générées en fabriquant des gaussiennes de points pour chaque
classe qui sont ensuite réparties aléatoirement sur les sommets d’un hypercube.
Le problème peut ainsi être considéré comme une généralisation d’un XOR.
Cette configuration en fait donc un problème difficile du point de vue de la
sélection de variables. Il peut en effet être compliqué d’identifier la pertinence
des variables si elles ont besoin d’être en groupe pour l’être, comme dans l’hypothèse de cliques que nous avons décrite précédemment. Des variables "bruit"
aléatoires sont ensuite ajoutées au problème. La Figure 2.3 illustre une configuration "madelon" pour trois variables informatives sans variables de bruit. Une
variable seule ne permet pas d’obtenir de l’information sur la classe des points
et il faut bien la combinaison des trois pour prédire la classe. La pertinence des
variables est donc plus difficile à détecter.
4. "Neural Information Processing Systems", conférence annuelle en intelligence artificielle
29
Chapitre 3
Résultats
Dans cette partie, nous présentons dans un premier temps les résultats obtenus lors des simulations et commentons plus particulièrement l’impact des
structures des données et des paramètres des algorithmes. Nous développons
ensuite les résultats obtenus sur un ensemble de données afin de comparer les
performances et d’appuyer l’intérêt de notre algorithme intelligent en terme de
vitesse de convergence dans un cas réel.
3.1
Simulations
Afin d’étudier la vitesse de convergence des différents algorithmes et l’impact
de leurs paramètres, plusieurs types de données ont été testés. Un récapitulatif de toutes les configurations est disponible sur la Table 3.1. Pour chacune
de ces configurations, 50 tests ont été réalisés en générant des jeux de données
aléatoires, pour la version utilisant une infinité d’arbres et pour celle n’en utilisant qu’un. Tous les résultats présentés sauf dans la section 3.1.3 ou mention
contraire, utilisent des ensembles générés avec les paramètres p = 500, k = 20
(avec k le nombre de variables pertinentes), sans hypothèse sur les données et
pour un degré d’interaction maximal de 5.
Table 3.1 – Paramètres des données testés
p
500
500
500
500
500
500
5000
500
500
k
20
20
20
10
20
20
200
20
20
hypothèse
aucune
chaînage
clique
aucune
aucune
aucune
aucune
aucune
clique
deg (V )
5
/
/
5
2
10
50
5
/
30
n_cliques
/
/
5
/
/
/
/
/
5
redondance
non fixée
non fixée
non fixée
non fixée
non fixée
non fixée
non fixée
2 couples
2 couples de cliques
Table 3.2 – Valeurs des paramètres des algorithmes testés
Paramètre
q
K
α
β
Valeurs
6, 10, 15, 18, 20, 25, 50
1
q , 0.25, 0.50, 0.75, 1.
0.0, 0.1, 0.25, 0.50, 0.75, 0.80, 0.90
0.0, 0.25, 0.50, 0.75
Algorithme concerné
naïf, intelligent
naïf, intelligent
intelligent
intelligent
Les performances des deux algorithmes sont mesurées en regardant le nombre
moyen de variables pertinentes identifiées après un certain nombre d’itérations.
Les expériences ont été menées jusqu’à 100000 itérations et nous présentons
des courbes représentant le nombre moyen de variables pertinentes trouvées en
fonction du nombre d’itérations maximum autorisé. Les différentes combinaisons
de paramètres utilisées pour les données sont visibles sur la Table 3.1 et les
paramètres des algorithmes sur la Table 3.2.
Sur les courbes comparant les deux versions de l’algorithme, un trait plein
représente l’algorithme intelligent tandis qu’un pointillé indique l’algorithme
naïf. Les couleurs elles, sont associées à des valeurs de la taille de la mémoire.
3.1.1
Cas d’une infinité d’arbres
Simuler à chaque itération le calcul d’une infinité d’arbres permet d’améliorer significativement la vitesse de convergence de l’algorithme et de comparer
rapidement le comportement des deux algorithmes. C’est aussi le cas dans lequel
l’étude théorique est la plus simple. La convergence dans le cas q = 50 se fait
par exemple en quatre fois moins d’itérations qu’en ne construisant qu’un arbre
comme nous le verrons plus tard. La construction d’une infinité d’arbres en pratique est évidemment impossible mais la simulation et les résultats présentés
sur la Figure 3.1a permettent de confirmer l’intérêt de l’algorithme proposé en
montrant sa supériorité par rapport à l’algorithme naïf dans les cas testés à part
pour la très petite valeur de mémoire q = 6. Dans le cas particulier des cliques
illustré sur la Figure 3.1b par contre, les deux algorithmes sont plus proches et
l’algorithme naïf dépasse légèrement la méthode que nous proposons.
Les résultats présentés ensuite sont obtenus pour la construction d’un seul
arbre à chaque itération afin de se placer dans une configuration plus réaliste.
3.1.2
Comparaison des deux algorithmes
La Figure 3.2 représente l’impact de la taille de la mémoire sur les deux algorithmes étudiés pour une configuration particulière. On remarque la très nette
amélioration des performances en utilisant l’algorithme intelligent par rapport à
l’algorithme naïf. Dans tous les cas l’algorithme naïf ne parvient pas en 100000
itérations à trouver toutes les variables pertinentes tandis que l’algorithme intelligent y parvient pour q = 25 et q = 50. On retrouve néanmoins le soucis évoqué
précédemment dans le cas de très petites valeurs de mémoire pour l’algorithme
intelligent. La mémoire se remplit vite et l’algorithme reste alors bloqué sans
pouvoir explorer plus de variables. En effet cette courbe illustre une expérience
31
(a) Cas p = 500, k = 20, deg (V ) = 5
(b) Hypothèse des cliques
Figure 3.1 – Résultats pour la construction d’une infinité d’arbres
32
Figure 3.2 – Comparaison des deux algorithmes
où le paramètre α est fixé à 0. La pente que présentent les courbes de l’algorithme intelligent pour peu d’itérations illustre l’intérêt très net de conserver les
variables identifiées pour les itérations suivantes lorsque la taille de la mémoire
est suffisante.
Quels que soient les paramètres des algorithmes utilisés, la version intelligente est toujours supérieure à la version naïve en terme de vitesse de convergence pour des données sans propriétés particulières et q ≥ 10.
On remarque également sur cette figure que l’augmentation de la taille de la
mémoire a un impact net et similaire sur les deux algorithmes.
3.1.3
Impact des données
Dans cette partie, nous présentons les résultats obtenus par les deux algorithmes sur des données de différentes formes. Nous utilisons ici uniquement la
première version de l’algorithme intelligent, c’est-à-dire sans prendre en compte
les paramètres α et β (on fixe α = β = 0). Nous discutons plus en détails
l’impact de ces derniers dans la partie suivante.
Impact de la structure des données. Les hypothèses de chainage et de
cliques, assez extrêmes, ont été testées sur les deux algorithmes. On remarque
sur la Figure 3.3a que le chaînage réduit drastiquement les performances de l’algorithme naïf alors qu’il augmente significativement celles de l’algorithme proposé. Ceci paraît naturel dans la mesure où, pour identifier toutes les variables,
33
(a) Hypothèse de chainage
(b) Hypothèse de cliques
Figure 3.3 – Impact de la structure des données
l’algorithme naïf devrait les piocher toutes d’un coup. L’algorithme intelligent
a évidemment un avantage dans cette configuration puisque toutes les variables
qu’il conserve sont nécessaires aux conditionnements des autres.
L’hypothèse de cliques a un impact moins intuitif. En effet, il pourrait paraître gênant de conserver des variables identifiées dans la mesure où, sous cette
hypothèse, elles ne serviront dans aucun autre conditionnement. Théoriquement, dans le cas de variables marginalement pertinentes et pour un nombre
infini d’arbres, l’algorithme naïf est d’ailleurs supérieur à l’algorithme intelligent
(preuve en Annexe A). En réalité, cet effet n’est pas forcément handicapant. En
effet, si un arbre est construit sur toutes les variables d’une clique, seule celle
choisie le plus bas dans l’arbre sera identifiée comme pertinente. Conserver les
variables de la clique en cours d’identification dans la mémoire est donc un avantage. Ceci est visible sur la Figure 3.3b. L’algorithme proposé reste supérieur à
l’algorithme naïf même si l’écart entre les deux est réduit. On remarque que la
comparaison des performances s’inverse par rapport au cas d’un nombre infini
d’arbres présenté sur la Figure 3.1b et c’est uniquement sous cette hypothèse
de nombre infini d’arbres que l’hypothèse de cliques est la plus défavorable à
l’algorithme intelligent.
Impact des conditionnements minimaux des variables. Le degré d’interaction maximal impacte très fortement les performances. Comme il est possible de le voir sur la Figure 3.4, des conditionnements petits permettent à
l’algorithme naïf de devenir intéressant en terme de performance. Il est toujours
dépassé par l’algorithme intelligent mais gagne beaucoup en performance. Dans
le cas deg (V ) = 10, les deux algorithmes perdent en performance. Pour q = 25,
la différence entre les performances pour deg (V ) = 2 et deg (V ) = 10 est d’un
facteur 2 pour l’algorithme intelligent tandis qu’elle est d’un facteur 4 pour l’algorithme naïf. En pratique, il est néanmoins plus probable de travailler avec des
données dont les degrés d’interaction sont faibles.
Impact de la taille des données Afin de tester la mise à l’échelle de nos
résultats dans le cas de données de plus grande taille, nous avons multiplié par
10 les paramètres p, q, k et deg (V ). Les résultats obtenus sont très peu satisfaisants. En effet, au bout de 100000 itérations, on obtient au maximum 30
34
(a) Cas deg (V ) = 2
(b) Cas deg (V ) = 10
Figure 3.4 – Impact de la taille maximale des conditionnements
variables pertinentes sur les 200 l’étant réellement comme l’illustre la Figure
3.5.
Ceci peut en réalité s’expliquer théoriquement dans le cas d’un nombre
d’arbres infini. Considérons la probabilité de trouver une variable pertinente
particulière si l’on peut tester tous les conditionnements. D’un point de vue
combinatoire, cela revient à réussir à tirer uniformément la variable à identifier
et son conditionnement lors du même tirage (pour le cas naïf) de remplissage
de la mémoire. En notant c la taille du conditionnement de la variable Xi en
question, on a donc :
p−c−1
P (tirer Xi et son conditionnement) =
q−c−1
p
q
La Table 3.3 indique les valeurs numériques de cette probabilité pour certaines configurations. Le point notable est ici que pour des tailles de conditionnements identiques, les probabilités pour le cas de base et pour le cas multiplié
par 10 sont du même ordre de grandeur. Les performances des algorithmes ne
seront donc théoriquement pas affectées par le passage à une échelle plus grande
si les conditionnements restent de taille raisonnable. Le phénomène observé sur
la Figure 3.5 s’explique en comparant les probabilités de la configuration de
base pour des petits conditionnements à celles de la configuration multipliée
pour les conditionnements eux aussi multipliés par 10. Ici, l’écart de probabilité augmente très rapidement et il est donc normal que les performances des
algorithmes soient fortement impactées.
Impact de la redondance dans les données Le premier test effectué pour
la redondance des données consiste à placer deux couples de variables au sein
desquels les deux variables donnent strictement la même information et d’analyser l’impact sur la capacité des algorithmes à retrouver toutes les variables
notamment sur l’algorithme intelligent. En effet, une fois qu’une des variables
du couple est en mémoire si elle est choisie haut dans l’arbre, la deuxième
variable ne sera jamais détectée comme pertinente. Les Figures 3.6a et 3.6b
permettent de comparer les cas avec et sans redondance. L’effet est assez faible
mais on remarque néanmoins que pour une taille de mémoire inférieure à 25,
35
Figure 3.5 – Comparaison des deux algorithmes pour des données dont tous
les paramètres sont multipliés par dix
Table 3.3 – Probabilité de tirer une variable pertinente et son conditionnement
selon les paramètres des données
deg(V ) + 1
base
multiplié
deg(V ) + 1
base
multiplié
1
2, 40.10−3
2, 49.10−3
10
4, 07.10−16
3, 95.10−15
2
1, 11.10−4
1, 12.10−4
20
2, 07.10−33
2, 10.10−28
3
4, 92.10−6
6, 11.10−6
30
4
2, 08.10−7
3, 01.10−7
40
5
8, 41.10−9
1, 48.10−8
50
7, 34.10−42
1, 66.10−55
2, 38.10−69
La configuration dite "de base" correspond à p = 50, q = 25, k = 20.
La configuration "multiplié" correspond à p = 500, q = 250, k = 200.
36
(a) Cas sans redondance
(b) Cas avec deux couples de variables identiques
Figure 3.6 – Impact de la redondance des variables
(b) Cas avec deux cliques de variables identiques
(a) Cas sans redondance
Figure 3.7 – Impact de la redondance des variables dans le cas des cliques
l’algorithme intelligent identifie moins de variables quand il y a redondance. Ce
problème peut en fait être simplement résolu en réglant les paramètres α et β.
Dans le cas des cliques redondantes, comme l’illustre la Figure 3.7, l’impact
est assez peu visible. Les performances de l’algorithme naïf se rapprochent légèrement de celles de l’intelligent mais l’impact n’est pas excessif. Nous pouvions
nous attendre à un résultat plus négatif pour l’algorithme intelligent dans la
mesure où, une fois l’une des cliques en mémoire, elle complique l’identification
de la clique redondante. La randomisation au sein des arbres permet néanmoins
de palier sans modification supplémentaire ce problème.
3.1.4
Impact des paramètres
Impact de K. L’impact de K présenté sur la Figure 3.8 est assez léger. On
remarque tout de même qu’il est plus intéressant d’utiliser une valeur de K
différente de 1q (qui revient à choisir de façon totalement aléatoire la variable
sur laquelle effectuer la division à chaque nœud). En effet, on remarque que dans
37
(a) Algorithme aléatoire
(b) Algorithme intelligent
Figure 3.8 – Impact du paramètre K sur les deux algorithmes
les deux cas, construire des arbres totalement aléatoires ralentit légèrement la
convergence de la méthode.
L’impact de ce paramètre dans le cas de l’hypothèse de chaînage est plus
marqué (Figure 3.9). Ceci s’explique simplement par le fait qu’il existe un ordre
dans les variables qu’il n’est possible de retrouver efficacement qu’en choisissant
de manière ordonnée les variables sur lesquelles diviser les nœuds.
Figure 3.9 – Impact de K sous l’hypothèse de chaînage
Intérêt de l’élimination des variables. Comme l’illustre la Figure 3.10a,
l’élimination de variables dès le début de l’algorithme peut être contre-productive.
En effet, sur cette courbe, le cas où aucune variable n’est éliminée au fur et à mesure est efficace par rapport aux autres. Ceci est dû à de nombreuses itérations
au début de l’exécution pendant lesquelles l’algorithme se comporte quasiment
comme sa version naïve en n’utilisant que très peu de variables identifiées. Ce
problème est résolu par le paramètre β comme le montre la Figure 3.10b. En
effet, en ne commençant à éliminer des variables que quand la mémoire est
38
(a) Limites de l’effet de l’élimination
(b) Intérêt d’éliminer certaines variables
Figure 3.10 – Impact du paramètre α
Figure 3.11 – Impact de β pour α = 0.9
déjà presque remplie, les performances augmentent significativement et ne pas
éliminer de variables devient moins intéressant.
Les paramètres α et β sont en fait très liés. Par exemple, la Figure 3.11
montre qu’en éliminant à chaque itération un nombre très important de variables
(et donc en se rapprochant a priori de l’algorithme naïf), on peut améliorer très
significativement les performances en ne commençant à éliminer que très tard.
Il s’agit donc de trouver un juste milieu au réglage de ces paramètres. Dans
la plupart des cas testés, la configuration optimale se situait à α = 0.75 et
β = 0.5. On accumule donc un certain nombre de variables avant de commencer
à en chercher d’autres en ne les utilisant pas toutes.
Dans le cas de l’hypothèse de chaînage, l’effet de α est encore plus marqué
(comme l’illustre la Figure 3.12). En effet, utiliser α 6= 0 réduit très fortement les
performances et les rapproche très vite de celles de l’algorithme naïf. Fixer ces
paramètres peut donc nécessiter un a priori sur les données si l’on veut obtenir
des performances optimales.
39
Figure 3.12 – Impact de α sous l’hypothèse de chaînage
3.1.5
Conclusion
La plupart des cas testés confirment qu’en réglant les paramètres de l’algorithme intelligent, il dépasse assez largement les performances de l’algorithme
naïf. Certains de ces réglages peuvent néanmoins nécessiter un a priori sur la
structure des données et les liens entre les variables.
3.2
3.2.1
Données simulées : Madelon
Méthodologie
Des ensembles de données du type de l’ensemble "madelon" peuvent être
générés aisément grâce à la librairie Python scikit-learn en réglant de nombreux
paramètres tels que le nombres d’exemples, de variables, de variables pertinentes, redondantes ou répétées notamment. L’intérêt principal d’utiliser cet
ensemble de données réside dans le fait que nous connaissons exactement l’ensemble des variables pertinentes, ce qui n’est pas le cas pour des données réelles.
Nous pouvons sur ces ensembles fixer :
— le nombre d’exemples (n_ex)
— le nombre de variables en tout (n_var)
— le nombre de variables informatives, qui constitue la dimension du sousespace dans lequel se situe l’hypercube où les données sont placées (n_pert)
— le nombre de variables redondantes i.e de combinaisons linéaires des variables informatives (n_red)
— le nombre de variables identiques à des variables informatives ou redondantes (n_rep)
— le nombre de classes, que nous fixerons à 2
40
Table 3.4 – Paramètres des données Madelon utilisées
Nom
NIPS
Base
Redondance
Répétition
Mix
n_ex
2000
2000
2000
2000
2000
n_var
500
500
500
500
500
n_pert
5
20
10
10
10
n_red
5
0
10
0
5
n_rep
10
0
0
10
5
n_clusters
16
10
10
10
10
— le nombre de clusters par classe qui sera fixé à 10 à part pour le problème
initialement proposé à NIPS (n_clusters)
— f lipy le taux d’exemples dont la classe est changée aléatoirement et qui
est fixé à 0.01
— un facteur multipliant la dimension de l’hypercube que nous fixerons à 2
comme dans l’ensemble de données initialement proposé
— le fait de répartir les clusters aux sommets d’un hypercube ou d’un polytope quelconque. Nous utiliserons toujours le cas de l’hypercube.
Nous évaluerons donc les performances de nos algorithmes en comparant
l’ensemble de variables renvoyées à l’ensemble des variables pertinentes.
Il est également possible pour évaluer le résultat des algorithmes d’apprendre
une forêt d’arbres sur les variables identifiées comme pertinentes et de voir les
performances obtenues en apprentissage et en test ainsi que de les comparer aux
performances obtenues quand les modèles sont appris sur toutes les variables.
On peut alors par exemple remarquer si des variables de bruit ont bien été ignorées ou si toute l’information a été extraite. Il reste néanmoins impossible par
cette méthode de savoir si toutes les variables pertinentes ont été identifiées.
En effet, obtenir une bonne performance en test signifie que des variables pertinentes ont été extraites, voire que toute l’information est contenue dans les
variables sélectionnées mais ne permet en aucun cas de savoir si les variables
non sélectionnées sont non pertinentes. Or notre problème consiste à identifier
l’intégralité des variables pertinentes.
Nous avons testé notre algorithme sur les données présentant les mêmes
caractéristiques que les originales mais aussi en les paramétrant de manière à
pouvoir tester l’impact de différentes structures de données. Les paramètres
utilisés sont récapitulés sur la Table 3.4.
3.2.2
Comparaison des algorithmes et résultats généraux
Les courbes présentées dans cette partie portent sur l’ensemble de données
"NIPS". Afin de juger de la qualité des résultats obtenus, il convient de vérifier
si l’algorithme parvient à identifier les variables pertinentes mais aussi s’il ne
renvoie pas trop de faux positifs. Les courbes seront donc toujours présentées
par deux : (1) une courbe représentant le nombre de variables pertinentes (et
effectivement pertinentes) identifiées par l’algorithme en fonction du nombre
d’itérations et (2) la précision, i.e le nombre de vrais positifs sur le nombre total
de variables retournées par l’algorithme en fonction du nombre d’itérations. Les
expériences sont menées jusqu’à 10000 arbres construits et moyennées sur cinq
41
Nombre d’arbres
Seuil
10−5
10−7
10−9
Nombre d’arbres
Seuil
10−5
10−7
10−9
1
Pos. Préc.
0.91
90.05
0.13
100
0.7
100
1000
Pos. Préc.
19.34 22.66
14.10 94.27
11.8
100
10
Pos. Préc.
6.46
88.6
3.21
100
5.5
100
10000
Pos. Préc.
19.98
5.45
17.79 69.46
12.2
98.75
100
Pos. Préc.
15.47 66.91
10.53 99.42
10.8
100
Table 3.5 – Nombre moyen de variables pertinentes identifiées (pos.) et précision moyenne (préc.) par rapport au nombre d’arbres construits pour l’algorithmme naïf avec q = 50 et K = 1.
ensembles de données (générés à nouveau à chaque fois à partir des paramètres
de la Table 3.4) à chaque fois pour l’algorithme intelligent.
Seuil du test statistique Le réglage du seuil du test statistique effectué en
chaque nœud des arbres construits influe fortement sur les résultats obtenus. Il
convient donc de le régler avant de tester plus avant les algorithmes. La Table
3.5 montre le nombre moyen de variables pertinentes identifiées ainsi que la
précision moyenne obtenue pour l’algorithme naïf dans un cas particulier, pour
trois valeurs du seuil du test statistique. Comme on peut le remarquer, après
la construction de 10000 arbres dans le cas où le seuil vaut 10−5 , la précision
n’est plus que de l’ordre de 5%. Ceci signifie que l’algorithme identifie quasiment toutes les variables comme pertinentes ce qui n’est pas du tout le but
recherché. Nous avons fixé le paramètre à 10−7 qui présente de meilleurs résultats en précision et garde un nombre de variables identifiées au bout de 10000
itérations correct. En effet, le cas 10−9 garde une précision excellente mais demanderait un nombre d’itérations très grand pour retrouver toutes les variables
pertinentes (la moyenne de 12.2 variables identifiées est atteinte depuis 2500
itérations, l’évolution à partir de ce moment est donc très lente).
Comparaison des algorithmes Les Figures 3.13a et 3.13b montrent les résultats obtenus sur l’ensemble "NIPS" pour une configuration particulière. Les
performances des deux algorithmes sont relativement proches mais la version
intelligente reste supérieure tant en nombre de variables pertinentes identifiées
qu’en précision. Néanmoins, ceci n’est pas le cas pour toutes les configurations.
Par exemple, les Figures 3.14a et 3.14b présentent un cas très défavorable à
l’algorithme intelligent. On remarque néanmoins que la précision de ce dernier
est toujours bonne même si le nombre de variables retrouvées est très faible.
De plus, ce paramétrage est également mauvais pour l’algorithme naïf qui est
beaucoup moins performant que dans le cas présenté précédemment.
A valeur de K fixée, il existe néanmoins toujours un paramétrage de α et
β qui permet de dépasser ou au moins d’égaler l’algorithme naïf en terme de
42
Table 3.6 – Score de classification pour "Base" et "Nips"
Nombre d’arbres
Seuil
Naïf (meilleur apprentissage)
Naïf (meilleur test)
Intelligent (meilleur apprentissage)
Intelligent (meilleur test)
Toutes les variables
Uniquement les pertinentes
BASE
App.
Test
99.01
65.53
99.01
65.53
99.14 63.63
98.82 66.85
99.02
61.61
99.48 83.85
NIPS
App.
Test
99.08 80.30
98.75
80.61
99.03
79.03
98.93 81.78
99.63 91.27
99.60 94.48
Table 3.7 – Paramètres utilisés pour obtenir les meilleurs résultats de classification de "Base"
Naïf (apprentissage)
Naïf (test)
Intelligent (apprentissage)
Intelligent (test)
q
25
25
50
25
BASE
K
α
0.25
/
0.25
/
0.25 0.0
0.5 0.75
β
/
/
/
0.25
q
50
15
25
25
NIPS
K
α
0.5
/
0.5
/
0.25 0.75
0.25 0.0
β
/
/
0.25
/
nombre de variables pertinentes identifiées. La précision de l’algorithme intelligent reste elle, dans tous les cas, supérieure à celle de l’algorithme naïf. Le
meilleur résultat obtenu l’a été pour K = 0.75, α = 0.8, β = 0.
Résultats de classification La Table 3.6 indique les meilleurs résultats moyens
obtenus en classification et en test à partir des variables identifiées par les deux
algorithmes testés en utilisant les paramètres indiqués dans la Table 3.7. Ces
résultats ont été obtenus en construisant des forêts aléatoires de dix arbres. Ils
sont à comparer à ceux obtenus en utilisant toutes les variables et ceux obtenus
en utilisant uniquement les variables pertinentes.
Sur l’ensemble de type "Base", on remarque que n’utiliser que les variables
pertinentes permet un gain de 20% en test, ce qui prouve que les variables
aléatoires ajoutées constituent bien un bruit important qu’il est nécessaire d’éliminer. L’algorithme naïf et l’algorithme intelligent présentent des résultats très
proches sous ce critère. Ils permettent tous les deux d’améliorer le score de test
de l’ordre de quelques pourcents par rapport à l’utilisation de toutes les variables. On peut donc en conclure que toutes les variables pertinentes ne sont
pas identifiées ou que trop de variables "bruit" sont ajoutées dans les ensembles.
C’est en réalité une combinaison des deux effets avec, pour le cas de l’algorithme
intelligent avec le meilleur score de test, une moyenne de 16.2 variables pertinentes identifiées et une précision de 52.9%.
Les résultats observés sur "Nips" sont plus surprenants. En effet, la perte
de performance en test par rapport à l’utilisation de toutes les variables est
contre-intuitive surtout compte tenu des bons résultats en terme de nombre de
variables identifiées comme de précision obtenus sur cet ensemble de données.
43
(a) Nombre de variables pertinentes identifiées
(b) Précision
Figure 3.13 – Résultats sur "NIPS" pour K = 0.25, α = 0.75, β = 0
44
(a) Nombre de variables pertinentes identifiées
(b) Précision
Figure 3.14 – Résultats sur "NIPS" pour K = 1q , α = 0., β = 0
45
3.2.3
Impact des données
L’impact du nombre d’échantillons disponibles dans la base de données n’a
pas pu être testé par manque de temps pour les expériences. Néanmoins, théoriquement, si l’algorithme dispose de moins d’exemples, les informations mutuelles
estimées sont moins précises et il devient donc plus difficile pour les algorithmes
de différencier les variables pertinentes des variables non pertinentes. Nous présentons donc ici l’impact de la structure des données.
Impact de la redondance Les Figures 3.15a et 3.15b montrent sur un cas
particulier l’impact négatif de la redondance sur l’algorithme intelligent. En
effet, ses performances sont réduites en terme de nombre de variables identifiées. Ceci s’explique par le fait que les variables pertinentes conservées risquent
d’être utilisées dans la partie haute des arbres et de compliquer l’identification
des variables redondantes en dessous en diminuant leur information mutuelle
conditionnelle avec la sortie.
Néanmoins, cette structure de données augmente significativement la précision des deux types d’algorithmes (Figure 3.16a et 3.16b). La redondance
permet de choisir, au moment de diviser un nœud, des variables donnant une
information mutuelle plus faible que s’il n’y avait pas de redondance mais néanmoins supérieure à celle une variable non pertinente. La différenciation entre
les deux types de variables est donc facilitée. De plus, les variables redondantes
sont ici des combinaisons linéaires des variables pertinentes de base. La nature
du problème laisse supposer que certaines variables redondantes sont alors plus
pertinentes que les variables de base, ce qui creuse encore l’écart entre variables
pertinentes et non pertinentes.
Cette structure particulière favorise nettement l’algorithme naïf dans toutes
les configurations testées en terme de nombre de variables identifiées (mais pas
en précision) et il n’est pas toujours possible malgré le réglage des différents paramètres de l’algorithme intelligent de rattraper les performances de l’algorithme
naïf. La meilleure performance réalisée pour l’algorithme intelligent est de 18.2
variables identifiées dans la configuration q = 20, K = 0.5, α = 0.8, β = 0.0
avec une précision de 90.29%. L’algorithme naïf quant à lui obtient au mieux
16.8 variables identifiées en moyenne pour q = 50, K = 0.5 et une précision de
74.47%. Il est donc possible d’obtenir de meilleures performances avec l’algorithme intelligent qu’avec l’algorithme naïf mais le réglage des paramètres est
ici crucial et l’algorithme naïf obtient le plus souvent de meilleurs résultats en
terme de nombre de variables identifiées malgré une précision plus toujours plus
faible.
Impact de la répétition Comme l’illustrent les Figures 3.17a et 3.17b, les
performances de l’algorithme naïf et de l’algorithme intelligent sont toutes les
deux augmentées par la répétition de variable. L’algorithme naïf bénéficie tout
particulièrement de cette configuration et gagne significativement en performance. De plus, comme le confirment les Figures 3.18a et 3.18b, la précision des
deux algorithmes est également augmentée dans cette configuration. La répétition de variables pertinentes semble donc améliorer les deux algorithmes quel
que soit le critère regardé.
46
(a) Sur "Base"
(b) Sur "Redondance"
Figure 3.15 – Nombre de variables identifiées pour K = 0.5, α = 0.5, β = 0.0
sur "Base et "Redondance"
(b) Sur "Redondance"
(a) Sur "Base"
Figure 3.16 – Précision pour K = 0.5, α = 0.5, β = 0.0 sur "Base" et "Redondance"
47
(a) Sur "Base"
(b) Sur "Répétition"
Figure 3.17 – Nombre de variables identifiées pour K = 0.5, α = 0.75, β = 0.25
sur "Base et "Répétition"
Ce résultat peut paraître surprenant. En effet, supposons que X1 et X2 sont
identiques. Si on construit un arbre dans lequel la variable X1 est sélectionnée en
un nœud, X2 ne pourra plus être sélectionnée dans les nœuds situés en dessous
car son information mutuelle conditionnelle avec la sortie est nulle. La variable
X1 masque donc la pertinence de X2 . Néanmoins, si X1 est dans un conditionnement minimal d’une variable X3 , cette dernière pourra être identifiée en utilisant
indifféremment X1 ou X2 ce qui facilite l’identification. L’algorithme intelligent
bénéficie moins de cet effet, car, en conservant les variables, il augmente les
chances de réutiliser par exemple X1 en haut de l’arbre et donc amplifie l’effet négatif de la répétition sans modifier son effet positif. C’est pourquoi les
performances des deux algorithmes sont plus proches que sur le cas précédent.
Le meilleur résultat moyen pour l’algorithme intelligent est de 19.83 variables
pertinentes identifiées avec une précision de 51.35% avec les paramètres q =
50, K = 0.25, α = 0.5, β = 0.25, tandis que l’algorithme naïf parvient au mieux
à 19.8 variables identifiées en moyenne pour une précision de 42.38% dans la
configuration q = 50, K = 0.5. Les performances maximales sont donc similaires
avec un avantage pour l’algorithme intelligent en précision. Comme dans le cas
de la redondance des variables, le paramétrage est crucial dans le résultat obtenu
pour les deux algorithmes.
Impact du mélange de redondance et répétition Le mélange de redondance et de répétition permet à l’algorithme intelligent comme à l’algorithme
naïf de gagner en performances (Figures 3.19a et 3.19b) de façon très nette mais
aussi en précision (Figures 3.20a et 3.20b) de façon un peu moins marquée. La
redondance, qui tend à faire baisser les performances de l’algorithme intelligent
ne compense pas l’effet positif de la répétition que nous avons pu observer.
Ce résultat est encourageant pour la mise en pratique sur des données réelles
dans la mesure où il est très probable d’avoir de la redondance entre des variables voire des copies totales. Cet effet peut néanmoins être encouragé par la
nature des données qui peut permettre à une combinaison linéaire de variables
pertinentes d’être plus pertinente que chacune des variables qui la compose.
48
(a) Sur "Base"
(b) Sur "Répétition"
Figure 3.18 – Précision pour K = 0.5, α = 0.75, β = 0.25 sur "Base" et
"Répétition"
(b) Sur "Mix"
(a) Sur "Base"
Figure 3.19 – Nombre de variables identifiées pour K = 0.5, α = 0.75, β = 0.25
sur "Base et "Répétition"
Le meilleur résultat moyen obtenu pour l’algorithme naïf comme pour l’algorithme intelligent est de retrouver l’intégralité des variables pertinentes. Ceci
se fait sur la configuration q = 10, K = 0.5, α = 0.75, β = 0.75 pour l’algorithme
intelligent avec une précision de 83.5% et pour le paramétrage q = 50, K = 0.5
mais avec une précision de seulement 35.42% pour l’algorithme naïf. On a donc
à nouveau la possibilité d’obtenir de bien meilleurs résultats avec l’algorithme
intelligent qu’avec l’algorithme naïf en réglant les paramètres.
3.2.4
Impact des paramètres
L’impact des différents paramètres des algorithmes sera montré (sauf mention contraire) sur l’ensemble de données "Base", afin d’en faciliter l’interprétation.
49
(a) Sur "Base"
(b) Sur "Mix"
Figure 3.20 – Précision pour K = 0.5, α = 0.75, β = 0.25 sur "Base" et "Mix"
Impact de K Les résultats obtenus par l’algorithme naïf sur l’ensemble "NIPS"
pour une mémoire de taille 50 ainsi que l’impact du paramètre K sont visibles
sur les Figure 3.21a et 3.21b. La seule valeur de K se distinguant vraiment des
autres est le cas dans lequel on construit les arbres de manière aléatoire. En effet,
ceci donne de moins bon résultat en terme de nombre de variables pertinentes
identifiées (courbe bleue sur la Figure 3.21a), néanmoins, cette configuration
est aussi celle qui permet d’avoir le moins de faux positifs possibles et donc
la meilleure précision (courbe bleue sur la Figure 3.21b). Le même phénomène
s’observe quelle que soit la valeur de la taille de la mémoire mais est de plus en
plus marqué avec l’augmentation de cette taille. Il est intuitif que l’utilisation
d’arbres complètement aléatoires complique l’identification des variables pertinentes. La meilleure précision s’explique par le fait que, le choix à chaque nœud
n’étant pas optimisé, il est moins probable d’avoir une variable théoriquement
non pertinente avec une valeur d’importance passant le test statistique choisie
en un nœud. Il convient donc pour régler le paramètre K dans le cas de l’algorithme naïf de savoir si la présence de faux positifs est plus gênante que l’absence
de certaines variables pertinentes et de trouver un compromis dans le résultat.
Le résultat obtenu par l’algorithme naïf est néanmoins satisfaisant puisque
toutes les variables pertinentes sont identifiées en moins de 10000 itérations pour
la plupart des configurations malgré une précision parfois assez faible.
Sur l’ensemble de données "Base", on remarque que construire les arbres de
manière complètement aléatoire ou complètement déterministe n’est pas efficace
en terme de nombre de variables trouvées (Figure 3.22a). Néanmoins, comme
pour l’algorithme naïf et pour les mêmes raisons, le cas complètement aléatoire
a une meilleure précision que les autres cas (Figure 3.22b).
L’impact de ce paramètre est beaucoup plus marqué que ce que nous avions
pu observer en simulation dans la Section 3.1.4. La construction des arbres et
donc le calcul effectif des approximations des importances des variables mène à
ce résultat. Le cas déterministe peut s’expliquer par le fait que les mêmes arbres
sont construits de nombreuses fois parmi les 10000 et ne permettent donc pas
d’identifier de nouvelles variables. Dans les autres cas, la randomisation de la
construction permet de placer des variables différentes aux nœuds dans lesquels
50
(a) Nombre de variables pertinentes identifiées
(b) Précision
Figure 3.21 – Impact du paramètre K sur l’algorithme naïf sur "NIPS"
(a) Nombre de variables pertinentes identifiées
(b) Précision
Figure 3.22 – Impact du paramètre K sur l’algorithme intelligent sur "Base"
il y a encore de nombreux exemples. La précision quant à elle, est affectée,
comme expliqué précédemment, par l’optimisation du choix de la variable sur
laquelle effectuer la division en chaque nœud. La variable utilisée en chaque
nœud est en effet celle pour laquelle il est le plus probable de passer le test
statistique.
Impact de l’élimination de variables Les Figures 3.23a et 3.23b montrent
l’impact du paramètre α pour une configuration particulière. On remarque que
prendre α 6= 0 peut avoir un effet différent selon la valeur de α. Néanmoins, le
meilleur compromis se trouve pour α = 0.5 et on remarque nettement l’intérêt
de ce paramètre pour identifier plus de variables. L’impact du paramètre est
néanmoins assez léger notamment dans le cas K = 1q que nous avons déjà
identifié comme problématique. Les Figures en Annexe B illustrent en effet que
le réglage du paramètre α ne permet pas dans certains cas d’obtenir de meilleurs
résultats que l’algorithme naïf et donne des résultats très similaires quelles que
soient les valeurs choisies (à part α = 0) même si la précision reste supérieure.
L’impact de ce paramètre reste globalement plus léger que sur les simulations même s’il permet d’améliorer significativement les performances notamment dans le cas où la mémoire est de petite taille par rapport aux nombres de
variables pertinentes. Il est donc nécessaire de le fixer à des valeurs différentes
de 0 dans la mesure où, dans un cas concret, on ne connaît pas le nombre de
51
(a) Nombre de variables pertinentes identifiées
(b) Précision
Figure 3.23 – Impact du paramètre α sur l’algorithme intelligent sur "Base"
(a) Nombre de variables pertinentes identifiées
(b) Précision
Figure 3.24 – Impact du paramètre β sur l’algorithme intelligent sur "Base"
variables pertinentes et n’avons pas le choix de la mémoire disponible.
Les Figures 3.24a et 3.24b montrent l’intérêt, comme nous l’avions vu d’un
point de vue théorique dans les simulations, de commencer à éliminer certaines
variables de la mémoire une fois que celle-ci est déjà en partie remplie. La
précision ainsi que le nombre de variables identifiées sont ici tous les deux positivement impactés par l’usage de β = 0.5.
De nouveau, il convient de régler les deux paramètres conjointement afin
d’obtenir les meilleurs résultats. La configuration K = 0.5, α = 0.25 et β = 0.25
a par exemple donné les meilleurs résultats pour q = 50 (environ 18 variables
identifiées) mais la précision reste aux alentours de 60%.
3.2.5
Conclusion
L’écart entre l’algorithme intelligent et l’algorithme naïf est beaucoup moins
frappant en pratique sur les données testées que sur les simulations réalisées
précédemment. On note notamment un impact de la structure des données qui
peut être défavorable à l’algorithme intelligent. Néanmoins, notre version intelligente est toujours plus précise que l’algorithme naïve même si elle est parfois
équivalente voire un peu moins bonne en performances. Une trop grande randomisation dans les arbres construits a notamment un impact négatif sur l’écart
entre les deux versions de l’algorithme et pénalise l’algorithme intelligent. En
52
effet, dans ces cas-là, le fait de garder en mémoire des variables pertinentes représente un moins grand avantage car elles ne seront quand même peut-être pas
choisies dans un ordre pertinent lors de la construction des arbres. Le seul moyen
d’être plus performant que l’algorithme naïf dans ce cas précis est donc d’augmenter la valeur de α. Il convient néanmoins de nuancer les résultats obtenus.
En effet, les données Madelon étant particulières, l’identification des variables
ne peut se faire qu’en utilisant des ordres particuliers le long des branches, ce
qui, dans le cas d’une grande randomisation lors de la construction des arbres
complexifie la tâche des algorithmes.
La structure des données jouant fortement sur les meilleurs paramètres à
utiliser, il peut être compliqué de régler les différents paramètres pour obtenir
les meilleures performances possibles et notamment pour bénéficier de l’apport
de l’algorithme intelligent. Nous pouvons également noter l’effet surprenant de
la répétition de variables et de la redondance qui permet à nos algorithmes
d’améliorer leurs performances et les rend ainsi intéressants à utiliser sur des
données réelles.
Nous pouvons de plus supposer que dans le cas de structures de données
plus simples, les résultats seraient plus proches de ceux obtenus en simulation
et la domination de l’algorithme intelligent plus nette. En effet, Madelon se
rapproche plus du cas des cliques que du cas général majoritairement testé.
53
Discussion et perspectives
Nous avons étudié un algorithme naïf de sélection de variables et montré
ses limites en terme de vitesse de convergence. Dans la plupart des configurations testées, identifier toutes les variables pertinentes en construisant moins de
100000 arbres n’a pas été possible en utilisant cette méthode.
Nous avons également proposé un nouvel algorithme permettant d’utiliser
les variables déjà identifiées pour en trouver de nouvelles et avons montré que sa
vitesse de convergence était meilleure que celle de l’algorithme naïf sous toutes
les hypothèses sur les données testées. L’un des inconvénients de cet algorithme
est qu’il impose de construire les arbres de manière séquentielle alors qu’il était
possible pour l’algorithme naïf de construire plusieurs arbres en parallèle et ainsi
de gagner du temps. L’impact de la construction de plusieurs arbres en parallèle
sur les variables découvertes et sur le nombre d’itérations réalisées dans le cas
de l’algorithme intelligent peut être un point intéressant à étudier.
Les résultats obtenus sur les différents ensembles de données de type Madelon
confirment l’intérêt de l’approche de notre algorithme intelligent par rapport à
l’algorithme naïf mais aussi la nécessité de bien régler les différents paramètres.
L’écart entre les deux algorithmes est le plus souvent réduit par rapport aux
simulations effectuées mais cela peut être due à la nature des données et pas
uniquement aux algorithmes. Les résultats obtenus dans le cas de données contenant de la redondance et des répétitions sont encourageants quant à l’utilisation
de nos algorithmes sur des données réelles. Néanmoins, nos algorithmes n’ont
pu être testés que sur un ensemble de données dont la structure est très particulière. En effet, celui-ci ressemble plus à l’hypothèse de cliques que nous avons
présenté lors des simulations qu’au cas général.
Plusieurs pistes de poursuite de ce travail peuvent s’ouvrir :
— Le problème étudié peut également être légèrement modifié pour trouver par exemple les k variables les plus pertinentes et non plus toutes
les variables pertinentes. L’idée immédiate serait de conserver à chaque
itération les k variables les plus pertinentes trouvées et essayer à partir de celles-ci d’en trouver de nouvelles plus pertinentes. Un problème
de masquage des variables moyennement pertinentes par les plus pertinentes pourraient alors apparaître et nécessiter un travail plus fin sur les
variables à conserver.
— Le fait d’effectuer de nombreux tests statistiques lors de la détermination de la pertinence d’une variable peut conduire à des résultats biaisés.
En effet, si la même variable est testée plusieurs fois, il conviendrait de
corriger statistiquement le résultat du test afin de ne pas augmenter arti54
ficiellement les chances de la variable d’être considérée comme pertinente
simplement parce qu’elle est testée de nombreuses fois. Ceci conduirait à
sélectionner moins de variables pertinentes mais sûrement aussi à améliorer la précision des algorithmes.
— Des tests sur des données réelles sont nécessaires bien qu’il soit difficile
dans ce cas d’évaluer la performance des algorithmes pour notre problème
particulier consistant à identifier toutes les variables pertinentes.
— L’étude théorique des structures de données possibles dans le cas de variables binaires a été entamée pendant ce stage mais n’a pas abouti à des
résultats finaux. Il serait intéressant de développer des résultats sur ce
sujet afin de pouvoir générer des problèmes aux structures particulières
et tester les algorithmes.
D’un point de vue personnel, ce stage m’a permis de confirmer mon intérêt pour la démarche de recherche et me permet de m’engager dans ma thèse
avec enthousiasme. Travailler dans un domaine aussi passionnant et actuel que
l’apprentissage automatique a représenté un véritable plaisir pour moi et les
apports aussi bien personnels que professionnels que j’en ai tirés me seront, j’en
suis certaine, très utiles par la suite.
J’ai également développé, en plus des nombreuses connaissances sur l’apprentissage automatique et les arbres de décision plus particulièrement, des
compétences techniques. En effet, j’ai pu découvrir le cython et travailler de
manière plus soutenue avec des clusters de calcul ainsi qu’avec les librairies python pandas, numpy, scipy et scikit-learn (pour laquelle j’ai même été amenée
à m’intéresser au code source).
55
Bibliographie
[1] L. Breiman, J. Friedman, R. Olshen, and C. Stone. Classification and
Regression Trees. Wadsworth and Brooks, Monterey, CA, 1984.
[2] Leo Breiman. Bagging predictors. Mach. Learn., 24(2) :123–140, 1996.
[3] Leo Breiman. Random forests. Mach. Learn., 45(1) :5–32, October 2001.
[4] Thomas M. Cover and Joy A. Thomas. Elements of Information Theory.
Wiley-Interscience, 2006.
[5] Isabelle Guyon and André Elisseeff. An introduction to variable and feature
selection. J. Mach. Learn. Res., 3 :1157–1182, March 2003.
[6] Trevor Hastie, Robert Tibshirani, and Jerome Friedman. The Elements of
Statistical Learning. Springer New York Inc., 2001.
[7] Tin Kam Ho. The random subspace method for constructing decision forests. IEEE Trans. Pattern Anal. Mach. Intell., 20(8) :832–844, 1998.
[8] Ron Kohavi and George H. John. Wrappers for feature subset selection.
Artif. Intell., 97(1-2) :273–324, December 1997.
[9] Gilles Louppe and Pierre Geurts. Ensembles on random patches. In
ECML/PKDD (1), volume 7523 of Lecture Notes in Computer Science,
pages 346–361. Springer, 2012.
[10] Gilles Louppe, Louis Wehenkel, Antonio Sutera, and Pierre Geurts. Understanding variable importances in forests of randomized trees. In Advances
in Neural Information Processing Systems 26, pages 431–439. 2013.
[11] Louis Wehenkel. On uncertainty measures used for decision tree induction,
1996.
56
Annexe A
Comparaison théorique des
algorithmes pour le cas de
variables marginalement
pertinentes
Proposition 2. Si pour toute variable Xm pertinente, Xm est marginalement
pertinente alors la probabilité pour l’algorithme naïf utilisant des arbres totalement aléatoires de trouver au moins une nouvelle variable pertinente s’il en
a déjà trouvé t est plus élevée que celle associée à l’algorithme intelligent avec
α = 0.
Preuve. On note Pnaïf la probabilité pour l’algorithme naïf utilisant des arbres
totalement aléatoires de trouver au moins une nouvelle variable pertinente s’il en
a déjà trouvé t et Pintelligent cette même probabilité pour l’algorithme intelligent
utilisant des arbres totalement aléatoires. On a alors :
p−k+t
Pnaïf = 1 −
et :
q
p
q
p−k
q−t
p−t
q−t
Pintelligent = 1 −
57
Donc :
Pnaïf ≥ Pintelligent ⇐⇒ 1 −
(p−k+t
)
(p−k
q
q−t )
≥ 1 − p−t
p
(q )
(q−t)
⇐⇒
(p−k+t
)
(p−k
q
q−t )
≤ p−t
(pq)
(q−t)
⇐⇒
(p−k+t)!
p!
≤
(p−k)!
(p−t)!
⇐⇒
(p−k+t)!
(p−k)!
≤
p!
(p−t)!
⇐⇒
Qt
i=1
p−k+i≤
Qt
j=1
p−t+j
Or t ≤ k, donc ∀1 ≤ i ≤ t, p − t + i ≥ p − k + i.
Donc l’algorithme naïf a une probabilité plus forte de trouver de nouvelles variables que l’algorithme intelligent.
58
Annexe B
Impact de α dans le cas K = q1
sur l’ensemble Madelon
"Base"
Figure B.1 – Nombre de variables identifiées : Impact du paramètre α sur
l’algorithme intelligent sur "Base" pour K = 1q
59
Figure B.2 – Précision : Impact du paramètre α sur l’algorithme intelligent sur
"Base" pour K = 1q
60