Pré-traitement des données

Protéase du VIH

On s’intéresse dans ce projet à la protéase du VIH, une enzyme qui possède un rôle majeur dans le cycle du virus du SIDA. Cette enzyme permet en effet le clivage de certaines protéines, ce qui a pour effet de libérer et de créer d’autres protéines néfastes à l’organisme et d’aider la propagation de la maladie.

Pour mieux comprendre comment fonctionne la protéase du VIH, on dispose d’une base de données contenant un ensemble d’octamères (i.e. une séquence de 8 acides aminés), dont certains ont été clivés par la protéase et d’autres non.

L’objectif de l’étude est de prédire, à partir de sa séquence d’acides aminés, si un octamère est clivé ou non par la protéase du VIH.

Pré-traitement des données

La base de données contient deux variables : la première variable Octamer correspond à la séquence d’acides aminés composant l’octamère, et la deuxième variable Clived vaut 1 si l’octamère a été clivé par la protéase, et -1 sinon.

Octamer Clived
SLNLRETN 1
AECFRIFD 1
HLVEALYL 1
TQIMFETF 1
AEELAEIF 1
PFIFEEEP 1

1

A partir de la séquence de 8 lettres, on construit 8 variables qualitatives contenant chacune une des lettres de la séquence.

Clived v1 v2 v3 v4 v5 v6 v7 v8
1 S L N L R E T N
1 A E C F R I F D
1 H L V E A L Y L
1 T Q I M F E T F
1 A E E L A E I F
1 P F I F E E E P

2

On recode la variable cible Clived en un class factor valant 0 ou 1.

'data.frame':   1625 obs. of  9 variables:
 $ Clived: Factor w/ 2 levels "0","1": 2 2 2 2 2 2 2 2 2 2 ...
 $ v1    : Factor w/ 20 levels "A","C","D","E",..: 16 1 7 17 1 13 13 4 6 3 ...
 $ v2    : Factor w/ 20 levels "A","C","D","E",..: 10 4 10 14 4 5 8 17 6 1 ...
 $ v3    : Factor w/ 20 levels "A","C","D","E",..: 12 2 18 8 4 8 18 17 18 8 ...
 $ v4    : Factor w/ 20 levels "A","C","D","E",..: 10 5 4 11 10 5 6 1 20 12 ...
 $ v5    : Factor w/ 20 levels "A","C","D","E",..: 15 15 1 5 1 4 1 10 1 17 ...
 $ v6    : Factor w/ 20 levels "A","C","D","E",..: 4 8 10 4 4 4 4 18 17 4 ...
 $ v7    : Factor w/ 20 levels "A","C","D","E",..: 17 5 20 17 8 4 17 2 15 5 ...
 $ v8    : Factor w/ 20 levels "A","C","D","E",..: 12 3 10 5 5 13 5 3 16 9 ...

3

La proportion d’octamères clivés :

4

On partionne la base en deux parties : entrainement \(75\)% et test \(25\)%, on utilise la fonction createDataPartition du package caret

5

On construit le meilleur classifieur naif constant à partir de la base d’apprentissage ( ie attribue à toutes observation la même classe dominante)

le taux d’erreur sur la base de test correspond à la proportion de la classe 1 présente dans la base :

[1] 0.2296296

Arbres de décision CART

Comme les arbres CART sont à la base de la plupart des méthodes ensemblistes, on commence par étudier les performances obtenues sur un arbre individuel.

6

On construit une fonction qui prend en entrée un vecteur de prédictions ypred (sous la forme 0 ou 1) et un vecteur contenant les vraies classes yobs, et qui calcule le taux d’erreur associé.

7

On construit un arbre de décision avec la fonction rpart, en gardant les réglages par défaut.

On calcule le taux d’erreur sur la base de test.

[1] 0.07407407

Le taux d’erreur est de 0.0741 !

8

On construit un arbre de décision profond, en modifiant les options maxdepth, minbucket et cp.

On calcule ensuite le taux d’erreur sur la base de test.

[1] 0.08395062

Le taux d’erreur est de 0.084 !

9

On construit un arbre de décision de niveau 1 (avec seulement 1 noeud)

On calcule le taux d’erreur sur la base de test.

[1] 0.2222222

Le taux d’erreur est de 0.2222 !

9

10

En constate que l’arbre de niveau 1 est le mois précis de tous, qui au final n’utilise qu’une seule variable (qui correspond à la quatrième lettre de la séquence d’acide aminé : v4) et donc n’apprend pas suffisament, puis l’arbre profond qui au contraire se colle aux donnée de la base d’apprentissage : d’où le risque de sur-apprentissage, finalement le meilleur modèle est l’arbre par défaut avec le paramètrage par défaut.

Bagging

