cours
Classification par forêt aléatoire avec Scikit-Learn
Ce tutoriel explique comment utiliser les forêts aléatoires pour la classification en Python. Nous aborderons les sujets suivants :
- Fonctionnement des forêts aléatoires
- Comment les utiliser pour la classification
- Comment évaluer leur performance
Pour tirer le meilleur parti de cet article, vous devez avoir une connaissance de base de Python, de pandas et de scikit-learn. Il est utile de comprendre comment les arbres de décision sont utilisés pour la classification, alors pensez à lire d'abord notre tutoriel sur la classification par arbre de décision en Python. Si vous commencez à utiliser scikit-learn, consultez Kaggle Tutorial : Votre premier modèle d'apprentissage automatique.
Bien que les forêts aléatoires puissent être utilisées à la fois pour la classification et la régression, cet article se concentrera sur la construction d'un modèle de classification. Pour expérimenter facilement le code de ce tutoriel, consultez le classeur DataLab qui l'accompagne. Enfin, essayez de suivre notre cours Model Validation in Python, qui vous permet de vous entraîner à la classification par forêt aléatoire à l'aide de l'ensemble de données tic_tac_toe
.
Aperçu des forêts aléatoires
Les forêts aléatoires sont un algorithme populaire d'apprentissage automatique supervisé qui peut traiter à la fois les tâches de régression et de classification. Vous trouverez ci-dessous quelques-unes des principales caractéristiques des forêts aléatoires :
- Les forêts aléatoires sont destinées à l'apprentissage automatique supervisé, lorsqu'il existe une variable cible étiquetée.
- Les forêts aléatoires peuvent être utilisées pour résoudre des problèmes de régression (variable cible numérique) et de classification (variable cible catégorielle).
- Les forêts aléatoires sont une méthode d'ensemble, ce qui signifie qu'elles combinent les prédictions d'autres modèles.
- Chacun des petits modèles de la forêt aléatoire est un arbre de décision.
Devenez un scientifique ML
Comment fonctionne la classification par forêt aléatoire
Imaginez que vous ayez un problème complexe à résoudre et que vous réunissiez un groupe d'experts de différents domaines pour qu'ils apportent leur contribution. Chaque expert donne son avis sur la base de son expertise et de son expérience. Ensuite, les experts voteront pour prendre une décision finale.
Dans une classification par forêt aléatoire, plusieurs arbres de décision sont créés en utilisant différents sous-ensembles aléatoires de données et de caractéristiques. Chaque arbre de décision est comme un expert qui donne son avis sur la manière de classer les données. Les prédictions sont faites en calculant la prédiction pour chaque arbre de décision et en prenant le résultat le plus populaire. (Pour la régression, les prévisions utilisent plutôt une technique de calcul de la moyenne).
Dans le diagramme ci-dessous, nous avons une forêt aléatoire avec n arbres de décision, et nous avons montré les 5 premiers, ainsi que leurs prédictions (soit "Chien", soit "Chat"). Chaque arbre est exposé à un nombre différent de caractéristiques et à un échantillon différent de l'ensemble de données original. Chaque arbre fait une prédiction.
En regardant les 5 premiers arbres, nous pouvons voir que 4/5 ont prédit que l'échantillon était un Chat. Les cercles verts indiquent un chemin hypothétique emprunté par l'arbre pour parvenir à sa décision. La forêt aléatoire compterait le nombre de prédictions des arbres de décision pour Cat
et pour Dog
, et choisirait la prédiction la plus populaire.
Illustration du fonctionnement de la classification par forêt aléatoire. Image par l'auteur
Charger l'ensemble de données
Cet ensemble de données est constitué de campagnes de marketing direct menées par une institution bancaire portugaise au moyen d'appels téléphoniques. Les campagnes visaient à vendre des abonnements à un dépôt bancaire à terme. Nous allons stocker cet ensemble de données dans une variable appelée bank_data
. Les colonnes que nous utiliserons sont les suivantes :
age
: L'âge de la personne qui a reçu l'appel téléphoniquedefault
: Si la personne est en défaut de paiementcons.price.idx
: Indice des prix à la consommation au moment de l'appelcons.conf.idx
Indice de confiance des consommateurs au moment de l'appely
: Si la personne s'est abonnée (c'est ce que nous essayons de prédire)
Importation de paquets
Les paquets et fonctions suivants sont utilisés dans ce tutoriel :
# Data Processing
import pandas as pd
import numpy as np
# Modelling
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, precision_score, recall_score, ConfusionMatrixDisplay
from sklearn.model_selection import RandomizedSearchCV, train_test_split
from scipy.stats import randint
# Tree Visualisation
from sklearn.tree import export_graphviz
from IPython.display import Image
import graphviz
Le flux de travail de Random Forest
Pour ajuster et entraîner ce modèle, nous suivrons l'infographie The Machine Learning Workflow; cependant, comme nos données sont assez propres, nous n'effectuerons pas toutes les étapes. Nous ferons ce qui suit :
- Ingénierie des fonctionnalités
- Diviser les données
- Former le modèle
- Réglage des hyperparamètres
- Évaluer la performance du modèle
Prétraitement des données pour notre classificateur Random Forest
Les modèles arborescents sont beaucoup plus résistants aux valeurs aberrantes que les modèles linéaires, et ils n'ont pas besoin de normaliser les variables pour fonctionner. Ainsi, nous n'avons besoin que de très peu de prétraitement sur nos données.
- Nous ferons correspondre notre colonne
default
, qui contientno
etyes
, aux colonnes0
et1
, respectivement. Dans cet exemple, nous traiterons les valeursunknown
commeno
. - Nous allons également faire correspondre notre cible,
y
, à1
s et0
s.
bank_data['default'] = bank_data['default'].map({'no':0,'yes':1,'unknown':0})
bank_data['y'] = bank_data['y'].map({'no':0,'yes':1})
Diviser les données
Lors de l'apprentissage d'un modèle d'apprentissage supervisé, il est important de diviser les données en données d'apprentissage et en données de test. Les données d'apprentissage sont utilisées pour ajuster le modèle. L'algorithme utilise les données d'apprentissage pour apprendre la relation entre les caractéristiques et la cible. Les données de test sont utilisées pour évaluer la performance du modèle.
Le code ci-dessous divise les données en variables distinctes pour les caractéristiques et la cible, puis en données de formation et de test.
# Split the data into features (X) and target (y)
X = bank_data.drop('y', axis=1)
y = bank_data['y']
# Split the data into training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
Ajustement et évaluation du modèle Random Forest
Nous commençons par créer une instance du modèle Random forest avec les paramètres par défaut. Nous l'adaptons ensuite à nos données d'apprentissage. Nous transmettons à la fois les caractéristiques et la variable cible afin que le modèle puisse apprendre.
rf = RandomForestClassifier()
rf.fit(X_train, y_train)
À ce stade, nous disposons d'un modèle de forêt aléatoire entraîné, mais nous devons déterminer si ses prédictions sont exactes.
y_pred = rf.predict(X_test)
La façon la plus simple d'évaluer ce modèle est d'utiliser la précision ; nous vérifions les prédictions par rapport aux valeurs réelles de l'ensemble de test et comptons combien le modèle a eu raison.
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)
Sortie :
Accuracy: 0.888
C'est un très bon score ! Cependant, nous pouvons faire mieux en optimisant nos hyperparamètres.
Visualisation des résultats
Nous pouvons utiliser le code suivant pour visualiser nos trois premiers arbres.
# Export the first three decision trees from the forest
for i in range(3):
tree = rf.estimators_[i]
dot_data = export_graphviz(tree,
feature_names=X_train.columns,
filled=True,
max_depth=2,
impurity=False,
proportion=True)
graph = graphviz.Source(dot_data)
display(graph)
Chaque image d'arbre ne montre que les premiers nœuds. Ces arbres peuvent devenir très grands et difficiles à visualiser. Les couleurs représentent la classe majoritaire de chaque nœud (boîte), le rouge indiquant la majorité 0 (pas d'abonnement) et le bleu la majorité 1 (abonnement). Les couleurs sont d'autant plus foncées que le nœud est proche de 0 ou de 1. Chaque nœud contient également les informations suivantes :
- Nom et valeur de la variable utilisée pour le fractionnement
- Le pourcentage d'échantillons totaux dans chaque fraction
- Le % de répartition entre les classes dans chaque répartition
Réglage des hyperparamètres
Le code ci-dessous utilise la fonction RandomizedSearchCV
de Scikit-Learn, qui recherche aléatoirement des paramètres dans une fourchette par hyperparamètre. Nous définissons les hyperparamètres à utiliser et leurs plages dans le dictionnaire param_dist. Dans notre cas, nous utilisons :
- n_estimateurs: le nombre d'arbres de décision dans la forêt. L'augmentation de cet hyperparamètre améliore généralement les performances du modèle, mais augmente également le coût de calcul de l'apprentissage et de la prédiction.
- max_depth: la profondeur maximale de chaque arbre de décision dans la forêt. Une valeur plus élevée pour max_depth peut conduire à un surajustement, tandis qu'une valeur trop faible peut conduire à un sous-ajustement.
param_dist = {'n_estimators': randint(50,500),
'max_depth': randint(1,20)}
# Create a random forest classifier
rf = RandomForestClassifier()
# Use random search to find the best hyperparameters
rand_search = RandomizedSearchCV(rf,
param_distributions = param_dist,
n_iter=5,
cv=5)
# Fit the random search object to the data
rand_search.fit(X_train, y_train)
RandomizedSearchCV
entraînera de nombreux modèles (définis par n_iter_ et enregistrera chacun d'entre eux en tant que variables, le code ci-dessous crée une variable pour le meilleur modèle et imprime les hyperparamètres. Dans ce cas, nous n'avons pas transmis de système d'évaluation à la fonction, qui utilise donc par défaut la précision. Cette fonction utilise également la validation croisée, ce qui signifie qu'elle divise les données en cinq groupes de taille égale et qu'elle en utilise quatre pour la formation et un pour le test. Il passe en boucle sur chaque groupe et donne un score de précision, dont la moyenne est calculée pour trouver le meilleur modèle.
# Create a variable for the best model
best_rf = rand_search.best_estimator_
# Print the best hyperparameters
print('Best hyperparameters:', rand_search.best_params_)
Sortie :
Best hyperparameters: {'max_depth': 5, 'n_estimators': 260}
Autres mesures d'évaluation de Random Forest
Examinons la matrice de confusion. Il s'agit d'une représentation graphique de ce que le modèle a prédit par rapport à ce qu'a été la prédiction correcte. Nous pouvons l'utiliser pour comprendre le compromis entre les faux positifs (en haut à droite) et les faux négatifs (en bas à gauche). Nous pouvons tracer la matrice de confusion à l'aide de ce code :
# Generate predictions with the best model
y_pred = best_rf.predict(X_test)
# Create the confusion matrix
cm = confusion_matrix(y_test, y_pred)
ConfusionMatrixDisplay(confusion_matrix=cm).plot();
Sortie :
Évaluation d'un classificateur de forêt aléatoire à l'aide d'une matrice de confusion. Image par l'auteur
Nous devrions également évaluer le meilleur modèle en termes d'exactitude, de précision et de rappel (notez que vos résultats peuvent différer en raison de la randomisation).
y_pred = knn.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
print("Accuracy:", accuracy)
print("Precision:", precision)
print("Recall:", recall)
Sortie :
Accuracy: 0.885
Precision: 0.578
Recall: 0.0873
Le code ci-dessous indique l'importance de chaque caractéristique, en utilisant le score interne du modèle pour trouver la meilleure façon de diviser les données dans chaque arbre de décision.
# Create a series containing feature importances from the model and feature names from the training data
feature_importances = pd.Series(best_rf.feature_importances_, index=X_train.columns).sort_values(ascending=False)
# Plot a simple bar chart
feature_importances.plot.bar();
Cela nous indique que l'indice de confiance des consommateurs, au moment de l'appel, était le principal facteur permettant de prédire si la personne s'abonnait ou non.
Les caractéristiques du classificateur de forêt aléatoire sont classées par ordre d'importance. Image par l'auteur
Passez au niveau supérieur
Pour commencer avec l'apprentissage automatique supervisé en Python, prenez Apprentissage supervisé avec scikit-learn. Pour en savoir plus sur l'utilisation des forêts aléatoires et d'autres modèles d'apprentissage automatique basés sur des arbres, consultez nos cours Machine Learning with Tree-Based Models in Python (Apprentissage automatique avec des modèles basés sur des arbres en Python ) et Ensemble Methods in Python (Méthodes d'ensemble en Python).
FAQ sur les forêts aléatoires
Qu'est-ce que la classification par forêt aléatoire ?
La classification par forêt aléatoire est un algorithme d'apprentissage automatique qui utilise plusieurs arbres de décision pour classer les données. En agrégeant les prédictions de plusieurs arbres de décision, il réduit l'ajustement excessif et améliore la précision.
Comment la forêt aléatoire empêche-t-elle l'ajustement excessif ?
La forêt aléatoire réduit l'ajustement excessif en créant plusieurs arbres de décision utilisant différents sous-ensembles de données et de caractéristiques. Il calcule ensuite la moyenne des prédictions, ce qui rend le modèle plus généralisable et moins susceptible de s'adapter au bruit dans les données d'apprentissage.
Quels sont les principaux hyperparamètres à ajuster dans la classification par forêt aléatoire ?
Les hyperparamètres clés de la forêt aléatoire comprennent le nombre d'arbres, la profondeur maximale de chaque arbre, le nombre minimal d'échantillons requis pour diviser un nœud et le nombre de caractéristiques à prendre en compte pour chaque division.
Quels sont les avantages de la classification par forêt aléatoire ?
La classification par forêt aléatoire est résistante au surajustement, donne de bons résultats avec de grands ensembles de données, peut traiter des caractéristiques numériques et catégorielles et est moins sensible à l'ajustement des hyperparamètres que d'autres algorithmes tels que les réseaux neuronaux.
Comment la forêt aléatoire gère-t-elle les données manquantes ?
La forêt aléatoire peut gérer les valeurs manquantes en les estimant à l'aide de splits de substitution ou en calculant la moyenne des résultats de différents arbres de décision, ce qui la rend plus tolérante aux ensembles de données incomplets que les modèles d'arbres de décision individuels.
Quelle est la différence entre la classification par forêt aléatoire et la régression par forêt aléatoire ?
La classification par forêt aléatoire prédit des résultats catégoriels, tels que des étiquettes ou des classes (par exemple, "spam" ou "non spam"), tandis que la régression par forêt aléatoire prédit des résultats numériques continus, tels que les prix des maisons ou les températures.
Devenez un scientifique ML
Cours Python
cours
Introduction to Data Science in Python
cours