[PYTHON] [Kaggle] Ich habe versucht, Ensemble mit LightGBM zu lernen
0. Einleitung
Dieses Mal untersuchte ich ** LightGBM **, eine der Lernmodellmethoden. LightGBM wird in Kaggle auch häufig als Teil des Ensemble-Lernens verwendet. Daneben sind auch die Prozesse um sie herum (wie das Zeichnen der ROC-Kurve) erforderlich, daher habe ich sie zusammengefasst.
Der Artikel, auf den ich mich bezog, ist hier.
- Erklärung von LightGBM
- [Python: Versuchen Sie es mit 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-Brustkrebs-% E3% 83% 87% E3% 83% BC% E3% 82% BF% E3% 82% BB% E3% 83 % 83% E3% 83% 88)
- Memo mit einer Reihe von binären Klassifikationen mit lightgbm
1. Installieren Sie LightGBM
terminal
pip install lightgbm
Machen. Aber,
jupyter
import lightgbm as lgb
Ich habe einen Fehler erhalten und habe untersucht, wie ich damit umgehen soll.
Fehler beim Importieren von LightGBM
Ich kam an. Demzufolge
terminal
brew install libomp
Dann wurde es sicher gelöst. Dies wird Sie vorwärts bringen.
2. Bereiten Sie einen Pseudodatensatz vor
Importieren Sie zunächst die erforderlichen Bibliotheken.
In[1]
%matplotlib inline
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
print(pd.__version__) #Sie können die Version im Skript überprüfen.
Out[1]
0.21.0
Laden Sie dann den Datensatz. Dieses Mal werden wir die Irisdaten aus dem Scikit-Learn-Datensatz verwenden.
In[2]
from sklearn.datasets import load_iris
iris = load_iris()
#print(iris.DESCR) #Beschreibung des Datensatzes anzeigen
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()
Zeichnen wir diese Daten mit nur zwei Variablen.
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()
Dieses Mal werde ich versuchen, es als ein Zwei-Klassen-Klassifizierungsproblem von Versicolour und Virginica zu lösen, das unter diesen drei Typen relativ schwer zu klassifizieren scheint. Daher sind diejenigen mit einer Bezeichnung von 0 ausgeschlossen. Geben Sie den verbleibenden beiden Typen die Bezeichnungen 0 und 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.
Ich konnte mit dieser Warnung nicht gut umgehen. Wenn Sie also wissen, was zu tun ist ...
3. Lernen Sie mit LightGBM
Teilen Sie vorher die Trainingsdaten und die Testdaten auf. Dieses Mal führen wir eine Kreuzvalidierung durch. Bereiten Sie daher auch Validierungsdaten vor.
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)
Es ist endlich das Hauptthema. Wir werden ein LightGBM-Modell bauen.
Über Hyperparameter
Die Parameter und andere Argumente des lightgbm-Funktionszugs sind Hyperparameter. Die Dokumentation dazu ist hier.
Ich denke auch, dass die folgenden Artikel hilfreich sein werden.
- Ausführliche Einführung in LightGBM - Verwendung von LightGBM, Funktionsweise und Unterschiede zu XGBoost
- [Maschinelles Lernen] Einstellen von Hyperparametern
Hier werde ich nur diejenigen erklären, die wichtig erscheinen.
--objektiv: Da es sich diesmal um eine Zwei-Klassen-Klassifikation handelt, wird Binär angegeben. --metric: 2 Gibt auc an, einen der Indikatoren, die für die Klassenklassifizierung verwendet werden können. --early_stopping_rounds: Wenn sich die Metrik in der angegebenen Anzahl von Runden nicht verbessert, hören Sie vorher auf zu lernen.
- Ihr Verständnis ist möglicherweise falsch, aber bitte korrigieren Sie es in diesem Fall.
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_Auch mit logloss möglich
'objective' :'binary',
'max_depth' :1,
'num_leaves' :2,
'min_data_in_leaf' : 5,
}
evals_result = {} #Wörterbuch zum Speichern von Ergebnissen
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. Zeichnen Sie die Lernkurve
Das evals_result, das ich zuvor in das Argument der Zugfunktion eingefügt habe, enthält den Datensatz über die als Index angegebene auc. Wir werden dies verwenden, um eine Lernkurve zu zeichnen.
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])
Da es wie folgt als Liste im Wörterbuch enthalten ist, geben Sie den Schlüssel an, um diese Liste abzurufen.
Zeichnen Sie dann eine Lernkurve.
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. Untersuchen Sie wichtige Funktionen
lightgbm kann seine Bedeutung bei der Klassifizierung mithilfe von lightgbm.plot_importance visualisieren.
Die Dokumentation für lightgbm.plot_importance ist hier.
In[11]
lgb.plot_importance(gbm, figsize=(12, 6), max_num_features=4)
plt.show();
6. Testdaten schätzen ・ ROC-Kurve zeichnen
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
Die Dokumentation zu roc_curve finden Sie hier (https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html).
Als ich die ROC-Kurve untersuchte, waren die folgenden Artikel auf leicht verständliche Weise organisiert, sodass ich sie verknüpfen werde.
In[13]
plt.plot(fpr, tpr, marker='o')
plt.xlabel('FPR: False positive rate')
plt.ylabel('TPR: True positive rate')
plt.grid()
plt.plot();
Diesmal war es relativ einfach, so dass es zu einer extremen ROC-Kurve wurde.
Stellen Sie schließlich einen bestimmten Schwellenwert ein und sortieren Sie die Antwortbezeichnungen basierend auf diesem Schwellenwert.
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. Zeichnen Sie eine Wärmekarte der Verwirrungsmatrix
Schließlich,
Ich habe auch eine Heatmap der Verwirrungsmatrix mit Bezug auf gezeichnet.
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');
Recommended Posts