Le bagging permet de réduire la variance d’un classifieur par aggrégation. Il est donc particulièrement adapté lorsque le classifieur de base a un faible biais et une forte variance. Nous allons tester (vérifier) cette propriété.

Principe et algorithme : Soit \(Y\) une variable à expliquer quantitative ou qualitative, \(X^1, ... , X^p\) les variables explicatives et \(f(x)\) un modèle fonction de \(x = {x^1, . . . , x^p} ∈ \mathbb{R}^p\). On note \(n\) le nombre d’observations et \[z = \{(x_1, y_1), . . . ,(x_n, y_n)\}\] un échantillon de loi \(F\).

Considérant \(B\) échantillons indépendants notés \(\{z_b\}_{b=1,B}\), une prévision par agrégation de modèles est définie ci-dessous dans le cas où la variable à expliquer \(Y\) est :

  • quantitative : \(\hat{f}_B(.) = \frac{1}{B} \sum_{b=1}^B \hat{f}_{z_b}(.)\) ,
  • qualitative : \(\hat{f}_B(.) = arg \quad max_j \quad card\{b | \hat{f}_{z_b}(.)=j \}\)

Dans le premier cas, il s’agit d’une simple moyenne des résultats obtenus pour les modèles associés à chaque échantillon, dans le deuxième, un comité de modèles est constitué pour voter et élire la réponse la plus probable. Dans ce dernier cas, si le modèle retourne des probabilités associées à chaque modalité comme en régression logistique ou avec les arbres de décision, il est aussi simple de calculer des moyennes de ces probabilités.

Le principe est élémentaire, moyenner les prévisions de plusieurs modèles indépendants permet de réduire la variance et donc de réduire l’erreur de prévision.

Cependant, il n’est pas réaliste de considérer \(B\) échantillons indépendants.

Cela nécessiterait généralement trop de données. Ces échantillons sont donc remplacés par \(B\) réplications d’échantillons bootstrap obtenus chacun par n tirages avec remise selon la mesure empirique \(\hat F\). Ceci conduit à l’algorithme ci-dessous.

Algorithm : Bagging

Soit \(x_0\) à prévoir et
\(z = \{(x_1, y_1), . . . ,(x_n, y_n)\}\) un échantillon
> for \(b=1\) à \(B\) do

  • Tirer un échantillon bootstrap \(z^*_b\)
  • Estimer \(\hat{f}_{z_b}(x_0)\) sur l’échantillon bootstrap.

end for

Calculer l’estimation moyenne \(\hat{f}_B(x_0) = \frac{1}{B} \sum_{b=1}^B \hat{f}_{z_b}(x_0)\) ou le résultat du vote.

11

On charge le package adabag

12

On construit un modèle de bagging à l’aide de la fonction bagging avec mfinal\(=20\) arbres, en laissant les autres réglages par défaut.

On calcule le taux d’erreur sur la base de test.

Le taux d’erreur est de 0.0494 !

13

On construit un modèle de bagging avec 20 arbres de décision à 1 noeud.

On calcule le taux d’erreur sur la base de test.

Le taux d’erreur est de 0.2222 !

14

On calcule le taux d’erreur sur la base de test.

Le taux d’erreur est de 0.0519 !

15

Comparons les taux d’erreur obtenus avec chaque méthode.

Le bagging avec des arbres à noeud unique va toujour fournir le même résultat car chacun des 20 arbre utilise (bagging utilise tous les variable pendant la recherche des variable discriminantes) la variable v4 (la plus discriminante).

On voit clairement l’améloiration apportée par le bagging sur la pérfomance du modèle profond!

On test maintenant l’effet du nombre d’arbres, en calculant le taux d’erreur moyen sur 10 répétitions du modèle profond, pour des valeurs de mfinal égales à 1, 2, 5, 10, 20 et 50.

R est un language vectorisé, on doit éviter au maximum les boucles for, dans ce cas on utilise la fonction sapply pour itérer une fonction sur un veceur de paramètres et replicate pour répéter 10 fois :

Forêts aléatoires:

Les forêts aléatoires sont un cas particulier d’algorithme de bagging appliqué aux arbres CART.

Le bagging est appliqué à des arbres binaires de décision en ajoutant un tirage aléatoire de \(m\) variables explicatives parmi les \(p\)

Algorithm : Forêts Aléatoires

Soit \(x_0\) à prévoir et
\(z = \{(x_1, y_1), . . . ,(x_n, y_n)\}\) un échantillon
> for \(b=1\) à \(B\) do

  • Tirer un échantillon bootstrap \(z^*_b\)
  • Estimer un arbre sur cet échantillon avec randomisation des variables

end for

