Bagging et Random Forest en Machine Learning : comment ça marche ?

 Bagging et Random Forest en Machine Learning : comment ça marche ?


Dans le monde d’aujourd’hui, les innovations se produisent quotidiennement, rendant toutes les versions précédentes de ce produit, service ou ensemble de compétences obsolètes et obsolètes. Dans un espace aussi dynamique et chaotique, comment prendre une décision éclairée sans se laisser emporter par le battage publicitaire ? Pour prendre les bonnes décisions, nous devons suivre un ensemble de processus ; étudiez le scénario actuel, analysez vos attentes, recueillez les avis des autres, explorez vos options, sélectionnez la meilleure solution après avoir pesé le pour et le contre, prenez une décision et prenez les mesures nécessaires.

Par exemple, si vous cherchez à acheter un ordinateur, allez-vous simplement vous rendre au magasin et choisir un ordinateur portable ou un ordinateur portable ? Il est très peu probable que vous le fassiez. Vous rechercheriez probablement sur Amazon, parcourriez quelques portails Web où les gens ont publié leurs avis et compareriez différents modèles, en vérifiant leurs caractéristiques, leurs spécifications et leurs prix. Vous demanderez aussi probablement leur avis à vos amis et collègues. En bref, vous ne sauteriez pas directement à une conclusion, mais vous prendrez plutôt une décision en tenant compte également des opinions et des critiques d’autres personnes.

Mise en sac et forêt aléatoire dans l'apprentissage automatique

Les modèles d’ensemble dans l’apprentissage automatique fonctionnent également de la même manière. Ils combinent les décisions de plusieurs modèles pour améliorer les performances globales. L’objectif de cet article est d’introduire le concept d’apprentissage d’ensemble et de comprendre des algorithmes comme le bagging et la forêt aléatoire qui utilisent une technique similaire.

Qu’est-ce que l’Ensemble Learning ?

Les méthodes d’ensemble visent à améliorer les performances prédictives d’une technique donnée d’apprentissage statistique ou d’ajustement de modèle. Le principe général des méthodes d’ensemble est de construire une combinaison linéaire d’une méthode d’ajustement de modèle, au lieu d’utiliser un seul ajustement de la méthode.

Un ensemble est lui-même un algorithme d’apprentissage supervisé, car il peut être formé puis utilisé pour faire des prédictions. Les méthodes d’ensemble combinent plusieurs classificateurs d’arbres de décision pour produire de meilleures performances prédictives qu’un seul classificateur d’arbre de décision. Le principe principal du modèle d’ensemble est qu’un groupe d’apprenants faibles se rassemblent pour former un apprenant fort, augmentant ainsi la précision du modèle. Lorsque nous essayons de prédire la variable cible à l’aide d’une technique d’apprentissage automatique, les principales causes de différence dans les valeurs réelles et prédites sont bruit, variance et biais. Ensemble aide à réduire ces facteurs (sauf le bruit, qui est une erreur irréductible). L’erreur liée au bruit est principalement due au bruit dans les données d’entraînement et ne peut pas être supprimée. Cependant, les erreurs dues au biais et à la variance peuvent être réduites.
L’erreur totale peut être exprimée comme suit :

Erreur totale = biais + variance + erreur irréductible

Une mesure comme erreur quadratique moyenne (MSE) capture toutes ces erreurs pour une variable cible continue et peut être représentée comme suit :

Formule d'erreur quadratique moyenne

, E représente la moyenne attendue, Y représente les valeurs cibles réelles et fˆ(x) représente les valeurs prédites pour la variable cible. Il peut être décomposé en ses composants tels que le biais, la variance et le bruit, comme indiqué dans la formule suivante :

Biais, variance et formule de bruit

L’utilisation de techniques telles que le Bagging et le Boosting permet de réduire la variance et d’augmenter la robustesse du modèle. Les combinaisons de plusieurs classificateurs diminuent la variance, en particulier dans le cas de classificateurs instables, et peuvent produire une classification plus fiable qu’un seul classificateur.

Algorithme d’ensemble

Le but des algorithmes d’ensemble est de combiner les prédictions de plusieurs estimateurs de base construits avec un algorithme d’apprentissage donné afin d’améliorer la généralisabilité/robustesse sur un seul estimateur.

Algorithme d'ensemble

Il existe deux familles de méthodes d’ensemble que l’on distingue généralement :

  1. Méthodes de moyenne. Le principe directeur est de construire plusieurs estimateurs indépendamment puis de moyenner leurs prédictions. En moyenne, l’estimateur combiné est généralement meilleur que n’importe quel estimateur à base unique car sa variance est réduite.|
    Exemples: Méthodes d’ensachage, Forêts d’arbres randomisés.
  2. Méthodes de boosting. Les estimateurs de base sont construits séquentiellement et on essaie de réduire le biais de l’estimateur combiné. La motivation est de combiner plusieurs modèles faibles pour produire un ensemble puissant.
    Exemples: AdaBoost, amplification de l’arbre dégradé.

