[PYTHON] Prédiction des survivants à l'aide du réseau neuronal titanesque de Kaggle [80,8%]

La dernière fois, j'ai essayé de prédire le taux de survie en utilisant xgboost en fonction de l'arbre de décision. Dernière fois: Prédiction de survie utilisant le boost xg titanesque de Kaggle [80,1%]

Cette fois, je vais essayer de prédire la survie du Titanic en utilisant ** Neural Network **, qui est souvent utilisé dans kaggle.

1. Acquisition des données et confirmation des valeurs manquantes

import pandas as pd
import numpy as np

train = pd.read_csv('/kaggle/input/titanic/train.csv')
test = pd.read_csv('/kaggle/input/titanic/test.csv')
#Combinez les données de train et les données de test en un seul
data = pd.concat([train,test]).reset_index(drop=True)
#Vérifiez le nombre de lignes contenant des valeurs manquantes
train.isnull().sum()
test.isnull().sum()

Le numéro de chaque valeur manquante est le suivant.

2. Compléter les valeurs manquantes et créer des fonctionnalités

2.1 Complément de tarif

La ligne manquante avait une ** Pclass de 3 ** et ** Embarked était S **. Compléter avec la médiane ** parmi ceux qui remplissent ces deux conditions **.

data['Fare'] = data['Fare'].fillna(data.query('Pclass==3 & Embarked=="S"')['Fare'].median())

2.2 Différence de vie et de mort entre les groupes Création de la «survie de la famille»

Titanic [0.82] - [0.83] Création de la quantité de fonctionnalités "Family_survival" introduite dans ce code. Je vais.

** La famille et les amis sont plus susceptibles d'agir ensemble à bord **, on peut donc dire que le fait qu'ils aient survécu ou non ** a tendance à avoir le même résultat au sein du groupe **.

Par conséquent, le regroupement est effectué par le prénom et le nom et le numéro de ticket, et la valeur est déterminée par le fait que les membres du groupe sont en vie ou non.

** En créant ce montant de caractéristiques, le taux de précision de la prédiction s'est amélioré d'environ 2% **, ce regroupement est donc assez efficace.

#Obtenez le nom de famille du nom'Last_name'Mettre en
data['Last_name'] = data['Name'].apply(lambda x: x.split(",")[0])

data['Family_survival'] = 0.5 #Valeur par défaut
#Last_Regroupement par nom et tarif
for grp, grp_df in data.groupby(['Last_name', 'Fare']):
                               
    if (len(grp_df) != 1):
        #(Même nom)Et(Le tarif est le même)Quand il y a deux personnes ou plus
        for index, row in grp_df.iterrows():
            smax = grp_df.drop(index)['Survived'].max()
            smin = grp_df.drop(index)['Survived'].min()
            passID = row['PassengerId']
            
            if (smax == 1.0):
                data.loc[data['PassengerId'] == passID, 'Family_survival'] = 1
            elif (smin == 0.0):
                data.loc[data['PassengerId'] == passID, 'Family_survival'] = 0
            #À propos des membres autres que vous dans le groupe
            #Même une personne est en vie → 1
            #Aucun survivant(Y compris NaN) → 0
            #Tout NaN → 0.5

#Regroupement par numéro de billet
for grp, grp_df in data.groupby('Ticket'):
    if (len(grp_df) != 1):
        #Lorsqu'il y a deux personnes ou plus avec le même numéro de billet
        #S'il y a même un survivant dans le groupe'Family_survival'À 1
        for ind, row in grp_df.iterrows():
            if (row['Family_survival'] == 0) | (row['Family_survival']== 0.5):
                smax = grp_df.drop(ind)['Survived'].max()
                smin = grp_df.drop(ind)['Survived'].min()
                passID = row['PassengerId']
                if (smax == 1.0):
                    data.loc[data['PassengerId'] == passID, 'Family_survival'] = 1
                elif (smin == 0.0):
                    data.loc[data['PassengerId'] == passID, 'Family_survival'] = 0

