Tutoriel sur les forêts aléatoires en R : algorithme et exemple

Qu’est-ce que la forêt aléatoire dans R ?

Les forêts aléatoires reposent sur une idée simple : « la sagesse de la foule ». L’agrégation des résultats de plusieurs prédicteurs donne une meilleure prédiction que le meilleur prédicteur individuel. Un groupe de prédicteurs est appelé un ensemble. Ainsi, cette technique est appelée Apprentissage d'ensemble.

Dans un tutoriel précédent, vous avez appris à utiliser arbres de décision faire une prédiction binaire. Pour améliorer notre technique, nous pouvons former un groupe de Classificateurs d'arbre de décision, chacun sur un sous-ensemble aléatoire différent de l'ensemble d'entraînement. Pour faire une prédiction, on collecte les prédictions de tous les arbres individuels et on renvoie la classe qui reçoit le plus de votes. Cette technique est appelée Forêt aléatoire.

Avant d'écrire la moindre ligne de code, il est utile de voir précisément comment la forêt est assemblée à partir de ces arbres individuels.

Comment fonctionne la méthode Random Forest dans R ?

Comprendre les mécanismes permet de mieux appréhender chaque paramètre de réglage. Une forêt aléatoire est construite en quatre étapes.

1. Bootstrap échantillonnage. L'algorithme tire un échantillon aléatoire de lignes. avec remplacement Pour chaque arbre, on extrait de l'ensemble d'entraînement environ un tiers des lignes de chaque échantillon ; il s'agit des observations hors échantillon (OOB).
2. Sélection aléatoire de fonctionnalités. À chaque division, seul un sous-ensemble aléatoire de prédicteurs est pris en compte. La taille de ce sous-ensemble est le mtry Ce paramètre permet d'éviter que tous les arbres ne se ressemblent.
3. Croissance des arbres non taillés. Chaque arbre pousse jusqu'à ce qu'il s'arrête.ping règle telle que nœuds max or taille du nœudOn laisse délibérément chaque arbre sur-apprendre, car ses erreurs ne sont pas corrélées.
4. Agrégation. Pour la classification, la forêt renvoie la classe ayant le plus de votes ; pour la régression, elle renvoie la prédiction moyenne. Cette étape de moyennage correspond à ce que le terme ensachage (agrégation par bootstrap) décrit.

L'échantillonnage par lignes et par colonnes est la clé du succès. Un arbre profond isolé présente un faible biais et une variance très élevée ; la moyenne de centaines d'arbres permet de maintenir un faible biais tout en réduisant la variance.

Erreur de sortie de sac. Comme chaque observation est exclue d'environ un tiers des arbres, R peut évaluer chaque ligne en utilisant uniquement les arbres qui ne l'ont jamais vue. L'erreur OOB qui en résulte est une estimation de validation intégrée et gratuite, fournie par randomForest().

rf_oob <- randomForest(survived~., data = data_train, ntree = 800, mtry = 4)
print(rf_oob)   # reports the OOB estimate of error rate

L'erreur OOB est une vérification rapide pratique, mais ce tutoriel utilise une validation croisée à dix plis via caret afin que chaque grille de réglage soit comparée sur des plis identiques.

Forêt aléatoire vs arbre de décision dans R

Une forêt aléatoire est un ensemble de forêts aléatoires identiques. arbres de décision Ces différences ont été abordées dans le tutoriel précédent ; il est donc important de les énoncer clairement avant de faire votre choix.

Choisissez un arbre unique lorsque vous devez expliquer le processus de décision à un public non spécialisé. Privilégiez une forêt lorsque la précision des prédictions prime sur la lisibilité du diagramme.

Avantages et inconvénients de la forêt aléatoire

Savoir où l'algorithme est fort et où il est faible permet de déterminer à quel moment les efforts de réglage à venir valent la peine d'être entrepris.

Avantages

• Précision sans élagage : La moyenne de nombreux arbres non corrélés donne d'excellents résultats avec très peu de réglages manuels.
• Résistant au surajustement : L'ajout d'arbres supplémentaires n'augmente jamais l'erreur de généralisation, donc la valeur de ntree peut être augmentée sans risque.
• Gère les données mixtes : Les prédicteurs numériques et factoriels fonctionnent de concert, et la mise à l'échelle est inutile.
• Validation et classement gratuits : L'erreur OOB et varImp() n'entraînent aucun coût de calcul supplémentaire.

Désavantages

