Introduction
Ce laboratoire démontre la différence de performance entre l'algorithme d'amélioration SAMME discret et l'algorithme d'amélioration SAMME.R réel. Les deux algorithmes sont évalués sur une tâche de classification binaire où la variable cible Y est une fonction non linéaire de 10 caractéristiques d'entrée. Le laboratoire est basé sur la figure 10.2 d'Hastie et al 2009.
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.
Préparer les données et les modèles de base
Nous commençons par générer l'ensemble de données de classification binaire utilisé dans Hastie et al. 2009, Exemple 10.2. Ensuite, nous définissons les hyperparamètres pour nos classifieurs AdaBoost. Nous divisons les données en un ensemble d'entraînement et un ensemble de test. Après cela, nous entraînons nos classifieurs de base, un DecisionTreeClassifier avec depth=9 et un DecisionTreeClassifier "d'arbre simple" avec depth=1 et calculons l'erreur sur le test.
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 avec SAMME discret et SAMME.R réel
Nous définissons maintenant les classifieurs AdaBoost discret et réel et les ajustons à l'ensemble d'entraînement.
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)
Calculer l'erreur sur le test
Maintenant, calculons l'erreur sur le test des classifieurs AdaBoost discret et réel pour chaque nouveau arbre simple ajouté à l'ensemble dans n_estimators.
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)
Tracer les résultats
Enfin, nous traçons les erreurs sur l'entraînement et le test de nos modèles de base et des classifieurs AdaBoost discret et réel.
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="Decision Stump Error")
ax.plot([1, n_estimators], [dt_err] * 2, "k--", label="Decision Tree Error")
colors = sns.color_palette("colorblind")
ax.plot(
np.arange(n_estimators) + 1,
ada_discrete_err,
label="Discrete AdaBoost Test Error",
color=colors[0],
)
ax.plot(
np.arange(n_estimators) + 1,
ada_discrete_err_train,
label="Discrete AdaBoost Train Error",
color=colors[1],
)
ax.plot(
np.arange(n_estimators) + 1,
ada_real_err,
label="Real AdaBoost Test Error",
color=colors[2],
)
ax.plot(
np.arange(n_estimators) + 1,
ada_real_err_train,
label="Real AdaBoost Train Error",
color=colors[4],
)
ax.set_ylim((0.0, 0.5))
ax.set_xlabel("Number of weak learners")
ax.set_ylabel("error rate")
leg = ax.legend(loc="upper right", fancybox=True)
leg.get_frame().set_alpha(0.7)
plt.show()
Sommaire
Dans ce laboratoire, nous avons démontré la différence de performance entre l'algorithme d'amorçage SAMME discret et l'algorithme d'amorçage SAMME.R réel. Nous avons observé que le taux d'erreur pour les deux ensembles d'entraînement et de test de l'AdaBoost réel est inférieur à celui de l'AdaBoost discret.