[PYTHON] Vorhersage der Titanic von Kaggle mit Keras (kaggle ⑦)

Einführung

Dies ist eine Geschichte über die Teilnahme an einem Kaggle-Wettbewerb. Bis vorher lernte ich Titanic mit dem Scikit-Learn-Modell. Dieses Mal möchte ich mit Keras lernen.

Inhaltsverzeichnis

  1. Über das Keras-Modell
  2. Perceptron
  3. Rastersuche mit Keras
  4. Lernen
  5. Lernen Sie mit Keras
  6. Ergebnis
  7. Zusammenfassung Referenz Geschichte

1. Keras-Modell

Gemäß dem Buch Detailliertes Deep Learning werden Keras-Modelle grob in die folgenden drei Typen unterteilt.

· Perzeptron ・ Faltbares neuronales Netzwerk ・ Wiederkehrendes neuronales Netzwerk

Perceptron ist eines der grundlegenden neuronalen Netze. Das Faltungs-Neuronale Netz (CNN) wird hauptsächlich zur Bildverarbeitung verwendet. Das wiederkehrende neuronale Netzwerk (RNN) wird für Zeitreihendaten verwendet. Diesmal handelt es sich weder um Bildverarbeitungs- noch um Zeitreihendaten. Lernen wir also mit Perceptron.

2. Perceptron

Perceptron ist eines der grundlegenden neuronalen Netze und ein Modell des folgenden Bildes, das Sie häufig sehen.