• Prédictions opaques : vous ne pouvez pas tracchaque voie de décision unique, ce qui est important dans les environnements réglementés.
• Ralentissez dans les grandes forêts : Le temps d'entraînement et de prédiction évolue linéairement avec le nombre d'arbres.
• Scores d'importance biaisés : Les variables catégorielles à plusieurs niveaux peuvent paraître plus importantes qu'elles ne le sont réellement.
• Extrapolation faible : Pour la régression, la forêt ne peut jamais prédire en dehors de la plage observée lors de l'entraînement.

Une fois la théorie et les compromis établis, les six étapes suivantes consistent à construire, optimiser et évaluer de bout en bout une forêt aléatoire sur l'ensemble de données de survie du Titanic.

Étape 1) Importez les données

Pour vous assurer que vous disposez du même ensemble de données que dans le didacticiel pour arbres de décisionLes ensembles d'entraînement et de test sont hébergés en ligne. Vous pouvez les importer sans aucune modification.

library(dplyr)
data_train <- read.csv("https://raw.githubusercontent.com/guru99-edu/R-Programming/master/train.csv")
glimpse(data_train)
data_test <- read.csv("https://raw.githubusercontent.com/guru99-edu/R-Programming/master/test.csv") 
glimpse(data_test)

Étape 2) Entraîner le modèle

Une façon d'évaluer les performances d'un modèle consiste à l'entraîner sur plusieurs petits ensembles de données différents et à les évaluer sur un autre petit ensemble de test. C'est ce qu'on appelle validation croisée k-fold. R Cette fonction divise aléatoirement les données en k sous-ensembles de taille quasi identique. Par exemple, si k = 10, le modèle est entraîné sur neuf sous-ensembles et évalué sur le sous-ensemble restant. Ce processus est répété jusqu'à ce que tous les sous-ensembles aient été évalués. Cette technique est largement utilisée pour la sélection de modèles, notamment lorsque le modèle comporte des paramètres à optimiser.

Maintenant que nous avons un moyen d'évaluer notre modèle, nous devons déterminer quels paramètres se généralisent le mieux à des données non observées.

La forêt aléatoire choisit un sous-ensemble aléatoire de fonctionnalités et crée de nombreux arbres de décision. Le modèle fait la moyenne de toutes les prédictions des arbres de décision.

La méthode des forêts aléatoires possède des paramètres modifiables pour améliorer la généralisation des prédictions. Vous utiliserez la fonction `randomForest()` pour entraîner le modèle.

La syntaxe de randomForest() est :

randomForest(formula, ntree=n, mtry=FALSE, maxnodes = NULL)
Arguments:
- Formula: Formula of the fitted model
- ntree: number of trees in the forest
- mtry: Number of candidate variables drawn at each split. By default, it is the square root of the number of predictors for classification.
- maxnodes: Set the maximum number of terminal nodes each tree can have
- importance=TRUE: Whether independent variables importance in the random forest be assessed

Note: La forêt aléatoire peut être entraînée sur plus de paramètres. Vous pouvez vous référer au vignette pour voir les différents paramètres.

Le réglage d'un modèle est un travail fastidieux. Les combinaisons de paramètres possibles sont nombreuses et il n'est pas toujours possible de toutes les tester. Une bonne alternative consiste à laisser la machine trouver la meilleure combinaison. Deux méthodes sont disponibles :

• Recherche aléatoire
• Recherche de grille

Les deux méthodes sont définies ci-dessous, mais ce tutoriel entraîne le modèle en utilisant la recherche par grille.

Définition de la recherche en grille

La méthode de recherche par grille est simple, le modèle sera évalué sur toute la combinaison que vous transmettez dans la fonction, par validation croisée.

Par exemple, vous souhaitez essayer le modèle avec 10, 20, 30 arbres et chaque arbre sera testé sur un nombre de mètres égal à 1, 2, 3, 4, 5. Ensuite, la machine testera 15 modèles différents :

    .mtry ntrees
 1      1     10
 2      2     10
 3      3     10
 4      4     10
 5      5     10
 6      1     20
 7      2     20
 8      3     20
 9      4     20
 10     5     20
 11     1     30
 12     2     30
 13     3     30
 14     4     30
 15     5     30	

L'algorithme évaluera :

randomForest(formula, ntree=10, mtry=1)
randomForest(formula, ntree=10, mtry=2)
randomForest(formula, ntree=10, mtry=3)
randomForest(formula, ntree=20, mtry=2)
...

