[Kaggle] J'ai essayé l'apprentissage d'ensemble avec LightGBM

0. Introduction

Cette fois, j'ai étudié ** LightGBM **, qui est l'une des méthodes du modèle d'apprentissage. LightGBM est également souvent utilisé dans Kaggle comme l'un des apprentissages d'ensemble. Parallèlement à cela, les processus qui l'entourent (tels que le traçage de la courbe ROC) sont également nécessaires, je les ai donc résumés.

L'article dont j'ai parlé est ici.

• Explication de LightGBM
• [Python: Essayez d'utiliser LightGBM](https://blog.amedama.jp/entry/2018/05/01/081842#%E4%BA%8C%E5%80%A4%E5%88%86% E9% A1% 9E% E5% 95% 8F% E9% A1% 8C-Cancer du sein-% E3% 83% 87% E3% 83% BC% E3% 82% BF% E3% 82% BB% E3% 83 % 83% E3% 83% 88)
• Mémo avec une série de classification binaire avec lightgbm

1. Installez LightGBM

terminal

pip install lightgbm

Faire. Mais,

jupyter

import lightgbm as lgb 

J'ai eu une erreur, alors j'ai cherché comment y remédier.

Erreur lors de l'importation de LightGBM

Je suis arrivé à. Selon ce

terminal

brew install libomp

Ensuite, il a été résolu en toute sécurité. Cela vous fera avancer.

2. Préparez un pseudo ensemble de données

Tout d'abord, importez les bibliothèques requises.

In[1]

%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

print(pd.__version__) #Vous pouvez vérifier la version sur le script.

Out[1]

0.21.0

Chargez ensuite l'ensemble de données. Cette fois, nous utiliserons les données d'iris de l'ensemble de données scikit-learn.

In[2]

from sklearn.datasets import load_iris

iris = load_iris()
#print(iris.DESCR)  #Afficher la description de l'ensemble de données
print(type(iris))

Out[2]

<class 'sklearn.utils.Bunch'>

In[3]

df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['target'] = iris.target

print(df.shape)
df.head()

Tracons ces données avec seulement deux variables.

In[4]

fig = plt.figure(figsize = (5,5))
ax = fig.add_subplot(111)

plt.scatter(df[df['target']==0].iloc[:,0], df[df['target']==0].iloc[:,1], label='Setosa')
plt.scatter(df[df['target']==1].iloc[:,0], df[df['target']==1].iloc[:,1], label='Versicolour')
plt.scatter(df[df['target']==2].iloc[:,0], df[df['target']==2].iloc[:,1], label='Virginica')
plt.xlabel("sepal length[cm]", fontsize=13)
plt.ylabel("sepal width[cm]", fontsize=13)

plt.legend()
plt.show()

Cette fois, je vais essayer de le résoudre comme un problème de classification à deux classes de Versicolour et Virginica, qui semble être relativement difficile à classer parmi ces trois types. Par conséquent, ceux avec une étiquette de 0 sont exclus. Attribuez aux deux types restants les étiquettes 0 et 1.

In[5]

data = df[df['target']!=0]
data.head()

In[6]

data['target'] = data['target'] - 1

X = data.drop('target', axis=1)
y = data['target']

Out[6]

/Users/{user}/.pyenv/versions/3.6.6/lib/python3.6/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy
  """Entry point for launching an IPython kernel.

Je ne pourrais pas bien gérer cet avertissement, donc si vous savez quoi faire ...

3. Apprenez avec LightGBM

Avant cela, divisez les données d'entraînement et les données de test. Cette fois, nous effectuerons une validation croisée, donc préparez également les données de validation.

In[7]

from sklearn.model_selection import train_test_split

X_trainval, X_test, y_trainval, y_test = train_test_split(X, y, test_size=0.2, random_state=7, stratify=y)
X_train, X_val, y_train, y_val = train_test_split(X_trainval, y_trainval, test_size=0.2, random_state=7, stratify=y_trainval)

C'est finalement le sujet principal. Nous allons construire un modèle lightgbm.

À propos des hyper paramètres

Les paramètres et autres arguments du train de fonctions lightgbm sont des hyperparamètres. La documentation pour cela est ici.

De plus, je pense que les articles suivants seront utiles.

• Présentation détaillée de LightGBM - Comment utiliser LightGBM, comment il fonctionne et en quoi il diffère de XGBoost
• [Machine learning] Comment régler les hyper paramètres

Ici, je n'expliquerai que ceux qui semblent importants.

--objectif: Puisque cette fois il s'agit d'une classification à deux classes, le binaire est spécifié. --metric: 2 Spécifie auc, qui est l'un des indicateurs qui peuvent être utilisés pour la classification de classe. --early_stopping_rounds: si la métrique ne s'améliore pas dans le nombre de tours spécifié, arrêtez d'apprendre avant cela.

• Votre compréhension peut être incorrecte, mais veuillez la corriger dans ce cas.

In[8]

import lightgbm as lgb

lgb_train = lgb.Dataset(X_train, y_train)
lgb_val = lgb.Dataset(X_val, y_val)

params = {
    'metric' :'auc', #binary_Également possible avec logloss
    'objective' :'binary',
    'max_depth' :1,
    'num_leaves' :2,
    'min_data_in_leaf' : 5,    
}

evals_result = {} #Dictionnaire pour stocker les résultats

gbm = lgb.train(params,
                lgb_train,
                valid_sets = [lgb_train, lgb_val],
                valid_names = [ 'train', 'eval'],
                num_boost_round = 500,
                early_stopping_rounds = 20,
                verbose_eval = 10,
                evals_result = evals_result
               )

Out[8]

Training until validation scores don't improve for 20 rounds
[10]	train's auc: 0.997559	eval's auc: 0.914062
[20]	train's auc: 0.997559	eval's auc: 0.914062
Early stopping, best iteration is:
[3]	train's auc: 0.998047	eval's auc: 0.914062

4. Tracez la courbe d'apprentissage

Le evals_result que j'ai mis dans l'argument de la fonction train plus tôt contient l'enregistrement sur l'auc spécifié comme index. Nous allons l'utiliser pour dessiner une courbe d'apprentissage.

In[9]

print(evals_result.keys())
print(evals_result['eval'].keys())
print(evals_result['train'].keys())

train_metric = evals_result['train']['auc']
eval_metric = evals_result['eval']['auc']
train_metric[:5], eval_metric[:5]

Out[9]

dict_keys(['train', 'eval'])
odict_keys(['auc'])
odict_keys(['auc'])

([0.9375, 0.9375, 0.998046875, 0.998046875, 0.998046875],
 [0.8125, 0.8125, 0.9140625, 0.9140625, 0.9140625])

Comme il est inclus sous forme de liste dans le dictionnaire comme ceci, spécifiez la clé pour obtenir cette liste.

Ensuite, dessinez une courbe d'apprentissage.

In[10]

plt.plot(train_metric, label='train auc')
plt.plot(eval_metric, label='eval auc')
plt.grid()
plt.legend()
plt.ylim(0, 1.1)

plt.xlabel('rounds')
plt.ylabel('auc')
plt.show()

5. Examiner les caractéristiques importantes

lightgbm peut visualiser son importance dans la classification en utilisant lightgbm.plot_importance.

La documentation de lightgbm.plot_importance est ici.

In[11]

lgb.plot_importance(gbm, figsize=(12, 6), max_num_features=4)
plt.show();

6. Estimer les données de test ・ Tracer la courbe ROC

In[12]

from sklearn import metrics

y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration)

fpr, tpr, thresholds = metrics.roc_curve(y_test, y_pred, drop_intermediate=False, )
auc = metrics.auc(fpr, tpr)
print('auc:', auc)

Out[12]

auc: 1.0

La documentation de roc_curve est ici (https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html).

De plus, lorsque j'étudiais la courbe ROC, les articles suivants étaient organisés de manière facile à comprendre, je vais donc les lier.

• Calculer la courbe ROC et son AUC avec scicit-learn

In[13]

plt.plot(fpr, tpr, marker='o')
plt.xlabel('FPR: False positive rate')
plt.ylabel('TPR: True positive rate')
plt.grid()
plt.plot();

Cette fois, c'était relativement facile, c'est donc devenu une courbe ROC extrême.

Enfin, définissez un certain seuil et triez les étiquettes de réponse en fonction de ce seuil.

In[13]

y_pred = (y_pred >= 0.5).astype(int)
y_pred

Out[14]

array([1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0])

7. Dessinez une carte thermique de la matrice de confusion

Finalement,

• Belle visualisation avec carte thermique Seaborn

J'ai également dessiné une carte thermique de la matrice de confusion en référence à.

In[15]

from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

cm = confusion_matrix(y_test.values, y_pred)

sns.heatmap(cm, annot=True, annot_kws={'size': 20}, cmap= 'Reds');