Comment choisir le nombre d'estimateurs pour Gradient Boosting

En science des données, de nombreux algorithmes sont disponibles pour une utilisation de nos jours. Une technique utile consiste donc à les combiner dans un seul modèle pour tirer le meilleur parti de chacun, ce qui donne un modèle plus précis.

En utilisant Scikit-Learn, vous trouverez l'algorithme Random Forest, c'est-à-dire le type d'ensachage du modèle d'ensemble. D'autre part, vous trouverez également des modèles Boosting, qui entraînent les estimateurs en séquence, où le résultat d'un modèle est transmis au suivant, qui essaiera d'améliorer les prédictions, jusqu'à ce qu'ils atteignent un résultat optimal.

Lors de la création d'un estimateur Gradient Boosting, vous trouverez cet hyperparamètre n_estimator=100 avec une valeur par défaut de 100 arbres à créer pour arriver à un résultat. Plusieurs fois, nous le définissons simplement par défaut ou l'augmentons peut-être au besoin, même en utilisant des techniques de recherche de grille.

Dans cet article, nous trouverons un moyen simple d'accéder à un numéro unique à utiliser pour entraîner notre modèle.

Gradient Boosting peut être chargé depuis Scikit-Learn en utilisant cette classe from sklearn.ensemble import GradientBoostingRegressor. L'algorithme Gradient Boosting peut être utilisé soit pour la classification, soit pour les modèles de régression. Il s'agit d'un estimateur basé sur un arbre, ce qui signifie qu'il est composé de nombreux arbres de décision.

Le résultat de la Arbre 1 générera des erreurs. Ces erreurs seront utilisées et l'entrée pour le Arbre 2. Encore une fois, les erreurs du dernier modèle seront utilisées et l'entrée du suivant, jusqu'à ce qu'il atteigne le n_estimators valeur.

Étant donné que chaque estimateur s'ajustera à l'erreur du précédent, on s'attend à ce que la combinaison des prédictions soit meilleure que n'importe lequel des estimateurs seuls. Après chaque itération, nous rendons le modèle plus complexe, réduisant le biais mais augmentant la variance, d'un autre côté. Il faut donc savoir s'arrêter.

Voyons comment faire cela maintenant.

Le code de cet exercice est simple. Tout ce que nous devons faire est une boucle après chaque itération et vérifier à laquelle nous avons eu l'erreur la plus faible.

Commençons par choisir un jeu de données. Nous utiliserons le accidents de voiture dataset, natif de la bibliothèque seaborn (donc une open data sous licence BDS).

# Base de données
df = sns.load_dataset('car_crashes')

Voici un aperçu rapide des données. Nous essaierons d'estimer la total montant en utilisant les autres caractéristiques comme prédicteurs. Puisqu'il s'agit d'une sortie de nombre réel, nous parlons d'un modèle de régression.

Regardons rapidement les corrélations.

# Corrélations
df.corr().style.background_gradient(cmap='coolwarm')

Ok, pas de multicolinéarité majeure. On peut voir ça ins_premium ainsi que ins_losses ne correspondent pas très bien avec le total , nous ne les considérerons donc pas dans le modèle.

Si nous vérifions les données manquantes, il n'y en a pas

# Manquant
df.isnull().sum()
0

Bien, alors divisons les données maintenant.

# X et y
X = df.drop(['ins_premium', 'ins_losses', 'abbrev', 'total'], axe=1)
y = df['total']# Essai de trains
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=22)

Nous pouvons créer un pipeline pour mettre à l'échelle les données et les modéliser (il n'est vraiment pas vraiment nécessaire de mettre ces données à l'échelle, puisqu'elles sont déjà à la même échelle, sur la base des dizaines). Ensuite, nous adaptons les données au modèle et prédisons les résultats.

J'utilise 500 estimateurs avec un learning_rate de 0.3.

Le taux d'apprentissage est la taille du pas que nous faisons pour arriver à l'erreur minimale. Si nous utilisons une valeur trop élevée, nous pouvons dépasser le minimum. Si nous utilisons un nombre trop petit, nous ne nous en approcherons peut-être même pas. Donc, une règle empirique que vous pouvez considérer est la suivante : si vous avez un grand nombre d'estimateurs, vous pouvez utiliser des valeurs inférieures de taux d'apprentissage. Si vous n'avez que quelques estimateurs, préférez utiliser des valeurs plus élevées de taux d'apprentissage.