Chaque combinaison est évaluée par validation croisée. L'inconvénient de la recherche par grille réside dans le nombre d'expériences : celui-ci augmente de façon exponentielle lorsque le nombre de combinaisons est élevé. Pour pallier ce problème, on peut recourir à une recherche aléatoire.

Définition de la recherche aléatoire

La principale différence entre la recherche aléatoire et la recherche par grille réside dans le fait que la recherche aléatoire n'évalue pas toutes les combinaisons d'hyperparamètres de l'espace de recherche. Au lieu de cela, elle choisit une combinaison au hasard à chaque itération. L'avantage est un coût de calcul bien moindre.

Définir le paramètre de contrôle

Vous procéderez comme suit pour construire et évaluer le modèle :

• Évaluer le modèle avec le paramètre par défaut
• Trouver le meilleur nombre de mtry
• Trouver le meilleur nombre de maxnodes
• Trouver le meilleur nombre d'arbres
• Évaluer le modèle sur l'ensemble de données de test

Avant de commencer l'exploration des paramètres, vous devez installer deux bibliothèques.

• caret : bibliothèque d'apprentissage automatique R. Si tu as installer R avec r-essentiel. Il est déjà dans la bibliothèque
  • Anaconda: conda install -cr r-caret
• e1071 : bibliothèque d’apprentissage automatique R.
  • Anaconda: conda install -cr r-e1071

Vous pouvez les importer avec randomForest :

library(randomForest)
library(caret)
library(e1071)

Paramètres par défaut

La validation croisée K-fold est contrôlée par la fonction trainControl()

trainControl(method = "cv", number = n, search ="grid")
arguments
- method = "cv": The method used to resample the dataset. 
- number = n: Number of folds to create
- search = "grid": Use the grid search method. For the randomized method, use "random"
Note: You can refer to the vignette to see the other arguments of the function.

Vous pouvez essayer d'exécuter le modèle avec les paramètres par défaut et voir le score de précision.

Note: Vous utiliserez les mêmes commandes pendant tout le tutoriel.

# Define the control
trControl <- trainControl(method = "cv",
    number = 10,
    search = "grid")

Vous utiliserez la bibliothèque caret pour évaluer votre modèle. La bibliothèque a une fonction appelée train() pour évaluer presque tout machine learning algorithme. Autrement dit, vous pouvez utiliser cette fonction pour entraîner d’autres algorithmes.

La syntaxe de base est:

train(formula, df, method = "rf", metric= "Accuracy", trControl = trainControl(), tuneGrid = NULL)
argument
- `formula`: Define the formula of the algorithm
- `method`: Define which model to train. Note, at the end of the tutorial, there is a list of all the models that can be trained
- `metric` = "Accuracy": Define how to select the optimal model
- `trControl = trainControl()`: Define the control parameters
- `tuneGrid = NULL`: Return a data frame with all the possible combination

Construisons le modèle avec les valeurs par défaut.

set.seed(1234)
# Run the model
rf_default <- train(survived~.,
    data = data_train,
    method = "rf",
    metric = "Accuracy",
    trControl = trControl)
# Print the results
print(rf_default)

Code Explication

• trainControl(method="cv", number=10, search="grid") : Évalue le modèle avec une recherche par grille sur 10 plis
• train(…) : Entraîner un modèle de forêt aléatoire. Le meilleur modèle est choisi avec la mesure de précision.

Sortie :

## Random Forest 
## 
## 836 samples
##   7 predictor
##   2 classes: 'No', 'Yes' 
## 
## No pre-processing
## Resampling: Cross-Validated (10 fold) 
## Summary of sample sizes: 753, 752, 753, 752, 752, 752, ... 
## Resampling results across tuning parameters:
## 
##   mtry  Accuracy   Kappa    
##    2    0.7919248  0.5536486
##    6    0.7811245  0.5391611
##   10    0.7572002  0.4939620
## 
## Accuracy was used to select the optimal model using  the largest value.
## The final value used for the model was mtry = 2.

L'algorithme utilise 500 arbres et a testé trois valeurs différentes de mtry : 2, 6, 10.

La valeur finale utilisée pour le modèle était mtry = 2, avec une précision de validation croisée de 0.792. Essayons d'obtenir un score plus élevé.

Recherchez le meilleur mtry

Vous pouvez tester le modèle avec des valeurs de mtry de 1 à 10