Calculer l’estimation moyenne \(\hat{f}_B(x_0) = \frac{1}{B} \sum_{b=1}^B \hat{f}_{z_b}(x_0)\) ou le résultat du vote.

Nous allons tester l’effet des différents réglages de l’algorithme. On a vu en cours que la pratique consistait à choisir des arbres profonds et un valeur “faible” du nombre de variables utilisées pour construire chaque arbre.

16

On charge le package randomForest qui ne fait qu’interfacer le programme original développé en Fortran par Léo Breiman et Adele Cutler

17

la valeur optimal de mtry\(=\) 2, on voit clairemet l’impact de nomrbre de variables aléatoires choisit pendant la construction de chaque arbre, un faible nombre implique des arbres qui sont peu corrélés ce qui entraîne une baisse de la variance globale après aggrégation.

18

On va maintenant tester l’effet du nombre d’arbres en traçant l’évolution du taux d’erreur moyen calculé sur \(10\) forêts aléatoires, chacune construite avec la valeur optimale de mtry\(=2\), en fonction de ntree, avec ntree égal à 1, 2, 5, 10, 20, 50, 100, 200 ou 500.

Boosting

On s’intéresse maintenant aux méthodes de boosting, qui contrairement aux méthodes de bagging, ne construisent pas des arbres de décision en parallèle, mais de façon séquentielle, chaque arbre se concentrant d’avantage sur les individus les moins bien classés par l’arbre précédent. Ces méthodes fonctionnent bien lorsque les classifieurs sont faibles (fort biais et donc fort variance).

AdaBoost:

Dans la version originelle de l’algorithme Adaboost, chaque observation est pondérée par un poids \(w_i\) , et aucune source d’aléa n’est introduite contrairement aux méthodes de bagging. Les résultats de l’algorithme sont donc déterministes : si on lance plusieurs fois la méthode sur le même jeu de données, on obtient exactement les mêmes résultats.

19

On construit un modèle basé sur l’algorithme Adaboost, avec 20 itérations :

Son taux d’erreur est : 0.0568

20

On construit le même modèle mais cette fois à 1 noeud

21

On fait de même en utilisant cette fois des arbres de décision profonds.

22

Comparaison : Boosting vs Bagging

XGBoost:

XGBoost n’est pas une méthode spécifique, mais une implémentation efficace des méthodes du gradient boosting. Sous R, cette librairie est disponible dans le package xgboost. Ce package fonctionne un peu différemment des précédents, et a sa propre syntaxe.

23

On charge le package xgboost

24

L’encodage one-hot:

25

Création de deux objets contenant respictivement la base d’apprentissage etla base de test

26

Application d’algorithme de gradient boosting adapté à la classification binaire avec un nombre des iteration \(nrounds=20\)

le taux d’erreur

[1] 0.07160494

27

Test de l’effet des paramètres l’algorithme :

  • On évalue l’effet du paramètre maxdepth:
  • eta le taux d’apprentissage en gardant la valuer optimale de max_depth précedente

Bonus: On peut evaluer les combinaisons des deux paramètres avec une grille de recherche ( grid search)pour trouver la combinaison optimale.

( ⚠️ ce calcul peut etre lent en fonction de la machine la cellule est désactivée dans ce notebook)

Conclusion

En conclusion on présente les performences des différents modèles qu’on a testé :

On selectionne le meilleur algorithme pour réaliser des prédistions sur la nouvelle base 746Data

Clived v1 v2 v3 v4 v5 v6 v7 v8
0 A A A K F E R Q
0 A A A M K R H G
0 A A A M S S A I
0 A A K F E R Q H
0 A A K F E S N F
0 A A M K R H G L

On calcule ensuite le taux d’erreur de notre modèle :

[1] 0.04959786

Pour finir, deux types d’algorithmes ont été abordés. Ceux reposants sur une construction aléatoires d’une famille de modèles : bagging pour bootstrap aggregating (Breiman 1996) et les forêts aléatoires (random forests) de Breiman (2001) qui propose une amélioration du bagging spécifique aux modèles définis par des arbres binaires (CART).
Ceux basés sur le boosting (Freundet Shapiro,1996) et qui reposent sur une construction adaptative, déterministe ou aléatoire, d’une famille de modèles. Ces algorithmes se sont développés à la frontière entre apprentissage machine ( machine learning ) et Statistique.

Les principes du bagging ou du boosting s’appliquent à toute méthode de modélisation (régression, CART, réseaux de neurones) mais n’ont d’intérêt, et réduisent sensiblement l’erreur de prévision, que dans le cas de modèles instables. Ils sont surtout mis en œuvre en association avec des arbres binaires comme modèles de base. En effet, l’instabilité déjà soulignés des arbres apparaît alors comme une propriété nécessaire à la réduction de la variance par agrégation de modèles.