2.3 Création et classification de la quantité de caractéristiques 'Taille_famille' représentant le nombre de membres de la famille

En utilisant les valeurs de SibSp et Parch, nous allons créer une quantité caractéristique «Taille de la famille» qui indique le nombre de familles à bord du Titanic, et les classer en fonction du nombre de personnes.

#Family_Création de taille
data['Family_size'] = data['SibSp']+data['Parch']+1
#1, 2~4, 5~Divisez en trois
data['Family_size_bin'] = 0
data.loc[(data['Family_size']>=2) & (data['Family_size']<=4),'Family_size_bin'] = 1
data.loc[(data['Family_size']>=5) & (data['Family_size']<=7),'Family_size_bin'] = 2
data.loc[(data['Family_size']>=8),'Family_size_bin'] = 3

2.4 Création du titre du titre 'Titre'

Obtenez des titres tels que «Monsieur», «Miss» dans la colonne Nom. Incorporez quelques titres («Mme», «Mlle», etc.) dans des titres qui ont la même signification.

#Obtenez le titre du nom'Title'Mettre en
data['Title'] = data['Name'].map(lambda x: x.split(', ')[1].split('. ')[0])
#Intégrez quelques titres
data['Title'].replace(['Capt', 'Col', 'Major', 'Dr', 'Rev'], 'Officer', inplace=True)
data['Title'].replace(['Don', 'Sir',  'the Countess', 'Lady', 'Dona'], 'Royalty', inplace=True)
data['Title'].replace(['Mme', 'Ms'], 'Mrs', inplace=True)
data['Title'].replace(['Mlle'], 'Miss', inplace=True)
data['Title'].replace(['Jonkheer'], 'Master', inplace=True)

2.5 Complémentation et classification par âge

Utilisez ** l'âge moyen obtenu pour chaque titre du nom ** pour compléter la valeur manquante Age. Ensuite, il est divisé en trois catégories: ** enfants (0-18), adultes (18-60) et personnes âgées (60-) **.

#Complétez la valeur manquante de Age avec la valeur moyenne de chaque titre
title_list = data['Title'].unique().tolist()
for t in title_list:
    index = data[data['Title']==t].index.values.tolist()
    age = data.iloc[index]['Age'].mean()
    age = np.round(age,1)
    data.iloc[index,5] = data.iloc[index,5].fillna(age)

#Classification par âge
data['Age_bin'] = 0
data.loc[(data['Age']>18) & (data['Age']<=60),'Age_bin'] = 1
data.loc[(data['Age']>60),'Age_bin'] = 2

2.6 Standardisation du tarif et variable fictive du montant de la fonction

Étant donné que la différence d'échelle des variables est importante pour la valeur du tarif, ** normaliser ** (la valeur moyenne est 0, l'écart type est 1) afin que le réseau neuronal puisse être facilement appris.

Ensuite, la chaîne qui est une chaîne de caractères est transformée en une variable factice avec get_dummies. ** Pclass est une valeur numérique **, mais ** la taille de la valeur elle-même n'a aucune signification **, alors convertissons-la également en variable factice.

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
#Une version standardisée de Fare'Fare_std'Mettre en
data['Fare_std'] = sc.fit_transform(data[['Fare']])
#Convertir en variable factice
data['Sex'] = data['Sex'].map({'male':0, 'female':1})
data = pd.get_dummies(data=data, columns=['Title','Pclass','Family_survival'])

Enfin, supprimez les fonctionnalités inutiles.

data = data.drop(['PassengerId','Name','Age','SibSp','Parch','Ticket',
                     'Fare','Cabin','Embarked','Family_size','Last_name'], axis=1)

La trame de données ressemble à ceci.

1309 rows × 17 columns

Les données intégrées sont divisées en données de train et données de test, et le traitement des caractéristiques est terminé.

