Regularização de Gradient Boosting

Introdução

Neste laboratório, aprenderá a implementar diferentes estratégias de regularização para Gradient Boosting usando o scikit-learn. A regularização é uma técnica que ajuda a prevenir o sobreajuste, um problema comum em modelos de machine learning. Usaremos a função de perda de desvio binomial e o conjunto de dados make_hastie_10_2 para este laboratório.

Dicas da Máquina Virtual

Após o arranque da VM, clique no canto superior esquerdo para mudar para a aba Notebook para aceder ao Jupyter Notebook para a prática.

Por vezes, pode ser necessário esperar alguns segundos para o Jupyter Notebook terminar de carregar. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

Se tiver problemas durante o aprendizado, não hesite em contactar o Labby. Forneça feedback após a sessão e resolveremos o problema rapidamente para si.

Importar Bibliotecas

Comecemos importando as bibliotecas necessárias.

import numpy as np
import matplotlib.pyplot as plt

from sklearn import ensemble
from sklearn import datasets
from sklearn.metrics import log_loss
from sklearn.model_selection import train_test_split

Carregar e Dividir Dados

Usaremos o conjunto de dados make_hastie_10_2 e o dividiremos em conjuntos de treino e teste.

X, y = datasets.make_hastie_10_2(n_samples=4000, random_state=1)

## mapear rótulos de {-1, 1} para {0, 1}
labels, y = np.unique(y, return_inverse=True)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.8, random_state=0)

Definir Parâmetros

Vamos definir os parâmetros para o nosso Classificador de Reforço Gradiente. Usaremos os seguintes parâmetros:

• n_estimators: número de etapas de reforço a serem executadas
• max_leaf_nodes: número máximo de nós folha em cada árvore
• max_depth: profundidade máxima da árvore
• random_state: semente aleatória para consistência
• min_samples_split: número mínimo de amostras necessárias para dividir um nó interno

original_params = {
    "n_estimators": 400,
    "max_leaf_nodes": 4,
    "max_depth": None,
    "random_state": 2,
    "min_samples_split": 5,
}

Implementar Estratégias de Regularização

Agora, implementaremos diferentes estratégias de regularização e compararemos seu desempenho.

Sem Encolhimento

Começaremos sem encolhimento, o que significa que a taxa de aprendizado será definida como 1.

params = dict(original_params)
params.update({"learning_rate": 1.0, "subsample": 1.0})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Taxa de Aprendizado = 0,2

Em seguida, definiremos a taxa de aprendizado como 0,2 e o subsample como 1.

params = dict(original_params)
params.update({"learning_rate": 0.2, "subsample": 1.0})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Subsample = 0,5

Agora, definiremos o subsample como 0,5 e a taxa de aprendizado como 1.

params = dict(original_params)
params.update({"learning_rate": 1.0, "subsample": 0.5})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Taxa de Aprendizado = 0,2 e Subsample = 0,5

Em seguida, definiremos a taxa de aprendizado como 0,2 e o subsample como 0,5.

params = dict(original_params)
params.update({"learning_rate": 0.2, "subsample": 0.5})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Taxa de Aprendizado = 0,2 e Máximo de Características = 2

Finalmente, definiremos a taxa de aprendizado como 0,2 e usaremos apenas 2 características para cada árvore.

params = dict(original_params)
params.update({"learning_rate": 0.2, "max_features": 2})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Plotar Desvio do Conjunto de Teste

Agora, plotaremos o desvio do conjunto de teste para cada estratégia de regularização.

plt.figure()

for label, color, setting in [
    ("Sem encolhimento", "orange", {"learning_rate": 1.0, "subsample": 1.0}),
    ("taxa_aprendizado=0.2", "turquoise", {"learning_rate": 0.2, "subsample": 1.0}),
    ("subsample=0.5", "blue", {"learning_rate": 1.0, "subsample": 0.5}),
    (
        "taxa_aprendizado=0.2, subsample=0.5",
        "gray",
        {"learning_rate": 0.2, "subsample": 0.5},
    ),
    (
        "taxa_aprendizado=0.2, max_features=2",
        "magenta",
        {"learning_rate": 0.2, "max_features": 2},
    ),
]:
    params = dict(original_params)
    params.update(setting)

    clf = ensemble.GradientBoostingClassifier(**params)
    clf.fit(X_train, y_train)

    ## calcular o desvio do conjunto de teste
    test_deviance = np.zeros((params["n_estimators"],), dtype=np.float64)

    for i, y_proba in enumerate(clf.staged_predict_proba(X_test)):
        test_deviance[i] = 2 * log_loss(y_test, y_proba[:, 1])

    plt.plot(
        (np.arange(test_deviance.shape[0]) + 1)[::5],
        test_deviance[::5],
        "-",
        color=color,
        label=label,
    )

plt.legend(loc="upper right")
plt.xlabel("Iterações de Reforço")
plt.ylabel("Desvio do Conjunto de Teste")

plt.show()

Resumo

Neste laboratório, aprendemos como implementar diferentes estratégias de regularização para Gradient Boosting usando o scikit-learn. Utilizamos a função de perda de desvio binomial e o conjunto de dados make_hastie_10_2. Implementamos diferentes estratégias de regularização, como sem encolhimento, taxa de aprendizado = 0,2, subsample = 0,5 e máximo de características = 2. Finalmente, plotamos o desvio do conjunto de teste para cada estratégia de regularização para comparar seu desempenho.