[PYTHON] [Für Kaggle-Anfänger] Titanic (LightGBM)

■ Einführung

Dieses Mal habe ich mit LigthGBM am folgenden Wettbewerb gearbeitet. Ich habe versucht, es kurz zusammenzufassen.

【Überblick】 ・ Titanic: Maschinelles Lernen aus Katastrophen ・ Unterscheiden Sie anhand der Passagierinformationen des sinkenden Schiffes "Titanic" zwischen denen, die gerettet wurden, und denen, die es nicht sind.

[Zielgruppe Leser] ・ Kaggle Anfänger ・ Diejenigen, die mehr über den Basiscode von LightGBM erfahren möchten

1. Vorbereitung des Moduls

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
import lightgbm as lgb
from sklearn.metrics import roc_curve, roc_auc_score
from sklearn.metrics import accuracy_score, f1_score
from sklearn.metrics import confusion_matrix, classification_report

train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')

print(train.shape)
print(test.shape)

# (891, 12)
# (418, 11)

train.head()

【Datenelement】 ・ PassengerId: Passagier-ID ・ Überlebt: Ob es überlebt hat (0: nicht gespeichert, 1: gespeichert) ・ Klasse - Ticketklasse (1: Oberklasse, 2: Mittelklasse, 3: Unterklasse) ・ Name: Name des Passagiers ・ Geschlecht: Geschlecht ・ Alter: Alter ・ SibSp: Anzahl der Brüder und Ehepartner an Bord ・ Parch: Anzahl der Eltern / Kinder an Bord ・ Ticket: Ticketnummer ・ Tarif: Gebühr ・ Kabine: Zimmernummer ・ Eingeschifft: Hafen an Bord (C: Cherbourg, Q: Queenstown, S: Southampton)

test.head()

Speichern Sie die Passagiernummer (PassengerId) der Testdaten.

PassengerId = test['PassengerId']

Tatsächlich wird das Modell nur mit Zugdaten erstellt Ich möchte die Zug- / Testdaten gemeinsam vorverarbeiten, daher werde ich eine Kombination in Betracht ziehen.

Die Zugdaten enthalten noch ein Element (Zielvariable: Überlebt), sodass sie getrennt sind.

y = train['Survived']
train = train[[col for col in train.columns if col != 'Survived']]

print(train.shape)
print(test.shape)

# (891, 11)
# (418, 11)

Nachdem die Anzahl der Elemente (Merkmale) in den Zugdaten und Testdaten gleich ist, kombinieren Sie sie.

X_total = pd.concat([train, test], axis=0)

print(X_total.shape)
X_total.head()

# (1309, 11)

3. Vorbehandlung

Überprüfen Sie zunächst, wie viele Werte fehlen.

print(X_total.isnull().sum())

'''
PassengerId       0
Pclass            0
Name              0
Sex               0
Age             263
SibSp             0
Parch             0
Ticket            0
Fare              1
Cabin          1014
Embarked          2
dtype: int64
'''

Mit LightGBM ist es möglich, ein Modell mit Zeichenfolgendaten so wie es ist zu erstellen. Die Vorverarbeitung erfolgt ohne numerische Konvertierung.

X_total.fillna(value=-999, inplace=True)

print(X_total.isnull().sum())

'''
PassengerId    0
Pclass         0
Name           0
Sex            0
Age            0
SibSp          0
Parch          0
Ticket         0
Fare           0
Cabin          0
Embarked       0
dtype: int64
'''

Überprüfen Sie nun die Spalte mit den Zeichenfolgendaten (im Folgenden als kategorial bezeichnet).

categorical_col = [col for col in X_total.columns if X_total[col].dtype == 'object']
print('categorical_col:', categorical_col)

# categorical_col: ['Name', 'Sex', 'Ticket', 'Cabin', 'Embarked']

Untersuchen Sie den Datentyp jeder Kategorie.

for i in X_total[categorical_col]:
    print('{}: {}'.format(i, X_total[i].dtype))

'''
Name: object
Sex: object
Ticket: object
Cabin: object
Embarked: object
'''

LightGBM kann als String-Daten modelliert werden. Da wir es zu einem Kategorietyp anstelle eines Objekttyps machen müssen, konvertieren wir den Datentyp.

for i in categorical_col:
    X_total[i] = X_total[i].astype("category")

Schauen wir uns den Datentyp der Gesamtdaten an (X_total).

for i in X_total.columns:
    print('{}: {}'.format(i, X_total[i].dtype))

'''
PassengerId: int64
Pclass: int64
Name: category
Sex: category
Age: float64
SibSp: int64
Parch: int64
Ticket: category
Fare: float64
Cabin: category
Embarked: category
'''

