Ich habe Grid Search CV mit Keras ausprobiert

Die Modellgenauigkeit des maschinellen Lernens hängt von den Parametern ab. Beim Erstellen eines Modells werden viele Parameter festgelegt, z. B. Aktivierungsfunktionen, Optimierungsalgorithmen und die Anzahl der Einheiten in der mittleren Schicht. Es ist jedoch erst nach Schulung und praktischer Anwendung bekannt, ob die zu diesem Zeitpunkt festgelegten Parameter optimal sind.

Der Reiz des maschinellen Lernens besteht jedoch darin, dass es automatisch das optimale Modell generiert. In diesem Fall können die Parameter automatisch optimiert werden! Ich denke.

Scikit-learn, das für maschinelles Python-Lernen bekannt ist, verfügt über eine Bibliothek namens Gridsearch cv, die die Modellauswahl und Parametereinstellung ermöglicht.

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

Tatsächlich ist Keras ein Wrapper für Scicit-Learn, und Gridsearch cv kann beim Erstellen von Keras-Modellen verwendet werden.

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

Versuchen wir also sofort Keras 'Gridsearch-Lebenslauf.

Ziel

Erstellen Sie mit Grasearch cv mit Keras ein optimales Modell. Die Daten werden anhand von Iris-Daten kategorisiert, was bei allen sehr beliebt ist.

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

Codierung

Schreiben wir es gleich.

Importieren Sie zunächst das, was Sie benötigen. Verwenden Sie die von sklearn bereitgestellten Irisdaten.

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

Teilen Sie die Iris-Daten im Verhältnis 7: 3 in Training und Test auf.

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]

Definieren Sie ein neuronales Netzwerkmodell als Funktion. Hier wird die Anzahl der Ebenen definiert und den Argumenten Parameter zugewiesen.

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

Definieren Sie Auswahlmöglichkeiten für jeden Parameter. Gridsearch cv überprüft alle Muster der hier definierten Parameter.

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

Laden Sie die Modellfunktionen und -parameter in Gridsearch cv. Ich habe das Modell mit KerasClassifier gelesen und die Parameter für dict festgelegt. Es ist ein Mechanismus, um beide mit GridSearchCV zu kombinieren.

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)

Fange an zu trainieren!

grid_result = grid.fit(x_tr, y_tr)

... 30 Minuten warten ... ・・・ Obwohl es sich um eine Klassifizierung von Iris-Daten handelt, dauert es einige Zeit, wenn es sich um eine CPU handelt. ・・・ ... ist es mit GPGPU schneller? ・・・・・・・・・・・・ ... Ich möchte eine GPU ... ・・・・・・・・・・・・・・・・・・ ... Erledigt! ・・・

Das Ergebnis ausgeben. Beste Punktzahl und ihre Parameter.

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

95% ... OK.

Lassen Sie uns nun das Modell mit den Testdaten validieren, die wir zuerst hinterlassen haben. Übrigens, wenn Sie Keras gridsearchcv verwenden, scheint model.evaluate nicht möglich zu sein. Daher werden die richtige Antwort und der geschätzte Wert der Testdaten mit analog verglichen.

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％！ Es fühlt sich ziemlich gut an.

Das Modell sieht so aus.

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

Wie ist das? Die Iris-Daten haben einige Ausreißer, und selbst wenn Sie Ihr Bestes geben, werden sie nicht 100% sein. Das Trainieren durch Kombinieren von Parametern nimmt viel Zeit in Anspruch, ist jedoch einfacher als die manuelle Suche nach Parametern.

Unten ist der vollständige Code.

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

[PYTHON] Automatisierung der Parameteroptimierung mit Keras mit GridSearch CV

Ich habe Grid Search CV mit Keras ausprobiert

Ziel

Codierung