Aprendizado de Máquina | Engenharia de Recursos | Métodos de Conjunto

Introdução

Neste laboratório, aprenderemos a transformar características em um espaço esparso de alta dimensionalidade usando um conjunto de árvores. Em seguida, treinaremos um modelo linear com essas características. Usaremos diferentes tipos de métodos de conjunto, incluindo Random Forest e Gradient Boosting, e compararemos seu desempenho.

Dicas da Máquina Virtual

Após o término da inicialização da máquina virtual, clique no canto superior esquerdo para mudar para a aba Notebook para acessar o Jupyter Notebook para praticar.

Às vezes, pode ser necessário aguardar alguns segundos para que o Jupyter Notebook termine de carregar. A validação de operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se você enfrentar problemas durante o aprendizado, sinta-se à vontade para perguntar ao Labby. Forneça feedback após a sessão e resolveremos o problema para você prontamente.

Preparação de Dados

Primeiro, criaremos um conjunto de dados grande com 80.000 amostras e o dividiremos em três conjuntos:

Um conjunto para treinar os métodos de conjunto, que posteriormente serão usados como um transformador de engenharia de recursos.
Um conjunto para treinar o modelo linear.
Um conjunto para testar o modelo linear.

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
)

Treinamento de Métodos de Conjunto

Para cada um dos métodos de conjunto, usaremos 10 estimadores e uma profundidade máxima de 3 níveis.

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)

Treinamento do Transformador de Incorporação

O RandomTreesEmbedding é um método não supervisionado e não precisa ser treinado independentemente.

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 Recursos com Random Forest e Gradient Boosting

Agora, criaremos dois pipelines que usarão a incorporação acima como uma etapa de pré-processamento. A transformação de recursos ocorrerá chamando o método apply. Em seguida, concatenaremos random forest ou gradient boosting com uma regressão logística. No entanto, o pipeline no scikit-learn espera uma chamada para transform. Portanto, envolvemos a chamada para apply dentro de um 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)

Avaliando Modelos

Finalmente, podemos mostrar as diferentes curvas ROC para todos os 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("Curva ROC")

Resumo

Neste laboratório, aprendemos como transformar recursos em um espaço esparso de alta dimensionalidade usando um conjunto de árvores. Utilizamos diferentes tipos de métodos de conjunto, incluindo Random Forest e Gradient Boosting, e comparamos seu desempenho. O RandomTreesEmbedding é um método não supervisionado e não precisa ser treinado independentemente. Também aprendemos como criar pipelines de random forest ou gradient boosting com uma regressão logística usando o FunctionTransformer. Finalmente, avaliamos o desempenho de todos os modelos usando curvas ROC.

Transformações de Recursos com Conjuntos de Árvores