Arbres de décision AdaBoost multi-classe

Introduction

Dans ce laboratoire, nous allons explorer la manière dont le boosting peut améliorer la précision de prédiction sur un problème multi-classe. Nous utiliserons un ensemble de données construit en prenant une distribution normale standard de dix dimensions et en définissant trois classes séparées par des sphères concentriques imbriquées de dix dimensions de sorte que le nombre de samples soit approximativement égal dans chaque classe.

Nous comparerons les performances des algorithmes SAMME et SAMME.R. SAMME.R utilise les estimations de probabilité pour mettre à jour le modèle additif, tandis que SAMME utilise seulement les classifications.

Conseils sur la VM

Une fois le démarrage de la VM terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook 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 des commentaires après la session et nous résoudrons rapidement le problème pour vous.

Skills Graph

Importation des bibliothèques requises

Nous commencerons par importer les bibliothèques requises, y compris make_gaussian_quantiles et accuracy_score de sklearn.datasets, AdaBoostClassifier, DecisionTreeClassifier de sklearn.ensemble et matplotlib.pyplot.

import matplotlib.pyplot as plt
from sklearn.datasets import make_gaussian_quantiles
from sklearn.ensemble import AdaBoostClassifier
from sklearn.metrics import accuracy_score
from sklearn.tree import DecisionTreeClassifier

Charger l'ensemble de données

Nous utiliserons la fonction make_gaussian_quantiles de sklearn.datasets pour générer un ensemble de données. Cette fonction génère des Gaussiennes isotropes et ajoute une séparation entre les classes pour rendre le problème plus difficile.

X, y = make_gaussian_quantiles(
    n_samples=13000, n_features=10, n_classes=3, random_state=1
)

Diviser l'ensemble de données

Nous allons diviser l'ensemble de données en ensembles d'entraînement et de test, en utilisant les 3000 premiers échantillons pour l'entraînement et les échantillons restants pour les tests.

n_split = 3000
X_train, X_test = X[:n_split], X[n_split:]
y_train, y_test = y[:n_split], y[n_split:]

Créer et entraîner les modèles

Nous allons créer deux modèles AdaBoost, l'un utilisant SAMME et l'autre utilisant SAMME.R. Les deux modèles utiliseront DecisionTreeClassifier avec une profondeur maximale de 2 et 300 estimateurs.

bdt_real = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=2), n_estimators=300, learning_rate=1
)

bdt_discrete = AdaBoostClassifier(
    DecisionTreeClassifier(max_depth=2),
    n_estimators=300,
    learning_rate=1.5,
    algorithm="SAMME",
)

bdt_real.fit(X_train, y_train)
bdt_discrete.fit(X_train, y_train)

Tester les modèles

Nous allons tester les modèles et calculer l'erreur de test de chaque modèle après chaque itération d'amorçage.

real_test_errors = []
discrete_test_errors = []

for real_test_predict, discrete_test_predict in zip(
    bdt_real.staged_predict(X_test), bdt_discrete.staged_predict(X_test)
):
    real_test_errors.append(1.0 - accuracy_score(real_test_predict, y_test))
    discrete_test_errors.append(1.0 - accuracy_score(discrete_test_predict, y_test))

Tracer les résultats

Nous allons tracer l'erreur de test, l'erreur de classification et le poids d'amorçage de chaque modèle.

n_trees_discrete = len(bdt_discrete)
n_trees_real = len(bdt_real)

## L'amorçage peut se terminer tôt, mais les tableaux suivants sont toujours
## de longueur n_estimators. Nous les réduisons au nombre réel d'arbres ici :
discrete_estimator_errors = bdt_discrete.estimator_errors_[:n_trees_discrete]
real_estimator_errors = bdt_real.estimator_errors_[:n_trees_real]
discrete_estimator_weights = bdt_discrete.estimator_weights_[:n_trees_discrete]

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

plt.subplot(131)
plt.plot(range(1, n_trees_discrete + 1), discrete_test_errors, c="black", label="SAMME")
plt.plot(
    range(1, n_trees_real + 1),
    real_test_errors,
    c="black",
    linestyle="dashed",
    label="SAMME.R",
)
plt.legend()
plt.ylim(0.18, 0.62)
plt.ylabel("Erreur de test")
plt.xlabel("Nombre d'arbres")

plt.subplot(132)
plt.plot(
    range(1, n_trees_discrete + 1),
    discrete_estimator_errors,
    "b",
    label="SAMME",
    alpha=0.5,
)
plt.plot(
    range(1, n_trees_real + 1), real_estimator_errors, "r", label="SAMME.R", alpha=0.5
)
plt.legend()
plt.ylabel("Erreur")
plt.xlabel("Nombre d'arbres")
plt.ylim((0.2, max(real_estimator_errors.max(), discrete_estimator_errors.max()) * 1.2))
plt.xlim((-20, len(bdt_discrete) + 20))

plt.subplot(133)
plt.plot(range(1, n_trees_discrete + 1), discrete_estimator_weights, "b", label="SAMME")
plt.legend()
plt.ylabel("Poids")
plt.xlabel("Nombre d'arbres")
plt.ylim((0, discrete_estimator_weights.max() * 1.2))
plt.xlim((-20, n_trees_discrete + 20))

## Empêcher les étiquettes des axes y de se chevaucher
plt.subplots_adjust(wspace=0.25)
plt.show()

Sommaire

Dans ce laboratoire, nous avons exploré la manière dont l'amorçage peut améliorer la précision de prédiction dans un problème multi-classe. Nous avons utilisé un ensemble de données construit en prenant une distribution normale standard de dix dimensions et en définissant trois classes séparées par des sphères concentriques imbriquées de dix dimensions. Nous avons comparé les performances des algorithmes SAMME et SAMME.R et avons tracé l'erreur de test, l'erreur de classification et le poids d'amorçage de chaque modèle. Les résultats ont montré que SAMME.R converge généralement plus rapidement que SAMME, obtenant une erreur de test plus faible avec un nombre d'itérations d'amorçage plus réduit.