Avantages de l’algorithme d’ensemble

  • Ensemble est une méthode éprouvée pour améliorer la précision du modèle et fonctionne dans la plupart des cas.
  • Ensemble rend le modèle plus robuste et stable, garantissant ainsi des performances décentes sur les cas de test dans la plupart des scénarios.
  • Vous pouvez utiliser ensemble pour capturer des relations complexes linéaires et simples ainsi que non linéaires dans les données. Cela peut être fait en utilisant deux modèles différents et en formant un ensemble de deux.

Inconvénients de l’algorithme d’ensemble

  • Ensemble réduit la capacité d’interprétation du modèle et rend très difficile l’obtention d’informations commerciales cruciales à la fin
  • Cela prend du temps et n’est donc peut-être pas la meilleure idée pour les applications en temps réel
  • La sélection de modèles pour la création d’un ensemble est un art très difficile à maîtriser

Techniques d’ensemble de base

  • Vote maximum : Le vote maximal est l’un des moyens les plus simples de combiner les prédictions de plusieurs algorithmes d’apprentissage automatique. Chaque modèle de base fait une prédiction et vote pour chaque échantillon. La classe d’échantillon avec les votes les plus élevés est considérée dans la classe prédictive finale. Il est principalement utilisé pour les problèmes de classification.
  • Moyenne : La moyenne peut être utilisée lors de l’estimation des probabilités dans les tâches de classification. Mais il est généralement utilisé pour les problèmes de régression. Les prédictions sont extraites de plusieurs modèles et une moyenne des prédictions est utilisée pour faire la prédiction finale.
  • Moyenne pondérée: Comme la moyenne, la moyenne pondérée est également utilisée pour les tâches de régression. Alternativement, il peut être utilisé lors de l’estimation des probabilités dans les problèmes de classification. Les apprenants de base se voient attribuer différents poids, qui représentent l’importance de chaque modèle dans la prédiction.

Méthodes d’ensemble

Les méthodes d’ensemble sont devenues populaires en tant que dispositif relativement simple pour améliorer les performances prédictives d’une procédure de base. Il y a différentes raisons à cela : la procédure de bagging s’avère être un schéma de réduction de la variance, du moins pour certaines procédures de base. D’autre part, les méthodes de boosting réduisent principalement le biais (modèle) de la procédure de base. Cela indique déjà que le bagging et le boosting sont des méthodes d’ensemble très différentes. Du point de vue de la prédiction, les forêts aléatoires sont à peu près aussi efficaces que le boosting, et souvent meilleures que le bagging.

Bjugulaire Aggréglementation ou Ensachage essaie de mettre en œuvre des apprenants similaires sur de petites populations d’échantillons, puis prend une moyenne de toutes les prédictions.

  • Il combine Bootstrapping et Aggregation pour former un modèle d’ensemble
  • Réduit l’erreur de variance et aide à éviter le surajustement

Les algorithmes de bagging incluent :

  • Méta-estimateur de bagging
  • Forêt aléatoire

Booster fait référence à une famille d’algorithmes qui convertit les apprenants faibles en apprenants forts. Le boosting est un processus séquentiel, où chaque modèle suivant tente de corriger les erreurs du modèle précédent. Le boosting est axé sur la réduction du biais. Cela rend les algorithmes de boosting sujets au surajustement. Pour éviter le surajustement, le réglage des paramètres joue un rôle important dans le renforcement des algorithmes. Quelques exemples de boosting sont mentionnés ci-dessous :

  • AdaBoost
  • GBM
  • XGBM
  • GBM léger
  • CatBoost

Pourquoi utiliser des modèles d’ensemble ?

Les modèles d’ensemble aident à améliorer la précision de l’algorithme ainsi que la robustesse d’un modèle. Le bagging et le boosting devraient tous deux être connus des scientifiques des données et des ingénieurs en apprentissage automatique, et en particulier des personnes qui envisagent d’assister à des entretiens en science des données/apprentissage automatique.

L’apprentissage d’ensemble utilise des centaines, voire des milliers de modèles du même algorithme, puis travaille main dans la main pour trouver la classification correcte. Vous pouvez également envisager la fable des aveugles et de l’éléphant pour comprendre l’apprentissage d’ensemble, où chaque aveugle a trouvé une caractéristique de l’éléphant et ils ont tous pensé que c’était quelque chose de différent. Cependant, s’ils travaillaient ensemble et discutaient entre eux, ils auraient peut-être compris de quoi il s’agit.