model_train = data[:891]
model_test = data[891:]

x_train = model_train.drop('Survived', axis=1)
y_train = pd.DataFrame(model_train['Survived'])
x_test = model_test.drop('Survived', axis=1)

3. Construction de modèles et prédiction

Maintenant que la trame de données est terminée, construisons un modèle du réseau neuronal et faisons des prédictions.

from keras.layers import Dense,Dropout
from keras.models import Sequential
from keras.callbacks import EarlyStopping
#Initialisation du modèle
model = Sequential()
#Construction de couches
model.add(Dense(12, activation='relu', input_dim=16))
model.add(Dropout(0.2))
model.add(Dense(8, activation='relu'))
model.add(Dense(5, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
#Construire un modèle
model.compile(optimizer = 'adam', loss='binary_crossentropy', metrics='acc')
#Voir la structure du modèle
model.summary()

Former en passant les données du train. Si vous définissez validation_split, ce sera facile car les données de validation seront divisées arbitrairement à partir des données du train.

log = model.fit(x_train, y_train, epochs=5000, batch_size=32,verbose=1,
                callbacks=[EarlyStopping(monitor='val_loss',min_delta=0,patience=100,verbose=1)],
                validation_split=0.3)

Cela ressemble à ceci lorsque l'état d'avancement de l'apprentissage est affiché dans un graphique.

import matplotlib.pyplot as plt
plt.plot(log.history['loss'],label='loss')
plt.plot(log.history['val_loss'],label='val_loss')
plt.legend(frameon=False)
plt.xlabel('epochs')
plt.ylabel('crossentropy')
plt.show()

Enfin, predict_classes est utilisé pour afficher la valeur prédite.

#Prédire s'il sera classé 0 ou 1
y_pred_cls = model.predict_classes(x_test)
#Créer un bloc de données pour kaggle
y_pred_cls = y_pred_cls.reshape(-1)
submission = pd.DataFrame({'PassengerId':test['PassengerId'], 'Survived':y_pred_cls})
submission.to_csv('titanic_nn.csv', index=False)

Le taux de réponse correcte de ce modèle de prédiction était de ** 80,8% **. Je ne sais pas si ce modèle créé est optimal car le réseau neuronal peut décider librement des paramètres et du nombre de couches du modèle, mais s'il dépasse 80%, c'est raisonnable.

Si vous avez des opinions ou des suggestions, nous vous serions reconnaissants de bien vouloir faire un commentaire ou une demande de modification.

Sites et livres auxquels j'ai fait référence

Titanic - Neural Networks [KERAS] - 81.8% Titanic [0.82] - [0.83] [Technologie d'analyse de données qui gagne avec Kaggle](https://www.amazon.co.jp/Kaggle%E3%81%A7%E5%8B%9D%E3%81%A4%E3%83%87%E3% 83% BC% E3% 82% BF% E5% 88% 86% E6% 9E% 90% E3% 81% AE% E6% 8A% 80% E8% A1% 93-% E9% 96% 80% E8% 84 % 87-% E5% A4% A7% E8% BC% 94-ebook / dp / B07YTDBC3Z) [Deep Learning from scratch-Theory et implémentation du deep learning appris avec Python](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81%8B%E3] % 82% 89% E4% BD% 9C% E3% 82% 8BApprentissage en profondeur-% E2% 80% 95Python% E3% 81% A7% E5% AD% A6% E3% 81% B6% E3% 83% 87% E3% 82% A3% E3% 83% BC% E3% 83% 97% E3% 83% A9% E3% 83% BC% E3% 83% 8B% E3% 83% B3% E3% 82% B0% E3% 81% AE% E7% 90% 86% E8% AB% 96% E3% 81% A8% E5% AE% 9F% E8% A3% 85-% E6% 96% 8E% E8% 97% A4-% E5% BA% B7% E6% AF% 85 / dp / 4873117585)