set.seed(1234)
tuneGrid <- expand.grid(.mtry = c(1: 10))
rf_mtry <- train(survived~.,
    data = data_train,
    method = "rf",
    metric = "Accuracy",
    tuneGrid = tuneGrid,
    trControl = trControl,
    importance = TRUE,
    nodesize = 14,
    ntree = 300)
print(rf_mtry)

Code Explication

• tuneGrid <- expand.grid(.mtry = c(1:10)): Construire un vecteur avec des valeurs de 1 à 10

Sortie :

## Random Forest 
## 
## 836 samples
##   7 predictor
##   2 classes: 'No', 'Yes' 
## 
## No pre-processing
## Resampling: Cross-Validated (10 fold) 
## Summary of sample sizes: 753, 752, 753, 752, 752, 752, ... 
## Resampling results across tuning parameters:
## 
##   mtry  Accuracy   Kappa    
##    1    0.7572576  0.4647368
##    2    0.7979346  0.5662364
##    3    0.8075158  0.5884815
##    4    0.8110729  0.5970664
##    5    0.8074727  0.5900030
##    6    0.8099111  0.5949342
##    7    0.8050918  0.5866415
##    8    0.8050918  0.5855399
##    9    0.8050631  0.5855035
##   10    0.7978916  0.5707336
## 
## Accuracy was used to select the optimal model using  the largest value.
## The final value used for the model was mtry = 4.

La valeur optimale de mtry est 4. Elle est stockée dans :

rf_mtry$bestTune$mtry

Vous pouvez le stocker et l'utiliser lorsque vous devez régler les autres paramètres.

max(rf_mtry$results$Accuracy)

Sortie :

## [1] 0.8110729

best_mtry <- rf_mtry$bestTune$mtry 
best_mtry

Sortie :

## [1] 4

Étape 3) Recherchez les meilleurs maxnodes

Vous devez créer une boucle pour évaluer les différentes valeurs de maxnodes. Dans le code suivant, vous allez :

• Créer une liste
• Créez une variable avec la meilleure valeur du paramètre mtry ; Obligatoire
• Créer la boucle
• Stocker la valeur actuelle de maxnode
• Résumer les résultats

store_maxnode <- list()
tuneGrid <- expand.grid(.mtry = best_mtry)
for (maxnodes in c(5: 15)) {
    set.seed(1234)
    rf_maxnode <- train(survived~.,
        data = data_train,
        method = "rf",
        metric = "Accuracy",
        tuneGrid = tuneGrid,
        trControl = trControl,
        importance = TRUE,
        nodesize = 14,
        maxnodes = maxnodes,
        ntree = 300)
    current_iteration <- toString(maxnodes)
    store_maxnode[[current_iteration]] <- rf_maxnode
}
results_mtry <- resamples(store_maxnode)
summary(results_mtry)

Code explication:

• store_maxnode <- list() : Les résultats du modèle seront stockés dans cette liste
• expand.grid(.mtry=best_mtry) : utiliser la meilleure valeur de mtry
• for (maxnodes in c(5:15)) { … }: Calculer le modèle avec des valeurs de maxnodes de 5 à 15.
• maxnodes = maxnodes : À chaque itération, maxnodes est égal à la valeur de la boucle actuelle, c’est-à-dire 5, 6, 7, …
• current_iteration <- toString(maxnodes): Stocke la valeur de maxnodes sous forme de chaîne de caractères.
• store_maxnode[[current_iteration]] <- rf_maxnode: Enregistre le résultat du modèle dans la liste.
• resamples(store_maxnode) : Organiser les résultats du modèle
• summary(results_mtry) : Imprime le résumé de toutes les combinaisons.

Sortie :