L’utilisation de techniques telles que le bagging et le boosting conduit à une robustesse accrue des modèles statistiques et à une diminution de la variance. Maintenant la question devient, entre ces différents mots « B ». Ce qui est mieux?

Qu’est-ce qui est le mieux, le Bagging ou le Boosting ?

Il n’y a pas de réponse parfaitement correcte à cela. Cela dépend des données, de la simulation et des circonstances.

Le bagging et le boosting diminuent la variance de votre estimation unique car ils combinent plusieurs estimations de différents modèles. Ainsi, le résultat peut être un modèle avec plus grande stabilité.

Si le problème est que le modèle unique obtient une performance très faible, Bagging obtiendra rarement un meilleur biais. Cependant, Boosting pourrait générer un modèle combiné avec moins d’erreurs car il optimise les avantages et réduit les pièges du modèle unique.

En revanche, si la difficulté du modèle unique est sur-ajustement, alors l’ensachage est la meilleure option. Le boosting quant à lui ne permet pas d’éviter le sur-ajustement ; en fait, cette technique est elle-même confrontée à ce problème. Pour cette raison, le Bagging est plus efficace que le Boosting. Dans cet article, nous parlerons de Bagging, nous aborderons le Boosting dans le prochain post. Mais d’abord, examinons le concept très important de bootstrap.

Échantillonnage bootstrap

L’échantillonnage est le processus de sélection d’un sous-ensemble d’observations de la population dans le but d’estimer certains paramètres concernant l’ensemble de la population. Les méthodes de rééchantillonnage, quant à elles, sont utilisées pour améliorer les estimations des paramètres de la population.

Échantillonnage bootstrap dans l'apprentissage automatique

En apprentissage automatique, la méthode bootstrap fait référence à un échantillonnage aléatoire avec remise. Cet échantillon est appelé rééchantillonnage. Cela permet au modèle ou à l’algorithme de mieux comprendre les divers biais, variances et caractéristiques qui existent dans le rééchantillonnage. Prendre un échantillon des données permet au rééchantillon de contenir des caractéristiques différentes de celles qu’il aurait pu contenir dans son ensemble. Ceci est démontré dans la figure 1 où chaque échantillon de population a des morceaux différents, et aucun n’est identique. Cela affecterait alors la moyenne globale, l’écart type et d’autres mesures descriptives d’un ensemble de données. À son tour, il peut développer des modèles plus robustes.

Le bootstrapping est également idéal pour les ensembles de données de petite taille qui peuvent avoir tendance à sur-ajuster. En fait, nous l’avons recommandé à une entreprise qui s’inquiétait parce que ses ensembles de données étaient loin du « Big Data ». Le bootstrap peut être une solution dans ce cas car les algorithmes qui utilisent le bootstrap peuvent être plus robustes et gérer de nouveaux ensembles de données en fonction de la méthodologie choisie (boosting ou bagging).

La raison derrière l’utilisation de la méthode bootstrap est qu’elle peut tester la stabilité d’une solution. En utilisant plusieurs ensembles de données d’échantillons, puis en testant plusieurs modèles, cela peut augmenter la robustesse. Peut-être qu’un ensemble de données d’échantillon a une moyenne plus grande qu’un autre, ou un écart type différent. Cela pourrait casser un modèle surajusté et non testé à l’aide d’ensembles de données avec différentes variations.

L’augmentation de la puissance de calcul est l’une des nombreuses raisons pour lesquelles le bootstrap est devenu très courant. Cela permet d’effectuer plusieurs fois plus de permutations avec différents rééchantillonnages qu’auparavant. Le bootstrapping est utilisé à la fois dans le bagging et le boosting

Supposons que nous ayons un échantillon de « n » valeurs (x) et que nous aimerions obtenir une estimation de la moyenne de l’échantillon.

moyenne(x) = 1/n * somme(x)

Considérons un échantillon de 100 valeurs (x) et nous aimerions obtenir une estimation de la moyenne de l’échantillon. Nous pouvons calculer la moyenne directement à partir de l’échantillon comme suit :

Formule

Nous savons que notre échantillon est petit et que la moyenne a une erreur dedans. Nous pouvons améliorer l’estimation de notre moyenne en utilisant la procédure bootstrap :

  1. Créez de nombreux (par exemple 1000) sous-échantillons aléatoires de l’ensemble de données avec remplacement (ce qui signifie que nous pouvons sélectionner la même valeur plusieurs fois).
  2. Calculer la moyenne de chaque sous-échantillon
  3. Calculer la moyenne de tous nos moyens collectés et l’utiliser comme moyenne estimée pour les données

