[PYTHON] Überlebensvorhersage unter Verwendung des titanischen neuronalen Netzes von Kaggle [80,8%]

Letztes Mal habe ich versucht, die Überlebensrate mit xgboost anhand des Entscheidungsbaums vorherzusagen. Letztes Mal: Überlebensvorhersage mit Kaggles Titanic XG Boost [80,1%]

Dieses Mal werde ich versuchen, das Überleben der Titanic mithilfe von ** Neural Network ** vorherzusagen, das häufig in Kaggle verwendet wird.

1. Datenerfassung und Bestätigung fehlender Werte

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')
#Kombinieren Sie Zugdaten und Testdaten zu einem
data = pd.concat([train,test]).reset_index(drop=True)
#Überprüfen Sie die Anzahl der Zeilen, die fehlende Werte enthalten
train.isnull().sum()
test.isnull().sum()

Die Nummer jedes fehlenden Werts ist wie folgt.

2. Fehlende Werte ergänzen und Features erstellen

2.1 Ergänzung des Fahrpreises

Die fehlende Reihe hatte eine ** Klasse von 3 ** und ** eingeschifft war S **. Ergänzung mit dem Median ** unter denen, die diese beiden Bedingungen erfüllen **.

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

2.2 Unterschied zwischen Leben und Tod zwischen Gruppen Schaffung von "Family_Survival"

Titanic [0.82] - [0.83] Erstellt die in diesem Code eingeführte Feature-Menge 'Family_survival'. Ich werde.

** Familie und Freunde agieren eher zusammen an Bord **, daher kann gesagt werden, dass unabhängig davon, ob sie überlebt haben oder nicht **, innerhalb der Gruppe tendenziell dasselbe Ergebnis erzielt wird **.

Daher wird die Gruppierung anhand des Vor- und Nachnamens sowie der Ticketnummer durchgeführt, und der Wert wird dadurch bestimmt, ob die Mitglieder der Gruppe am Leben sind oder nicht.

** Durch das Erstellen dieser Feature-Menge hat sich die Genauigkeitsrate der Vorhersage um ca. 2% verbessert **, sodass diese Gruppierung sehr effektiv ist.

#Holen Sie sich den Nachnamen des Namens'Last_name'Einstellen
data['Last_name'] = data['Name'].apply(lambda x: x.split(",")[0])

data['Family_survival'] = 0.5 #Standardwert
#Last_Gruppierung nach Name und Tarif
for grp, grp_df in data.groupby(['Last_name', 'Fare']):
                               
    if (len(grp_df) != 1):
        #(Gleicher Nachname)Und(Der Fahrpreis ist der gleiche)Wenn zwei oder mehr Personen anwesend sind
        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
            #Über andere Mitglieder als Sie selbst in der Gruppe
            #Sogar eine Person lebt → 1
            #Keine Überlebenden(Einschließlich NaN) → 0
            #Alle NaN → 0.5

#Gruppierung nach Ticketnummer
for grp, grp_df in data.groupby('Ticket'):
    if (len(grp_df) != 1):
        #Wenn zwei oder mehr Personen dieselbe Ticketnummer haben
        #Wenn es überhaupt einen Überlebenden in der Gruppe gibt'Family_survival'Bis 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 Erstellung und Klassifizierung der Merkmalsmenge'Family_size ', die die Anzahl der Familienmitglieder darstellt

Unter Verwendung der Werte von SibSp und Parch erstellen wir eine charakteristische Menge "Family_size", die angibt, wie viele Familien an Bord der Titanic sind, und klassifizieren sie nach der Anzahl der Personen.

#Family_Größe schaffen
data['Family_size'] = data['SibSp']+data['Parch']+1
#1, 2~4, 5~In drei Teile teilen
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 Erstellen des Titeltitels 'Titel'

Holen Sie sich Titel wie "Mr", "Miss" aus der Spalte "Name". Integrieren Sie kleinere Titel ('Mme', 'Mlle' usw.) in Titel mit derselben Bedeutung.