## 
## Call:
## summary.resamples(object = results_mtry)
## 
## Models: 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 
## Number of resamples: 10 
## 
## Accuracy 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 5  0.6785714 0.7529762 0.7903758 0.7799771 0.8168388 0.8433735    0
## 6  0.6904762 0.7648810 0.7784710 0.7811962 0.8125000 0.8313253    0
## 7  0.6904762 0.7619048 0.7738095 0.7788009 0.8102410 0.8333333    0
## 8  0.6904762 0.7627295 0.7844234 0.7847820 0.8184524 0.8433735    0
## 9  0.7261905 0.7747418 0.8083764 0.7955250 0.8258749 0.8333333    0
## 10 0.6904762 0.7837780 0.7904475 0.7895869 0.8214286 0.8433735    0
## 11 0.7023810 0.7791523 0.8024240 0.7943775 0.8184524 0.8433735    0
## 12 0.7380952 0.7910929 0.8144005 0.8051205 0.8288511 0.8452381    0
## 13 0.7142857 0.8005952 0.8192771 0.8075158 0.8403614 0.8452381    0
## 14 0.7380952 0.7941050 0.8203528 0.8098967 0.8403614 0.8452381    0
## 15 0.7142857 0.8000215 0.8203528 0.8075301 0.8378873 0.8554217    0
## 
## Kappa 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 5  0.3297872 0.4640436 0.5459706 0.5270773 0.6068751 0.6717371    0
## 6  0.3576471 0.4981484 0.5248805 0.5366310 0.6031287 0.6480921    0
## 7  0.3576471 0.4927448 0.5192771 0.5297159 0.5996437 0.6508314    0
## 8  0.3576471 0.4848320 0.5408159 0.5427127 0.6200253 0.6717371    0
## 9  0.4236277 0.5074421 0.5859472 0.5601687 0.6228626 0.6480921    0
## 10 0.3576471 0.5255698 0.5527057 0.5497490 0.6204819 0.6717371    0
## 11 0.3794326 0.5235007 0.5783191 0.5600467 0.6126720 0.6717371    0
## 12 0.4460432 0.5480930 0.5999072 0.5808134 0.6296780 0.6717371    0
## 13 0.4014252 0.5725752 0.6087279 0.5875305 0.6576219 0.6678832    0
## 14 0.4460432 0.5585005 0.6117973 0.5911995 0.6590982 0.6717371    0
## 15 0.4014252 0.5689401 0.6117973 0.5867010 0.6507194 0.6955990    0

La meilleure précision moyenne dans cette plage (0.8099) est obtenue pour maxnodes = 14, en haut de l'intervalle testé. Comme la valeur optimale se situe à la limite de la grille, il convient d'étendre la recherche vers le haut.

store_maxnode <- list()
tuneGrid <- expand.grid(.mtry = best_mtry)
for (maxnodes in c(20: 30)) {
    set.seed(1234)
    rf_maxnode <- train(survived~.,
        data = data_train,
        method = "rf",
        metric = "Accuracy",
        tuneGrid = tuneGrid,
        trControl = trControl,
        importance = TRUE,
        nodesize = 14,
        maxnodes = maxnodes,
        ntree = 300)
    key <- toString(maxnodes)
    store_maxnode[[key]] <- rf_maxnode
}
results_node <- resamples(store_maxnode)
summary(results_node)

Sortie :

## 
## Call:
## summary.resamples(object = results_node)
## 
## Models: 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 
## Number of resamples: 10 
## 
## Accuracy 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 20 0.7142857 0.7821644 0.8144005 0.8075301 0.8447719 0.8571429    0
## 21 0.7142857 0.8000215 0.8144005 0.8075014 0.8403614 0.8571429    0
## 22 0.7023810 0.7941050 0.8263769 0.8099254 0.8328313 0.8690476    0
## 23 0.7023810 0.7941050 0.8263769 0.8111302 0.8447719 0.8571429    0
## 24 0.7142857 0.7946429 0.8313253 0.8135112 0.8417599 0.8690476    0
## 25 0.7142857 0.7916667 0.8313253 0.8099398 0.8408635 0.8690476    0
## 26 0.7142857 0.7941050 0.8203528 0.8123207 0.8528758 0.8571429    0
## 27 0.7023810 0.8060456 0.8313253 0.8135112 0.8333333 0.8690476    0
## 28 0.7261905 0.7941050 0.8203528 0.8111015 0.8328313 0.8690476    0
## 29 0.7142857 0.7910929 0.8313253 0.8087063 0.8333333 0.8571429    0
## 30 0.6785714 0.7910929 0.8263769 0.8063253 0.8403614 0.8690476    0
## 
## Kappa 
##         Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 20 0.3956835 0.5316120 0.5961830 0.5854366 0.6661120 0.6955990    0
## 21 0.3956835 0.5699332 0.5960343 0.5853247 0.6590982 0.6919315    0
## 22 0.3735084 0.5560661 0.6221836 0.5914492 0.6422128 0.7189781    0
## 23 0.3735084 0.5594228 0.6228827 0.5939786 0.6657372 0.6955990    0
## 24 0.3956835 0.5600352 0.6337821 0.5992188 0.6604703 0.7189781    0
## 25 0.3956835 0.5530760 0.6354875 0.5912239 0.6554912 0.7189781    0
## 26 0.3956835 0.5589331 0.6136074 0.5969142 0.6822128 0.6955990    0
## 27 0.3735084 0.5852459 0.6368425 0.5998148 0.6426088 0.7189781    0
## 28 0.4290780 0.5589331 0.6154905 0.5946859 0.6356141 0.7189781    0
## 29 0.4070588 0.5534173 0.6337821 0.5901173 0.6423101 0.6919315    0
## 30 0.3297872 0.5534173 0.6202632 0.5843432 0.6590982 0.7189781    0

