Feature Transformations mit Ensembles von Bäumen

Einführung

In diesem Lab lernen wir, wie wir Merkmale in einen höherdimensionalen, dünn besetzten Raum mit einem Ensemble von Bäumen transformieren. Anschließend trainieren wir ein lineares Modell auf diesen Merkmalen. Wir verwenden verschiedene Arten von Ensemble-Methoden, einschließlich Random Forest und Gradient Boosting, und vergleichen deren Leistung.

VM-Tipps

Nachdem die VM gestartet ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in 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

Datenvorbereitung

Zunächst erstellen wir einen großen Datensatz mit 80.000 Proben und teilen ihn in drei Mengen auf:

• Eine Menge, um die Ensemble-Methoden zu trainieren, die später als Feature-Engineering-Transformer verwendet werden
• Eine Menge, um das lineare Modell zu trainieren
• Eine Menge, um das lineare Modell zu testen.

from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=80_000, random_state=10)

X_full_train, X_test, y_full_train, y_test = train_test_split(
    X, y, test_size=0.5, random_state=10
)

X_train_ensemble, X_train_linear, y_train_ensemble, y_train_linear = train_test_split(
    X_full_train, y_full_train, test_size=0.5, random_state=10
)

Training Ensemble Methods

Für jede der Ensemble-Methoden werden wir 10 Schätzer und eine maximale Tiefe von 3 Ebenen verwenden.

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier

n_estimators = 10
max_depth = 3

random_forest = RandomForestClassifier(
    n_estimators=n_estimators, max_depth=max_depth, random_state=10
)
random_forest.fit(X_train_ensemble, y_train_ensemble)

gradient_boosting = GradientBoostingClassifier(
    n_estimators=n_estimators, max_depth=max_depth, random_state=10
)
_ = gradient_boosting.fit(X_train_ensemble, y_train_ensemble)

Training Embedding Transformer

Der RandomTreesEmbedding ist eine unüberwachte Methode und muss nicht separat trainiert werden.

from sklearn.ensemble import RandomTreesEmbedding

random_tree_embedding = RandomTreesEmbedding(
    n_estimators=n_estimators, max_depth=max_depth, random_state=0
)

rt_model = make_pipeline(random_tree_embedding, LogisticRegression(max_iter=1000))
rt_model.fit(X_train_linear, y_train_linear)

Transforming Features with Random Forest and Gradient Boosting

Jetzt werden wir zwei Pipelines erstellen, die die obige Embedding als Vorverarbeitungsschritt verwenden. Die Feature-Transformation wird durch Aufruf der Methode apply erfolgen. Anschließend werden wir Random Forest oder Gradient Boosting mit einer logistischen Regression in eine Pipeline packen. Allerdings erwartet die Pipeline in scikit-learn einen Aufruf von transform. Daher haben wir den Aufruf von apply in einem FunctionTransformer eingeschlossen.

from sklearn.preprocessing import FunctionTransformer
from sklearn.preprocessing import OneHotEncoder

def rf_apply(X, model):
    return model.apply(X)

rf_leaves_yielder = FunctionTransformer(rf_apply, kw_args={"model": random_forest})

rf_model = make_pipeline(
    rf_leaves_yielder,
    OneHotEncoder(handle_unknown="ignore"),
    LogisticRegression(max_iter=1000),
)
rf_model.fit(X_train_linear, y_train_linear)

def gbdt_apply(X, model):
    return model.apply(X)[:, :, 0]

gbdt_leaves_yielder = FunctionTransformer(
    gbdt_apply, kw_args={"model": gradient_boosting}
)

gbdt_model = make_pipeline(
    gbdt_leaves_yielder,
    OneHotEncoder(handle_unknown="ignore"),
    LogisticRegression(max_iter=1000),
)
gbdt_model.fit(X_train_linear, y_train_linear)

Evaluating Models

Wir können schließlich die verschiedenen ROC-Kurven für alle Modelle anzeigen.

import matplotlib.pyplot as plt
from sklearn.metrics import RocCurveDisplay

fig, ax = plt.subplots()

models = [
    ("RT embedding -> LR", rt_model),
    ("RF", random_forest),
    ("RF embedding -> LR", rf_model),
    ("GBDT", gradient_boosting),
    ("GBDT embedding -> LR", gbdt_model),
]

model_displays = {}
for name, pipeline in models:
    model_displays[name] = RocCurveDisplay.from_estimator(
        pipeline, X_test, y_test, ax=ax, name=name
    )
_ = ax.set_title("ROC curve")

Summary

In diesem Lab haben wir gelernt, wie man Features in einen höherdimensionalen, dünn besetzten Raum mit einem Ensemble von Bäumen transformiert. Wir haben verschiedene Arten von Ensemble-Methoden wie Random Forest und Gradient Boosting verwendet und deren Leistung verglichen. Der RandomTreesEmbedding ist eine unüberwachte Methode und muss nicht separat trainiert werden. Wir haben auch gelernt, wie man Random Forest oder Gradient Boosting mit einer logistischen Regression in eine Pipeline packen kann, indem man den FunctionTransformer verwendet. Schließlich haben wir die Leistung aller Modelle mit Hilfe von ROC-Kurven ausgewertet.