Arrêt précoce du gradient boosting

Introduction

Le gradient boosting est une technique d'ensemble où plusieurs apprenants faibles (arbres de régression) sont combinés pour produire un modèle unique puissant, de manière itérative. Le support de l'arrêt précoce dans le gradient boosting nous permet de trouver le nombre minimal d'itérations suffisant pour construire un modèle qui généralise bien aux données non vues.

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 au carnet Jupyter pour la pratique.

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

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.

Charger les bibliothèques et les données requises

Tout d'abord, nous devons charger les bibliothèques et les données requises. Nous utiliserons la bibliothèque scikit - learn pour la mise en œuvre du gradient boosting.

import time
import numpy as np
import matplotlib.pyplot as plt
from sklearn import ensemble
from sklearn import datasets
from sklearn.model_selection import train_test_split

data_list = [
    datasets.load_iris(return_X_y=True),
    datasets.make_classification(n_samples=800, random_state=0),
    datasets.make_hastie_10_2(n_samples=2000, random_state=0),
]
names = ["Données Iris", "Données de classification", "Données Hastie"]
n_estimators = 200

Préparer les données

Ensuite, nous allons préparer les données en les divisant en ensembles d'entraînement et de test.

for X, y in data_list:
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=0
    )

Construire et entraîner le modèle sans arrêt précoce

Nous allons maintenant construire et entraîner un modèle de gradient boosting sans arrêt précoce.

gb = ensemble.GradientBoostingClassifier(n_estimators=n_estimators, random_state=0)
start = time.time()
gb.fit(X_train, y_train)
time_gb.append(time.time() - start)

Construire et entraîner le modèle avec arrêt précoce

Nous allons maintenant construire et entraîner un modèle de gradient boosting avec arrêt précoce. Nous spécifions un validation_fraction qui indique la fraction de l'ensemble de données complet qui sera mise de côté pour l'entraînement afin d'évaluer la perte de validation du modèle. Le modèle de gradient boosting est entraîné à l'aide de l'ensemble d'entraînement et évalué à l'aide de l'ensemble de validation. Lorsque chaque étape supplémentaire d'arbre de régression est ajoutée, l'ensemble de validation est utilisé pour évaluer le modèle. Cela se poursuit jusqu'à ce que les scores du modèle dans les dernières n_iter_no_change étapes n'améliorent pas d'au moins tol. Après cela, le modèle est considéré comme convergé et l'ajout supplémentaire d'étapes est "arrêté tôt". Le nombre d'étapes du modèle final est disponible dans l'attribut n_estimators.

gbes = ensemble.GradientBoostingClassifier(
        n_estimators=n_estimators,
        validation_fraction=0.2,
        n_iter_no_change=5,
        tol=0.01,
        random_state=0,
    )
start = time.time()
gbes.fit(X_train, y_train)
time_gbes.append(time.time() - start)

#Comparer les scores avec et sans arrêt précoce

Nous allons maintenant comparer les scores des deux modèles.

score_gb.append(gb.score(X_test, y_test))
score_gbes.append(gbes.score(X_test, y_test))

#Comparer les temps d'ajustement avec et sans arrêt précoce

Nous allons maintenant comparer les temps d'ajustement des deux modèles.

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

bar1 = plt.bar(
    index, time_gb, bar_width, label="Sans arrêt précoce", color="crimson"
)
bar2 = plt.bar(
    index + bar_width, time_gbes, bar_width, label="Avec arrêt précoce", color="coral"
)

max_y = np.amax(np.maximum(time_gb, time_gbes))

plt.xticks(index + bar_width, names)
plt.yticks(np.linspace(0, 1.3 * max_y, 13))

autolabel(bar1, n_gb)
autolabel(bar2, n_gbes)

plt.ylim([0, 1.3 * max_y])
plt.legend(loc="best")
plt.grid(True)

plt.xlabel("Ensembles de données")
plt.ylabel("Temps d'ajustement")

plt.show()

#Comparer les scores avec et sans arrêt précoce

Nous allons maintenant comparer les scores des deux modèles.

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

bar1 = plt.bar(
    index, score_gb, bar_width, label="Sans arrêt précoce", color="crimson"
)
bar2 = plt.bar(
    index + bar_width, score_gbes, bar_width, label="Avec arrêt précoce", color="coral"
)

plt.xticks(index + bar_width, names)
plt.yticks(np.arange(0, 1.3, 0.1))

autolabel(bar1, n_gb)
autolabel(bar2, n_gbes)

plt.ylim([0, 1.3])
plt.legend(loc="best")
plt.grid(True)

plt.xlabel("Ensembles de données")
plt.ylabel("Score de test")

plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à propos de l'arrêt précoce dans le gradient boosting, qui nous permet de trouver le nombre minimal d'itérations suffisant pour construire un modèle qui généralise bien aux données non vues. Nous avons comparé les performances d'un modèle de gradient boosting avec et sans arrêt précoce, et avons observé que l'arrêt précoce peut réduire considérablement le temps d'entraînement, la consommation de mémoire et la latence de prédiction.