Transformaciones de características con conjuntos de árboles

Introducción

En este laboratorio, aprenderemos cómo transformar características en un espacio disperso de dimensión más alta utilizando un conjunto de árboles. Luego entrenaremos un modelo lineal en estas características. Utilizaremos diferentes tipos de métodos de conjunto, incluyendo Random Forest y Gradient Boosting, y compararemos su rendimiento.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no puede automatizarse debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Preparación de los datos

Primero, crearemos un gran conjunto de datos de 80.000 muestras y lo dividiremos en tres conjuntos:

• Un conjunto para entrenar los métodos de conjunto que luego se utilizarán como transformador de ingeniería de características
• Un conjunto para entrenar el modelo lineal
• Un conjunto para probar el modelo lineal.

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
)

Entrenamiento de métodos de conjunto

Para cada uno de los métodos de conjunto, utilizaremos 10 estimadores y una profundidad máxima de 3 niveles.

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)

Entrenamiento del transformador de incrustación

RandomTreesEmbedding es un método no supervisado y no requiere ser entrenado independientemente.

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)

Transformando características con Random Forest y Gradient Boosting

Ahora, crearemos dos tuberías que utilizarán la incrustación anterior como etapa de preprocesamiento. La transformación de características se realizará llamando al método apply. Luego, encadenaremos Random Forest o Gradient Boosting con una regresión logística. Sin embargo, la tubería en scikit-learn espera una llamada a transform. Por lo tanto, envolvemos la llamada a apply dentro de un FunctionTransformer.

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)

Evaluando los modelos

Finalmente, podemos mostrar las diferentes curvas ROC para todos los modelos.

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

Resumen

En este laboratorio, aprendimos cómo transformar características a un espacio disperso de dimensión más alta utilizando un conjunto de árboles. Utilizamos diferentes tipos de métodos de conjunto, incluyendo Random Forest y Gradient Boosting, y comparamos su rendimiento. RandomTreesEmbedding es un método no supervisado y no requiere ser entrenado independientemente. También aprendimos cómo encadenar Random Forest o Gradient Boosting con una regresión logística utilizando FunctionTransformer. Finalmente, evaluamos el rendimiento de todos los modelos utilizando curvas ROC.