pas = [('scale', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03)) ]# Instance Pipeline et ajustement
pipe = Pipeline(étapes).fit(X_train, y_train)# Prédire
preds = pipe.predict(X_test)

Maintenant, évaluons.

# RMSE des prédictions
print(f'RMSE : { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[SORTIE] : RMSE : 1.1# Moyenne des vraies valeurs Y
print(f'Data y signifie : {round( y.mean(),1 )}')[OUT] : Données y moyennes : 15.8

Bien. Notre RMSE est d'environ 6.9 % de la moyenne. Nous sommes donc loin de cela, en moyenne.

Voyons maintenant une façon d'ajuster notre modèle en choisissant le nombre optimal d'estimateurs à former qui nous donnera le taux d'erreur le plus bas.

Comme je l'ai dit, nous n'avons pas vraiment besoin de mettre à l'échelle ces données car elles sont déjà dans la même proportion. Alors adaptons le modèle.

#Modèle
gbr = GradientBoostingRegressor(n_estimators=500, learning_rate=0.3).fit(X_train, y_train)

Maintenant, c'est le bon truc. Il existe une méthode dans Gradient Boosting qui nous permet de parcourir les prédictions de chaque estimateur formé, de 1 à 500. Nous allons donc créer une boucle qui parcourt les 500 estimateurs du gbr modèle, prédit les résultats en utilisant la méthode staged_predict(), calcule l'erreur quadratique moyenne et stocke le résultat dans la liste errors.

# Boucle pour le meilleur numéro
erreurs = [mean_squared_error(y_test, preds) pour les preds dans gbr.staged_predict(X_test)]# Nombre optimal d'estimateurs
optimal_num_estimators = np.argmin (erreurs) + 1

Ensuite, nous pouvons tracer le résultat.

#Parcelle
g=sns.lineplot(x=range(500), y=erreurs)
g.set_title(f'Meilleur nombre d'estimateurs à {best_n_estimators}', size=15);

Nous voyons que le taux d'erreur le plus faible est avec 34 estimateurs. Donc, réentraînons notre modèle avec 34 estimateurs et comparons avec le résultat du modèle entraîné avec le pipeline.

# Recyclage
gbr = GradientBoostingRegressor(n_estimators=34, learning_rate=0.3).fit(X_train, y_train)# Prédictions
preds2 = gbr.predict(X_test)

Évaluation…

# RMSE des prédictions
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[SORTIE] : RMSE : 1.0# Données Y signifient
print(f'Data y signifie : {round( y.mean(),1 )}')[OUT] : Données y moyennes : 15.8

Nous sommes passés de 6.9 % à 6.3 % de réduction maintenant. Environ. 9% mieux. Regardons quelques prédictions.

Des résultats intéressants. Certaines des prédictions du second modèle sont meilleures que celles du premier.

Nous avons appris à déterminer le meilleur nombre d'estimateurs pour ajuster un GradientBoostingRegressor de Scikit-Learn. Il s'agit d'un hyperparamètre qui peut faire la différence dans ce type de modèle d'ensemble, qui entraîne les estimateurs en séquence.

Parfois, après quelques itérations, le modèle peut commencer à sur-ajuster, donc il commencera à trop augmenter la variance, impactant les prédictions.

Nous avons vu qu'une simple boucle peut nous aider à trouver la solution optimale dans ce cas. Mais, certainement, pour les grands ensembles de données, cela peut être coûteux à calculer, donc une idée serait d'essayer une valeur inférieure n_estimators d'abord et voyez si vous pouvez atteindre l'erreur minimale assez tôt.

Voici le code complet dans GitHub.

Si vous avez aimé ce contenu, suivez mon blog.

Trouvez-moi sur LinkedIn.

Cet exercice s'appuyait sur l'excellent manuel d'Aurélien Géron, dans la référence.

Comment choisir le nombre d'estimateurs pour Gradient Boosting Republié à partir de Source https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 via https://towardsdatascience.com/feed

<!–

->