Classifieur à arbre de décision simple AdaBoost | Tutoriel d'apprentissage automatique

Introduction

Ceci est un laboratoire étape par étape sur la manière d'utiliser AdaBoost pour entraîner un arbre de décision simple et classifier un ensemble de données bidimensionnelles composé de deux grappes de quantiles gaussiennes.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder à Jupyter Notebook pour la pratique.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Importez les bibliothèques nécessaires

Dans cette étape, nous allons importer les bibliothèques nécessaires pour ce laboratoire.

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

Construisez l'ensemble de données

Dans cette étape, nous allons créer un ensemble de données de classification non linéairement séparable composé de deux grappes de quantiles gaussiennes à l'aide de la fonction make_gaussian_quantiles du module sklearn.datasets. Nous allons également concaténer les deux grappes et leur attribuer des étiquettes.

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

Créez et ajustez un arbre de décision AdaBoost

Dans cette étape, nous allons créer un arbre de décision AdaBoost à l'aide de la classe AdaBoostClassifier du module sklearn.ensemble. Nous utiliserons l'arbre de décision comme estimateur de base et définirons le paramètre max_depth sur 1. Nous définirons également le paramètre algorithm sur "SAMME" et le paramètre n_estimators sur 200. Enfin, nous ajusterons le classifieur à l'ensemble de données.

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

bdt.fit(X, y)

Tracez les limites de décision et les points d'entraînement

Dans cette étape, nous allons tracer les limites de décision et les points d'entraînement. Nous allons créer un objet DecisionBoundaryDisplay à l'aide de la méthode from_estimator du module sklearn.inspection et passer le classifieur AdaBoost, l'ensemble de données et d'autres paramètres. Nous allons également tracer les points d'entraînement en utilisant des couleurs différentes pour chaque classe.

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

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

## Tracez les limites de décision
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")

## Tracez les points d'entraînement
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")

Tracez les scores de décision pour deux classes

Dans cette étape, nous allons tracer les scores de décision pour deux classes. Nous utiliserons la méthode decision_function du classifieur AdaBoost pour obtenir les scores de décision pour chaque échantillon dans l'ensemble de données. Nous tracerons ensuite les histogrammes des scores de décision pour chaque classe.

## Tracez les scores de décision pour deux 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="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()

Sommaire

Dans ce laboratoire, nous avons appris à utiliser AdaBoost pour entraîner un arbre de décision simple et classifier un ensemble de données bidimensionnelles composé de deux grappes de quantiles gaussiennes. Nous avons également appris à tracer les limites de décision et les scores de décision du classifieur.

Classification avec un arbre de décision simple AdaBoost