Classificação de Stump de Decisão com AdaBoost

Introdução

Este é um laboratório passo a passo sobre como usar o AdaBoost para treinar um decision stump e classificar um conjunto de dados bidimensional composto por dois clusters de quantiles gaussianos.

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 prontamente o problema para si.

Importação de bibliotecas necessárias

Neste passo, iremos importar as bibliotecas necessárias para este laboratório.

import numpy as np
import matplotlib.pyplot as plt

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_gaussian_quantiles
from sklearn.inspection import DecisionBoundaryDisplay

Construção do conjunto de dados

Neste passo, criaremos um conjunto de dados de classificação não linearmente separável composto por dois clusters de quantiles gaussianos utilizando a função make_gaussian_quantiles do módulo sklearn.datasets. Também concatenaremos os dois clusters e atribuiremos rótulos a eles.

X1, y1 = make_gaussian_quantiles(
    cov=2.0, n_samples=200, n_features=2, n_classes=2, random_state=1
)
X2, y2 = make_gaussian_quantiles(
    mean=(3, 3), cov=1.5, n_samples=300, n_features=2, n_classes=2, random_state=1
)
X = np.concatenate((X1, X2))
y = np.concatenate((y1, -y2 + 1))

Criar e ajustar uma árvore de decisão AdaBoost

Neste passo, criaremos uma árvore de decisão AdaBoost utilizando a classe AdaBoostClassifier do módulo sklearn.ensemble. Usaremos a árvore de decisão como estimador base e definiremos o parâmetro max_depth para 1. Também definiremos o parâmetro algorithm para "SAMME" e o parâmetro n_estimators para 200. Finalmente, ajustaremos o classificador ao conjunto de dados.

bdt = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=1), algorithm="SAMME", n_estimators=200
)

bdt.fit(X, y)

Plotar os limites de decisão e os pontos de treino

Neste passo, plotaremos os limites de decisão e os pontos de treino. Criaremos um objeto DecisionBoundaryDisplay utilizando o método from_estimator do módulo sklearn.inspection e passaremos o classificador AdaBoost, o conjunto de dados e outros parâmetros. Também plotaremos os pontos de treino utilizando cores diferentes para cada classe.

plot_colors = "br"
plot_step = 0.02
class_names = "AB"

plt.figure(figsize=(10, 5))

## Plotar os limites de decisão
ax = plt.subplot(121)
disp = DecisionBoundaryDisplay.from_estimator(
    bdt,
    X,
    cmap=plt.cm.Paired,
    response_method="predict",
    ax=ax,
    xlabel="x",
    ylabel="y",
)
x_min, x_max = disp.xx0.min(), disp.xx0.max()
y_min, y_max = disp.xx1.min(), disp.xx1.max()
plt.axis("tight")

## Plotar os pontos de treino
for i, n, c in zip(range(2), class_names, plot_colors):
    idx = np.where(y == i)
    plt.scatter(
        X[idx, 0],
        X[idx, 1],
        c=c,
        cmap=plt.cm.Paired,
        s=20,
        edgecolor="k",
        label="Classe %s" % n,
    )
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.legend(loc="upper right")

plt.title("Limite de Decisão")

Plotar as pontuações de decisão das duas classes

Neste passo, plotaremos as pontuações de decisão das duas classes. Usaremos o método decision_function do classificador AdaBoost para obter as pontuações de decisão para cada amostra no conjunto de dados. Em seguida, plotaremos os histogramas das pontuações de decisão para cada classe.

## Plotar as pontuações de decisão das duas classes
twoclass_output = bdt.decision_function(X)
plot_range = (twoclass_output.min(), twoclass_output.max())
plt.subplot(122)
for i, n, c in zip(range(2), class_names, plot_colors):
    plt.hist(
        twoclass_output[y == i],
        bins=10,
        range=plot_range,
        facecolor=c,
        label="Classe %s" % n,
        alpha=0.5,
        edgecolor="k",
    )
x1, x2, y1, y2 = plt.axis()
plt.axis((x1, x2, y1, y2 * 1.2))
plt.legend(loc="upper right")
plt.ylabel("Amostras")
plt.xlabel("Pontuação")
plt.title("Pontuações de Decisão")

plt.tight_layout()
plt.subplots_adjust(wspace=0.35)
plt.show()

Resumo

Neste laboratório, aprendemos como utilizar o AdaBoost para treinar um decision stump e classificar um conjunto de dados bidimensional composto por dois grupos de quantiles gaussianos. Também aprendemos a plotar os limites de decisão e as pontuações de decisão do classificador.