La meilleure précision moyenne, soit 0.8135, est obtenue avec maxnodes = 24 (maxnodes = 27 donne une moyenne identique, mais son troisième quartile est inférieur). Vous utiliserez donc maxnodes = 24 pour les étapes suivantes.

Étape 4) Recherchez les meilleurs ntrees

Maintenant que vous disposez de la meilleure valeur de mtry et maxnode, vous pouvez régler le nombre d'arbres. La méthode est exactement la même que celle de maxnode.

store_maxtrees <- list()
for (ntree in c(250, 300, 350, 400, 450, 500, 550, 600, 800, 1000, 2000)) {
    set.seed(5678)
    rf_maxtrees <- train(survived~.,
        data = data_train,
        method = "rf",
        metric = "Accuracy",
        tuneGrid = tuneGrid,
        trControl = trControl,
        importance = TRUE,
        nodesize = 14,
        maxnodes = 24,
        ntree = ntree)
    key <- toString(ntree)
    store_maxtrees[[key]] <- rf_maxtrees
}
results_tree <- resamples(store_maxtrees)
summary(results_tree)

Sortie :

## 
## Call:
## summary.resamples(object = results_tree)
## 
## Models: 250, 300, 350, 400, 450, 500, 550, 600, 800, 1000, 2000 
## Number of resamples: 10 
## 
## Accuracy 
##           Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 250  0.7380952 0.7976190 0.8083764 0.8087010 0.8292683 0.8674699    0
## 300  0.7500000 0.7886905 0.8024240 0.8027199 0.8203397 0.8452381    0
## 350  0.7500000 0.7886905 0.8024240 0.8027056 0.8277623 0.8452381    0
## 400  0.7500000 0.7886905 0.8083764 0.8051009 0.8292683 0.8452381    0
## 450  0.7500000 0.7886905 0.8024240 0.8039104 0.8292683 0.8452381    0
## 500  0.7619048 0.7886905 0.8024240 0.8062914 0.8292683 0.8571429    0
## 550  0.7619048 0.7886905 0.8083764 0.8099062 0.8323171 0.8571429    0
## 600  0.7619048 0.7886905 0.8083764 0.8099205 0.8323171 0.8674699    0
## 800  0.7619048 0.7976190 0.8083764 0.8110820 0.8292683 0.8674699    0
## 1000 0.7619048 0.7976190 0.8121510 0.8086723 0.8303571 0.8452381    0
## 2000 0.7619048 0.7886905 0.8121510 0.8086723 0.8333333 0.8452381    0
## 
## Kappa 
##           Min.   1st Qu.    Median      Mean   3rd Qu.      Max. NA's
## 250  0.4061697 0.5667400 0.5836013 0.5856103 0.6335363 0.7196807    0
## 300  0.4302326 0.5449376 0.5780349 0.5723307 0.6130767 0.6710843    0
## 350  0.4302326 0.5449376 0.5780349 0.5723185 0.6291592 0.6710843    0
## 400  0.4302326 0.5482030 0.5836013 0.5774782 0.6335363 0.6710843    0
## 450  0.4302326 0.5449376 0.5780349 0.5750587 0.6335363 0.6710843    0
## 500  0.4601542 0.5449376 0.5780349 0.5804340 0.6335363 0.6949153    0
## 550  0.4601542 0.5482030 0.5857118 0.5884507 0.6396872 0.6949153    0
## 600  0.4601542 0.5482030 0.5857118 0.5884374 0.6396872 0.7196807    0
## 800  0.4601542 0.5667400 0.5836013 0.5910088 0.6335363 0.7196807    0
## 1000 0.4601542 0.5667400 0.5961590 0.5857446 0.6343666 0.6678832    0
## 2000 0.4601542 0.5482030 0.5961590 0.5862151 0.6440678 0.6656337    0

Vous avez votre modèle final. Vous pouvez entraîner la forêt aléatoire avec les paramètres suivants :

• ntree = 800 : 800 arbres seront entraînés
• mtry = 4 : 4 caractéristiques candidates sont tirées à chaque division.
• maxnodes = 24 : Chaque arbre est limité à 24 nœuds terminaux (feuilles).

