Chapitre 11 Forêts aléatoires | Apprentissage automatique pratique avec R

Conditions préalables

Ce chapitre exploite les packages suivants. Certains de ces packages jouent un rôle de soutien; cependant, l’accent est mis sur la façon de mettre en œuvre des forêts aléatoires avec le ranger (Wright et Ziegler 2017) et h2o paquets.

# Helper packages
library(dplyr)    # for data wrangling
library(ggplot2)  # for awesome graphics

# Modeling packages
library(ranger)   # a c++ implementation of random forest 
library(h2o)      # a java-based implementation of random forest

Nous continuerons à travailler avec le ames_train ensemble de données créé à la section 2.7 pour illustrer les principaux concepts.

Extension de l’ensachage

Les forêts aléatoires sont construites en utilisant les mêmes principes fondamentaux que les arbres de décision (chapitre 9) et l’ensachage (chapitre 10). L’ensachage d’arbres introduit un composant aléatoire dans le processus de création de l’arborescence en créant de nombreuses arborescences sur des copies bootstrap des données d’apprentissage. L’ensachage regroupe ensuite les prédictions sur tous les arbres; cette agrégation réduit la variance de la procédure globale et se traduit par une amélioration des performances prédictives. Cependant, comme nous l’avons vu dans la section 10.6, le simple fait de mettre en sac les arbres aboutit à une corrélation entre les arbres qui limite l’effet de la réduction de la variance.

Les forêts aléatoires aident à réduire la corrélation des arbres en injectant plus de caractère aléatoire dans le processus de croissance des arbres. Plus précisément, tout en développant un arbre de décision pendant le processus d’ensachage, les forêts aléatoires exécutent randomisation à variable fractionnée où chaque fois qu’une scission doit être effectuée, la recherche de la variable de scission est limitée à un sous-ensemble aléatoire de (m_ {essayer} ) de l’original (p ) fonctionnalités. Les valeurs par défaut typiques sont (m_ {try} = frac {p} {3} ) (régression) et (m_ {try} = sqrt {p} ) (classification) mais cela doit être considéré comme un paramètre de réglage.

L’algorithme de base d’une forêt aléatoire de régression ou de classification peut être généralisé comme suit:

1.  Given a training data set
2.  Select number of trees to build (n_trees)
3.  for i = 1 to n_trees do
4.  |  Generate a bootstrap sample of the original data
5.  |  Grow a regression/classification tree to the bootstrapped data
6.  |  for each split do
7.  |  | Select m_try variables at random from all p variables
8.  |  | Pick the best variable/split-point among the m_try
9.  |  | Split the node into two child nodes
10. |  end
11. | Use typical tree model stopping criteria to determine when a 
    | tree is complete (but do not prune)
12. end
13. Output ensemble of trees 

Étant donné que l’algorithme sélectionne au hasard un échantillon bootstrap sur lequel s’entraîner et un échantillon aléatoire de caractéristiques à utiliser à chaque division, un ensemble d’arbres plus diversifié est produit, ce qui tend à réduire la corrélation des arbres au-delà des arbres ensachés et augmente souvent considérablement le pouvoir de prédiction.

Performances prêtes à l’emploi

Les forêts aléatoires sont devenues populaires parce qu’elles ont tendance à offrir de très bonnes performances prêtes à l’emploi. Bien qu’ils aient plusieurs hyperparamètres qui peuvent être réglés, les valeurs par défaut ont tendance à produire de bons résultats. En outre, Probst, Bischl et Boulesteix (2018) ont illustré que parmi les algorithmes d’apprentissage automatique les plus populaires, les forêts aléatoires présentent le moins de variabilité dans leur précision de prédiction lors du réglage.

Par exemple, si nous entraînons un modèle de forêt aléatoire avec tous les hyperparamètres définis sur leurs valeurs par défaut, nous obtenons un RMSE OOB qui est meilleur que tout modèle que nous avons exécuté jusqu’à présent (sans aucun réglage).

# number of features
n_features <- length(setdiff(names(ames_train), "Sale_Price"))

# train a default random forest model
ames_rf1 <- ranger(
  Sale_Price ~ ., 
  data = ames_train,
  mtry = floor(n_features / 3),
  respect.unordered.factors = "order",
  seed = 123
)

# get OOB RMSE
(default_rmse <- sqrt(ames_rf1$prediction.error))
## [1] 24859.27