Eexemple : Supposons que nous utilisions 3 rééchantillons et que nous obtenions les valeurs moyennes 2,3, 4,5 et 3,3. En prenant la moyenne de ceux-ci, nous pourrions prendre la moyenne estimée des données à 3,367. Ce processus peut être utilisé pour estimer d’autres quantités comme l’écart type et même des quantités utilisées dans les algorithmes d’apprentissage automatique, comme les coefficients appris.

Lors de l’utilisation de Python, nous n’avons pas à implémenter la méthode bootstrap manuellement. La bibliothèque scikit-learn fournit une implémentation qui crée un échantillon bootstrap unique d’un ensemble de données.

le fonction resample() scikit-learn peut être utilisé pour l’échantillonnage. Il prend comme arguments le tableau de données, s’il faut ou non échantillonner avec remplacement, la taille de l’échantillon et la graine du générateur de nombres pseudo-aléatoires utilisé avant l’échantillonnage.

Par exemple, créons un bootstrap qui crée un échantillon avec remplacement avec 4 observations et utilise une valeur de 1 pour le générateur de nombres pseudo-aléatoires.

boot = resample(data, replace=True, n_samples=4, random_state=1)

Comme l’API bootstrap ne permet pas de rassembler facilement les observations out-of-bag qui pourraient être utilisées comme ensemble de test pour évaluer un modèle d’ajustement, dans le cas univarié, nous pouvons rassembler les observations out-of-bag en utilisant une simple liste Python compréhension.

# out of bag observations 
oob = [x for x in data if x not in boot]

Prenons un petit exemple et exécutons-le.

# scikit-learn bootstrap 
from sklearn.utils import resample 
# data sample 
data = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6] 
# prepare bootstrap sample 
boot = resample(data, replace=True, n_samples=4, random_state=1) 
print('Bootstrap Sample: %s' % boot) 
# out of bag observations 
oob = [x for x in data if x not in boot] 
print('OOB Sample: %s' % oob) 

La sortie inclura les observations dans l’échantillon bootstrap et les observations dans l’échantillon hors sac.

Bootstrap Sample: [0.6, 0.4, 0.5, 0.1] 
OOB Sample: [0.2, 0.3]

Ensachage

Agrégation bootstrap, aussi connu sous le nom Ensachage, est une méthode d’ensemble puissante qui a été proposée par Leo Breiman en 1994 pour éviter le surajustement. Le concept derrière le bagging est de combiner les prédictions de plusieurs apprenants de base pour créer une sortie plus précise. Le bagging est l’application de la procédure Bootstrap à un algorithme d’apprentissage automatique à variance élevée, généralement des arbres de décision.

  1. Supposons qu’il y ait N observations et M caractéristiques. Un échantillon d’observation est sélectionné au hasard avec remise (Bootstrapping).
  2. Un sous-ensemble de caractéristiques est sélectionné pour créer un modèle avec un échantillon d’observations et un sous-ensemble de caractéristiques.
  3. La fonctionnalité du sous-ensemble est sélectionnée, ce qui donne la meilleure répartition des données d’apprentissage.
  4. Ceci est répété pour créer de nombreux modèles et chaque modèle est formé en parallèle
  5. La prédiction est donnée sur la base de l’agrégation des prédictions de tous les modèles.

Cette approche peut être utilisée avec des algorithmes d’apprentissage automatique qui ont une variance élevée, tels que les arbres de décision. Un modèle distinct est formé sur chaque échantillon bootstrap de données et la sortie moyenne de ces modèles est utilisée pour faire des prédictions. Cette technique est appelée agrégation bootstrap ou bagging en abrégé.

La variance signifie que les performances d’un algorithme sont sensibles aux données d’apprentissage, une variance élevée suggérant que plus les données d’apprentissage sont modifiées, plus les performances de l’algorithme varient.

Les performances des algorithmes d’apprentissage automatique à variance élevée, comme les arbres de décision non élagués, peuvent être améliorées en formant de nombreux arbres et en prenant la moyenne de leurs prédictions. Les résultats sont souvent meilleurs qu’un simple arbre de décision.

Ce que fait Bagging, c’est aider à réduire la variance des modèles qui peuvent être très précis, mais uniquement sur les données sur lesquelles ils ont été formés. Ceci est également connu sous le nom de surajustement.

Le surajustement se produit lorsqu’une fonction s’adapte trop bien aux données. Cela est généralement dû au fait que l’équation réelle est beaucoup trop compliquée pour prendre en compte chaque point de données et chaque valeur aberrante.

Surajustement dans l'apprentissage automatique

Le bagging contourne ce problème en créant sa propre variance parmi les données en échantillonnant et en remplaçant les données pendant qu’il teste plusieurs hypothèses (modèles). À son tour, cela réduit le bruit en utilisant plusieurs échantillons qui seraient très probablement constitués de données avec divers attributs (médiane, moyenne, etc.).