#Holen Sie sich den Titel des Namens'Title'Einstellen
data['Title'] = data['Name'].map(lambda x: x.split(', ')[1].split('. ')[0])
#Integrieren Sie einige Titel
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 Ergänzung und Klassifizierung des Alters

Verwenden Sie ** das Durchschnittsalter für jeden Titel des Namens **, um den fehlenden Wert für Alter zu vervollständigen. Dann wird es in drei Kategorien unterteilt: ** Kinder (0-18), Erwachsene (18-60) und ältere Menschen (60-) **.

#Ergänzen Sie den fehlenden Wert von Alter mit dem Durchschnittswert für jeden Titel
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)

#Einteilung nach Alter
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 Standardisierung der Tarif- und Dummy-Variablen des Merkmalsbetrags

Da die Skalendifferenz der Variablen für den Tarifwert groß ist, ** standardisieren ** (Mittelwert ist 0, Standardabweichung ist 1), damit das neuronale Netz leicht gelernt werden kann.

Dann wird die Zeichenfolge, die eine Zeichenfolge ist, mit get_dummies in eine Dummy-Variable umgewandelt. ** Pclass ist ein numerischer Wert **, aber ** die Größe des Werts selbst hat keine Bedeutung **, also konvertieren wir ihn auch in eine Dummy-Variable.

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
#Eine standardisierte Version von Fare'Fare_std'Einstellen
data['Fare_std'] = sc.fit_transform(data[['Fare']])
#In Dummy-Variable konvertieren
data['Sex'] = data['Sex'].map({'male':0, 'female':1})
data = pd.get_dummies(data=data, columns=['Title','Pclass','Family_survival'])

Entfernen Sie schließlich unnötige Funktionen.

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

Der Datenrahmen sieht so aus.

1309 rows × 17 columns

Die integrierten Daten werden in Zugdaten und Testdaten unterteilt, und die Merkmalsverarbeitung ist abgeschlossen.

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. Modellbildung und Vorhersage

Nachdem der Datenrahmen vollständig ist, erstellen wir ein Modell des neuronalen Netzes und machen Vorhersagen.

from keras.layers import Dense,Dropout
from keras.models import Sequential
from keras.callbacks import EarlyStopping
#Modellinitialisierung
model = Sequential()
#Schichtaufbau
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'))
#Ein Modell bauen
model.compile(optimizer = 'adam', loss='binary_crossentropy', metrics='acc')
#Modellstruktur anzeigen
model.summary()

Zug durch Übergabe von Zugdaten. Wenn Sie validation_split festlegen, ist dies einfach, da die zu validierenden Daten willkürlich von den Zugdaten getrennt werden.

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)

Es sieht so aus, wenn der Status des Lernfortschritts in einem Diagramm angezeigt wird.

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

Schließlich wird Predict_classes verwendet, um den vorhergesagten Wert auszugeben.

#Sagen Sie voraus, ob es als 0 oder 1 klassifiziert wird
y_pred_cls = model.predict_classes(x_test)
#Erstellen Sie einen Datenrahmen für 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)

Die korrekte Antwortrate dieses Vorhersagemodells betrug ** 80,8% **. Ich weiß nicht, ob dieses erstellte Modell optimal ist, da das neuronale Netz die Parameter und die Anzahl der Schichten des Modells frei bestimmen kann, aber wenn es 80% überschreitet, ist es vernünftig.

Wenn Sie Meinungen oder Vorschläge haben, würden wir uns freuen, wenn Sie einen Kommentar abgeben oder eine Anfrage bearbeiten könnten.

Websites und Bücher, auf die ich mich bezog

Titanic - Neural Networks [KERAS] - 81.8% Titanic [0.82] - [0.83] [Datenanalysetechnologie, die mit Kaggle gewinnt](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 von Grund auf neu und Theorie des mit Python erlernten Deep Learning](https://www.amazon.co.jp/%E3%82%BC%E3%83%AD%E3%81%8B%E3] % 82% 89% E4% BD% 9C% E3% 82% 8BDeep-Learning-% 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)