fit_rf <- train(survived~.,
    data_train,
    method = "rf",
    metric = "Accuracy",
    tuneGrid = tuneGrid,
    trControl = trControl,
    importance = TRUE,
    nodesize = 14,
    ntree = 800,
    maxnodes = 24)

Étape 5) Évaluer le modèle

Le curseur de bibliothèque a pour fonction de faire des prédictions.

predict(model, newdata= df)
argument
- `model`: Define the model evaluated before. 
- `newdata`: Define the dataset to make prediction

prediction <-predict(fit_rf, data_test)

Vous pouvez utiliser la prédiction pour calculer la matrice de confusion et voir le score de précision

confusionMatrix(prediction, data_test$survived)

Sortie :

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction  No Yes
##        No  110  32
##        Yes  11  56
##                                          
##                Accuracy : 0.7943         
##                  95% CI : (0.733, 0.8469)
##     No Information Rate : 0.5789         
##     P-Value [Acc > NIR] : 3.959e-11      
##                                          
##                   Kappa : 0.5638         
##  Mcnemar's Test P-Value : 0.002289       
##                                          
##             Sensitivity : 0.9091         
##             Specificity : 0.6364         
##          Pos Pred Value : 0.7746         
##          Neg Pred Value : 0.8358         
##              Prevalence : 0.5789         
##          Detection Rate : 0.5263         
##    Detection Prevalence : 0.6794         
##       Balanced Accuracy : 0.7727         
##                                          
##        'Positive' Class : No             
## 

Le modèle atteint une précision de 0.7943, soit 79.43 % sur l'ensemble de test non utilisé pour l'entraînement, ce qui est supérieur à la configuration par défaut. Sa sensibilité est de 0.9091 et sa spécificité de 0.6364 ; le modèle identifie donc les patients décédés avec une fiabilité bien supérieure à celle des survivants.

Étape 6) Visualiser le résultat

Enfin, vous pouvez examiner l'importance des caractéristiques avec la fonction `varImp()`. Les caractéristiques les plus importantes sont le sexe et l'âge. Cela n'est pas surprenant, car les caractéristiques importantes ont tendance à se situer près de la racine de l'arbre, tandis que les caractéristiques moins importantes se trouvent généralement près des feuilles.

varImp(fit_rf)

Sortie :

## rf variable importance
## 
##              Importance
## sexmale         100.000
## age              28.014
## pclassMiddle     27.016
## fare             21.557
## pclassUpper      16.324
## sibsp            11.246
## parch             5.522
## embarkedC         4.908
## embarkedQ         1.420
## embarkedS         0.000		

Forêt aléatoire dans R : Guide rapide des fonctions

Le tableau ci-dessous répertorie chaque fonction utilisée au cours des six étapes, le package qui la fournit et les paramètres qu'elle attend.

Annexe : Modèles disponibles chez caret

La fonction `train()` peut s'adapter à bien plus de modèles que les forêts aléatoires. Exécutez la commande ci-dessous pour afficher tous les identifiants de modèles pris en charge par `caret`, puis transmettez-en un à l'argument de la méthode.

names(getModelInfo())

Sortie :