Une fois que chaque modèle a développé une hypothèse. Les modèles utilisent voter pour le classement ou moyenne pour la régression. C’est là qu’intervient l' »agrégation » dans « Bootstrap Aggregating ». Chaque hypothèse a le même poids que toutes les autres. Lorsque nous discuterons plus tard du boosting, c’est l’un des endroits où les deux méthodologies diffèrent.

Mise en sac dans l'apprentissage automatique

Essentiellement, tous ces modèles fonctionnent en même temps et votent sur l’hypothèse la plus précise.

Cela aide à diminuer la variance, c’est-à-dire à réduire le surajustement.

Avantages

  • Le bagging tire parti de l’apprentissage d’ensemble dans lequel plusieurs apprenants faibles surpassent un seul apprenant fort.
  • Cela aide à réduire la variance et nous aide ainsi à éviter le surajustement.

Désavantages

  • Il y a perte d’interprétabilité du modèle.
  • Il peut éventuellement y avoir un problème de biais élevé s’il n’est pas modélisé correctement.
  • Bien que l’ensachage nous donne plus de précision, il est coûteux en calcul et peut ne pas être souhaitable selon le cas d’utilisation.

Il existe de nombreux algorithmes de bagging dont le plus important serait peut-être Random Forest.

Arbres de décision

Les arbres de décision sont des modèles simples mais intuitifs. En utilisant une approche descendante, un nœud racine crée des divisions binaires à moins qu’un critère particulier ne soit rempli. Ce découpage binaire des nœuds aboutit à une valeur prédite sur la base des nœuds intérieurs qui mènent au terminal ou aux nœuds finaux. Pour un problème de classification, un arbre de décision produira une classe cible prédite pour chaque nœud terminal produit. Nous avons couvert en détail l’algorithme de l’arbre de décision pour la classification et la régression dans un autre article.

Limites des arbres de décision

Les arbres de décision ont tendance à avoir une variance élevée lorsqu’ils utilisent différents ensembles d’apprentissage et de test des mêmes données, car ils ont tendance à surajuster les données d’apprentissage. Cela entraîne des performances médiocres lorsque des données nouvelles et invisibles sont ajoutées. Cela limite l’utilisation des arbres de décision dans la modélisation prédictive. Cependant, en utilisant des méthodes d’ensemble, des modèles qui utilisent des arbres de décision peuvent être créés comme base pour produire des résultats puissants.

Arbres d’agrégation Bootstrap

Nous avons déjà discuté de l’agrégation bootstrap (ou bagging), nous pouvons créer un ensemble (forêt) d’arbres où plusieurs ensembles d’apprentissage sont générés avec remplacement, c’est-à-dire des instances de données. Une fois les ensembles d’apprentissage créés, un modèle CART peut être formé sur chaque sous-échantillon.

Caractéristiques des arbres ensachés

  • Réduit la variance en faisant la moyenne des résultats de l’ensemble.
  • Le modèle résultant utilise l’intégralité de l’espace de caractéristiques lors de l’examen des fractionnements de nœuds.
  • L’ensachage des arbres permet aux arbres de pousser sans élagage, ce qui réduit la taille des arbres en profondeur et entraîne une variance élevée mais un biais plus faible, ce qui peut aider à améliorer le pouvoir prédictif.

Limitations à l’ensachage des arbres

La principale limitation des arbres d’ensachage est qu’il utilise tout l’espace de fonctions lors de la création de divisions dans les arbres. Supposons que certaines variables dans l’espace des caractéristiques indiquent certaines prédictions, il existe un risque d’avoir une forêt d’arbres corrélés, ce qui augmente en fait le biais et réduit la variance.

Pourquoi une forêt est-elle meilleure qu’un arbre ?

L’objectif principal d’un modèle d’apprentissage automatique est de généraliser correctement à des données nouvelles et inédites. Lorsque nous avons un modèle flexible, sur-ajustement se déroule. On dit qu’un modèle flexible a une forte variance car les paramètres appris (tels que la structure de l’arbre de décision) varieront avec les données d’apprentissage.

D’un autre côté, on dit qu’un modèle inflexible a une forte biais comme ça fait hypothèses sur les données d’entraînement. Un modèle inflexible peut ne pas avoir la capacité d’ajuster même les données de formation et dans les deux cas – variance élevée et biais élevé – le modèle n’est pas capable de généraliser correctement les données nouvelles et invisibles.

Vous pouvez à travers l’article sur l’un des concepts fondamentaux de l’apprentissage automatique, le compromis biais-variance qui vous aidera à comprendre que l’équilibre entre la création d’un modèle si flexible mémorise les données de formation et un modèle inflexible ne peut pas apprendre les données de formation.

