Automatisation de l'optimisation des paramètres avec Keras avec GridSearch CV

J'ai essayé Grid Search CV avec Keras

La précision du modèle de l'apprentissage automatique dépend des paramètres. De nombreux paramètres sont définis lors de la construction d'un modèle, tels que les fonctions d'activation, les algorithmes d'optimisation et le nombre d'unités dans la couche intermédiaire, mais on ne sait pas avant la formation et l'utilisation pratique si les paramètres définis à ce moment-là sont optimaux.

Cependant, l'attrait de l'apprentissage automatique est qu'il génère automatiquement le modèle optimal. Si tel est le cas, les paramètres peuvent être optimisés automatiquement! Je pense.

Scikit-learn, qui est célèbre pour l'apprentissage automatique Python, dispose d'une bibliothèque appelée Gridsearch cv qui permet la sélection de modèles et le réglage des paramètres.

http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html

En fait, Keras est un wrapper pour scicit-learn, et Gridsearch cv peut être utilisé lors de la création de modèles Keras.

https://keras.io/ja/scikit-learn-api/

Alors, essayons immédiatement le CV Gridsearch de Keras.

Cible

Créez un modèle optimal à l'aide de Gridsearch cv avec Keras. Les données sont catégorisées à l'aide des données Iris, qui sont très populaires auprès de tous.

https://en.wikipedia.org/wiki/Iris_flower_data_set

codage

Écrivons-le tout de suite.

Tout d'abord, importez ce dont vous avez besoin. Utilisez les données Iris fournies par sklearn.

import numpy as np
from sklearn import datasets, preprocessing
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.utils import np_utils
from keras import backend as K
from keras.wrappers.scikit_learn import KerasClassifier

Divisez les données Iris en entraînement et test dans un rapport de 7: 3.

iris = datasets.load_iris()
x = preprocessing.scale(iris.data)
y = np_utils.to_categorical(iris.target)
x_tr, x_te, y_tr, y_te = train_test_split(x, y, train_size  = 0.7)
num_classes = y_te.shape[1]

Définissez un modèle de réseau neuronal en tant que fonction. Ici, le nombre de couches est défini et des paramètres sont donnés aux arguments.

def iris_model(activation="relu", optimizer="adam", out_dim=100):
    model = Sequential()
    model.add(Dense(out_dim, input_dim=4, activation=activation))
    model.add(Dense(out_dim, activation=activation))
    model.add(Dense(num_classes, activation="softmax"))
    model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
    return model

Définissez des choix pour chaque paramètre. Gridsearch cv vérifie tous les modèles des paramètres définis ici.

activation = ["relu", "sigmoid"]
optimizer = ["adam", "adagrad"]
out_dim = [100, 200]
nb_epoch = [10, 25]
batch_size = [5, 10]

Chargez les fonctions et paramètres du modèle dans Gridsearch cv. J'ai lu le modèle avec KerasClassifier et défini les paramètres de dict. C'est un mécanisme pour combiner les deux avec GridSearchCV.

model = KerasClassifier(build_fn=iris_model, verbose=0)
param_grid = dict(activation=activation, 
                  optimizer=optimizer, 
                  out_dim=out_dim, 
                  nb_epoch=nb_epoch, 
                  batch_size=batch_size)
grid = GridSearchCV(estimator=model, param_grid=param_grid)

Commence l'entraînement!

grid_result = grid.fit(x_tr, y_tr)

... 30 minutes d'attente ... ・ ・ ・ Bien qu'il s'agisse d'une classification des données Iris, cela prend du temps s'il s'agit d'un processeur. ・ ・ ・ ... Est-ce plus rapide avec GPGPU? ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ... je veux un GPU ... ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ・ ... Terminé! ・ ・ ・

Sortez le résultat. Meilleur score et ses paramètres.

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

95% ... OK.

Maintenant, validons le modèle avec les données de test que nous avons laissées en premier. En passant, si vous gridsearchcv Keras, il semble que model.evaluate ne puisse pas être fait. Par conséquent, la réponse correcte et la valeur estimée des données de test sont comparées à l'analogique.

grid_eval = grid.predict(x_te)
def y_binary(i):
    if   i == 0: return [1, 0, 0]
    elif i == 1: return [0, 1, 0]
    elif i == 2: return [0, 0, 1]
y_eval = np.array([y_binary(i) for i in grid_eval])
accuracy = (y_eval == y_te)
print (np.count_nonzero(accuracy == True) / (accuracy.shape[0] * accuracy.shape[1]))

98％！ Ça fait du bien.

Le modèle ressemble à ceci.

model = iris_model(activation=grid_result.best_params_['activation'], 
                   optimizer=grid_result.best_params_['optimizer'], 
                   out_dim=grid_result.best_params_['out_dim'])
model.summary()

Comment c'est? Les données Iris ont des valeurs aberrantes, et même si vous faites de votre mieux, elles ne seront pas à 100%. Il faut beaucoup de temps pour s'entraîner en combinant des paramètres, mais c'est plus facile que de rechercher des paramètres manuellement.

Voici le code complet.

import numpy as np
from sklearn import datasets, preprocessing
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.utils import np_utils
from keras import backend as K
from keras.wrappers.scikit_learn import KerasClassifier


# import data and divided it into training and test purposes
iris = datasets.load_iris()
x = preprocessing.scale(iris.data)
y = np_utils.to_categorical(iris.target)
x_tr, x_te, y_tr, y_te = train_test_split(x, y, train_size  = 0.7)
num_classes = y_te.shape[1]


# Define model for iris classification
def iris_model(activation="relu", optimizer="adam", out_dim=100):
    model = Sequential()
    model.add(Dense(out_dim, input_dim=4, activation=activation))
    model.add(Dense(out_dim, activation=activation))   
    model.add(Dense(num_classes, activation="softmax"))
    model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
    return model

# Define options for parameters
activation = ["relu", "sigmoid"]
optimizer = ["adam", "adagrad"]
out_dim = [100, 200]
nb_epoch = [10, 25]
batch_size = [5, 10]


# Retrieve model and parameter into GridSearchCV
model = KerasClassifier(build_fn=iris_model, verbose=0)
param_grid = dict(activation=activation, 
                  optimizer=optimizer, 
                  out_dim=out_dim, 
                  nb_epoch=nb_epoch, 
                  batch_size=batch_size)
grid = GridSearchCV(estimator=model, param_grid=param_grid)


# Run grid search
grid_result = grid.fit(x_tr, y_tr)


# Get the best score and the optimized mode
print (grid_result.best_score_)
print (grid_result.best_params_)

# Evaluate the model with test data
grid_eval = grid.predict(x_te)
def y_binary(i):
    if   i == 0: return [1, 0, 0]
    elif i == 1: return [0, 1, 0]
    elif i == 2: return [0, 0, 1]
y_eval = np.array([y_binary(i) for i in grid_eval])
accuracy = (y_eval == y_te)
print (np.count_nonzero(accuracy == True) / (accuracy.shape[0] * accuracy.shape[1]))


# Now see the optimized model
model = iris_model(activation=grid_result.best_params_['activation'], 
                   optimizer=grid_result.best_params_['optimizer'], 
                   out_dim=grid_result.best_params_['out_dim'])
model.summary()