##   [1] "ada"                 "AdaBag"              "AdaBoost.M1"        ##   [4] "adaboost"            "amdai"               "ANFIS"              ##   [7] "avNNet"              "awnb"                "awtan"              ##  [10] "bag"                 "bagEarth"            "bagEarthGCV"        ##  [13] "bagFDA"              "bagFDAGCV"           "bam"                ##  [16] "bartMachine"         "bayesglm"            "binda"              ##  [19] "blackboost"          "blasso"              "blassoAveraged"     ##  [22] "bridge"              "brnn"                "BstLm"              ##  [25] "bstSm"               "bstTree"             "C5.0"               ##  [28] "C5.0Cost"            "C5.0Rules"           "C5.0Tree"           ##  [31] "cforest"             "chaid"               "CSimca"             ##  [34] "ctree"               "ctree2"              "cubist"             ##  [37] "dda"                 "deepboost"           "DENFIS"             ##  [40] "dnn"                 "dwdLinear"           "dwdPoly"            ##  [43] "dwdRadial"           "earth"               "elm"                ##  [46] "enet"                "evtree"              "extraTrees"         ##  [49] "fda"                 "FH.GBML"             "FIR.DM"             ##  [52] "foba"                "FRBCS.CHI"           "FRBCS.W"            ##  [55] "FS.HGD"              "gam"                 "gamboost"           ##  [58] "gamLoess"            "gamSpline"           "gaussprLinear"      ##  [61] "gaussprPoly"         "gaussprRadial"       "gbm_h3o"            ##  [64] "gbm"                 "gcvEarth"            "GFS.FR.MOGUL"       ##  [67] "GFS.GCCL"            "GFS.LT.RS"           "GFS.THRIFT"         ##  [70] "glm.nb"              "glm"                 "glmboost"           ##  [73] "glmnet_h3o"          "glmnet"              "glmStepAIC"         ##  [76] "gpls"                "hda"                 "hdda"               ##  [79] "hdrda"               "HYFIS"               "icr"                ##  [82] "J48"                 "JRip"                "kernelpls"          ##  [85] "kknn"                "knn"                 "krlsPoly"           ##  [88] "krlsRadial"          "lars"                "lars2"              ##  [91] "lasso"               "lda"                 "lda2"               ##  [94] "leapBackward"        "leapForward"         "leapSeq"            ##  [97] "Linda"               "lm"                  "lmStepAIC"          ## [100] "LMT"                 "loclda"              "logicBag"           ## [103] "LogitBoost"          "logreg"              "lssvmLinear"        ## [106] "lssvmPoly"           "lssvmRadial"         "lvq"                ## [109] "M5"                  "M5Rules"             "manb"               ## [112] "mda"                 "Mlda"                "mlp"                ## [115] "mlpKerasDecay"       "mlpKerasDecayCost"   "mlpKerasDropout"    ## [118] "mlpKerasDropoutCost" "mlpML"               "mlpSGD"             ## [121] "mlpWeightDecay"      "mlpWeightDecayML"    "monmlp"             ## [124] "msaenet"             "multinom"            "mxnet"              ## [127] "mxnetAdam"           "naive_bayes"         "nb"                 ## [130] "nbDiscrete"          "nbSearch"            "neuralnet"          ## [133] "nnet"                "nnls"                "nodeHarvest"        ## [136] "null"                "OneR"                "ordinalNet"         ## [139] "ORFlog"              "ORFpls"              "ORFridge"           ## [142] "ORFsvm"              "ownn"                "pam"                ## [145] "parRF"               "PART"                "partDSA"            ## [148] "pcaNNet"             "pcr"                 "pda"                ## [151] "pda2"                "penalized"           "PenalizedLDA"       ## [154] "plr"                 "pls"                 "plsRglm"            ## [157] "polr"                "ppr"                 "PRIM"               ## [160] "protoclass"          "pythonKnnReg"        "qda"                ## [163] "QdaCov"              "qrf"                 "qrnn"               ## [166] "randomGLM"           "ranger"              "rbf"                ## [169] "rbfDDA"              "Rborist"             "rda"                ## [172] "regLogistic"         "relaxo"              "rf"                 ## [175] "rFerns"              "RFlda"               "rfRules"            ## [178] "ridge"               "rlda"                "rlm"                ## [181] "rmda"                "rocc"                "rotationForest"     ## [184] "rotationForestCp"    "rpart"               "rpart1SE"           ## [187] "rpart2"              "rpartCost"           "rpartScore"         ## [190] "rqlasso"             "rqnc"                "RRF"                ## [193] "RRFglobal"           "rrlda"               "RSimca"             ## [196] "rvmLinear"           "rvmPoly"             "rvmRadial"          ## [199] "SBC"                 "sda"                 "sdwd"               ## [202] "simpls"              "SLAVE"               "slda"               ## [205] "smda"                "snn"                 "sparseLDA"          ## [208] "spikeslab"           "spls"                "stepLDA"            ## [211] "stepQDA"             "superpc"             "svmBoundrangeString"## [214] "svmExpoString"       "svmLinear"           "svmLinear2"         ## [217] "svmLinear3"          "svmLinearWeights"    "svmLinearWeights2"  ## [220] "svmPoly"             "svmRadial"           "svmRadialCost"      ## [223] "svmRadialSigma"      "svmRadialWeights"    "svmSpectrumString"  ## [226] "tan"                 "tanSearch"           "treebag"            ## [229] "vbmpRadial"          "vglmAdjCat"          "vglmContRatio"      ## [232] "vglmCumulative"      "widekernelpls"       "WM"                 ## [235] "wsrf"                "xgbLinear"           "xgbTree"            ## [238] "xyf"

FAQ