AdaBoost Discreto vs Real

Introducción

Esta práctica demuestra la diferencia en rendimiento entre el algoritmo de potenciación SAMME discreto y el algoritmo de potenciación real SAMME.R. Ambos algoritmos se evalúan en una tarea de clasificación binaria donde la variable objetivo Y es una función no lineal de 10 características de entrada. Esta práctica se basa en la Figura 10.2 de Hastie et al 2009.

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 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 su retroalimentación después de la sesión y le resolveremos el problema inmediatamente.

Preparar los datos y los modelos de referencia

Comenzamos generando el conjunto de datos de clasificación binaria utilizado en Hastie et al. 2009, Ejemplo 10.2. Luego, establecemos los hiperparámetros para nuestros clasificadores AdaBoost. Dividimos los datos en un conjunto de entrenamiento y un conjunto de prueba. Después de eso, entrenamos nuestros clasificadores de referencia, un DecisionTreeClassifier con depth=9 y un DecisionTreeClassifier de "tronco" con depth=1 y calculamos el error de prueba.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

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

n_estimators = 400
learning_rate = 1.0

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=2_000, shuffle=False
)

dt_stump = DecisionTreeClassifier(max_depth=1, min_samples_leaf=1)
dt_stump.fit(X_train, y_train)
dt_stump_err = 1.0 - dt_stump.score(X_test, y_test)

dt = DecisionTreeClassifier(max_depth=9, min_samples_leaf=1)
dt.fit(X_train, y_train)
dt_err = 1.0 - dt.score(X_test, y_test)

Adaboost con SAMME discreto y SAMME.R real

Ahora definimos los clasificadores AdaBoost discretos y reales y los ajustamos al conjunto de entrenamiento.

from sklearn.ensemble import AdaBoostClassifier

ada_discrete = AdaBoostClassifier(
    estimator=dt_stump,
    learning_rate=learning_rate,
    n_estimators=n_estimators,
    algorithm="SAMME",
)
ada_discrete.fit(X_train, y_train)

ada_real = AdaBoostClassifier(
    estimator=dt_stump,
    learning_rate=learning_rate,
    n_estimators=n_estimators,
    algorithm="SAMME.R",
)
ada_real.fit(X_train, y_train)

Calcular el error de prueba

Ahora, calculemos el error de prueba de los clasificadores AdaBoost discretos y reales para cada nuevo tronco en n_estimators agregado al conjunto.

import numpy as np
from sklearn.metrics import zero_one_loss

ada_discrete_err = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_discrete.staged_predict(X_test)):
    ada_discrete_err[i] = zero_one_loss(y_pred, y_test)

ada_discrete_err_train = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_discrete.staged_predict(X_train)):
    ada_discrete_err_train[i] = zero_one_loss(y_pred, y_train)

ada_real_err = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_real.staged_predict(X_test)):
    ada_real_err[i] = zero_one_loss(y_pred, y_test)

ada_real_err_train = np.zeros((n_estimators,))
for i, y_pred in enumerate(ada_real.staged_predict(X_train)):
    ada_real_err_train[i] = zero_one_loss(y_pred, y_train)

Graficar los resultados

Finalmente, graficamos los errores de entrenamiento y prueba de nuestras líneas base y de los clasificadores AdaBoost discreto y real.

import matplotlib.pyplot as plt
import seaborn as sns

fig = plt.figure()
ax = fig.add_subplot(111)

ax.plot([1, n_estimators], [dt_stump_err] * 2, "k-", label="Error del Árbol de Decisión de Nodo Hoja")
ax.plot([1, n_estimators], [dt_err] * 2, "k--", label="Error del Árbol de Decisión")

colors = sns.color_palette("colorblind")

ax.plot(
    np.arange(n_estimators) + 1,
    ada_discrete_err,
    label="Error de Prueba de AdaBoost Discreto",
    color=colors[0],
)
ax.plot(
    np.arange(n_estimators) + 1,
    ada_discrete_err_train,
    label="Error de Entrenamiento de AdaBoost Discreto",
    color=colors[1],
)
ax.plot(
    np.arange(n_estimators) + 1,
    ada_real_err,
    label="Error de Prueba de AdaBoost Real",
    color=colors[2],
)
ax.plot(
    np.arange(n_estimators) + 1,
    ada_real_err_train,
    label="Error de Entrenamiento de AdaBoost Real",
    color=colors[4],
)

ax.set_ylim((0.0, 0.5))
ax.set_xlabel("Número de clasificadores débiles")
ax.set_ylabel("tasa de error")

leg = ax.legend(loc="upper right", fancybox=True)
leg.get_frame().set_alpha(0.7)

plt.show()

Resumen

En este laboratorio, demostramos la diferencia en el rendimiento entre el algoritmo de potenciación SAMME discreto y el algoritmo de potenciación real SAMME.R. Observamos que la tasa de error para los conjuntos de entrenamiento y prueba de AdaBoost real es menor que la de AdaBoost discreto.