introduction

Ceci est une histoire de participation à un concours Kaggle. Jusqu'à précédent, j'apprenais le Titanic avec le modèle scikit-learn. Cette fois, j'aimerais étudier avec les keras.

table des matières

À propos du modèle Keras
Perceptron
Recherche de grille avec Keras
Apprendre
Apprenez avec Keras
Résultat
Résumé référence Histoire

1. Modèle Keras

Selon le livre Apprendre en profondeur détaillé, les modèles Keras sont à peu près divisés en trois types.

· Perceptron ・ Réseau de neurones pliable ・ Réseau neuronal récurrent

Perceptron est l'un des réseaux neuronaux de base. Le réseau de neurones convolutifs (CNN) est principalement utilisé pour le traitement d'images. Le réseau neuronal récurrent (RNN) est utilisé pour les données chronologiques. Cette fois, il ne s'agit ni de traitement d'image ni de données de séries chronologiques, apprenons donc avec Perceptron.

2. Perceptron

Perceptron est l'un des réseaux de neurones de base et est un modèle de l'image suivante que vous voyez souvent.

Source: [Matériel d'image tel que Neural Network / Deep Learning [WTFPL] pour les présentations / séminaires](http://nkdkccmbr.hateblo.jp/entry/2016/10/06/222245)

Construire un Perceptron avec des keras est relativement facile. Il peut être construit en ajoutant des couches au modèle séquentiel comme indiqué ci-dessous.

##############################
#Construction de modèles Perceptron 5 couches
##############################
def create_model_5dim_layer_perceptron(activation="relu", optimizer="adam", out_dim=100, dropout=0.5):
    
    model = Sequential()

    #Couche d'entrée-Couche cachée 1
    model.add(Dense(input_dim=len(x_train.columns), units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Couche cachée 1-Couche cachée 2
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Couche cachée 2-Couche cachée 3
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Couche cachée 3-Couche de sortie
    model.add(Dense(units=1))
    model.add(Activation("sigmoid"))

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

Définissez le calque avec Dense. Le premier Dense définit les dimensions de l'entrée avec input_dim. input_dim doit correspondre au nombre de dimensions des données d'entrée. Spécifiez le nombre de dimensions du calque correspondant avec des unités. Puisque la couche de sortie a cette fois une dimension (survie 1 ou 0), il est nécessaire de définir unités = 1 à la fin.

Définissez la fonction d'activation avec Activation. Toute fonction d'activation peut être utilisée autre que la couche de sortie, mais comme la couche de sortie est une classification binaire, spécifiez «sigmoïde».

De plus, Dropout supprime le surapprentissage et la normalisation des lots normalise chaque mini-lot.

4. Recherche de grille avec Keras

Dans la fonction Perceptron à 5 couches ci-dessus, l'activation, l'optimiseur, etc. sont reçus comme arguments. Comme vous pouvez le voir, il est nécessaire de définir les paramètres même pour le perceptron de keras. Dans cet article, nous avons fait une recherche de grille avec scikit-learn et étudié les paramètres, mais les keras peuvent également utiliser la recherche de grille. Utilisez KerasClassifier.

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

En utilisant KerasClassifier comme décrit ci-dessus, vous pouvez traiter le modèle de Keras de la même manière que le modèle de scikit-learn. Après cela, vous pouvez utiliser GridSearchCV ainsi que scikit-learn. Le code ressemble à ceci:

# 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_)

Si vous imprimez best_score_ et best_params_, ce qui suit sera affiché.

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

5. Apprenez avec Keras

Une fois les paramètres définis, apprenez avec Keras et prédisez le résultat. Le code complet est ci-dessous. Le processus jusqu'à la préparation des données est le même que Dernière fois.

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

############################################################
#Un encodage à chaud 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 est un encodé à chaud
# 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

############################################################
#Un ticket d'encodage à chaud
# 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

############################################################
#Standardisation
# 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

############################################################
#Préparation des données
# prepare Data
############################################################
def prepareData() :

    ##############################
    #Prétraitement des données
    #Extraire les éléments requis
    # Data preprocessing
    # Extract necessary items
    ##############################
    # gender_submission.Charger 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']]
    
    ##############################
    #Prétraitement des données
    #Gérer les valeurs manquantes
    # 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)

    ##############################
    #Prétraitement des données
    #Quantifier l'étiquette (nom)
    # Data preprocessing
    # Digitize labels
    ##############################
    ##############################
    #sexe
    ##############################
    encoder_sex = LabelEncoder()
    df['Sex'] = encoder_sex.fit_transform(df['Sex'].values)
    df_test['Sex'] = encoder_sex.transform(df_test['Sex'].values)
    
    ##############################
    #Prétraitement des données
    # One-Encodage à chaud
    # 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)
 
    ##############################
    #Prétraitement des données
    #Normaliser les nombres
    # Data preprocessing
    # Standardize numbers
    ##############################
    df, df_test = standardization(df, df_test)

    ##############################
    #Prétraitement des données
    #Gérer les valeurs manquantes
    # Data preprocessing
    # Fill or remove missing values
    ##############################
    df.fillna({'Fare':0}, inplace=True)
    df_test.fillna({'Fare':0}, inplace=True)
        
    ##############################
    #Séparez les données d'entraînement et les données de test
    # Split training data and test data
    ##############################
    x = df.drop(columns='Survived')
    y = df[['Survived']]

    return x, y, df_test, df_test_index

##############################
#Construction de modèles Perceptron 5 couches
##############################
def create_model_5dim_layer_perceptron(input_dim, \
                                       activation="relu", \
                                       optimizer="adam", \
                                       out_dim=100, \
                                       dropout=0.5):
    
    model = Sequential()

    #Couche d'entrée-Couche cachée 1
    model.add(Dense(input_dim=input_dim, units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Couche cachée 1-Couche cachée 2
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Couche cachée 2-Couche cachée 3
    model.add(Dense(units=out_dim))
    model.add(BatchNormalization())
    model.add(Activation(activation))
    model.add(Dropout(dropout))

    #Couche cachée 3-Couche de sortie
    model.add(Dense(units=1))
    model.add(Activation("sigmoid"))

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

if __name__ == "__main__":
    
    #Préparation des données
    x_train, y_train, x_test, y_test_index = prepareData()
    
    #Construire un modèle
    model = create_model_5dim_layer_perceptron(len(x_train.columns), \
                                               activation="relu", \
                                               optimizer="adam", \
                                               out_dim=702, \
                                               dropout=0.5)

    #Apprentissage
    fit = model.fit(x_train, y_train, epochs=25, batch_size=16, verbose=2)
    
    #Prévoir
    y_test_proba = model.predict(x_test)
    y_test = numpy.round(y_test_proba).astype(int)
    
    #Combinez le résultat avec le DataFrame du 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.Ecrire csv dans le répertoire courant
    # Write result.csv to the current directory
    df_output.to_csv('result.csv', index=False)

6. Résultat

Le résultat était "0,79425".

7. Résumé

Par rapport à scikit-learn, Keras donne l'impression que vous pouvez effectuer des réglages détaillés tels que le nombre de couches et le nombre de neurones. Cependant, je pense qu'il existe peu de types de modèles autres que le réseau neuronal convolutif (CNN) et le réseau neuronal récurrent (RNN). Il semble bon d'utiliser correctement scikit-learn et Keras en fonction de la situation.

La prochaine fois aimerait apprendre à utiliser le langage R.

référence

Automatisation de l'optimisation des paramètres avec Keras avec GridSearch CV https://qiita.com/cvusk/items/285e2b02b0950537b65e

Histoire

2020/02/15 Première édition publiée 2020/02/22 Lien suivant ajouté

[PYTHON] Prédire le Titanic de Kaggle avec Keras (Kaggle ⑦)