La principale raison pour laquelle l’arbre de décision est sujet au surajustement lorsque nous ne limitons pas la profondeur maximale est qu’il a une flexibilité illimitée, ce qui signifie qu’il continue de croître à moins qu’il n’y ait un nœud feuille pour chaque observation.

Au lieu de limiter la profondeur de l’arbre, ce qui entraîne une réduction de la variance et une augmentation du biais, nous pouvons combiner de nombreux arbres de décision en un seul modèle d’ensemble connu sous le nom de forêt aléatoire.

Qu’est-ce que l’algorithme Random Forest ?

La forêt aléatoire est comme un algorithme d’amorçage avec le modèle d’arbre de décision (CART). Supposons que nous ayons 1000 observations dans la population complète avec 10 variables. La forêt aléatoire essaiera de construire plusieurs CART avec différents échantillons et différentes variables initiales. Il prendra un échantillon aléatoire de 100 observations, puis choisira 5 variables initiales au hasard pour construire un modèle CART. Il continuera à répéter le processus, disons environ 10 fois, puis fera une prédiction finale sur chacune des observations. La prédiction finale est fonction de chaque prédiction. Cette prédiction finale peut simplement être la moyenne de chaque prédiction.

La forêt aléatoire est un modèle composé de nombreux arbres de décision. Plutôt que de simplement faire la moyenne de la prédiction des arbres (que nous pourrions appeler une «forêt»), ce modèle utilise deux concepts clés qui lui donnent le nom Aléatoire:

  1. Échantillonnage aléatoire de points de données d’apprentissage lors de la construction d’arbres
  2. Sous-ensembles aléatoires d’entités prises en compte lors du fractionnement des nœuds

Fonctionnement de l’algorithme de forêt aléatoire

Les étapes de base impliquées dans l’exécution de l’algorithme de forêt aléatoire sont mentionnées ci-dessous :

  1. Choisissez N enregistrements aléatoires dans l’ensemble de données.
  2. Construisez un arbre de décision basé sur ces N enregistrements.
  3. Choisissez le nombre d’arbres que vous voulez dans votre algorithme et répétez les étapes 1 et 2.
  4. En cas de problème de régression, pour un nouvel enregistrement, chaque arbre de la forêt prédit une valeur pour Y (sortie). La valeur finale peut être calculée en prenant la moyenne de toutes les valeurs prédites par tous les arbres de la forêt. Ou, dans le cas d’un problème de classification, chaque arbre de la forêt prédit la catégorie à laquelle appartient le nouvel enregistrement. Enfin, le nouveau record est attribué à la catégorie qui remporte le vote majoritaire.

Utilisation de la forêt aléatoire pour la régression

Ici, nous avons un problème où nous devons prédire la consommation de gaz (en millions de gallons) dans 48 États américains sur la base de la taxe sur l’essence (en cents), du revenu par habitant (en dollars), des autoroutes pavées (en miles) et de la proportion de la population avec le permis de conduire. Nous utiliserons l’algorithme de forêt aléatoire via la bibliothèque Scikit-Learn Python pour résoudre ce problème de régression.

Nous importons d’abord les bibliothèques nécessaires et notre ensemble de données.

import pandas as pd 
import numpy as np 
dataset = pd.read_csv('/content/petrol_consumption.csv') 
dataset.head() 
Taxe sur l’essence Revenu moyen routes_pavées Population_Driver_licence(%) Consommation_Essence
0 9.0 3571 1976 0,525 541
1 9.0 4092 1250 0,572 524
2 9.0 3865 1586 0,580 561
3 7.5 4870 2351 0,529 414
4 8.0 4399 431 0,544 410

Vous remarquerez que les valeurs de notre ensemble de données ne sont pas très bien mises à l’échelle. Réduisons-les avant d’entraîner l’algorithme.

Préparation des données pour la formation

Nous effectuerons deux tâches afin de préparer les données. Tout d’abord, nous diviserons les données en ensembles d' »attributs » et d' »étiquettes ». Le résultat sera ensuite divisé en ensembles d’apprentissage et de test.

X = dataset.iloc[:, 0:4].values 
y = dataset.iloc[:, 4].values

Divisons maintenant les données en ensembles d’entraînement et de test :

from sklearn.model_selection import train_test_split 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)

Mise à l’échelle des fonctionnalités

L’ensemble de données n’est pas encore une valeur mise à l’échelle car vous verrez que le champ Average_Income a des valeurs de l’ordre des milliers tandis que Petrol_tax a des valeurs de l’ordre des dizaines. Ce sera mieux si nous mettons à l’échelle nos données. Nous utiliserons la classe StandardScaler de Scikit-Learn pour faire de même.

