[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

## 2. Préparation des données

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

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

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

train.head()

image.png 【é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()

image.png 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)

image.png

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

# 4. Créez un modèle Je souhaite créer un modèle en utilisant uniquement des données de train Puisque X_total contient également des données de test, seule la partie nécessaire est extraite.
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]

## 5. Évaluation des performances Évaluer à l'aide de la courbe ROC et de l'ASC.

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

image.png

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

'''

image.png
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()

image.png Puis convertissez-le en données CSV.


df_submit.to_csv('titanic_lgb_submit.csv')

C'est la fin de la soumission. image.png

■ 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.

Recommended Posts

[Pour les débutants de Kaggle] Titanic (LightGBM)
[Kaggle pour les super débutants] Titanic (retour logistique)
Défis de la compétition Titanic pour les débutants de Kaggle
[Pour les débutants] kaggle exercice (merucari)
Défiez Kaggle Titanic
Explication d'approche pour que les débutants soient dans le top 1,5% (0,83732) dans Kaggle Titanic_3
Explication d'approche pour que les débutants soient dans le top 1,5% (0,83732) dans Kaggle Titanic_1
Explication d'approche pour que les débutants soient dans le top 1,5% (0,83732) dans Kaggle Titanic_2
Paramètres Spacemacs (pour les débutants)
C'est normal de tomber sur Titanic! Présentation de la stratégie Kaggle pour les super débutants
Manuel python pour les débutants
Algorithme Dikstra pour les débutants
OpenCV pour les débutants en Python
Premier Kaggle (kaggle ①)
Flux d'apprentissage pour les débutants en Python
Distribution Linux recommandée pour les débutants
■ Kaggle Practice pour les débutants - Introduction de Python - par Google Colaboratory
Construction de l'environnement Python3 (pour les débutants)
Vue d'ensemble de Docker (pour les débutants)
Python #function 2 pour les super débutants
Kaggle Tutorial Titanic Précision 80.9% (Top 7% 0.80861)
Les bases de Seaborn pour les débutants ④ Pairplot
Grammaire de base Python pour les débutants
Pandas 100 coups pour les débutants en Python
#List Python pour les super débutants
~ Conseils pour les débutants de Python présentés avec amour par Pythonista ③ ~
Mémorandum de commande Linux [pour les débutants]
Raccourci Linux pratique (pour les débutants)
[Explication pour les débutants] Tutoriel TensorFlow MNIST (pour les débutants)
Principes de base de Pandas pour les débutants ① Lecture et traitement
Traduction TensorFlow MNIST pour les débutants en ML
Arbre de décision (pour les débutants) -Édition de code-
Certains modèles de Kaggle's Titanic (kaggle ④)
Principes de base de Pandas pour les débutants ⑧ Traitement des chiffres
Exercices Python pour les débutants # 2 [pour instruction / instruction while]
[Pour les non-programmeurs] Comment marcher Kaggle
Prédire le Titanic de Kaggle avec Keras (Kaggle ⑦)
Python pour les super débutants Super débutants Python # dictionnaire type 1
Bases de Seaborn pour les débutants ② histogramme (distplot)
[Pour les débutants] Django -Construction d'environnement de développement-
[Pour les débutants] Script en 10 lignes (1.folium)
Retour logistique (pour les débutants) -Code Edition-
Qu'est-ce que le grattage? [Résumé pour les débutants]
Python #index pour les super débutants, tranches
<Pour les débutants> bibliothèque python <Pour l'apprentissage automatique>
Tutoriel TensorFlow MNIST pour les débutants en ML
Commandes Linux fréquemment utilisées (pour les débutants)
[À voir pour les débutants] Bases de Linux
Fonction Python #len pour les super débutants
Web scraping pour les débutants en Python (1)
Exécutez unittest en Python (pour les débutants)
Qu'est-ce que xg boost (1) (pour les débutants)
Web scraping pour les débutants en Python (4) -1
Python #Hello World pour les super débutants
Régression linéaire (pour les débutants) -Édition de code-
Python pour les super débutants Super débutants Python # dictionnaire type 2
Lien récapitulatif des bases de Pandas pour les débutants
[Pour les débutants] Surveillance des processus à l'aide de cron
LSTM (1) pour la prédiction de séries chronologiques (pour les débutants)