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.

out01.png

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.

out02.png

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.

out03.png

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.

out04.png

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.

out05.png

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.

out06.png

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

J'ai essayé d'apprendre LightGBM avec Yellowbrick
J'ai essayé l'apprentissage automatique avec liblinear
[Kaggle] J'ai essayé l'apprentissage d'ensemble avec LightGBM
J'ai essayé le deep learning
J'ai essayé d'utiliser lightGBM, xg boost avec Boruta
[Mac] J'ai essayé de renforcer l'apprentissage avec Open AI Baselines
J'ai essayé fp-growth avec python
J'ai essayé Learning-to-Rank avec Elasticsearch!
J'ai essayé le clustering avec PyCaret
J'ai essayé gRPC avec Python
J'ai essayé de gratter avec du python
J'ai essayé de déplacer l'apprentissage automatique (détection d'objet) avec TouchDesigner
Mayungo's Python Learning Episode 1: J'ai essayé d'imprimer avec impression
J'ai essayé de résumer des phrases avec summpy
J'ai essayé webScraping avec python.
J'ai essayé de déplacer de la nourriture avec SinGAN
Mayungo's Python Learning Episode 3: J'ai essayé d'imprimer des nombres
J'ai essayé la détection de visage avec MTCNN
J'ai essayé l'apprentissage par renforcement avec PyBrain
J'ai essayé l'apprentissage en profondeur avec Theano
J'ai essayé d'exécuter prolog avec python 3.8.2.
J'ai essayé la communication SMTP avec Python
J'ai essayé la génération de phrases avec GPT-2
J'ai essayé d'écrire dans un modèle de langage profondément appris
J'ai essayé la reconnaissance faciale avec OpenCV
J'ai essayé de rendre le deep learning évolutif avec Spark × Keras × Docker
J'ai essayé l'apprentissage par renforcement profond (Double DQN) avec ChainerRL
Mayungo's Python Learning Episode 7: J'ai essayé d'imprimer avec if, elif, else
J'ai essayé l'analyse de régression multiple avec régression polypoly
J'ai essayé d'envoyer un SMS avec Twilio
J'ai essayé d'utiliser Amazon SQS avec django-celery
J'ai essayé d'implémenter Autoencoder avec TensorFlow
J'ai essayé linebot avec flacon (anaconda) + heroku
J'ai essayé de visualiser AutoEncoder avec TensorFlow
J'ai essayé de commencer avec Hy
J'ai essayé d'utiliser du sélénium avec du chrome sans tête
J'ai essayé le rendu non réaliste avec Python + opencv
J'ai essayé un langage fonctionnel avec Python
J'ai essayé la récurrence avec Python ② (séquence de nombres Fibonatch)
J'ai essayé d'implémenter DeepPose avec PyTorch PartⅡ
J'ai essayé d'implémenter CVAE avec PyTorch
J'ai essayé de jouer avec l'image avec Pillow
Mayungo's Python Learning Episode 8: J'ai essayé l'entrée
J'ai essayé de résoudre TSP avec QAOA
J'ai essayé la reconnaissance d'image simple avec Jupyter
J'ai essayé le réglage fin de CNN avec Resnet
J'ai essayé le traitement du langage naturel avec des transformateurs.
# J'ai essayé quelque chose comme Vlookup avec Python # 2
J'ai essayé de mettre en œuvre un apprentissage en profondeur qui n'est pas profond avec uniquement NumPy
J'ai essayé de gratter
J'ai essayé PyQ
Mayungo's Python Learning Episode 2: J'ai essayé de mettre des caractères avec des variables
J'ai essayé AutoKeras
J'ai essayé de visualiser le modèle avec la bibliothèque d'apprentissage automatique low-code "PyCaret"
J'ai essayé django-slack
J'ai essayé Django
J'ai essayé spleeter