∀ x ∈ X , f(T )(x) =
T
X
t=1
h(t)(x) avec h(t) : X → RK ∀ t ∈ {1, ..., T } (2.3)
Pour un exemple (x, y) ∈ X × Y, et dans le cadre de la classification à étiquette unique, l’opération d’estimer une étiquette y ∈ Y à partir de fˆ (T ) est régie par l’expression :
ˆ
y= argmax
k
(fkT(x)). (2.4)
2.1.3 Perte de Hamming et risque exponentiel multi-classes
En utilisant un ensemble d’exemples étiquetés S = {(xi, yi), ∀ i ∈ {1, ..., m}, xi ∈ X , yi ∈
{±1}K} , où chaque exemple est généré selon une distribution D, l’objectif de l’algorithme
Adaboost-MH est de produire un classificateur H : X → {±1}K à sortie vectorielle et qui
minimise le «vrai» risque de classification suivant. RD
def
= E
(x,y)∼DL(H(x), y)
Dans le cadre de la classification à étiquette unique ou multi-étiquettes, on utilise la perte de Hamming pondérée Lw, définie comme suit.
Lw(H(x), y) def = K X k=1 wk1[Hk(x) 6= yk] , ∀ (x, y) ∈ X × {±1}K. (2.5)
w est une distribution de probabilité sur l’ensemble {1, ..., K}. Chaque composante wkexprime
le poids de la pénalité associée à une erreur de prédiction Hk(x) 6= yk. Dans le cadre de
la classification multi-étiquettes, les composantes de y sont de même importance. Le choix wk = 1/K est un choix adéquat. Dans, le cas de la classification à étiquette unique, il est
courant de choisir une distribution dépendante de la classe afin de donner plus d’importance à la composante ykde valeur+1. En effet, se tromper sur la valeur de cette composante est plus
grave que se tromper sur les valeurs des autres composantes. En notant `(y) = y ∈ {1, ..., K} l’indice tel que y`(y) = +1, il est fréquent d’effectuer le choix 2.6 de la distribution w(y) dépendante de y. wk(y) = ( 1 2 si k= y 1 2(K−1) si k 6= y . (2.6)
Avec ce choix, et en supposant que le nombre d’exemples dans chaque classe est le même, on crée K problèmes de classification binaire balancés. C’est-à-dire que, pour chaque composante k de la sortie, la somme des poids des exemples à étiquettes positives est égale à celle des exemples à étiquettes négatives.
Le risque empirique 0/1 de Hamming s’exprime alors comme suit.
RHamS (H)def= 1 m m X i=1 K X k=1 wk(yi) 1[Hk(xi) 6= yi,k] (2.7)
Pour tout exemple (x, y) ∈ X × {±1}K, et pour tout k ∈ {1, ..., K}, nous avons que
1[Hk(x) 6= yk] = 1[f (T )
k (x).yk<0]
≤ exp − yk.fk(T )(x)
Il s’ensuit que le risque empirique multi-classes de Hamming est majoré par le risque expo- nentiel RExpS suivant.
RExpS (f(T )) = 1 m m X i=1 K X k=1 wk(yi)exp − yi,k.fk(T )(xi)
La minimisation du risque0/1 de Hamming sera effectuée à travers la minimisation du risque exponentiel de Hamming RSExp.
2.1.4 L’algorithme de boosting
D’après (Kégl,2013), le risque RExpS (f(T )) peut être factorisé comme suit.
RExpS (f(T )) =
T
Y
t=1
Avec, Z(h(t), w(t)) = 1 m m X i=1 K X k=1 w(t)k (yi) exp(−h(t)k (xi) yi,k) et w(t)k (yi) = w(t−1)k (yi) exp(−h(t−1)k (xi) yi,k) Z(h(t−1), w(t−1))
Ainsi, de manière analogue à Adaboost dans le cas binaire, le risque exponentiel peut être minimisé en minimisant le terme Z(h(t), W(t)) à chaque itération t. L’algorithme Adaboost- MH en découle.
Algorithm 1: Adaboost-MH
Input: Le nombre T de votants faibles.
Input: Une distribution w sur {1, ..., K}, possiblement dépendante de la classe. Input: S = {(xi, yi), ∀ i ∈ {1, ..., m}, xi ∈ X , yi∈ {±1}K} Initialisation : w(1) = w ; for t= 1 to T do h(t) ← WL(S, w(t)); Mise à jour : ∀k ∈ {1, ..., K} , ∀ i ∈ {1, ..., m} w(t+1)k (xi) = w(t)k (x). exp(−h(t)k (x) yi,k) Pm i0=1 PK k0=1wk0(xi0).exp − h(t) k0 (xi0) yi0,k0
Output: Un prédicteur H(T ) à valeurs dans {±1}K, et une fonction f(T ) à valeurs dans
RK telle que H(T )= signe(f(T )) avec :
f(T ) =
T
X
t=1
h(t)(x), ∀x ∈ Rd.
À chaque itération t, l’algorithme invoque l’apprenant faible pour générer un votant qui, idéa- lement, minimise Z(h(t), w(t)). Pour un exemple x, w(y) est mise à jour de sorte à augmenter
les poids wk(x) correspondants à une marge h(t)k (x) yknégative, et à diminuer les poids associés
à une marge positive. Ceci est équivalent à augmenter l’importance des erreurs de prédiction effectuées par h(t).
2.1.5 Modèle de l’apprenant faible
Dans la version originale d’Adaboost-MH (Schapire et Freund,2012a), l’apprenant faible est composé par K prédicteurs. Chaque prédicteur d’indice k est entraîné indépendamment des
autres, et vise à minimiser le terme : 1 m m X i=1 wk(t)(yi) exp(−h(t)k (xi) yi,k)
Dans cette version, chaque prédicteur effectue un partitionnement de l’espace des instances qui peut être différent des partitionnements obtenus par les autres prédicteurs. Kégl (2013) propose deux apprenants faibles, permettant d’utiliser un partitionnement partagé entre les prédicteurs h(t)k . En l’occurrence, ces apprenants sont :
— Souche de décision factorisée.
— Arbre de décision MH basés sur des souches de décision factorisées. Souche de décision factorisée
La souche de décision factorisée est le produit d’une fonction ϕ : X → {±1} qui dépend uniquement des instances, d’un vecteur v ∈ {±1}K qui exprime l’accord ou le désaccord avec
les valeurs de ϕ et d’un scalaire α qui exprime le degré de confiance en la prédiction vϕ. La sortie de l’hypothèse faible s’exprime donc comme suit.
∀x ∈ X , h(x) = α v ϕ(x) (2.8)
La factorisation permet de définir une séparation partagée entre les différentes classifications binaires. L’introduction du vecteur de votes v permet de réutiliser les prédictions de ϕ pour produire un votant faible. En effet, si ϕ effectue un risque empirique supérieur à 12, alors −ϕ effectue un risque empirique inférieur à 12. Ainsi, pour tout x ∈ X , chaque composante vk
corrige les prédictions données par ϕ de sorte que les performances de chaque composante du votant faible devient meilleure que celles d’un prédicteur qui prédit une étiquette aléatoire. En utilisant l’expression (2.8) de la souche de décision factorisée, Z(h, w) devient :
Z(h, w) = exp(α) + exp(−α) 2 − exp(α) − exp(−α) 2 K X k=1 vk.(µk+− µk−) (2.9) Avec :
µk+ =Pmi=1wi,k(yi) 1[ϕ(xi) = yi,k)]
µk− =
Pm
i=1wi,l(yi) 1[ϕ(xi) 6= yi,k)]
Notons, γk la quantité vk.(µk+− µk−) =
Pm
i=1wk(y) vk ϕ(xi) yi,k, pour tout k ∈ {1, ..., K}.
Notons γ =PK
k=1γk. Dans ce qui suit, γ sera appeléeedge, γk sera appeléper-class-edge et
le vecteur γ = (γ1, γ2, ..., γK ) sera appelé multiclass-edge. Sous cette notation, l’expression 2.9 devient.
Z(h, w) = exp(α) + exp(−α)
2 −
exp(α) − exp(−α)
Ainsi, la valeur optimale de α qui minimise Z(h, w) est : α= 1
2log( 1 + γ
1 − γ) (2.10)
En utilisant cette valeur de α, la valeur optimale de Z(h, w) est : ˆ
Z(h, W) =p1 − γ2
Ainsi, ˆZ est minimale lorsque γ est maximale. Comme γ=PK
k=1vk.(µk+− µk−), ceci revient
à dire que chaque composante vk est de même signe que µk+− µk−.¸
∀ k ∈ {1, ..., K}, vk = signe(µk+− µk−) (2.11)
La tâche de l’apprenant faible consiste alors à produire un prédicteur h qui maximise le edge γ. Ceci pourra être effectué en trois étapes clés. La première consiste à chercher une fonction ϕ: X −→ {±1} qui maximise la somme des valeurs absolues des per-class-edges. L’introduction de la valeur absolue permet d’enlever la dépendance en vk.
ˆ ϕ= argmax ϕ X k=1 |vk m X i=1 wi,k(yi)yi,kϕ(xi)| = argmax ϕ X k=1 | m X i=1 wi,k(yi)yi,kϕ(xi)|
Si les instances sont triées selon toutes les composantes, il suffit de parcourir une seule fois tous les seuils possibles afin de retrouver le meilleur seuil θ∗. À chaque itération, l’évaluation de la quantité Pm
i=1wi,k(yi)yi,kϕ(xi) peut être déduite par addition ou soustraction d’un
terme2wi,k(yi)yi,k selon le signe du seul exemple qui change de région lorsque θ varie. Alors,
la recherche du meilleur seuil s’effectue efficacement en O(m.d). La deuxième étape consiste à déduire le vecteur v optimal selon l’équation (2.11) et de calculer le edge correspondant. Finalement, la valeur optimale de α est estimée selon l’équation (2.10).
L’algorithme2 de l’apprentissage d’une souche de décision factorisée en découle. Algorithm 2: Minimisation de Z avec une souche de décision factorisée
Input: Une distribution w sur {1, ..., K}, possiblement dépendante de la classe Input: S = {(xi, yi), ∀ i ∈ {1, ..., m}, xi ∈ X , yi∈ {±1}K} Initialisation : γ∗ = 0; for k= 1 to K do γk= Pm i=1wk(yi) yi,k Initialisation : α= N il ; j∗ = N il ; θ∗= N il ; v∗ = (0, 0, ..., 0) de taille K; for j = 1 to d do Calculer θ ←argmax a Pm
i=1wi,k(yi)yi,k 1[xi,j > a] − 1[xi,j < a]
; γ ←0; for k= 1 to K do µ+= Pm
i=1wi,k(yi)yi,k1[xi,j > θ];
µ−=Pmi=1wi,k(yi)yi,k1[xi,j < θ];
vk = signe(µ+− µ−); Mise-à-jour γ ← γ+ vk(µ+− µ−) if γ > γ∗ then Mise à jour : γ∗= γ ; v∗ ← v ; θ∗ = θ ; j∗= j ; Calculer α= 1 2log( 1+γ∗ 1−γ∗);
Output: Une fonction h à valeurs dans RK, définie par :
∀x ∈ X , h(x) = α.v∗.signe(xj∗− θ∗)
Arbre de Hamming
Kégl(2013) utilise la souche de décision factorisée afin de construire un arbre de décision qui effectue un partitionnement disjoint de X partagé entre les différents problèmes de classifi- cation binaires. Chaque nœud interne de l’arbre est muni d’une fonction indépendante de la classe ϕ, permettant de prédire si l’instance doit être acheminée à son fils de droite ou à son fils de gauche. Chaque feuille de l’arbre effectue une prédiction dans {±}K. Finalement, cette prédiction est multipliée par un scalaire α. Cette modélisation est illustrée par la figure 2.1.
+1 −1 +1 −1 1 2 1 2 2 +1 −1
Figure 2.1 – Arbre de Hamming, à gauche : arbre de Hamming avec un seul nœud interne, à droite : arbre de Hamming avec deux nœuds internes
Remarquons que le scalaire α, qui représente un degré de confiance en les prédictions effectuées par vjϕj, est commun à toutes les feuilles de l’arbre. Ainsi, pour tout x ∈ X , et pour tout k ∈
{1, ..., K}, les prédictions hk(x) de l’arbre auront la même valeur absolue. Notons également
que pour les feuilles issues du même nœud interne j, un seul vecteur vj ∈ {±1}K est utilisé
pour effectuer des prédictions.
2.2
L’algorithme XGBoost
Dans cette section, nous allons présenter l’algorithme XGBoost proposé parChen et Guestrin
(2016). Le nom XGBoost est l’abréviation de «eXtreme Gradient Boosting». Cet algorithme constitue une continuité de GBM (Gradient Boosting Machines). Ce dernier traite le problème de la construction du vote de majorité comme une descente du gradient, dans l’espace des fonctions de X →RK. À chaque itération, l’apprenant faible retourne un votant faible qui est corrélé avec le gradient négatif de la fonction objective, calculé par rapport aux prédictions données par la fonction à valeurs réelles f(T )(x) pour tout x ∈ X . Le poids du votant est analogue à un poids de descente du gradient. Dans GBM, il est optimisé par ‘line-search”, comme étant le poids qui minimise la fonction objective à la même itération (Schapire et Freund,2012b).
XGBoost simplifie l’étape du calcul du poids optimal de la descente du gradient en considérant le développement de Taylor à l’ordre 2 de la fonction objective. Dans ce qui suit, nous allons voir comment cette approximation est minimisée, ainsi que le choix de la famille des votants faibles.
2.2.1 Encodage de la sortie, vote de majorité et modèle de l’apprenant faible
XGBoost utilise un encodage une-classe-contre-le-reste. À la différence d’Adaboost-MH, pour un exemple (x, y) les composantes de la sortie y sont à valeurs dans {0, 1}.
yk=
(
1 si k = y
0 si k 6= y . (2.12)
De manière similaire à Adaboost-MH, XGBoost construit en T itérations une fonction f(T )qui effectue des prédictions dansRK. Ces prédictions sont ensuite transformées en une prédiction dans Y par la relation :
ˆ
y= argmax
k
(fkT(x)).
Chaque votant faible effectue des prédictions à niveaux de confiance. L’expression de la fonction f(T ) est donnée par :
∀ x ∈ X , f(T )(x) =
T
X
t=1
h(t)(x) avec h(t) : X → RK ∀ t ∈ {1, ..., T }
L’apprenant faible est formé par K arbres de régression entraînés indépendamment les uns des autres. Un arbre de régression est formé par des nœuds internes qui indiquent si une instance doit être acheminée à un fils de droite ou à un fils de gauche, et par des feuilles qui effectuent des prédictions scalaires. Le scalaire associé à une feuille d’indice j du prédicteur hk sera noté ck,j. Le nombre maximum de feuilles sera noté N . La figure2.2illustre un exemple d’un votant
= 1 = 2 = 3
= 0.3, 0.5 , 0
0.1 0.6 − 1 0.5 0.3 0.4 0.1 0Figure 2.2 – Prédiction avec le votant faible utilisé dans XGBoost pour N = 3 et K = 3, les flèches vertes indiquent le chemin suivi par l’instance
x.
Mathématiquement, chaque arbre de régression est modélisé par une fonction q : X → {1, ..., N } et un vecteur c ∈ RN formé par les scalaires associés à chaque feuille. Pour toute
instance x ∈ X , la valeur q(x) indique l’indice de la feuille à laquelle x doit être acheminée. Sous cette notation, les prédictions effectuées par un arbre de régression h sont données par :
∀ x ∈ X , h(x) = cq(x).
2.2.2 Fonction objective et algorithme
XGBoost prend en paramètre une fonction de perte ` deux fois différentiable, et construit un vote de majorité f(T ) qui minimise le risque empirique RS` associé à cette perte. À chaque itération t, sachant que fk(t) = fk(t−1)+ h(t)k , R`S est approximé par son développement de Taylor à l’ordre 2 autour des anciennes prédictions.
∀k ∈ Y , R`S(f(t), k) ' 1 m m X i=1 `(fk(t−1)(xi), yi,k) + a (t) i,k h (t) k (xi) + 1 2 b (t) i,k [h (t)(x i)]2
Le terme a(t)i,k désigne la dérivée ∂`(f
(t−1)
k (xi),yi,k)
∂fk(t−1)(xi)
calculée à l’itération t, b(t)i,k désigne la dérivée seconde ∂
2`(f(t−1)
k (xi),yi,k)
∂fk(t−1)(xi)2
calculée à la même itération.
Notons, pour k ∈ Y, Ik,j= {i : qk(xi) = j} l’ensemble des indices des instances acheminées à
la feuille j. En ignorant le termePm
i=1 `(f
(t−1)
réécrire la fonction objective ˜R` S comme suit. ∀k ∈ {1, ..., K}, ˜R`S(f(t), k) ' 1 m m X i=1 [a(t)i,k h(t)k (xi) + 1 2b (t) i,k [h (t) k (xi)] 2] (2.13)
Cette fonction constitue la fonction objective à minimiser par l’apprenant faible à chaque itération de XGBoost. De plus, afin de contrôler le sur-apprentissage et la complexité du votant faible, on ajoute à ˜R`
S un terme de régularisation Ω(h(t)). La fonction objective à
minimiser par l’apprenant faible devient : ∀k ∈ {1, ..., K}, F (f(t), k) ' 1 m m X i=1 [a(t)i,k h(t)k (xi) + 1 2b (t) i,k [h (t) k (xi)] 2] + Ω(h(t) k ) (2.14)
L’algorithmeXGBoosten découle. Algorithm 3: XGBoost
Input: Le nombre T de votants faibles.
Input: S = {(xi, yi), ∀i ∈ {1, ..., m}, xi∈ X , yi ∈ {0, 1}K}
Input: Une fonction de perte `
Input: Un apprenant faible WL qui prend en entrée un ensemble
{(xi, ai, bi), ∀i ∈ {1, ..., m}} et retourne un votant faible h qui minimise (2.14)
Initialization : f(0)= 0; for t= 1 to T do
for i= 1 to m do Calculer ai et bi
Construire l’ensemble S0 = {(xi, ai, bi), ∀i ∈ {1, ..., m}, xi∈ X };
Invoquer l’apprenant faible : h(t) ← WL(S0); Mise à jour : f(t) = f(t−1)+ h(t);
Output: f(T )
2.2.3 Contrôle du sur-apprentissage
Le termeΩ(hk) est utilisé pour contrôler la profondeur des arbres de régression et l’amplitude
des poids associés aux feuilles de chaque arbre. Pour tout arbre de régression h , à N feuilles, et muni d’un vecteur c de niveaux de confiances associés aux feuilles, l’expression de Ω est donnée par :
Ω(h) = γN + 1 2λkck
2
2 avec γ ≥0 et λ ≥ 0. (2.15)
Le terme γN empêche l’apprenant faible de converger vers des arbres de grande taille. Le terme 12λkck22 l’empêche les niveaux de confiance d’avoir des valeurs élevées. Afin d’atténuer encore la contribution des votants faibles dans la fonction f(T ) , la règle de mise à jour de f(t) pour une itération t est modifiée comme suit.
La constante η est appelée taux d’apprentissage (angl. learning rate). Elle est équivalente au pas de la descente de l’algorithme de descente du Gradient.
En plus de la régularisation et de l’utilisation d’un taux d’apprentissage, à chaque itération, les votants faibles sont appris sur un sous-ensemble de l’ensemble d’entraînement. Les exemples de cet ensemble sont échantillonnés de manière aléatoire uniforme à partir des exemples d’en- traînement. Cette opération est paramétrée par un taux d’échantillonnage que nous allons noter τ . Il est défini comme suit :
τ = Nombre des exemples échantillonnés Nombre des exemples d’entraînement En écrivant la relation (2.13) sous une forme canonique, on obtient :
∀k ∈ {1, ..., K}, F (f(t), k) = 1 m m X i=1 bi,k 2 h (t) k (xi) − ai,k bi,k 2 + constante
Le terme bi,k/2 agit comme une pondération de l’exemple (xi, ai,k/bi,k). Lors de l’apprentissage
des arbres de décision par l’apprenant faible, les exemples d’entraînement seront répartis sur l’ensemble des régions définies par les feuilles des arbres. Le sur-apprentissage survient lorsque le nombre des exemples acheminés à certaines feuilles est très faible. XGBoost permet de limiter ce phénomène en imposant une somme minimum des poids {bi,k/2 : q(xi) = j, ∀i ∈ {1, ..., m}}
à réaliser par les exemples de la feuille j. Une subdivision d’une feuille en un nœud interne et deux feuilles est rejetée si cette somme n’atteint pas un seuil prédéfini pour chacune des feuilles nouvellement créées.
Finalement, les composantes des instances sont échantillonnées lors de l’apprentissage des arbres de régression. En d’autres termes, on pige aléatoirement un sous-ensemble de {1, ..., d} et on utilise les composantes dans cet ensemble pour apprendre un arbre de régression. Ceci est effectué une seule fois dans une des occasions suivantes :
— À chaque itération.
— À chaque niveau de l’arbre ;
— À chaque tentative de création d’un nœud interne ;
Dans le premier cas, l’échantillon des composantes est utilisé pour l’apprentissage de tous les nœuds interne de l’arbre. Dans le second cas, l’échantillon est utilisé dans l’apprentissage des nœuds internes du même niveau. Lorsque la profondeur de l’arbre augmente, les composantes sont ré-échantillonnées. Dans le troisième cas, les composantes sont ré-échantillonnées avant la création de chaque nœud interne.
Les hyper-paramètres sont sélectionnés par validation croisée, ce qui rend l’apprentissage lent. Toutefois, les paramètres gérant l’échantillonnage des exemples et les composantes permettent d’accélérer l’apprentissage. XGBoost exploite la puissance des cartes graphiques GPU (Gra- phical Processing Unit) et les systèmes distribués pour apprendre les votants faibles.
2.2.4 Tâche de l’apprenant faible
En remplaçantΩ dans la fonction objective (2.14) par son expression (2.15), nous avons :
∀k ∈ Y, F (f(t), k) = 1 m N X j=1 [ (X i∈Ik,j a(t)i,k)ck,j+ 1 2( X i∈Ij b(t)i,k+ λ.m)c2k,j ] + γN
Ainsi, à une itération t et pour une feuille d’indice j d’un arbre d’indice k, en posant que la dérivée de la fonction objective par rapport à ck,j est nulle, la valeur optimale du niveau de confiance ck,j est donnée par :
c∗k,j = − P i∈Ij,ka (t) i,k P i∈Ij,kb (t) i,k+ λ.m (2.16)
En remplaçant ck,j dans l’expression de la fonction objective par les valeurs optimales de c∗k,j, et en supposant que qk est fixe, la fonction objectif devient :
∀k ∈ Y, ˜RS`(f(t), k) = − 1 2m N X j=1 P i∈Ik,ja (t) i,k 2 P i∈Ik,jb (t) i,k + λ.m + γN (2.17)
On obtient alors un score permettant d’évaluer le votant faible de type arbre de régression comme une somme de scores individuels des feuilles. Ce score permet de manière similaire à l’indice de Gini, de décider si la subdivision d’une feuille en un nœud interne et deux feuilles minimise encore la fonction (2.14). Comme la somme (2.17) est séparable sur les feuilles, la maximisation de ce score peut être effectuée en maximisant les scores de chacune des feuilles, de manière indépendante. Une subdivision à la feuille d’indice j0 implique une modification exclusive du terme m1 P i∈Ik,j0a (t) i,k 2 P i∈Ik,j0b (t) i,k+λ.m
. Ainsi, nous pouvons en déduire un critère de choix de la meilleure subdivision d’une feuille en un nœud interne et deux feuilles filles, puis d’en déduire une procédure itérative de la construction d’un arbre de régression.
On considère une feuille d’un arbre de régression h. Notons I l’ensemble des indices des exemples acheminés à cette feuille. Notons également Id et Ig respectivement les indices des
instances acheminées à droite et à gauche après une subdivision de cette feuille. Nous avons alors I = Id∪ Ig. Notons s0 le score associé à cette feuille avant subdivision. Il est donné par :
s0= 1 m P i∈Ia (t) i 2 P i∈Ib (t) i,k+ λ.m − γ
Le gain après subdivision s’exprime comme suit.
gain= 1 m P i∈Ida (t) i 2 P i∈Idb (t) i + λ.m + 1 m P i∈Iga (t) i 2 P i∈Igb (t) i + λ.m − s0− 2γ
La subdivision optimale est alors la subdivision qui donne le meilleur gain.
Dans le cas où la fonction qui régit un nœud interne est de type souche de décision, l’évaluation des gains pour tous les seuils possibles sur un attribut pourra être effectuée efficacement en parcourant une seule fois les exemples, lorsque ces derniers sont pré triés selon cet attribut. À chaque itération, les sommes dans les scores des feuilles créées sont mis à jour en un nombre constant d’opérations, et le gain est recalculé avec ces nouveaux scores. L’algorithme4illustre la procédure du calcul d’une souche de décision optimale.
Algorithm 4: MeilleureSupdivision Input: Le nombre T de votants faibles.
Input: S = {(xi, ai, bi), ∀i ∈ {1, ..., m}, xi∈ X , }, ai et bi sont supposés contenir les
évaluations des dérivées utilisées dans le développement de Taylor (2.13) pour un arbre d’indice k
Input: Argsort la matrice de taille m × d telle que chaque colonne j stocke la
permutation des indices {1, ..., m} permettant de trier (x1,j, x2,j, ..., xm,j) dans
l’ordre croissant
Input: l’ensemble des indices des exemples acheminés à la feuille courante I Input: Le nombre maximal de feuilles N
Input: λ >0 et γ > 0
initialiser : gain= 0, gain∗= 0, θ∗= 0, j∗ = 0; initialiser : G=P
i∈Iai, H =Pi∈Ibi;
for j to {1...d} do Gd= 0, Gl= 0;
π la permutation stockée à la colonne j de la matrice Argsort; for i ∈ π do Gg ← Gg+ ai, Hg ← Hg+ bi; Gd← G − Gg, Hd← Hd− Hg ; gain= 1 m( G2 g Hg+λ.m+ G2 d Hd+λ.m − G2 H+λ.m) − γ;
if gain > gain∗ et xi,j 6= xi+1,j then
gain∗ = gain; θ∗= xi,j+xi+1,j
2 ;
j∗ = j;
Output: Un tuple (ϕ, gain∗) avec ϕ une souche de décision définie par : ∀x ∈ X , ϕ(x) = signe(xj∗− θ∗)
Conclusion
Dans ce chapitre, nous avons présenté les deux algorithmes performants de boosting, à savoir, Adaboost-MH et XGBoost. Deux idées originales de chaque algorithme peuvent être combinées dans un même apprenant faible. Notamment, l’idée d’avoir partitionnement commun entre les composantes de la sortie, et l’idée de pouvoir effectuer des prédictions à niveaux de confiance. Cette possibilité sera étudié dans le prochain chapitre.
Chapitre 3
L’algorithme QuadBoost-MHCR
Introduction
Dans ce chapitre, nous allons présenter notre propre algorithme de classification, appelé QuadBoost-MHCR, permettant de traiter les cas à étiquette-unique et multi-étiquettes en utilisant l’encodage de la sortie. De même qu’Adaboost-MH, nous utiliserons un apprenant faible de type arbre de régression, qui effectue un partitionnement de l’espace des instances et qui est partagé entre les composantes de la sortie. De même que XGBoost, les feuilles de notre apprenant faible sont à niveaux de confiance. Dans ce chapitre, nous allons présenter l’algo- rithme QuadBoost-MHCR, établir ses garanties de convergence et le comparer qualitativement à XGBoost et Adaboost-MH.
3.1
Description de l’algorithme
3.1.1 Encodage de la sortie et vote de majorité
On utilise l’encodage de Hamming expliqué dans la section 2.1. Notons S def= {(xi, yi), ∀ i ∈
{1, ..., m}, xi ∈ Rd, yi ∈ {±1}K} l’ensemble des exemples avec étiquettes encodées. Le vote
de majorité suit l’expression 2.2. Comme dans Adaboost-MH, l’obtention de l’étiquette dans Y s’effectue en utilisant la relation 2.4. Les votants faibles pour QuadBoost-MHCR sont des prédicteurs à niveaux de confiance. On associe également à chaque y une pondération possi- blement dépendante de la classe w(y).
3.1.2 Fonction de perte et risque empirique multi-classes
L’objectif du boosting de ces arbres est de générer une fonction f(T ) = PT
t=1h(t), et un
classificateur H(T ) def= signe(f(T )), où pour tout t ∈ {1, ...T }, h(t) : X 7−→ RK désigne le
L’apprentissage de f(T ) est effectué en minimisant le risque multi-classe 0/1 de Hamming suivant. RHamS (H(T ))def = 1 m m X i=1 K X k=1 wk(yi)1[yi,k 6= Hk(T )(xi)]
Dans Adaboost-MH, on utilise le risque exponentiel pour borner supérieurement le risque RHamS (H(T )). Dans XGBoost, on laisse la liberté de choisir une fonction de perte continue et
différentiable, et on minimise, à chaque itération, le développement de Taylor au second ordre du risque correspondant.
Remarquons que
1[yi,k 6= Hk(T )(xi)] = 1[yi,kfk(T )(xi) < 0]
≤ (1 − yi,kfk(T )(xi))2
= (yi,k− fk(T )(xi))2
Nous pouvons donc majorer le risque RHamS (H(T )) comme suit.
RHamS (H(T )) ≤ 1 m m X i=1 K X k=1 wk(yi)(yi,k− fk(T )(xi))2 def = RQuadS (f(T ))) (3.1)
Par analogie avec XGBoost et afin de pouvoir déduire les mesures de confiances avec notre apprenant faible, nous allons viser à minimiser le risque quadratique RSQuad. L’algorithme sera alors nommé QuadBoost.MHCR. Quad pour la minimisation du risque quadratique, MH pour l’encodage multiclasse de Hamming, et CR pour les prédictions à niveaux de confiance (angl. Confidence-Rated-predictions).
3.1.3 Modèle du votant faible
L’apprenant faible produit un votant faible h : X 7−→ RK. Dans ce qui suit, nous allons illustrer deux types d’hypothèses faibles, à savoir, la souche de décision à niveaux de confiance et l’arbre de régression à niveaux de confiance, appelé Arbre-MHCR.
Souche de décision à niveaux de confiance
Soient la fonction ϕ: X 7−→ {±1} et les vecteurs c1 ∈ RK et c2 ∈ RK. Une souche de décision
à niveaux de confiance est une fonction h: X 7−→ RK définie comme suit. ∀x ∈ X , h(x) = 1
2 1 + ϕ(x) c1+ 1
2 1 − ϕ(x) c2 (3.2)
= 1[ϕ(x) = 1] c1+ 1[ϕ(x) = −1] c2
ϕ définit un partitionnement disjoint de l’espace Rden deux régions. Chaque région est associée