Hyperparamètres

Bien que les forêts aléatoires fonctionnent bien hors de la boîte, il existe plusieurs hyperparamètres réglables que nous devons prendre en compte lors de la formation d’un modèle. Bien que nous abordions brièvement les principaux hyperparamètres, Probst, Wright et Boulesteix (2019) fournir une discussion beaucoup plus approfondie. Les principaux hyperparamètres à prendre en compte sont les suivants:

1. Le nombre d’arbres dans la forêt
2. Le nombre de fonctionnalités à prendre en compte à un fractionnement donné: (m_ {essayer} )
3. La complexité de chaque arbre
4. Le schéma d’échantillonnage

5. La règle de fractionnement à utiliser lors de la construction de l’arbre

6. et (2) ont généralement le plus grand impact sur la précision prédictive et doivent toujours être réglés. (3) et (4) ont tendance à avoir un impact marginal sur la précision prédictive, mais méritent tout de même d’être explorés. Ils ont également la capacité d’influencer l’efficacité des calculs. (5) a tendance à avoir le plus petit impact sur la précision prédictive et est principalement utilisé pour augmenter l’efficacité du calcul.

Nombre d’arbres

La première considération est le nombre d’arbres dans votre forêt aléatoire. Bien qu’il ne s’agisse pas techniquement d’un hyperparamètre, le nombre d’arbres doit être suffisamment grand pour stabiliser le taux d’erreur. Une bonne règle de base est de commencer avec 10 fois le nombre d’entités comme illustré dans la Figure 11.1; cependant, lorsque vous ajustez d’autres hyperparamètres tels que (m_ {essayer} ) et la taille du nœud, plus ou moins d’arbres peuvent être nécessaires. Un plus grand nombre d’arbres fournit des estimations d’erreur plus robustes et plus stables et des mesures d’importance variable; cependant, l’impact sur le temps de calcul augmente linéairement avec le nombre d’arbres.

Commencer avec (p fois 10 ) arbres et ajustez si nécessaire

Figure 11.1: Les données Ames ont 80 caractéristiques et, en commençant par 10 fois le nombre d’entités, assure généralement la convergence de l’estimation d’erreur.

(m_ {essayer} )

L’hyperparamètre qui contrôle la fonction de randomisation à variable fractionnée des forêts aléatoires est souvent appelé (m_ {essayer} ) et il aide à équilibrer une faible corrélation des arbres avec une force prédictive raisonnable. Avec des problèmes de régression, la valeur par défaut est souvent (m_ {try} = frac {p} {3} ) et pour la classification (m_ {try} = sqrt {p} ). Cependant, lorsqu’il y a moins de prédicteurs pertinents (par exemple, des données bruyantes), une valeur plus élevée de (m_ {essayer} ) a tendance à être plus performant car il est plus susceptible de sélectionner les fonctionnalités avec le signal le plus fort. Lorsqu’il existe de nombreux prédicteurs pertinents, un (m_ {essayer} ) pourrait mieux fonctionner.

Commencez par cinq valeurs de (m_ {essayer} ) sur la plage 2– (p ) centré sur la valeur par défaut recommandée, comme illustré dans la Figure 11.2.

Figure 11.2: Pour les données Ames, une valeur mtry légèrement inférieure (21) à la valeur par défaut (26) améliore les performances.

Complexité de l’arbre

Les forêts aléatoires sont construites sur des arbres de décision individuels; par conséquent, la plupart des implémentations de forêt aléatoires ont un ou plusieurs hyperparamètres qui nous permettent de contrôler la profondeur et la complexité des arbres individuels. Cela inclut souvent des hyperparamètres tels que la taille du nœud, la profondeur maximale, le nombre maximal de nœuds terminaux ou la taille de nœud requise pour permettre des fractionnements supplémentaires. La taille du nœud est probablement l’hyperparamètre le plus courant pour contrôler la complexité de l’arborescence et la plupart des implémentations utilisent les valeurs par défaut de un pour la classification et de cinq pour la régression, car ces valeurs ont tendance à produire de bons résultats. (Dı’az-Uriarte et De Andres 2006; Goldstein, Polley et Briggs 2011). cependant, Segal (2004) a montré que si vos données ont de nombreux prédicteurs bruyants et plus (m_ {essayer} ) les valeurs fonctionnent le mieux, alors les performances peuvent s’améliorer en augmentant la taille des nœuds (c’est-à-dire en diminuant la profondeur et la complexité de l’arbre). De plus, si le temps de calcul est un problème, vous pouvez souvent réduire considérablement le temps d’exécution en augmentant la taille du nœud et n’avoir qu’un impact marginal sur votre estimation d’erreur, comme illustré dans la Figure 11.3.

