AdaBoost Discreto vs. Real: Comparação de Desempenho

Introdução

Este laboratório demonstra a diferença de desempenho entre o algoritmo de reforço SAMME discreto e o algoritmo de reforço SAMME.R. Ambos os algoritmos são avaliados numa tarefa de classificação binária onde o alvo Y é uma função não linear de 10 características de entrada. O laboratório baseia-se na Figura 10.2 de Hastie et al 2009.

Dicas da Máquina Virtual

Após o arranque da máquina virtual, 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 o carregamento. A validação das operações não pode ser automatizada devido a limitações no Jupyter Notebook.

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

Preparar os dados e modelos base

Começamos por gerar o conjunto de dados de classificação binária utilizado em Hastie et al. 2009, Exemplo 10.2. Em seguida, definimos os hiperparâmetros para os nossos classificadores AdaBoost. Dividimos os dados em conjuntos de treino e teste. Depois disso, treinamos os nossos classificadores base, um DecisionTreeClassifier com depth=9 e um "stump" DecisionTreeClassifier com depth=1, e calculamos o erro de teste.

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 com SAMME discreto e SAMME.R real

Agora definimos os classificadores AdaBoost discretos e reais e ajustamo-los ao conjunto de treino.

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 o erro de teste

Agora, vamos calcular o erro de teste dos classificadores AdaBoost discretos e reais para cada novo "stump" em n_estimators adicionado ao 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)

Plotar os resultados

Finalmente, plotamos os erros de treino e teste dos nossos modelos base e dos classificadores AdaBoost discretos e reais.

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="Erro do Stump de Decisão")
ax.plot([1, n_estimators], [dt_err] * 2, "k--", label="Erro da Árvore de Decisão")

colors = sns.color_palette("colorblind")

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

ax.set_ylim((0.0, 0.5))
ax.set_xlabel("Número de aprendizes fracos")
ax.set_ylabel("Taxa de erro")

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

plt.show()

Resumo

Neste laboratório, demonstramos a diferença de desempenho entre o algoritmo de boosting SAMME discreto e o algoritmo de boosting SAMME.R real. Observamos que a taxa de erro para os conjuntos de treino e teste do AdaBoost real é inferior à do AdaBoost discreto.