# Feature Scaling 
from sklearn.preprocessing import StandardScaler 
sc = StandardScaler() 
X_train = sc.fit_transform(X_train) 
X_test = sc.transform(X_test)

Entraînement de l’algorithme

Maintenant que nous avons mis à l’échelle notre ensemble de données, entraînons l’algorithme de forêt aléatoire pour résoudre ce problème de régression.

from sklearn.ensemble import Random Forest Regressor 
regressor = Random Forest Regressor(n_estimators=20,random_state=0) 
regressor.fit(X_train, y_train) 
y_pred = regressor.predict(X_test)

Le RandomForestRegressor est utilisé pour résoudre des problèmes de régression via une forêt aléatoire. Le paramètre le plus important de la classe RandomForestRegressor est le n_estimators paramètre. Ce paramètre définit le nombre d’arbres dans la forêt aléatoire. Ici, nous avons commencé avec n_estimator=20 et vérifions les performances de l’algorithme. Vous pouvez trouver des détails pour tous les paramètres de RandomForestRegressor ici.

Évaluation de l’algorithme

Évaluons les performances de l’algorithme. Pour les problèmes de régression, les métriques utilisées pour évaluer un algorithme sont l’erreur absolue moyenne, l’erreur quadratique moyenne et l’erreur quadratique moyenne.

from sklearn import metrics 
print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred)) 
print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred)) 
print('Root Mean Squared Error:', 
np.sqrt(metrics.mean_squared_error(y_test, y_pred))) 
Mean Absolute Error: 51.76500000000001 
Mean Squared Error: 4216.166749999999 
Root Mean Squared Error: 64.93201637097064 

Avec 20 arbres, l’erreur quadratique moyenne est de 64,93, ce qui est supérieur à 10 % de la consommation moyenne d’essence, c’est-à-dire 576,77. Cela peut indiquer, entre autres, que nous n’avons pas utilisé suffisamment d’estimateurs (arbres).

Passons maintenant le nombre d’estimateurs à 200, les résultats sont les suivants :

Mean Absolute Error: 48.33899999999999 
Mean Squared Error: 3494.2330150000003 
Root Mean Squared Error: 59.112037818028234 

Le graphique ci-dessous montre la diminution de la valeur du erreur quadratique moyenne (RMSE) par rapport au nombre d’estimateurs.

Graphique RMSE dans l'apprentissage automatique

Vous remarquerez que les valeurs d’erreur diminuent avec l’augmentation du nombre d’estimateurs. Vous pouvez considérer que 200 est un bon nombre pour les n_estimators à mesure que le taux de diminution de l’erreur diminue. Vous pouvez essayer de jouer avec d’autres paramètres pour trouver un meilleur résultat.

Utilisation de la forêt aléatoire pour la classification

Considérons maintenant un problème de classification pour prédire si un billet de banque est authentique ou non sur la base de quatre attributs, à savoir la variance de l’image transformée en ondelettes, l’asymétrie, l’entropie et l’aplatissement de l’image. Nous allons utiliser Random Forest Classifier pour résoudre ce problème de classification binaire. Commençons.

import pandas as pd 
import numpy as np 
dataset = pd.read_csv('/content/bill_authentication.csv') 
dataset.head()
Variance Asymétrie Aplatissement Entropie Classer
0 3.62160 8.6661 -2.8073 -0,44699 0
1 4.54590 8.1674 -2,4586 -1.46210 0
2 3.86600 -2,6383 1.9242 0,10645 0
3 3.45660 9.5228 -4.0112 -3.59440 0
4 0,32924 -4.4552 4,5718 -0,98880 0

Semblables aux données que nous avons utilisées précédemment pour le problème de régression, ces données ne sont pas mises à l’échelle. Préparons les données pour la formation.

Préparation des données pour la formation

Le code suivant divise les données en attributs et libellés :

X = dataset.iloc[:, 0:4].values 
y = dataset.iloc[:, 4].values 

Le code suivant divise les données en ensembles d’entraînement et de test :

from sklearn.model_selection import train_test_split 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0) 

Mise à l’échelle des fonctionnalités

Nous ferons la même chose que nous avons fait pour le problème précédent.

# Feature Scaling 
from sklearn.preprocessing import StandardScaler 
sc = StandardScaler() 
X_train = sc.fit_transform(X_train) 
X_test = sc.transform(X_test)

Entraînement de l’algorithme

Maintenant que nous avons mis à l’échelle notre ensemble de données, entraînons l’algorithme de forêt aléatoire pour résoudre ce problème de classification.

from sklearn.ensemble import Random Forest Classifier 
classifier = RandomForestClassifier(n_estimators=20, random_state=0) 
classifier.fit(X_train, y_train) 
y_pred = classifier.predict(X_test)

