Modèles arborescents : arbres de décision et forêts aléatoires
Créez et optimisez des modèles d’arbres de décision et de forêts ensemblistes.
Modèles arborescents : arbres de décision et forêts aléatoires est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 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 Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.
Concepts des arbres de décision
Un arbre de décision divise les données en sous-ensembles en posant une suite de questions binaires. Chaque nœud interne correspond à un seuil sur une caractéristique ; chaque feuille produit une prédiction.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=3, random_state=0).fit(X, y)
print("Depth:", model.get_depth())
print("Leaves:", model.get_n_leaves())DecisionTreeClassifier
Hyperparamètres principaux : max_depth, min_samples_split et min_samples_leaf. Les arbres plus profonds surapprennent ; les arbres moins profonds sous-apprennent.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = DecisionTreeClassifier(max_depth=5, min_samples_leaf=5)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))DecisionTreeRegressor
Les arbres de décision prennent également en charge la régression en prédisant la valeur moyenne de la cible dans chaque feuille.
from sklearn.tree import DecisionTreeRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import mean_squared_error
X, y = make_regression(noise=15, random_state=0)
model = DecisionTreeRegressor(max_depth=4).fit(X, y)
print("RMSE:", mean_squared_error(y, model.predict(X))**0.5)Importance des caractéristiques
model.feature_importances_ indique l'importance relative de chaque caractéristique, selon la réduction de l'impureté.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
model = DecisionTreeClassifier().fit(X, y)
for name, imp in sorted(zip(feature_names, model.feature_importances_), key=lambda x: -x[1]):
print(f"{name}: {imp:.3f}")Présentation des forêts aléatoires
Une forêt aléatoire entraîne de nombreux arbres de décision décorrélés sur des échantillons bootstrap et fait la moyenne de leurs prédictions — ce qui réduit la variance sans augmenter le biais.
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = RandomForestClassifier(n_estimators=100, random_state=0)
model.fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))RandomForestRegressor
Les forêts aléatoires sont tout aussi efficaces pour la régression.
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import make_regression
from sklearn.metrics import r2_score
X, y = make_regression(noise=10, random_state=0)
model = RandomForestRegressor(n_estimators=100, random_state=0).fit(X, y)
print("R²:", r2_score(y, model.predict(X)))Score hors sac
Définissez oob_score=True pour obtenir gratuitement un score de validation à partir des échantillons absents de l'échantillon bootstrap de chaque arbre (aucun jeu de test distinct n'est nécessaire).
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(random_state=0)
model = RandomForestClassifier(n_estimators=100, oob_score=True, random_state=0).fit(X, y)
print("OOB score:", model.oob_score_)Gradient boosting
Le gradient boosting (GBM) entraîne les arbres séquentiellement, chacun corrigeant les erreurs du précédent. Il est souvent plus précis que les forêts aléatoires, mais son entraînement est plus lent.
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
model = GradientBoostingClassifier(n_estimators=100).fit(X_tr, y_tr)
print("Test acc:", model.score(X_te, y_te))XGBoost / LightGBM
XGBoost et LightGBM sont des bibliothèques de gradient boosting optimisées — plus rapides, plus évolutives et souvent plus précises que le GBM de sklearn.
# pip install xgboost lightgbm
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(random_state=0)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
xgb = XGBClassifier(n_estimators=100, eval_metric="logloss").fit(X_tr, y_tr)
print("XGB acc:", xgb.score(X_te, y_te))Réglage de n_estimators
Un plus grand nombre d'arbres dans une forêt aléatoire réduit la variance (jusqu'à un certain point) sans entraîner de surapprentissage. Utilisez une courbe de validation pour trouver le nombre optimal.
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(random_state=0)
for n in [10, 50, 100, 200]:
scores = cross_val_score(RandomForestClassifier(n_estimators=n, random_state=0), X, y, cv=5)
print(f"n={n}: {scores.mean():.3f}")Visualisation d'un arbre de décision
Utilisez sklearn.tree.plot_tree ou export_text pour examiner ce que l'arbre a appris.
from sklearn.tree import DecisionTreeClassifier, export_text, plot_tree
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = DecisionTreeClassifier(max_depth=2).fit(X, y)
print(export_text(model, feature_names=load_iris().feature_names.tolist()))Vérification rapide
Comment une forêt aléatoire réduit-elle le surapprentissage par rapport à un seul arbre de décision ?
Récapitulatif
Les arbres de décision divisent les données selon des seuils de caractéristiques et prédisent à partir des valeurs des feuilles. Réglez max_depth pour contrôler le surapprentissage. Les forêts aléatoires font la moyenne de nombreux arbres afin de réduire la variance. Le gradient boosting entraîne les arbres séquentiellement pour obtenir une grande précision. En production, préférez XGBoost ou LightGBM.
Questions Fréquemment Posées
La leçon « Modèles arborescents : arbres de décision et forêts aléatoires » est-elle gratuite ?
Oui — le texte complet de « Modèles arborescents : arbres de décision et 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 Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Modèles arborescents : arbres de décision et forêts aléatoires » ?
Créez et optimisez des modèles d’arbres de décision et de forêts ensemblistes. Tu pratiques Python 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 Python Academy ?
Aucune expérience préalable n'est requise. Python 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 3 sur 4.
Combien de temps prend la leçon « Modèles arborescents : arbres de décision et 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 Python Academy ?
Oui. Chaque leçon Python 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
- L’API scikit-learn : fit, transform, predict
- Modèles linéaires : régression et classification
- Modèles arborescents : arbres de décision et forêts aléatoires
- Évaluation des modèles et validation croisée