train_rows = train.shape[0]
X = X_total[:train_rows]

print(X.shape)
print(y.shape)

# (891, 11)
# (891,)

Da der Merkmalsbetrag und die Zielvariable entsprechend den Zugdaten verfügbar sind Darüber hinaus erstellen wir ein Modell, indem wir es in Trainingsdaten und Testdaten unterteilen.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

# (623, 11)
# (623,)
# (268, 11)
# (268,)

Legen Sie die Parameter fest und übergeben Sie sie als Wörterbuchtypargumente an LGBMClassifier ().

params = {
"random_state": 42
}

cls = lgb.LGBMClassifier(**params)
cls.fit(X_train, y_train, categorical_feature = categorical_col)

'''
LGBMClassifier(boosting_type='gbdt', class_weight=None, colsample_bytree=1.0,
               importance_type='split', learning_rate=0.1, max_depth=-1,
               min_child_samples=20, min_child_weight=0.001, min_split_gain=0.0,
               n_estimators=100, n_jobs=-1, num_leaves=31, objective=None,
               random_state=42, reg_alpha=0.0, reg_lambda=0.0, silent=True,
               subsample=1.0, subsample_for_bin=200000, subsample_freq=0)
'''

Als nächstes finden Sie den vorhergesagten Wert.

Durch Angabe von [:, 1] für y_proba wird die Wahrscheinlichkeit vorhergesagt, Klasse 1 (Survived = 1) zu werden. y_pred wird in 1 konvertiert, wenn es größer als 0,5 ist, und in 0, wenn es kleiner als 0,5 ist.

y_proba = cls.predict_proba(X_test)[: , 1]
print(y_proba[:5])

y_pred = cls.predict(X_test)
print(y_pred[:5])

# [0.38007409 0.00666063 0.04531554 0.95244042 0.35233708]
# [0 0 0 1 0]

fpr, tpr, thresholds = roc_curve(y_test, y_proba)
auc_score = roc_auc_score(y_test, y_proba)
plt.plot(fpr, tpr, label='AUC = %.3f' % (auc_score))
plt.legend()
plt.title('ROC curve')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.grid(True)

print('accuracy:',accuracy_score(y_test, y_pred))
print('f1_score:',f1_score(y_test, y_pred))

# accuracy: 0.8208955223880597
# f1_score: 0.7446808510638298

Lassen Sie uns auch anhand einer Verwirrungsmatrix bewerten.

classes = [1, 0]
cm = confusion_matrix(y_test, y_pred, labels=classes)

cmdf = pd.DataFrame(cm, index=classes, columns=classes)

sns.heatmap(cmdf, annot=True)
print(classification_report(y_test, y_pred))

'''
              precision    recall  f1-score   support

           0       0.83      0.89      0.86       168
           1       0.80      0.70      0.74       100

    accuracy                           0.82       268
   macro avg       0.81      0.80      0.80       268
weighted avg       0.82      0.82      0.82       268

'''

6. Submit Da konnte ich anhand von Zugdaten ein Modell erstellen und auswerten Geben Sie die Informationen der Testdaten und den vorhergesagten Wert an.

Extrahieren Sie zunächst den den Testdaten entsprechenden Teil aus den Gesamtdaten (X_total).

X_submit = X_total[train_rows:]

print(X_train.shape)
print(X_submit.shape)

# (623, 11)
# (418, 11)

Im Vergleich zu X_train, mit dem das Modell erstellt wurde, verfügt es über die gleiche Anzahl von Funktionen (2431). Senden Sie X_submit in das Modell, um den vorhergesagten Wert zu erhalten.

y_proba_submit = cls.predict_proba(X_submit)[: , 1]
print(y_proba_submit[:5])

y_pred_submit = cls.predict(X_submit)
print(y_pred_submit[:5])

# [0.00948223 0.02473048 0.01005387 0.50935871 0.45433965]
# [0 0 0 1 0]

Bereiten Sie die CSV-Daten für die Übermittlung an Kaggle vor.

Erstellen Sie zunächst einen Datenrahmen mit den erforderlichen Informationen.

df_submit = pd.DataFrame(y_pred_submit, index=PassengerId, columns=['Survived'])
df_submit.head()

Konvertieren Sie es dann in CSV-Daten.

df_submit.to_csv('titanic_lgb_submit.csv')

Dies ist das Ende der Einreichung.

■ Endlich

Dieses Mal haben wir einen Artikel für Kaggle-Anfänger zusammengestellt. Ich hoffe es hat dir sogar ein bisschen geholfen.

Danke fürs Lesen.