Forêts aléatoires et bagging
Concept d’ensemble, RandomForestClassifier, n_estimators, importance des caractéristiques et score OOB.
Forêts aléatoires et bagging est une leçon Learn AI with Python 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 Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
Le problème des arbres uniques
Un arbre de décision unique présente une variance élevée : un nouvel entraînement sur des données légèrement différentes peut produire un arbre très différent. Les méthodes d’ensemble corrigent ce problème en combinant de nombreux arbres.
Agrégation par rééchantillonnage
L’agrégation par rééchantillonnage entraîne de nombreux modèles sur différents échantillons rééchantillonnés des données (échantillonnage aléatoire avec remise), puis fait la moyenne de leurs prédictions.
Faire la moyenne de nombreux modèles à variance élevée réduit la variance globale sans augmenter beaucoup le biais.
from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier
bag = BaggingClassifier(
estimator=DecisionTreeClassifier(),
n_estimators=100,
random_state=0,
)
bag.fit(Xtr, ytr)De l’agrégation aux forêts aléatoires
Une forêt aléatoire applique l’agrégation à des arbres et ajoute une astuce : à chaque séparation, elle ne considère qu’un sous-ensemble aléatoire de caractéristiques.
Cela décorrèle les arbres, de sorte que leurs erreurs s’annulent davantage, ce qui améliore l’ensemble.
Bases de RandomForestClassifier
Utilisez RandomForestClassifier. Le paramètre clé n_estimators définit le nombre d’arbres à construire. Plus il y a d’arbres, plus le résultat est stable, mais plus l’exécution est lente.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, random_state=0)
rf.fit(Xtr, ytr)
print("Accuracy:", rf.score(Xte, yte))Entraînement parallèle avec n_jobs
Les arbres d’une forêt sont indépendants et peuvent donc être entraînés en parallèle. Définissez n_jobs=-1 pour utiliser tous les cœurs du CPU et accélérer considérablement l’entraînement.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=500,
n_jobs=-1, # use all cores
random_state=0,
)
rf.fit(Xtr, ytr)Score hors échantillon (OOB)
Chaque arbre laisse de côté environ un tiers des échantillons, car le rééchantillonnage ne les a pas sélectionnés. Ces échantillons hors échantillon forment un ensemble de validation intégré.
Définissez oob_score=True pour obtenir gratuitement une estimation de l’erreur de généralisation, sans séparation supplémentaire des données.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
oob_score=True,
random_state=0,
)
rf.fit(Xtr, ytr)
print("OOB score:", rf.oob_score_)Contrôler la profondeur des arbres de la forêt
Les mêmes paramètres s’appliquent aux arbres : max_depth, min_samples_leaf et max_features (le nombre de caractéristiques à essayer pour chaque séparation).
max_features="sqrt" est la valeur par défaut courante pour la classification.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(
n_estimators=300,
max_depth=12,
max_features="sqrt",
random_state=0,
)Importance intégrée des caractéristiques
Comme les arbres uniques, les forêts exposent feature_importances_, dont la valeur est moyennée sur tous les arbres. Cette importance fondée sur l’impureté est rapide à calculer, mais peut favoriser les caractéristiques à forte cardinalité.
from sklearn.ensemble import RandomForestClassifier
import numpy as np
rf = RandomForestClassifier(n_estimators=200, random_state=0).fit(Xtr, ytr)
order = np.argsort(rf.feature_importances_)[::-1]
for i in order[:5]:
print(i, rf.feature_importances_[i])Importance par permutation
L’importance par permutation est plus fiable : elle permute une colonne de caractéristique et mesure la baisse du score. Une forte baisse signifie que la caractéristique était importante.
Cette méthode ne dépend pas du modèle et évite le biais lié à l’impureté.
from sklearn.inspection import permutation_importance
result = permutation_importance(
rf, Xte, yte, n_repeats=10, random_state=0, n_jobs=-1
)
print(result.importances_mean)Interpréter les résultats des permutations
permutation_importance renvoie importances_mean et importances_std sur plusieurs répétitions. Calculez-la sur un ensemble mis de côté afin de mesurer l’impact sur la généralisation, et non sur l’ajustement aux données d’entraînement.
import numpy as np
means = result.importances_mean
stds = result.importances_std
for i in np.argsort(means)[::-1]:
print(f"feature {i}: {means[i]:.3f} +/- {stds[i]:.3f}")Quand utiliser les forêts aléatoires
Les forêts aléatoires constituent un excellent choix par défaut : elles sont robustes, nécessitent peu de réglages, gèrent les non-linéarités et les interactions, et résistent au surapprentissage. Leurs inconvénients sont une consommation mémoire plus importante, des prédictions plus lentes qu’avec un arbre unique et une interprétabilité moindre.
Vérification rapide
Vérifiez votre compréhension de l’agrégation par rééchantillonnage et des forêts aléatoires.
Récapitulatif
Récapitulatif : l’agrégation par rééchantillonnage entraîne des modèles sur des échantillons rééchantillonnés et en fait la moyenne pour réduire la variance. Les forêts aléatoires ajoutent des sous-ensembles aléatoires de caractéristiques à chaque séparation. Ajustez n_estimators, utilisez n_jobs=-1 pour accélérer l’entraînement, obtenez une validation gratuite avec oob_score et préférez permutation_importance à l’importance fondée sur l’impureté pour obtenir des classements fiables.
Questions Fréquemment Posées
La leçon « Forêts aléatoires et bagging » est-elle gratuite ?
Oui — le texte complet de « Forêts aléatoires et bagging » 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 Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Forêts aléatoires et bagging » ?
Concept d’ensemble, RandomForestClassifier, n_estimators, importance des caractéristiques et score OOB. Tu pratiques Learn AI with Python 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 Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python 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 « Forêts aléatoires et bagging » ?
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 Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python 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
- Arbres de décision : théorie et implémentation
- Forêts aléatoires et bagging
- Gradient boosting : GBM et XGBoost
- LightGBM et CatBoost