Sélection aléatoire des caractéristiques : l’astuce des forêts aléatoires
Configurez max_features dans RandomForestClassifier, observez comment le sous-échantillonnage des caractéristiques décorrèle les arbres et constatez l’augmentation de la précision sur les données de test.
Sélection aléatoire des caractéristiques : l’astuce des forêts aléatoires est une leçon Machine Learning Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Machine Learning Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Machine Learning Academy comprend 4 leçons au total.
Du Bagging aux forêts aléatoires
Un ensemble de bagging classique entraîne chaque arbre sur un échantillon bootstrap différent, mais tous les arbres peuvent toujours utiliser chaque caractéristique lorsqu’ils choisissent une séparation. La caractéristique la plus prédictive domine alors chaque arbre, ce qui les rend fortement corrélés. Lorsque des modèles corrélés sont combinés par une moyenne, la réduction de la variance est limitée. Les forêts aléatoires ajoutent une astuce : à chaque séparation, seul un sous-ensemble aléatoire de caractéristiques est pris en compte. Cela décorrèle les arbres et améliore considérablement la généralisation de l’ensemble.
Le paramètre max_features
Dans RandomForestClassifier, le paramètre max_features contrôle le nombre de caractéristiques candidates à chaque séparation. Les choix courants sont 'sqrt', la racine carrée du nombre total de caractéristiques, valeur par défaut pour la classification, 'log2', ou un entier ou un nombre flottant. Pour la régression (RandomForestRegressor), la valeur par défaut est 1.0, c’est-à-dire toutes les caractéristiques, et 'sqrt' ou 0.33 sont des choix courants. Des valeurs plus petites produisent des arbres plus diversifiés, au prix d’une légère diminution de la performance individuelle de chaque arbre.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
for mf in ['sqrt', 'log2', 0.5, 1.0]:
rf = RandomForestClassifier(n_estimators=100, max_features=mf, random_state=42)
score = cross_val_score(rf, X, y, cv=5).mean()
print(f'max_features={str(mf):6s}: CV accuracy={score:.4f}')Pourquoi le sous-échantillonnage des caractéristiques décorrèle les arbres
Considérez un jeu de données comportant une caractéristique dominante qui prédit l’étiquette bien mieux que toutes les autres. Sans sous-échantillonnage des caractéristiques, chaque arbre de l’ensemble effectuerait une séparation sur cette caractéristique à la racine, produisant des arbres presque identiques. Faire la moyenne de prédictions identiques donne la même prédiction : aucune réduction de la variance. Lorsque seules sqrt(p) caractéristiques sont candidates à chaque nœud, cette caractéristique dominante est absente de nombreuses séparations, ce qui force les arbres à découvrir d’autres régularités prédictives et à devenir réellement diversifiés.
Entraîner un RandomForestClassifier
Utiliser RandomForestClassifier de scikit-learn est simple. Vous spécifiez le nombre d’arbres avec n_estimators, contrôlez la complexité des arbres avec max_depth et activez l’évaluation OOB avec oob_score=True. Le modèle entraîne tous les arbres en parallèle lorsque n_jobs=-1. Après l’ajustement, feature_importances_ fournit une mesure classée des caractéristiques d’entrée qui ont contribué aux prédictions dans l’ensemble des arbres.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
rf = RandomForestClassifier(
n_estimators=200,
max_features='sqrt',
oob_score=True,
n_jobs=-1,
random_state=42
)
rf.fit(X_train, y_train)
print('OOB score:', rf.oob_score_)
print('Test accuracy:', rf.score(X_test, y_test))Importance des caractéristiques dans une forêt aléatoire
Les forêts aléatoires calculent l’importance d’une caractéristique comme la diminution moyenne de l’impureté (Gini ou entropie) causée par les séparations sur cette caractéristique, pondérée par le nombre d’échantillons qui passent par chaque nœud, puis moyennée sur tous les arbres. Cela fournit un classement global rapide de la puissance prédictive. Les importances ont une somme égale à 1 et sont accessibles via rf.feature_importances_. Elles peuvent toutefois favoriser les caractéristiques à forte cardinalité ; considérez-les donc comme une heuristique utile plutôt que comme une vérité absolue.
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X, y = data.data, data.target
feature_names = data.feature_names
rf = RandomForestClassifier(n_estimators=200, random_state=42)
rf.fit(X, y)
importances = pd.Series(rf.feature_importances_, index=feature_names)
print(importances.sort_values(ascending=False).head(5))Comparer une forêt aléatoire à un arbre unique
Un arbre de décision unique entraîné sur l’ensemble des données est très sensible au bruit des données d’entraînement : la modification de quelques exemples peut changer radicalement la structure de l’arbre. Une forêt aléatoire, en faisant la moyenne de centaines d’arbres aussi sensibles, crée une surface de prédiction beaucoup plus lisse et robuste. Cette comparaison illustre particulièrement clairement comment la diversité d’un ensemble se traduit par une amélioration de la généralisation.
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
single = DecisionTreeClassifier(random_state=42)
forest = RandomForestClassifier(n_estimators=200, random_state=42)
print('Single tree CV:', np.round(cross_val_score(single, X, y, cv=5), 4))
print('Random forest CV:', np.round(cross_val_score(forest, X, y, cv=5), 4))Contrôler la profondeur des arbres dans une forêt
Chaque arbre d’une forêt aléatoire est généralement développé en profondeur (faible biais, variance élevée). Le bagging corrige ensuite la variance. Toutefois, pour les très grands jeux de données, vous pouvez limiter max_depth ou min_samples_leaf afin de réduire la mémoire et le temps d’entraînement. Définir max_depth=None (la valeur par défaut) permet aux arbres de croître jusqu’à ce que toutes les feuilles soient pures. Une forêt peu profonde se comporte davantage comme un ensemble de boosting : des apprenants de base à faible variance qui peinent à capturer des frontières complexes. Le meilleur compromis dépend du niveau de bruit de votre jeu de données.
Forêt aléatoire pour la régression
RandomForestRegressor suit le même algorithme, mais effectue la moyenne des valeurs numériques prédites par chaque arbre au lieu de voter pour une étiquette de classe. La valeur par défaut de max_features pour la régression dans les versions modernes de scikit-learn est 1.0, mais l’utilisation de 'sqrt' ou d’une fraction est souvent bénéfique. Les forêts de régression fonctionnent bien sur les données tabulaires présentant des interactions non linéaires et sont fréquemment utilisées pour la prédiction du prix des logements, la prévision de la consommation d’énergie et d’autres problèmes à cible continue.
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import cross_val_score
import numpy as np
X, y = fetch_california_housing(return_X_y=True)
rfr = RandomForestRegressor(n_estimators=100, max_features='sqrt', n_jobs=-1, random_state=42)
rmse = np.sqrt(-cross_val_score(rfr, X, y, scoring='neg_mean_squared_error', cv=3).mean())
print(f'Random Forest Regression RMSE: {rmse:.4f}')Variance des importances des caractéristiques
Comme chaque arbre observe un échantillon bootstrap et des sous-ensembles de caractéristiques différents, les importances calculées lors de différentes exécutions ou avec différentes forêts peuvent varier. Pour obtenir des estimations plus fiables de l’importance, utilisez l’importance par permutation (sklearn.inspection.permutation_importance), qui mesure la baisse de la précision du modèle lorsque les valeurs d’une caractéristique sont mélangées aléatoirement. L’importance par permutation fonctionne avec tout modèle boîte noire et ne souffre pas du biais envers les fortes cardinalités des importances fondées sur l’impureté.
from sklearn.inspection import permutation_importance
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import pandas as pd
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
rf = RandomForestClassifier(n_estimators=100, random_state=42).fit(X_train, y_train)
result = permutation_importance(rf, X_test, y_test, n_repeats=10, random_state=42)
print(pd.Series(result.importances_mean, index=load_breast_cancer().feature_names).sort_values(ascending=False).head(5))Réglage des hyperparamètres des forêts aléatoires
Les hyperparamètres les plus importants d’une forêt aléatoire sont n_estimators (un nombre plus élevé est généralement préférable, jusqu’à atteindre un plateau), max_features (contrôle la décorrélation), max_depth et min_samples_leaf (contrôlent le compromis biais-variance de chaque arbre). Une recherche sur grille portant sur max_features et min_samples_leaf est souvent suffisante, car n_estimators peut être défini à une valeur élevée et max_depth=None constitue une bonne valeur par défaut. Utilisez le score OOB pour un réglage approximatif rapide avant de lancer une validation croisée complète.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
param_grid = {'max_features': ['sqrt', 'log2', 0.5], 'min_samples_leaf': [1, 3, 5]}
grid = GridSearchCV(RandomForestClassifier(n_estimators=100, random_state=42), param_grid, cv=5)
grid.fit(X, y)
print('Best params:', grid.best_params_)
print('Best CV score:', round(grid.best_score_, 4))Limites des forêts aléatoires
Les forêts aléatoires sont puissantes, mais présentent des limites importantes. Elles sont gourmandes en mémoire, car chaque arbre doit être stocké. Les prédictions sont lentes avec les très grandes forêts, puisque chaque prédiction nécessite de parcourir tous les arbres. Elles ne sont pas non plus les plus adaptées aux données tabulaires structurées comportant de nombreuses caractéristiques non pertinentes, où le boosting par gradient est souvent plus performant. Enfin, les forêts aléatoires ne disposent d’aucun mécanisme naturel pour capturer une structure séquentielle ou spatiale : pour les images ou le texte, les méthodes d’apprentissage profond les surpassent nettement.
Vérification rapide
Vérifiez votre compréhension des concepts de sélection des caractéristiques dans les forêts aléatoires présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que : les forêts aléatoires ajoutent le sous-échantillonnage des caractéristiques au bagging afin de décorréler les arbres, max_features contrôle le nombre de caractéristiques candidates à chaque séparation et les importances des caractéristiques révèlent quelles entrées déterminent les prédictions dans la forêt. Nous allons maintenant explorer l’erreur hors sac, un mécanisme intégré de validation gratuit.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Sélection aléatoire des caractéristiques : l’astuce des forêts aléatoires » est-elle gratuite ?
Oui — le texte complet de « Sélection aléatoire des caractéristiques : l’astuce des forêts aléatoires » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Machine Learning Academy, passe à CoddyKit PRO. Le cours Machine Learning Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Sélection aléatoire des caractéristiques : l’astuce des forêts aléatoires » ?
Configurez max_features dans RandomForestClassifier, observez comment le sous-échantillonnage des caractéristiques décorrèle les arbres et constatez l’augmentation de la précision sur les données de… Tu pratiques Machine Learning Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Machine Learning Academy ?
Aucune expérience préalable n'est requise. Machine Learning Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Sélection aléatoire des caractéristiques : l’astuce des forêts aléatoires » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Machine Learning Academy ?
Oui. Chaque leçon Machine Learning Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Agrégation par bootstrap (bagging) expliquée
- Sélection aléatoire des caractéristiques : l’astuce des forêts aléatoires
- Erreur hors sac : validation gratuite dans la forêt
- Ensembles par vote : vote dur ou vote souple