Clasificación con árbol de decisión simple de AdaBoost

Introducción

Este es un laboratorio paso a paso sobre cómo usar AdaBoost para entrenar un árbol de decisión simple y clasificar un conjunto de datos bidimensional compuesto por dos clusters de cuantiles gaussianos.

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 las bibliotecas necesarias

En este paso, importaremos las bibliotecas necesarias para este laboratorio.

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

Construir el conjunto de datos

En este paso, crearemos un conjunto de datos de clasificación no linealmente separable compuesto por dos clusters de cuantiles gaussianos utilizando la función make_gaussian_quantiles del módulo sklearn.datasets. También concatenaremos los dos clusters y les asignaremos etiquetas.

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))

Crear y ajustar un árbol de decisión potenciado por AdaBoost

En este paso, crearemos un árbol de decisión potenciado por AdaBoost utilizando la clase AdaBoostClassifier del módulo sklearn.ensemble. Usaremos el árbol de decisión como estimador base y estableceremos el parámetro max_depth en 1. También estableceremos el parámetro algorithm en "SAMME" y el parámetro n_estimators en 200. Finalmente, ajustaremos el clasificador al conjunto de datos.

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

bdt.fit(X, y)

Graficar los límites de decisión y los puntos de entrenamiento

En este paso, graficaremos los límites de decisión y los puntos de entrenamiento. Crearemos un objeto DecisionBoundaryDisplay utilizando el método from_estimator del módulo sklearn.inspection y pasaremos el clasificador AdaBoost, el conjunto de datos y otros parámetros. También graficaremos los puntos de entrenamiento utilizando diferentes colores para cada clase.

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

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

## Graficar los límites de decisión
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")

## Graficar los puntos de entrenamiento
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="Class %s" % n,
    )
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.legend(loc="upper right")

plt.title("Decision Boundary")

Graficar las puntuaciones de decisión de dos clases

En este paso, graficaremos las puntuaciones de decisión de dos clases. Usaremos el método decision_function del clasificador AdaBoost para obtener las puntuaciones de decisión para cada muestra en el conjunto de datos. Luego graficaremos los histogramas de las puntuaciones de decisión para cada clase.

## Graficar las puntuaciones de decisión de dos clases
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="Class %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("Samples")
plt.xlabel("Score")
plt.title("Decision Scores")

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

Resumen

En este laboratorio, aprendimos cómo usar AdaBoost para entrenar un árbol de decisión simple y clasificar un conjunto de datos bidimensional compuesto por dos clusters de cuantiles gaussianos. También aprendimos cómo graficar los límites de decisión y las puntuaciones de decisión del clasificador.