Schätzung der OOB-Fehlerrate für Random Forest

Einführung

In diesem Lab werden wir demonstrieren, wie man die Out-Of-Bag (OOB)-Fehlerrate für ein Random Forest-Modell mit der Python-Bibliothek scikit-learn misst. Die OOB-Fehlerrate ist die durchschnittliche Fehlerrate für jede Trainingsbeobachtung, die mithilfe der Vorhersagen der Bäume berechnet wird, die die Beobachtung in ihrer jeweiligen Bootstrap-Stichprobe nicht enthalten. Dies ermöglicht es, das Random Forest-Modell während des Trainings zu trainieren und zu validieren.

Tipps für die virtuelle Maschine

Nachdem der Start der virtuellen Maschine abgeschlossen ist, klicken Sie in der linken oberen Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu nutzen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Importieren der erforderlichen Bibliotheken

Wir beginnen mit dem Importieren der erforderlichen Bibliotheken, einschließlich scikit-learn, NumPy und Matplotlib. Wir setzen auch einen Zufallszustandswert, um die Reproduzierbarkeit zu gewährleisten.

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

RANDOM_STATE = 123

Erzeugen eines binären Klassifizierungsdatensatzes

Als nächstes werden wir einen binären Klassifizierungsdatensatz mit der Funktion make_classification von scikit-learn erzeugen. Mit dieser Funktion können wir die Anzahl der Proben, Merkmale, Cluster pro Klasse und informativen Merkmale angeben. Wir werden einen festen Zufallszustandswert verwenden, um die Reproduzierbarkeit zu gewährleisten.

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

Definieren der Ensemble-Klassifizierer

Wir werden eine Liste von drei Random Forest-Klassifizierern definieren, wobei jeder einen anderen Wert für den Parameter max_features hat. Wir setzen den Konstruktionsparameter warm_start auf True, um die Verfolgung der OOB-Fehlerrate während des Trainings zu ermöglichen. Wir setzen auch den Parameter oob_score auf True, um die Berechnung der OOB-Fehlerrate zu ermöglichen.

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,
        ),
    ),
]

Berechnen der OOB-Fehlerrate

Für jeden Klassifizierer werden wir durch einen Bereich von n_estimators-Werten iterieren und den Klassifizierer an den Datensatz anpassen. Wir werden die OOB-Fehlerrate für jeden n_estimators-Wert aufzeichnen und sie in einem OrderedDict-Objekt speichern.

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))

Visualisieren der OOB-Fehlerrate

Schließlich werden wir die OOB-Fehlerrate für jeden Klassifizierer als Funktion der Anzahl der Schätzer plotten. Dies wird uns ermöglichen, die Anzahl der Schätzer zu identifizieren, bei der die Fehlerrate stabilisiert. Wir werden Matplotlib verwenden, um das Diagramm zu generieren.

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("OOB error rate")
plt.legend(loc="upper right")
plt.show()

Zusammenfassung

In diesem Lab haben wir gezeigt, wie man die Out-Of-Bag (OOB)-Fehlerrate für ein Random Forest-Modell mit scikit-learn misst. Wir haben einen binären Klassifizierungsdatensatz erzeugt, eine Liste von Ensemble-Klassifizierern definiert, die OOB-Fehlerrate für jeden Klassifizierer berechnet und die Ergebnisse visualisiert. Diese Technik ermöglicht es uns, die Fehlerrate eines Random Forest-Modells zu schätzen, ohne dass ein separates Validierungsset erforderlich ist.