Estimation de l'erreur hors-bag (OOB) pour les forêts aléatoires

Introduction

Dans ce laboratoire, nous allons démontrer comment mesurer le taux d'erreur hors-bag (OOB) pour un modèle Random Forest à l'aide de la bibliothèque scikit-learn en Python. Le taux d'erreur hors-bag est la moyenne des erreurs pour chaque observation d'entraînement calculée à partir des prédictions des arbres qui ne contiennent pas l'observation dans leur échantillonnage bootstrap respectif. Cela permet d'ajuster et de valider le modèle Random Forest pendant l'entraînement.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques requises

Nous allons commencer par importer les bibliothèques requises, y compris scikit-learn, NumPy et Matplotlib. Nous allons également définir une valeur d'état aléatoire pour garantir la reproductibilité.

import matplotlib.pyplot as plt
from collections import OrderedDict
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier

RANDOM_STATE = 123

Générer un ensemble de données de classification binaire

Ensuite, nous allons générer un ensemble de données de classification binaire à l'aide de la fonction make_classification fournie par scikit-learn. Cette fonction nous permet de spécifier le nombre d'échantillons, de caractéristiques, de grappes par classe et de caractéristiques informatives. Nous utiliserons une valeur d'état aléatoire fixe pour garantir la reproductibilité.

X, y = make_classification(
    n_samples=500,
    n_features=25,
    n_clusters_per_class=1,
    n_informative=15,
    random_state=RANDOM_STATE,
)

Définir les classifieurs d'ensemble

Nous allons définir une liste de trois classifieurs Random Forest, chacun avec une valeur différente pour le paramètre max_features. Nous allons définir le paramètre de construction warm_start sur True pour activer le suivi du taux d'erreur hors-bag (OOB) pendant l'entraînement. Nous allons également définir le paramètre oob_score sur True pour activer le calcul du taux d'erreur hors-bag.

ensemble_clfs = [
    (
        "RandomForestClassifier, max_features='sqrt'",
        RandomForestClassifier(
            warm_start=True,
            oob_score=True,
            max_features="sqrt",
            random_state=RANDOM_STATE,
        ),
    ),
    (
        "RandomForestClassifier, max_features='log2'",
        RandomForestClassifier(
            warm_start=True,
            max_features="log2",
            oob_score=True,
            random_state=RANDOM_STATE,
        ),
    ),
    (
        "RandomForestClassifier, max_features=None",
        RandomForestClassifier(
            warm_start=True,
            max_features=None,
            oob_score=True,
            random_state=RANDOM_STATE,
        ),
    ),
]

Calculer le taux d'erreur hors-bag (OOB)

Pour chaque classifieur, nous allons parcourir une plage de valeurs de n_estimators et ajuster le classifieur à l'ensemble de données. Nous allons enregistrer le taux d'erreur hors-bag pour chaque valeur de n_estimators et le stocker dans un objet OrderedDict.

error_rate = OrderedDict((label, []) for label, _ in ensemble_clfs)

min_estimators = 15
max_estimators = 150

for label, clf in ensemble_clfs:
    for i in range(min_estimators, max_estimators + 1, 5):
        clf.set_params(n_estimators=i)
        clf.fit(X, y)

        oob_error = 1 - clf.oob_score_
        error_rate[label].append((i, oob_error))

Visualiser le taux d'erreur hors-bag (OOB)

Enfin, nous allons tracer le taux d'erreur hors-bag pour chaque classifieur en fonction du nombre d'estimateurs. Cela nous permettra d'identifier le nombre d'estimateurs à partir duquel le taux d'erreur se stabilise. Nous utiliserons Matplotlib pour générer le tracé.

for label, clf_err in error_rate.items():
    xs, ys = zip(*clf_err)
    plt.plot(xs, ys, label=label)

plt.xlim(min_estimators, max_estimators)
plt.xlabel("n_estimators")
plt.ylabel("Taux d'erreur hors-bag")
plt.legend(loc="upper right")
plt.show()

Sommaire

Dans ce laboratoire, nous avons démontré comment mesurer le taux d'erreur hors-bag (OOB) pour un modèle Random Forest à l'aide de scikit-learn. Nous avons généré un ensemble de données de classification binaire, défini une liste de classifieurs d'ensemble, calculé le taux d'erreur hors-bag pour chaque classifieur et visualisé les résultats. Cette technique nous permet d'estimer le taux d'erreur d'un modèle Random Forest sans avoir besoin d'un ensemble de validation séparé.