Pour la classification, nous avons utilisé la classe RandomForestClassifier de la bibliothèque sklearn.ensemble. Il prend n_estimators comme paramètre. Ce paramètre définit le nombre d’arbres dans notre forêt aléatoire. Semblable au problème de régression, nous avons commencé ici avec 20 arbres. Vous pouvez trouver des détails pour tous les paramètres de Random Forest Classifier ici.

Évaluation de l’algorithme

Pour évaluer les problèmes de classification, les métriques utilisées sont la précision, la matrice de confusion, le rappel de précision et les valeurs F1.

from sklearn.metrics import classification_report, confusion_matrix, accuracy_score 
print(confusion_matrix(y_test,y_pred)) 
print(classification_report(y_test,y_pred)) 
print(accuracy_score(y_test, y_pred)) 

La sortie ressemblera à ceci :

Sortir:

[ [ 155   2]
[     1  117] ]
Précision rappeler score f1 Support
0 0,99 0,99 0,99 157
1 0,98 0,99 0,99 118
précision 0,99 275
moyenne macro 0,99 0,99 0,99 275
0.9890909090909091 0,99 0,99 0,99 275

La précision obtenue par notre classificateur de forêt aléatoire avec 20 arbres est de 98,90 %. Modifions le nombre d’arbres à 200.

from sklearn.ensemble import Random Forest Classifier 
classifier = Random Forest Classifier(n_estimators=200, random_state=0) 
classifier.fit(X_train, y_train) 
y_pred = classifier.predict(X_test) 

Sortir:

[ [ 155   2]
[     1  117] ]
Précision rappeler score f1 Support
0 0,99 0,99 0,99 157
1 0,98 0,99 0,99 118
précision 0,99 275
moyenne macro 0,99 0,99 0,99 275
0.9890909090909091 0,99 0,99 0,99 275

Contrairement au problème de régression, la modification du nombre d’estimateurs pour ce problème n’a fait aucune différence dans les résultats.

Forêt aléatoire de précision dans l'apprentissage automatique

Une précision de 98,9% est plutôt bonne. Dans ce cas, nous avons vu qu’il n’y a pas beaucoup d’amélioration si le nombre d’arbres est augmenté. Vous pouvez essayer de jouer avec d’autres paramètres de la classe RandomForestClassifier et voir si vous pouvez améliorer nos résultats.

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

Comme pour tout algorithme, il y a des avantages et des inconvénients à l’utiliser. Examinons les avantages et les inconvénients de l’utilisation de Random Forest pour la classification et la régression.

Avantages

  • L’algorithme de forêt aléatoire est impartial car il existe plusieurs arbres et chaque arbre est formé sur un sous-ensemble de données.
  • L’algorithme Random Forest est très stable. L’introduction de nouvelles données dans l’ensemble de données n’affecte pas grand-chose car les nouvelles données affectent un arbre et sont assez difficiles à affecter tous les arbres.
  • L’algorithme de forêt aléatoire fonctionne bien lorsque vous avez à la fois des caractéristiques catégorielles et numériques.
  • Avec des valeurs manquantes dans l’ensemble de données, l’algorithme de forêt aléatoire fonctionne très bien.

Désavantages

  • Un inconvénient majeur des forêts aléatoires réside dans leur complexité. Plus de ressources de calcul sont nécessaires et entraînent également le grand nombre d’arbres de décision réunis.
  • En raison de leur complexité, le temps d’apprentissage est supérieur à celui d’autres algorithmes.

Résumé

Dans cet article, nous avons couvert ce qu’est l’apprentissage d’ensemble et discuté des techniques d’ensemble de base. Nous avons également examiné l’échantillonnage bootstrap qui implique un rééchantillonnage itératif d’un ensemble de données avec remplacement, ce qui permet au modèle ou à l’algorithme de mieux comprendre diverses caractéristiques. Ensuite, nous sommes passés à l’ensachage suivi d’une forêt aléatoire. Nous avons également implémenté la forêt aléatoire en Python pour la régression et la classification et sommes arrivés à la conclusion que l’augmentation du nombre d’arbres ou d’estimateurs ne fait pas toujours une différence dans un problème de classification. Cependant, dans la régression, il y a un impact.

Nous avons couvert la plupart des sujets liés aux algorithmes dans notre série de blogs sur l’apprentissage automatique, cliquez ici. Si vous êtes inspiré par les opportunités offertes par l’apprentissage automatique, inscrivez-vous à nos cours de science des données et d’apprentissage automatique pour des options de carrière plus lucratives dans ce paysage.

Construisez vos propres projets en utilisant Apprentissage automatique avec Python. Entraînez-vous avec nos experts de l’industrie sur nos ateliers en direct maintenant.





Source de l’article

A découvrir