[Pour les débutants de Kaggle] Titanic (LightGBM)

■ Présentation

Cette fois, j'ai travaillé sur le concours suivant avec LigthGBM. J'ai essayé de le résumer brièvement.

【Aperçu】 ・ Titanic: Machine Learning from Disaster ・ Sur la base des informations sur les passagers du navire en train de couler "Titanic", faites la distinction entre ceux qui sont sauvés et ceux qui ne le sont pas.

[Lecteurs cibles] ・ Kaggle débutants ・ Ceux qui veulent en savoir plus sur le code de base de LightGBM

1. Préparation du module

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()

【élément de données】 ・ PassengerId: ID du passager ・ Survécu: s'il a survécu (0: non enregistré, 1: enregistré) ・ Pclass - Classe de billet (1: Classe supérieure, 2: Classe intermédiaire, 3: Classe inférieure) ・ Nom: nom du passager ・ Sexe: sexe ・ Âge: Âge ・ SibSp: nombre de frères et de conjoints à bord ・ Parch: nombre de parents / enfants à bord ・ Ticket: numéro de ticket ・ Tarif: Frais ・ Cabine: numéro de chambre ・ Embarqué: Port à bord (C: Cherbourg, Q: Queenstown, S: Southampton)

test.head()

Enregistrez le numéro de passager (PassengerId) des données de test.

PassengerId = test['PassengerId']

En fait, le modèle est créé uniquement avec des données de train Je veux prétraiter les données de train / test ensemble, je vais donc envisager de les combiner.

Les données du train ont un élément supplémentaire (variable objective: survécu), elles sont donc séparées.

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

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

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

Maintenant que le nombre d'éléments (caractéristiques) dans les données de train et les données de test est le même, combinez-les.

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

print(X_total.shape)
X_total.head()

# (1309, 11)

3. Prétraitement

Tout d'abord, vérifiez le nombre de valeurs manquantes.

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
'''

Avec LightGBM, il est possible de créer un modèle avec des données de chaîne de caractères telles quelles. Le prétraitement est effectué sans conversion numérique.

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
'''

Maintenant, vérifiez la colonne de données de chaîne de caractères (ci-après dénommée catégorielle).

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']

Examinez le type de données de chaque catégorie.

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 peut être modélisé en tant que données de chaîne, Puisque nous devons en faire un type de catégorie au lieu d'un type d'objet, nous convertirons le type de données.

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

Regardons le type de données des données totales (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,)

Étant donné que la quantité de caractéristiques et la variable objective correspondant aux données du train sont disponibles De plus, nous créerons un modèle en le divisant en données d'entraînement et en données de test.

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,)

Définissez les paramètres et transmettez-les à LGBMClassifier () comme arguments de type dictionnaire.

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)
'''

Ensuite, recherchez la valeur prévue.

En spécifiant [:, 1] pour y_proba, la probabilité de devenir Class1 (Survived = 1) est prédite. y_pred est converti en 1 s'il est supérieur à 0,5 et 0 s'il est inférieur à 0,5.

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

Aussi, évaluons en utilisant une matrice de confusion.

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 Depuis que j'ai pu créer et évaluer un modèle à l'aide de données de train Donnez les informations des données de test et donnez la valeur prévue.

Tout d'abord, extrayez la partie correspondant aux données de test des données totales (X_total).

X_submit = X_total[train_rows:]

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

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

Comparé au X_train qui a créé le modèle, il a le même nombre de fonctionnalités (2431). Soumettez X_submit dans le modèle pour obtenir la valeur prévue.

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]

Préparez les données CSV à soumettre à Kaggle.

Commencez par créer un bloc de données avec les informations nécessaires.

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

Puis convertissez-le en données CSV.

df_submit.to_csv('titanic_lgb_submit.csv')

C'est la fin de la soumission.

■ Enfin

Cette fois, nous avons compilé un article pour les débutants de Kaggle. J'espère que cela vous a même un peu aidé.

Merci pour la lecture.