Maîtriser la régularisation du Gradient Boosting

Introduction

Dans ce laboratoire, vous allez apprendre à implémenter différentes stratégies de régularisation pour le Gradient Boosting à l'aide de scikit-learn. La régularisation est une technique qui aide à prévenir le surapprentissage, qui est un problème courant dans les modèles d'apprentissage automatique. Nous utiliserons la fonction de perte de déviation binaire et le jeu de données make_hastie_10_2 pour ce laboratoire.

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 pratiquer.

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 limites 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.

Importation des bibliothèques

Commenceons par importer les bibliothèques nécessaires.

import numpy as np
import matplotlib.pyplot as plt

from sklearn import ensemble
from sklearn import datasets
from sklearn.metrics import log_loss
from sklearn.model_selection import train_test_split

Charger et diviser les données

Nous allons utiliser le jeu de données make_hastie_10_2 et le diviser en ensembles d'entraînement et de test.

X, y = datasets.make_hastie_10_2(n_samples=4000, random_state=1)

## map labels from {-1, 1} to {0, 1}
labels, y = np.unique(y, return_inverse=True)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.8, random_state=0)

Définir les paramètres

Nous allons définir les paramètres pour notre classifieur Gradient Boosting. Nous utiliserons les paramètres suivants :

n_estimators : nombre d'étapes de boosting à effectuer
max_leaf_nodes : nombre maximum de nœuds terminaux dans chaque arbre
max_depth : profondeur maximale de l'arbre
random_state : graine aléatoire pour la cohérence
min_samples_split : nombre minimum d'échantillons requis pour diviser un nœud interne

original_params = {
    "n_estimators": 400,
    "max_leaf_nodes": 4,
    "max_depth": None,
    "random_state": 2,
    "min_samples_split": 5,
}

Implémenter les stratégies de régularisation

Nous allons maintenant implémenter différentes stratégies de régularisation et comparer leurs performances.

Sans réduction

Nous commencerons sans réduction, ce qui signifie que le taux d'apprentissage sera fixé à 1.

params = dict(original_params)
params.update({"learning_rate": 1.0, "subsample": 1.0})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Taux d'apprentissage = 0,2

Ensuite, nous fixerons le taux d'apprentissage à 0,2 et le sous-échantillonnage à 1.

params = dict(original_params)
params.update({"learning_rate": 0.2, "subsample": 1.0})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Sous-échantillonnage = 0,5

Nous allons maintenant fixer le sous-échantillonnage à 0,5 et le taux d'apprentissage à 1.

params = dict(original_params)
params.update({"learning_rate": 1.0, "subsample": 0.5})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Taux d'apprentissage = 0,2 et sous-échantillonnage = 0,5

Ensuite, nous fixerons le taux d'apprentissage à 0,2 et le sous-échantillonnage à 0,5.

params = dict(original_params)
params.update({"learning_rate": 0.2, "subsample": 0.5})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Taux d'apprentissage = 0,2 et nombre maximum de caractéristiques = 2

Enfin, nous fixerons le taux d'apprentissage à 0,2 et utiliserons seulement 2 caractéristiques pour chaque arbre.

params = dict(original_params)
params.update({"learning_rate": 0.2, "max_features": 2})

clf = ensemble.GradientBoostingClassifier(**params)
clf.fit(X_train, y_train)

Tracer la déviation de l'ensemble de test

Nous allons maintenant tracer la déviation de l'ensemble de test pour chaque stratégie de régularisation.

plt.figure()

for label, color, setting in [
    ("Sans réduction", "orange", {"learning_rate": 1.0, "subsample": 1.0}),
    ("learning_rate=0,2", "turquoise", {"learning_rate": 0.2, "subsample": 1.0}),
    ("subsample=0,5", "bleu", {"learning_rate": 1.0, "subsample": 0.5}),
    (
        "learning_rate=0,2, subsample=0,5",
        "gris",
        {"learning_rate": 0.2, "subsample": 0.5},
    ),
    (
        "learning_rate=0,2, max_features=2",
        "magenta",
        {"learning_rate": 0.2, "max_features": 2},
    ),
]:
    params = dict(original_params)
    params.update(setting)

    clf = ensemble.GradientBoostingClassifier(**params)
    clf.fit(X_train, y_train)

    ## calculer la déviation de l'ensemble de test
    test_deviance = np.zeros((params["n_estimators"],), dtype=np.float64)

    for i, y_proba in enumerate(clf.staged_predict_proba(X_test)):
        test_deviance[i] = 2 * log_loss(y_test, y_proba[:, 1])

    plt.plot(
        (np.arange(test_deviance.shape[0]) + 1)[::5],
        test_deviance[::5],
        "-",
        color=color,
        label=label,
    )

plt.legend(loc="upper right")
plt.xlabel("Itérations de boosting")
plt.ylabel("Déviation de l'ensemble de test")

plt.show()

Sommaire

Dans ce laboratoire, nous avons appris à implémenter différentes stratégies de régularisation pour le Gradient Boosting à l'aide de scikit - learn. Nous avons utilisé la fonction de perte de déviation binaire et le jeu de données make_hastie_10_2. Nous avons implémenté différentes stratégies de régularisation telles que sans réduction, taux d'apprentissage = 0,2, sous - échantillonnage = 0,5 et nombre maximum de caractéristiques = 2. Enfin, nous avons tracé la déviation de l'ensemble de test pour chaque stratégie de régularisation pour comparer leurs performances.

Régularisation du Gradient Boosting