[PYTHON] J'ai essayé d'apprendre LightGBM avec Yellowbrick
introduction
J'ai essayé Yellowbrick un peu avant [^ 1], mais j'ai juste essayé de le déplacer en me basant sur l'exemple de code de Yellowbrick, alors j'ai essayé de découvrir ce que Yellowbrick pouvait faire. Cette fois, je vais construire LightGBM, qui est souvent utilisé dans kaggle, en utilisant Yellowbrick, et même enregistrer le modèle. Cependant, Yellowbrick peut ne pas être en mesure d'effectuer un prétraitement tel que la création d'entités et une évaluation détaillée de la précision du modèle, il ne sera donc pas traité.
environnement
L'environnement d'exécution est le suivant.
$sw_vers
ProductName: Mac OS X
ProductVersion: 10.13.6
BuildVersion: 17G8037
$python3 --version
Python 3.7.4
L'installation de Yellowbrick est décrite dans [^ 1], elle sera donc omise. Pour l'installation de LightGBM, reportez-vous ici [^ 2].
Construire un modèle
Préparation
Importez la bibliothèque à utiliser cette fois.
import pandas as pd
import numpy as np
import yellowbrick
from yellowbrick.datasets import load_bikeshare
from yellowbrick.model_selection import LearningCurve,ValidationCurve,FeatureImportances
from yellowbrick.regressor import ResidualsPlot
import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from joblib import dump, load
Pour les données, utilisez `` load_bikeshare '' préparé par Yellowbrick.
# Load data
X, y = load_bikeshare()
print(X.head())
Il existe 12 variables explicatives, qui sont toutes des données numériques. La variable objective est le nombre de vélos partagés loués. Cette fois, je vais mettre ces données dans LightGBM telles quelles et créer un modèle.
season year month hour holiday weekday workingday weather temp \
0 1 0 1 0 0 6 0 1 0.24
1 1 0 1 1 0 6 0 1 0.22
2 1 0 1 2 0 6 0 1 0.22
3 1 0 1 3 0 6 0 1 0.24
4 1 0 1 4 0 6 0 1 0.24
feelslike humidity windspeed
0 0.2879 0.81 0.0
1 0.2727 0.80 0.0
2 0.2727 0.80 0.0
3 0.2879 0.75 0.0
4 0.2879 0.75 0.0
Divisez les données pour la formation et la validation avant la formation. Le rapport de division est réglé sur 8: 2 pour le texte.
# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
Le modèle utilise LightGBM comme mentionné ci-dessus. Cependant, comme Yellowbrick est une bibliothèque comme la version étendue de scikit-learn, LightGBM utilise également l'API de scilit-learn [^ 3].
# Model
model = lgb.LGBMRegressor()
Essayez de régler
Maintenant, utilisons ValidationCurve de Yellowbrick pour déterminer les hyperparamètres. Cette fois, je vais essayer d'étudier la relation entre les valeurs de max_depth, n_estimators et num_leaves et la précision. Voir ici [^ 5] pour les spécifications API de Validation Curve.
Spécifiez le modèle, le nom du paramètre à vérifier et la plage de paramètres dans l'argument de ValidationCurve comme suit. cv peut définir le nombre de divisions du test croisé et du générateur. Cette fois, le nombre de divisions du test croisé est fixé à 5. Le dernier score spécifie l'index pour voir la précision, et définit neg_mean_squared_error parmi les index [^ 4] définis par scicit-learn.
visualizer = ValidationCurve(
model, param_name="max_depth",
param_range=np.arange(1, 11), cv=5, scoring='neg_mean_squared_error'
)
visualizer.fit(X_train, y_train)
visualizer.show()
La sortie est comme indiqué dans la figure ci-dessous, et l'axe vertical est neg_mean_squared_error. Cet indice multiplie littéralement l'erreur quadratique moyenne par (-1), indiquant que le côté supérieur (plus proche de 0) de la figure a une précision plus élevée. En regardant le score de validation croisée, si max_depth est égal ou supérieur à 6, la précision ne changera guère, alors définissez max_depth sur 6.
Ensuite, examinons n_estimators de la même manière. Le programme est le suivant.
visualizer = ValidationCurve(
model, param_name="n_estimators",
param_range=np.arange(100, 1100, 100), cv=5, scoring='neg_mean_squared_error'
)
visualizer.fit(X_train, y_train)
visualizer.show()
La sortie est comme indiqué dans la figure ci-dessous. En regardant le score de validation croisée, si les nestimateurs sont de 600 ou plus, la précision est presque la même, alors définissez n_estimators sur 600.
Enfin, vérifiez num_leaves de la même manière. Le programme est le suivant.
visualizer = ValidationCurve(
model, param_name="num_leaves",
param_range=np.arange(2, 54, 4), cv=5, scoring='neg_mean_squared_error'
)
visualizer.fit(X_train, y_train)
visualizer.show()
Cette sortie est comme illustré dans la figure ci-dessous. En regardant le score de validation croisée, num_leaves est égal ou supérieur à 20 et la précision n'a pratiquement pas changé, définissez-le sur 20.
Comme décrit ci-dessus, il était possible d'ajuster facilement les paramètres avec ValidationCurve. Définissez à nouveau le modèle.
# Model
model = lgb.LGBMRegressor(
boosting_type='gbdt',
num_leaves=20,
max_depth=6,
n_estimators=600,
random_state=1234,
importance_type='gain')
Essayez de dessiner une courbe d'apprentissage
Pour voir si le modèle est sous-ajusté ou sur-ajusté Regardons la précision du modèle tout en modifiant la quantité de données d'entraînement. Il peut être facilement visualisé à l'aide de LearningCurve.
visualizer = LearningCurve(model, cv=5, scoring='neg_mean_squared_error')
visualizer.fit(X_train, y_train)
visualizer.show()
Le résultat est illustré dans la figure ci-dessous. On peut voir que la précision du score de validation croisée s'améliore à mesure que la quantité de données augmente. Même si la quantité de données peut être augmentée, la précision ne s'améliorera pas de façon spectaculaire.
Importance de la quantité de caractéristiques
Il est également facile d'afficher des variables explicatives par ordre d'importance lors de la prédiction du nombre de vélos partagés loués.
visualizer = FeatureImportances(model)
visualizer.fit(X_train, y_train)
visualizer.show()
Le résultat est illustré dans la figure ci-dessous. L'heure la plus efficace était l'heure de la journée. Les autres variables sont affichées avec cette importance définie sur 100.
Précision du modèle
Comme indiqué dans l'article précédent [^ 1], vérifiez la précision avec la distribution résiduelle.
visualizer = ResidualsPlot(model)
visualizer.fit(X_train, y_train)
visualizer.score(X_test, y_test)
visualizer.show()
La sortie est comme indiqué dans la figure ci-dessous. En regardant le graphique en nuage de points, il y a des endroits où la valeur prévue est désactivée, mais la valeur $ R ^ 2 $ est de 0,9 ou plus, En regardant la distribution résiduelle dans l'histogramme, la précision semble bonne car il y a un pic autour du résidu de 0.
Il semble que le score affiché dans la figure ne puisse pas être changé en un indice autre que $ R ^ 2 $, donc lorsque j'ai calculé à nouveau le RMSE, il était d'environ 38. Maintenant que nous avons un modèle comme celui-là, nous allons terminer la construction du modèle ici.
model = model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print('The rmse of prediction is:', mean_squared_error(y_test, y_pred) ** 0.5)
# The rmse of prediction is: 38.82245025441572
Enregistrer le modèle
Enregistrez le modèle construit. Quand je l'ai recherché avec Scikit-learn, il a décrit comment le sauvegarder avec joblib [^ 6], donc enregistrez-le de la même manière.
dump(model, 'lightgbm.joblib')
à la fin
Dans le programme ci-dessus, l'exemple de code [^ 7] de LightGBM est également mentionné. L'impression est que c'est pratique car vous pouvez facilement vérifier la précision du modèle et du tracé qui peut être utilisé pour la vérification avec Yellowbrick. D'un autre côté, il est étrange de rendre Visualizer "adapté" à chaque fois ...
Recommended Posts