Dominando la regularización de Gradient Boosting

Introducción

En este laboratorio, aprenderá a implementar diferentes estrategias de regularización para el Gradient Boosting utilizando scikit-learn. La regularización es una técnica que ayuda a prevenir el sobreajuste, que es un problema común en los modelos de aprendizaje automático. Utilizaremos la función de pérdida de desviación binomial y el conjunto de datos make_hastie_10_2 para este laboratorio.

Consejos sobre la VM

Una vez que se haya iniciado 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 las operaciones no se puede automatizar 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.

Importar bibliotecas

Comencemos importando las bibliotecas necesarias.

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

Cargar y dividir los datos

Utilizaremos el conjunto de datos make_hastie_10_2 y lo dividiremos en conjuntos de entrenamiento y prueba.

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

## map labels from {-1, 1} to {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

Definiremos los parámetros para nuestro clasificador Gradient Boosting. Utilizaremos los siguientes parámetros:

n_estimators: número de etapas de potenciación a realizar
max_leaf_nodes: número máximo de nodos hoja en cada árbol
max_depth: profundidad máxima del árbol
random_state: semilla aleatoria para la consistencia
min_samples_split: número mínimo de muestras necesarias para dividir un nodo interno

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

Implementar estrategias de regularización

Ahora implementaremos diferentes estrategias de regularización y compararemos su rendimiento.

Sin contracción

Comenzaremos sin contracción, lo que significa que la tasa de aprendizaje se establecerá en 1.

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

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

Tasa de aprendizaje = 0.2

A continuación, estableceremos la tasa de aprendizaje en 0.2 y el submuestreo en 1.

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

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

Submuestreo = 0.5

Ahora estableceremos el submuestreo en 0.5 y la tasa de aprendizaje en 1.

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

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

Tasa de aprendizaje = 0.2 y Submuestreo = 0.5

A continuación, estableceremos la tasa de aprendizaje en 0.2 y el submuestreo en 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)

Tasa de aprendizaje = 0.2 y Máximo de características = 2

Finalmente, estableceremos la tasa de aprendizaje en 0.2 y usaremos solo 2 características para cada árbol.

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

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

Graficar la desviación del conjunto de prueba

Ahora graficaremos la desviación del conjunto de prueba para cada estrategia de regularización.

plt.figure()

for label, color, setting in [
    ("No shrinkage", "naranja", {"learning_rate": 1.0, "subsample": 1.0}),
    ("learning_rate=0.2", "turquesa", {"learning_rate": 0.2, "subsample": 1.0}),
    ("subsample=0.5", "azul", {"learning_rate": 1.0, "subsample": 0.5}),
    (
        "learning_rate=0.2, subsample=0.5",
        "gris",
        {"learning_rate": 0.2, "subsample": 0.5},
    ),
    (
        "learning_rate=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)

    ## compute test set deviance
    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("Boosting Iterations")
plt.ylabel("Test Set Deviance")

plt.show()

Resumen

En este laboratorio, aprendimos cómo implementar diferentes estrategias de regularización para Gradient Boosting utilizando scikit-learn. Utilizamos la función de pérdida de desviación binomial y el conjunto de datos make_hastie_10_2. Implementamos diferentes estrategias de regularización como no contracción, tasa de aprendizaje = 0.2, submuestreo = 0.5 y máximo de características = 2. Finalmente, graficamos la desviación del conjunto de prueba para cada estrategia de regularización para comparar su rendimiento.

Regularización de Gradient Boosting