Lorsque vous ajustez la taille du nœud, commencez par trois valeurs comprises entre 1 et 10 et ajustez en fonction de l’impact sur la précision et la durée d’exécution.

Figure 11.3: L’augmentation de la taille des nœuds pour réduire la complexité de l’arborescence aura souvent un impact plus important sur la vitesse de calcul (à droite) que sur votre estimation d’erreur.

Schéma d’échantillonnage

Le schéma d’échantillonnage par défaut pour les forêts aléatoires est le bootstrap où 100% des observations sont échantillonnées avec remplacement (en d’autres termes, chaque copie bootstrap a la même taille que les données d’apprentissage d’origine); cependant, nous pouvons ajuster à la fois la taille de l’échantillon et s’il faut échantillonner avec ou sans remplacement. Le paramètre de taille d’échantillon détermine le nombre d’observations tirées pour l’apprentissage de chaque arbre. La diminution de la taille de l’échantillon conduit à des arbres plus diversifiés et donc à une corrélation entre les arbres plus faible, ce qui peut avoir un effet positif sur la précision de la prédiction. Par conséquent, s’il existe quelques fonctionnalités dominantes dans votre ensemble de données, la réduction de la taille de l’échantillon peut également aider à minimiser la corrélation entre les arbres.

De plus, lorsque vous avez de nombreuses fonctionnalités catégorielles avec un nombre variable de niveaux, l’échantillonnage avec remplacement peut conduire à une sélection de division de variable biaisée. (Janitza, Binder et Boulesteix 2016; Strobl et al.2007). Par conséquent, si vous avez des catégories qui ne sont pas équilibrées, l’échantillonnage sans remplacement permet une utilisation moins biaisée de tous les niveaux dans les arbres de la forêt aléatoire.

Évaluez 3 à 4 valeurs de tailles d’échantillon comprises entre 25% et 100% et si vous avez des caractéristiques catégorielles déséquilibrées, essayez d’échantillonner sans remplacement.

Figure 11.4: Les données Ames présentent plusieurs caractéristiques catégoriques déséquilibrées telles que le voisinage, le zonage, la qualité globale, etc. Par conséquent, l’échantillonnage sans remplacement semble améliorer les performances car il conduit à une sélection de variables fractionnées moins biaisée et à davantage d’arbres non corrélés.

Stratégies de réglage

À mesure que nous introduisons des algorithmes plus complexes avec un plus grand nombre d’hyperparamètres, nous devrions devenir plus stratégiques avec nos stratégies de réglage. Une façon de devenir plus stratégique consiste à réfléchir à la façon dont nous procédons dans notre recherche de grille. Jusqu’à présent, toutes nos recherches de grille ont été recherches de grille cartésienne complète où nous évaluons chaque combinaison d’hyperparamètres d’intérêt. Nous pourrions continuer à faire de même; par exemple, le bloc de code suivant recherche parmi 120 combinaisons de paramètres d’hyperparamètres.

# create hyperparameter grid
hyper_grid <- expand.grid(
  mtry = floor(n_features * c(.05, .15, .25, .333, .4)),
  min.node.size = c(1, 3, 5, 10), 
  replace = c(TRUE, FALSE),                               
  sample.fraction = c(.5, .63, .8),                       
  rmse = NA                                               
)

# execute full cartesian grid search
for(i in seq_len(nrow(hyper_grid))) {
  # fit model for ith hyperparameter combination
  fit <- ranger(
    formula         = Sale_Price ~ ., 
    data            = ames_train, 
    num.trees       = n_features * 10,
    mtry            = hyper_grid$mtry[i],
    min.node.size   = hyper_grid$min.node.size[i],
    replace         = hyper_grid$replace[i],
    sample.fraction = hyper_grid$sample.fraction[i],
    verbose         = FALSE,
    seed            = 123,
    respect.unordered.factors = 'order',
  )
  # export OOB error 
  hyper_grid$rmse[i] <- sqrt(fit$prediction.error)
}