Quelle: [Bildmaterial wie Neuronales Netzwerk / Deep Learning [WTFPL] für Präsentationen / Seminare](http://nkdkccmbr.hateblo.jp/entry/2016/10/06/222245)

Ein Perceptron mit Keras zu bauen ist relativ einfach. Es kann durch Hinzufügen von Ebenen zum sequentiellen Modell wie unten gezeigt erstellt werden.

##############################
#Modellbau 5-lagiges Perceptron
##############################
def create_model_5dim_layer_perceptron(activation="relu", optimizer="adam", out_dim=100, dropout=0.5):
    
    model = Sequential()

    #Eingabeebene-Versteckte Ebene 1
    model.add(Dense(input_dim=len(x_train.columns), units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Versteckte Ebene 1-Versteckte Ebene 2
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Versteckte Ebene 2-Versteckte Schicht 3
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Versteckte Schicht 3-Ausgabeschicht
    model.add(Dense(units=1))
    model.add(Activation("sigmoid"))

    model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
    
    return model

Definieren Sie die Ebene mit Dicht. Die erste Dichte definiert die Dimensionen der Eingabe mit input_dim. input_dim muss mit der Anzahl der Dimensionen der Eingabedaten übereinstimmen. Geben Sie die Anzahl der Dimensionen der entsprechenden Ebene mit Einheiten an. Da die Ausgabeschicht diesmal eine Dimension hat (Überleben 1 oder 0), müssen am Ende Einheiten = 1 gesetzt werden.

Definieren Sie die Aktivierungsfunktion mit Aktivierung. Jede Aktivierungsfunktion kann anders als die Ausgabeschicht verwendet werden. Da es sich bei der Ausgabeschicht jedoch um eine binäre Klassifizierung handelt, geben Sie "Sigmoid" an.

Darüber hinaus unterdrückt Dropout das Überlernen und die Stapelnormalisierung normalisiert jeden Mini-Stapel.

4. Rastersuche mit Keras

In der obigen 5-Schicht-Perceptron-Funktion werden Aktivierung, Optimierer usw. als Argumente empfangen. Wie Sie sehen können, müssen die Parameter auch für das Perzeptron von Keras eingestellt werden. In diesem Artikel haben wir eine Rastersuche mit scikit-learn durchgeführt und die Parameter untersucht, aber Keras können auch die Rastersuche verwenden. Verwenden Sie KerasClassifier.

from keras.wrappers.scikit_learn import KerasClassifier
model = KerasClassifier(build_fn=create_model_5dim_layer_perceptron(input_dim), verbose=0)

Wenn Sie KerasClassifier wie oben beschrieben verwenden, können Sie das Keras-Modell genauso behandeln wie das Modell von scikit-learn. Danach können Sie sowohl GridSearchCV als auch Scikit-Learn verwenden. Der Code sieht folgendermaßen aus:

# Define options for parameters
activation = ["tanh", "relu"]
optimizer = ["adam", "adagrad"]
out_dim = [234, 468, 702]
nb_epoch = [25, 50]
batch_size = [8, 16]
dropout = [0.2, 0.4, 0.5]

param_grid = dict(activation=activation, 
                  optimizer=optimizer, 
                  out_dim=out_dim, 
                  nb_epoch=nb_epoch, 
                  batch_size=batch_size,
                  dropout=dropout)
grid = GridSearchCV(estimator=model, param_grid=param_grid)

# Run grid search
grid_result = grid.fit(x_train, y_train)

print(grid_result.best_score_)
print(grid_result.best_params_)

Wenn Sie best_score_ und best_params_ drucken, wird Folgendes ausgegeben.

0.7814285721097673
{'activation': 'relu', 'batch_size': 16, 'dropout': 0.5, 'nb_epoch': 25, 'optimizer': 'adam', 'out_dim': 702}
acc:0.72

5. Lernen Sie mit Keras

Sobald die Parameter festgelegt sind, lernen Sie mit Keras und sagen Sie das Ergebnis voraus. Der vollständige Code ist unten. Der Prozess bis zur Datenaufbereitung ist der gleiche wie bei Letztes Mal.

import numpy
import pandas
import datetime

from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import StandardScaler

from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.layers.core import Dropout
from keras.layers.normalization import BatchNormalization

############################################################
#Eine heiße Codierung SibSp
# One hot encoding SibSp
############################################################
def get_dummies_sibSp(df_all, df, df_test) :
    
    categories = set(df_all['SibSp'].unique())
    df['SibSp'] = pandas.Categorical(df['SibSp'], categories=categories)
    df_test['SibSp'] = pandas.Categorical(df_test['SibSp'], categories=categories)
    
    df = pandas.get_dummies(df, columns=['SibSp'])
    df_test = pandas.get_dummies(df_test, columns=['SibSp'])

    return df, df_test

############################################################
#Parch ist eine heiß codierte
# One hot encoding SibSp
############################################################
def get_dummies_parch(df_all, df, df_test) :
    
    categories = set(df_all['Parch'].unique())
    df['Parch'] = pandas.Categorical(df['Parch'], categories=categories)
    df_test['Parch'] = pandas.Categorical(df_test['Parch'], categories=categories)
    
    df = pandas.get_dummies(df, columns=['Parch'])
    df_test = pandas.get_dummies(df_test, columns=['Parch'])
    
    return df, df_test

############################################################
#Ticket ist ein Hot-Coded
# One hot encoding SibSp
############################################################
def get_dummies_ticket(df_all, df, df_test) :

    ticket_values = df_all['Ticket'].value_counts()
    ticket_values = ticket_values[ticket_values > 1]
    ticket_values = pandas.Series(ticket_values.index, name='Ticket')
    categories = set(ticket_values.tolist())
    df['Ticket'] = pandas.Categorical(df['Ticket'], categories=categories)
    df_test['Ticket'] = pandas.Categorical(df_test['Ticket'], categories=categories)
    
    df = pandas.get_dummies(df, columns=['Ticket'])
    df_test = pandas.get_dummies(df_test, columns=['Ticket'])

    return df, df_test

############################################################
#Standardisierung
# Standardization
############################################################
def standardization(df, df_test) :

    standard = StandardScaler()
    df_std = pandas.DataFrame(standard.fit_transform(df[['Pclass', 'Fare']].values), columns=['Pclass', 'Fare'])
    df.loc[:,'Pclass'] = df_std['Pclass']
    df.loc[:,'Fare'] = df_std['Fare']

    df_test_std = pandas.DataFrame(standard.transform(df_test[['Pclass', 'Fare']].values), columns=['Pclass', 'Fare'])
    df_test.loc[:,'Pclass'] = df_test_std['Pclass']
    df_test.loc[:,'Fare'] = df_test_std['Fare']

    return df, df_test

############################################################
#Datenaufbereitung
# prepare Data
############################################################
def prepareData() :

    ##############################
    #Datenvorverarbeitung
    #Extrahieren Sie die erforderlichen Elemente
    # Data preprocessing
    # Extract necessary items
    ##############################
    # gender_submission.Laden Sie csv
    # Load gender_submission.csv
    df = pandas.read_csv('/kaggle/input/titanic/train.csv')
    df_test = pandas.read_csv('/kaggle/input/titanic/test.csv')
    
    df_all = pandas.concat([df, df_test], sort=False)
    
    df_test_index = df_test[['PassengerId']]

    df = df[['Survived', 'Pclass', 'Sex', 'SibSp', 'Parch', 'Ticket', 'Fare']]
    df_test = df_test[['Pclass', 'Sex', 'SibSp', 'Parch', 'Ticket', 'Fare']]
    
    ##############################
    #Datenvorverarbeitung
    #Behandeln Sie fehlende Werte
    # Data preprocessing
    # Fill or remove missing values
    ##############################
    ##############################
    df = df[df['Fare'] != 5].reset_index(drop=True)
    df = df[df['Fare'] != 0].reset_index(drop=True)

    ##############################
    #Datenvorverarbeitung
    #Quantifizieren Sie das Etikett (Name)
    # Data preprocessing
    # Digitize labels
    ##############################
    ##############################
    #Sex
    ##############################
    encoder_sex = LabelEncoder()
    df['Sex'] = encoder_sex.fit_transform(df['Sex'].values)
    df_test['Sex'] = encoder_sex.transform(df_test['Sex'].values)
    
    ##############################
    #Datenvorverarbeitung
    # One-Hot-Codierung
    # Data preprocessing
    # One-Hot Encoding
    ##############################
    ##############################
    # SibSp
    ##############################
    df, df_test = get_dummies_sibSp(df_all, df, df_test)
    
    ##############################
    # Parch
    ##############################
    df, df_test = get_dummies_parch(df_all, df, df_test)
    
    ##############################
    # Ticket
    ##############################
    df, df_test = get_dummies_ticket(df_all, df, df_test)
 
    ##############################
    #Datenvorverarbeitung
    #Zahlen standardisieren
    # Data preprocessing
    # Standardize numbers
    ##############################
    df, df_test = standardization(df, df_test)

    ##############################
    #Datenvorverarbeitung
    #Behandeln Sie fehlende Werte
    # Data preprocessing
    # Fill or remove missing values
    ##############################
    df.fillna({'Fare':0}, inplace=True)
    df_test.fillna({'Fare':0}, inplace=True)
        
    ##############################
    #Trainingsdaten und Testdaten trennen
    # Split training data and test data
    ##############################
    x = df.drop(columns='Survived')
    y = df[['Survived']]

    return x, y, df_test, df_test_index

##############################
#Modellbau 5-lagiges Perceptron
##############################
def create_model_5dim_layer_perceptron(input_dim, \
                                       activation="relu", \
                                       optimizer="adam", \
                                       out_dim=100, \
                                       dropout=0.5):
    
    model = Sequential()

    #Eingabeebene-Versteckte Ebene 1
    model.add(Dense(input_dim=input_dim, units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Versteckte Ebene 1-Versteckte Ebene 2
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Versteckte Ebene 2-Versteckte Schicht 3
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Versteckte Schicht 3-Ausgabeschicht
    model.add(Dense(units=1))
    model.add(Activation("sigmoid"))

    model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
    
    return model
    

if __name__ == "__main__":
    
    #Datenaufbereitung
    x_train, y_train, x_test, y_test_index = prepareData()
    
    #Modell bauen
    model = create_model_5dim_layer_perceptron(len(x_train.columns), \
                                               activation="relu", \
                                               optimizer="adam", \
                                               out_dim=702, \
                                               dropout=0.5)

    #Lernen
    fit = model.fit(x_train, y_train, epochs=25, batch_size=16, verbose=2)
    
    #Prognose
    y_test_proba = model.predict(x_test)
    y_test = numpy.round(y_test_proba).astype(int)
    
    #Kombinieren Sie das Ergebnis mit dem DataFrame der PassengerId
    # Combine the data frame of PassengerId and the result
    df_output = pandas.concat([y_test_index, pandas.DataFrame(y_test, columns=['Survived'])], axis=1)

    # result.Schreiben Sie csv in das aktuelle Verzeichnis
    # Write result.csv to the current directory
    df_output.to_csv('result.csv', index=False)

6. Ergebnis

Das Ergebnis war "0,79425".

7. Zusammenfassung

Im Vergleich zu Scikit-Learn vermittelt Keras den Eindruck, dass Sie detaillierte Einstellungen vornehmen können, z. B. die Anzahl der Schichten und die Anzahl der Neuronen. Ich denke jedoch, dass es nur wenige Arten von Modellen gibt, außer dem Faltungs-Neuronalen Netzwerk (CNN) und dem Wiederkehrenden Neuronalen Netzwerk (RNN). Es scheint gut, scikit-learn und Keras je nach Situation richtig zu verwenden.

Nächstes Mal möchte mit der R-Sprache lernen.

Referenz

Automatisierung der Parameteroptimierung mit Keras mit GridSearch CV https://qiita.com/cvusk/items/285e2b02b0950537b65e

Geschichte

2020/02/15 Erste Ausgabe veröffentlicht 2020/02/22 Nächster Link hinzugefügt

Recommended Posts

Vorhersage der Titanic von Kaggle mit Keras (kaggle ⑦)
Wählen Sie Modelle von Kaggles Titanic (kaggle ④)
Überprüfen Sie die Rohdaten mit Kaggles Titanic (kaggle ⑥)
Ich habe versucht, mit Kaggles Titanic (kaggle②) zu lernen.
Überprüfen Sie die Korrelation mit Kaggles Titanic (kaggle③)
Ich habe versucht, Überlebende der Titanic mit Kaggle vorherzusagen und einzureichen
Fordern Sie die Kaggle Titanic heraus
Probieren Sie alle Modelle des Scikit-Lernens mit Kaggles Titanic (kaggle ⑤) aus.
Ich habe versucht, das Überleben der Titanic mit PyCaret vorherzusagen
Bilderkennung mit Keras
Deep Learning Bildanalyse beginnend mit Kaggle und Keras
Optuna, Keras und Titanic
CIFAR-10-Tutorial mit Keras
Multivariates LSTM mit Keras
Probieren Sie Kaggles Titanic-Tutorial aus
Lassen Sie uns die Überlebenden von Kaggles Hello World, Titanic, durch logistische Regression vorhersagen.
Lassen Sie uns die Überlebenden von Kaggles Hello World, Titanic durch logistische Regression vorhersagen - Vorhersage / Bewertung
Multiple Regressionsanalyse mit Keras
Vorhersage von Kerzenbeinen mit künstlicher Intelligenz
AutoEncodder-Notizen mit Keras
Word2vec mit Theano + Keras implementiert
[Kaggle] Versuchen Sie, Future Engineering vorherzusagen
Satzerzeugung mit GRU (Keras)
Optimieren von Keras-Parametern mit Keras Tuner
Kaggle Tutorial Titanic Genauigkeit 80,9% (Top 7% 0,80861)
Erstellen Sie einfach CNNs mit Keras
Effizientes GAN mit Keras implementiert
[Für Kaggle-Anfänger] Titanic (LightGBM)
Versuchen Sie es mit Kaggle leicht maschinell
Bilderkennung mit Keras + OpenCV
Fordern Sie die Bildklassifizierung mit TensorFlow2 + Keras 4 heraus. ~ Lassen Sie uns mit dem trainierten Modell ~ vorhersagen