# assess top 10 models
hyper_grid %>%
  arrange(rmse) %>%
  mutate(perc_gain = (default_rmse - rmse) / default_rmse * 100) %>%
  head(10)
##    mtry min.node.size replace sample.fraction     rmse perc_gain
## 1    32             1   FALSE             0.8 23975.32  3.555819
## 2    32             3   FALSE             0.8 24022.97  3.364127
## 3    32             5   FALSE             0.8 24032.69  3.325041
## 4    26             3   FALSE             0.8 24103.53  3.040058
## 5    20             1   FALSE             0.8 24132.35  2.924142
## 6    26             5   FALSE             0.8 24144.38  2.875752
## 7    20             3   FALSE             0.8 24194.64  2.673560
## 8    26             1   FALSE             0.8 24216.02  2.587589
## 9    32            10   FALSE             0.8 24224.18  2.554755
## 10   20             5   FALSE             0.8 24249.46  2.453056

Si nous regardons les résultats, nous voyons que les 10 meilleurs modèles sont tous proches ou inférieurs à un RMSE de 24 000 (une amélioration de 2,5% à 3,5% par rapport à notre modèle de base). Dans ces résultats, la valeur par défaut mtry valeur de ( left lfloor { frac { texttt {# features}} {3}} right rfloor = 26 ) est presque suffisante et les plus petites tailles de nœuds (arbres plus profonds) fonctionnent le mieux. Ce qui ressort le plus, c’est que la prise d’un taux d’échantillonnage inférieur à 100% et l’échantillonnage sans remplacement sont toujours les meilleures. Un échantillonnage inférieur à 100% ajoute un caractère aléatoire supplémentaire à la procédure, ce qui contribue à décorréler davantage les arbres. L’échantillonnage sans remplacement améliore probablement les performances, car ces données présentent de nombreuses caractéristiques catégorielles à cardinalité élevée qui sont déséquilibrées.

Cependant, au fur et à mesure que nous ajoutons plus d’hyperparamètres et de valeurs à rechercher et que nos ensembles de données s’agrandissent, vous pouvez voir comment une recherche cartésienne complète peut devenir exhaustive et coûteuse en calcul. En plus de la recherche cartésienne complète, le h2o le package fournit un recherche de grille aléatoire qui vous permet de passer d’une combinaison aléatoire à une autre et fournit également arrêt précoce des règles qui vous permettent d’arrêter la recherche de grille une fois qu’une certaine condition est remplie (par exemple, un certain nombre de modèles ont été entraînés, un certain temps d’exécution s’est écoulé ou la précision a cessé de s’améliorer d’un certain montant). Bien que l’utilisation d’un chemin de recherche discret aléatoire ne trouve probablement pas le modèle optimal, elle permet généralement de trouver un très bon modèle.

Pour adapter un modèle de forêt aléatoire avec h2o, nous devons d’abord lancer notre h2o session.

h2o.no_progress()
h2o.init(max_mem_size = "5g")

Ensuite, nous devons convertir nos ensembles de données d’entraînement et de test en objets qui h2o peut travailler avec.

# convert training data to h2o object
train_h2o <- as.h2o(ames_train)

# set the response column to Sale_Price
response <- "Sale_Price"

# set the predictor names
predictors <- setdiff(colnames(ames_train), response)

Ce qui suit correspond à un modèle de forêt aléatoire par défaut avec h2o pour illustrer que nos résultats de base ( ( text {OOB RMSE} = 24439 )) sont très similaires à la ligne de base ranger modèle que nous adaptons plus tôt.

h2o_rf1 <- h2o.randomForest(
    x = predictors, 
    y = response,
    training_frame = train_h2o, 
    ntrees = n_features * 10,
    seed = 123
)

h2o_rf1
## Model Details:
## ==============
## 
## H2ORegressionModel: drf
## Model ID:  DRF_model_R_1554292876245_2 
## Model Summary: 
##   number_of_trees number_of_internal_trees model_size_in_bytes min_depth max_depth mean_depth min_leaves max_leaves mean_leaves
## 1             800                      800            12365675        19        20   19.99875       1148       1283  1225.04630
## 
## 
## H2ORegressionMetrics: drf
## ** Reported on training data. **
## ** Metrics reported on Out-Of-Bag training samples **
## 
## MSE:  597254712
## RMSE:  24438.8
## MAE:  14833.34
## RMSLE:  0.1396219
## Mean Residual Deviance :  597254712

Pour exécuter une recherche de grille dans h2o nous avons besoin que notre grille d’hyperparamètres soit une liste. Par exemple, le code suivant recherche un espace de grille plus grand qu’auparavant avec un total de 240 combinaisons d’hyperparamètres. Nous créons ensuite une stratégie de recherche de grille aléatoire qui s’arrêtera si aucun des 10 derniers modèles n’a réussi à avoir une amélioration de 0,1% de MSE par rapport au meilleur modèle avant cela. Si nous continuons à trouver des améliorations, nous interrompons la recherche de grille au bout de 300 secondes (5 minutes).

# hyperparameter grid
hyper_grid <- list(
  mtries = floor(n_features * c(.05, .15, .25, .333, .4)),
  min_rows = c(1, 3, 5, 10),
  max_depth = c(10, 20, 30),
  sample_rate = c(.55, .632, .70, .80)
)

# random grid search strategy
search_criteria <- list(
  strategy = "RandomDiscrete",
  stopping_metric = "mse",
  stopping_tolerance = 0.001,   # stop if improvement is < 0.1%
  stopping_rounds = 10,         # over the last 10 models
  max_runtime_secs = 60*5      # or stop search after 5 min.
)

On peut alors effectuer la recherche de grille avec h2o.grid(). Ce qui suit exécute la recherche de grille avec l’arrêt anticipé activé. L’arrêt précoce que nous spécifions ci-dessous dans h2o.grid() arrêtera de cultiver un modèle de forêt aléatoire individuel si nous n’avons pas connu une amélioration d’au moins 0,05% de l’erreur globale OOB dans les 10 derniers arbres. Ceci est très utile car nous pouvons spécifier de construire 1000 arbres pour chaque modèle de forêt aléatoire mais h2o ne peut construire que 200 arbres si nous ne constatons aucune amélioration.

# perform grid search 
random_grid <- h2o.grid(
  algorithm = "randomForest",
  grid_id = "rf_random_grid",
  x = predictors, 
  y = response, 
  training_frame = train_h2o,
  hyper_params = hyper_grid,
  ntrees = n_features * 10,
  seed = 123,
  stopping_metric = "RMSE",   
  stopping_rounds = 10,           # stop if last 10 trees added 
  stopping_tolerance = 0.005,     # don't improve RMSE by 0.5%
  search_criteria = search_criteria
)

Notre recherche de grille évaluée 129 modèles avant de s’arrêter en raison du temps. Le meilleur modèle (max_depth = 30, min_rows = 1, mtries = 20, et sample_rate = 0.8) a obtenu un RMSE OOB de 23932. Ainsi, bien que notre recherche aléatoire ait évalué environ 30% du nombre de modèles comme le ferait une recherche de grille complète, la recherche aléatoire plus efficace a trouvé un modèle presque optimal dans la contrainte de temps spécifiée.

# collect the results and sort by our model performance metric 
# of choice
random_grid_perf <- h2o.getGrid(
  grid_id = "rf_random_grid", 
  sort_by = "mse", 
  decreasing = FALSE
)
random_grid_perf
## H2O Grid Details
## ================
## 
## Grid ID: rf_random_grid 
## Used hyper parameters: 
##   -  max_depth 
##   -  min_rows 
##   -  mtries 
##   -  sample_rate 
## Number of models: 129 
## Number of failed models: 0 
## 
## Hyper-Parameter Search Summary: ordered by increasing mse
##   max_depth min_rows mtries sample_rate                 model_ids                 mse
## 1        30      1.0     20         0.8  rf_random_grid_model_113 5.727214331253618E8
## 2        20      1.0     20         0.8   rf_random_grid_model_39 5.727741137204964E8
## 3        20      1.0     32         0.7    rf_random_grid_model_8  5.76799145123527E8
## 4        30      1.0     26         0.7   rf_random_grid_model_67 5.815643260591004E8
## 5        30      1.0     12         0.8   rf_random_grid_model_64 5.951710701891141E8
## 
## ---
##     max_depth min_rows mtries sample_rate                model_ids                  mse
## 124        10     10.0      4         0.7  rf_random_grid_model_44 1.0367731339073703E9
## 125        20     10.0      4         0.8  rf_random_grid_model_73 1.0451421787520385E9
## 126        20      5.0      4        0.55  rf_random_grid_model_12 1.0710840266353173E9
## 127        10      5.0      4        0.55  rf_random_grid_model_75 1.0793293549247448E9
## 128        10     10.0      4       0.632  rf_random_grid_model_37 1.0804801985871077E9
## 129        20     10.0      4        0.55  rf_random_grid_model_22 1.1525799087784908E9

Interprétation des fonctionnalités

Le calcul de l’importance des caractéristiques et des effets des caractéristiques pour les forêts aléatoires suit la même procédure que celle décrite dans la section 10.5. Cependant, en plus de la mesure de l’importance des caractéristiques basée sur les impuretés, où nous basons l’importance des caractéristiques sur la réduction totale moyenne de la fonction de perte pour une caractéristique donnée dans tous les arbres, les forêts aléatoires comprennent généralement un basé sur la permutation mesure d’importance. Dans l’approche basée sur la permutation, pour chaque arbre, l’échantillon OOB est passé dans l’arbre et la précision de la prédiction est enregistrée. Ensuite, les valeurs de chaque variable (une à la fois) sont permutées au hasard et la précision est à nouveau calculée. La diminution de la précision résultant de ce brassage aléatoire des valeurs de caractéristiques est moyennée sur tous les arbres pour chaque prédicteur. Les variables présentant la plus forte diminution moyenne de l’exactitude sont considérées comme les plus importantes.

Par exemple, nous pouvons calculer les deux mesures d’importance des fonctionnalités avec ranger en définissant le importance argument.

# re-run model with impurity-based variable importance
rf_impurity <- ranger(
  formula = Sale_Price ~ ., 
  data = ames_train, 
  num.trees = 2000,
  mtry = 32,
  min.node.size = 1,
  sample.fraction = .80,
  replace = FALSE,
  importance = "impurity",
  respect.unordered.factors = "order",
  verbose = FALSE,
  seed  = 123
)

# re-run model with permutation-based variable importance
rf_permutation <- ranger(
  formula = Sale_Price ~ ., 
  data = ames_train, 
  num.trees = 2000,
  mtry = 32,
  min.node.size = 1,
  sample.fraction = .80,
  replace = FALSE,
  importance = "permutation",
  respect.unordered.factors = "order",
  verbose = FALSE,
  seed  = 123
)

Les VIP résultants sont affichés dans la Figure 11.5. En règle générale, vous ne verrez pas le même ordre d’importance variable entre les deux options; cependant, vous verrez souvent des variables similaires en haut des graphiques (et également en bas). Par conséquent, dans cet exemple, nous pouvons affirmer confortablement qu’il semble y avoir suffisamment de preuves pour suggérer que trois variables ressortent comme les plus influentes:

• Overall_Qual
• Gr_Liv_Area
• Neighborhood

En regardant les ~ 10 prochaines variables dans les deux graphiques, vous verrez également des points communs dans les variables influentes (par exemple, Garage_Cars, Exter_Qual, Bsmt_Qual, et Year_Built).

p1 <- vip::vip(rf_impurity, num_features = 25, bar = FALSE)
p2 <- vip::vip(rf_permutation, num_features = 25, bar = FALSE)

gridExtra::grid.arrange(p1, p2, nrow = 1)

Figure 11.5: Top 25 des variables les plus importantes basées sur l’impureté (à gauche) et la permutation (à droite).

Dernières pensées

Les forêts aléatoires fournissent un algorithme prêt à l’emploi très puissant qui a souvent une grande précision prédictive. Ils présentent tous les avantages des arbres de décision (à l’exception des fractionnements de substitution) et de l’ensachage, mais réduisent considérablement l’instabilité et la corrélation entre les arbres. Et en raison de l’attribut de sélection de variable de fractionnement ajouté, les forêts aléatoires sont également plus rapides que le bagging car elles ont un espace de recherche d’entités plus petit à chaque division d’arbre. Cependant, les forêts aléatoires souffriront toujours d’une vitesse de calcul lente à mesure que vos ensembles de données s’agrandissent, mais, comme pour le bagging, l’algorithme est construit sur des étapes indépendantes et sur la plupart des implémentations modernes (par exemple, ranger, h2o) permettent la parallélisation pour améliorer le temps de formation.