[PYTHON] Anwenden der Bayes'schen Optimierung auf das Keras-DNN-Modell
Anwenden der Bayes'schen Optimierung auf das Keras-DNN-Modell
Das Anpassen von Parametern ist nicht nur auf tiefes Lernen beschränkt, sondern auch eine schwierige Aufgabe beim Erstellen von Modellen für maschinelles Lernen. Die Genauigkeit des maschinellen Lernmodells hängt von den Parametern ab, aber die Anzahl und der Bereich der Parameter sind breit und es ist schwierig, die optimale Lösung zu finden.
Wenn beispielsweise ein neuronales Netzwerkmodell für die verborgene Schicht 3 betrachtet wird, müssen viele Faktoren bestimmt werden, wie z. B. die Anzahl der Neuronen, die Abbrecherquote, die Stapelgröße und die Anzahl der Epochen, die die Ausgaben jeder Schicht sind, und der Bereich ist breit. Es gibt verschiedene Möglichkeiten, jeden Parameter zu bestimmen. Im Folgenden finden Sie Beispiele für mögliche numerische Werte.
- Anzahl der Neuronen: Ganzzahl größer oder gleich 1
- Dropout-Rate: 0 oder mehr und weniger als 1
- Stapelgröße: Ganzzahl kleiner oder gleich den Eingabedaten
- Anzahl der Epochen: ganze Zahlen größer oder gleich 1
Abhängig vom neuronalen Netzwerk kann es geeignete numerische Werte geben, aber ehrlich gesagt ist die Parametereinstellung problematisch, da es geeignete Werte gibt, die von den Daten und dem neuronalen Netzwerkmodell abhängen. Außerdem können Sie nicht feststellen, ob der Parameter gut oder schlecht ist, bis Sie es versuchen.
Zuvor habe ich die Suche nach Parametern mit GridSearchCV vorgestellt. http://qiita.com/cvusk/items/285e2b02b0950537b65e
Bei dieser Methode habe ich alle Kombinationen der von mir festgelegten Parameter ausgewählt, um den optimalen Parameter zu finden. Die Schwierigkeit bei dieser Methode besteht darin, dass mit zunehmender Anzahl von Parametern die Anzahl der zu versuchenden Kombinationen durch Multiplikation zunimmt.
Dieses Mal werden wir die Bayes'sche Optimierung als leistungsfähigere Methode zur Parameteranpassung einführen.
Was ist diesmal zu tun?
Ich werde Ihnen zeigen, wie Sie ein in Keras geschriebenes Modell mithilfe der Bayes'schen Optimierung optimieren. Das als Beispiel verwendete Modell ist MNIST.
Ich möchte die folgenden Parameter in einem dreischichtigen Modell mit einer Eingabeebene, einer verborgenen Ebene und einer Ausgabeebene optimieren.
- Anzahl der Ausgaben in der Eingabeebene
- Abbrecherquote der Eingabeebene
- Anzahl der Ausgaben für versteckte Ebenen
- Versteckte Layer-Dropout-Rate
- Stapelgröße
- Anzahl der Epochen
- Überprüfungsdatenrate
Über die Bayes'sche Optimierung
Die Erklärung der Bayes'schen Optimierung wird hier detailliert beschrieben.
- Einführung in die Bayes'sche Optimierung
- [Hyperparametersuche für maschinelles Lernen: Nutzung der Bayes'schen Optimierung](http://www.techscore.com/blog/2016/12/20/%E6%A9%9F%E6%A2%B0%E5%AD % A6% E7% BF% 92% E3% 81% AE% E3% 83% 8F% E3% 82% A4% E3% 83% 91% E3% 83% BC% E3% 83% 91% E3% 83% A9 % E3% 83% A1% E3% 83% BC% E3% 82% BF% E6% 8E% A2% E7% B4% A2-% E3% 83% 99% E3% 82% A4% E3% 82% BA% E6% 9C% 80% E9% 81% A9 /)
- Versuch, die Interpretation medizinischer Bilder durch Deep Learning und Bayesian Optimization zu unterstützen
Bei der Bayes'schen Optimierung werden Parameter eingegeben, die Genauigkeit der Modellüberprüfung (Verlustfunktion, Genauigkeitsverhältnis usw.) ausgegeben und dazwischen liegende Funktionen (Modelle) sind Black Boxes. Die Black-Box-Funktion ist [Gaußscher Prozess](https://ja.wikipedia.org/wiki/%E3%82%AC%E3%82%A6%E3%82%B9%E9%81%8E%E7%A8% Unter der Annahme, dass 8B) befolgt wird, wird die hintere Verteilung durchsucht und die Parameter werden durch Wiederholen der Überprüfung optimiert.
Werkzeug
In Python können Sie die Bayes'sche Optimierung mit einem Tool namens GPyOpt durchführen. Klicken Sie hier, um Einzelheiten zur Verwendung zu erfahren. Bayes-Optimierungspaket GPyOpt mit Python
Code und Verwendung
Der Code, den ich dieses Mal geschrieben habe, ist hier. https://github.com/shibuiwilliam/keras_gpyopt
Ich werde den Inhalt erklären. Definieren Sie zunächst das Modell von MNIST.
# Import libraries
import GPy, GPyOpt
import numpy as np
import pandas as pds
import random
from keras.layers import Activation, Dropout, BatchNormalization, Dense
from keras.models import Sequential
from keras.datasets import mnist
from keras.metrics import categorical_crossentropy
from keras.utils import np_utils
from keras.optimizers import Adam
from keras.callbacks import EarlyStopping
# MNIST class
class MNIST():
def __init__(self, first_input=784, last_output=10,
l1_out=512,
l2_out=512,
l1_drop=0.2,
l2_drop=0.2,
batch_size=100,
epochs=10,
validation_split=0.1):
self.__first_input = first_input
self.__last_output = last_output
self.l1_out = l1_out
self.l2_out = l2_out
self.l1_drop = l1_drop
self.l2_drop = l2_drop
self.batch_size = batch_size
self.epochs = epochs
self.validation_split = validation_split
self.__x_train, self.__x_test, self.__y_train, self.__y_test = self.mnist_data()
self.__model = self.mnist_model()
# load mnist data from keras dataset
def mnist_data(self):
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)
return X_train, X_test, Y_train, Y_test
# mnist model
def mnist_model(self):
model = Sequential()
model.add(Dense(self.l1_out, input_shape=(self.__first_input,)))
model.add(Activation('relu'))
model.add(Dropout(self.l1_drop))
model.add(Dense(self.l2_out))
model.add(Activation('relu'))
model.add(Dropout(self.l2_drop))
model.add(Dense(self.__last_output))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=Adam(),
metrics=['accuracy'])
return model
# fit mnist model
def mnist_fit(self):
early_stopping = EarlyStopping(patience=0, verbose=1)
self.__model.fit(self.__x_train, self.__y_train,
batch_size=self.batch_size,
epochs=self.epochs,
verbose=0,
validation_split=self.validation_split,
callbacks=[early_stopping])
# evaluate mnist model
def mnist_evaluate(self):
self.mnist_fit()
evaluation = self.__model.evaluate(self.__x_test, self.__y_test, batch_size=self.batch_size, verbose=0)
return evaluation
# function to run mnist class
def run_mnist(first_input=784, last_output=10,
l1_out=512, l2_out=512,
l1_drop=0.2, l2_drop=0.2,
batch_size=100, epochs=10, validation_split=0.1):
_mnist = MNIST(first_input=first_input, last_output=last_output,
l1_out=l1_out, l2_out=l2_out,
l1_drop=l1_drop, l2_drop=l2_drop,
batch_size=batch_size, epochs=epochs,
validation_split=validation_split)
mnist_evaluation = _mnist.mnist_evaluate()
return mnist_evaluation
Führen Sie dann die Bayes'sche Optimierung mit dem obigen MNIST-Modell durch.
# Bayesian Optimization
#Definieren Sie die Auswahl und den Bereich jedes Parameters.
#Hinweis: Der Parameter ist Typ: continuous、type:Muss in diskreter Reihenfolge geschrieben werden.
#Andernfalls tritt im nachfolgenden Prozess ein Fehler auf.
bounds = [{'name': 'validation_split', 'type': 'continuous', 'domain': (0.0, 0.3)},
{'name': 'l1_drop', 'type': 'continuous', 'domain': (0.0, 0.3)},
{'name': 'l2_drop', 'type': 'continuous', 'domain': (0.0, 0.3)},
{'name': 'l1_out', 'type': 'discrete', 'domain': (64, 128, 256, 512, 1024)},
{'name': 'l2_out', 'type': 'discrete', 'domain': (64, 128, 256, 512, 1024)},
{'name': 'batch_size', 'type': 'discrete', 'domain': (10, 100, 500)},
{'name': 'epochs', 'type': 'discrete', 'domain': (5, 10, 20)}]
#Definieren Sie eine Funktion für die Bayes'sche Optimierung (die oben beschriebene Blackbox).
#x ist die Eingabe und die Ausgabe wird zurückgegeben.
def f(x):
print(x)
evaluation = run_mnist(
l1_drop = float(x[:,1]),
l2_drop = float(x[:,2]),
l1_out = int(x[:,3]),
l2_out = int(x[:,4]),
batch_size = int(x[:,5]),
epochs = int(x[:,6]),
validation_split = float(x[:,0]))
print("loss:{0} \t\t accuracy:{1}".format(evaluation[0], evaluation[1]))
print(evaluation)
return evaluation[0]
#Führen Sie eine vorläufige Suche durch.
opt_mnist = GPyOpt.methods.BayesianOptimization(f=f, domain=bounds)
#Suchen Sie nach den besten Parametern.
opt_mnist.run_optimization(max_iter=10)
print("optimized parameters: {0}".format(opt_mnist.x_opt))
print("optimized loss: {0}".format(opt_mnist.fx_opt))
GPyOpt.methods.BayesianOptimization definiert Methoden zur Bayes'schen Optimierung.
Mit dieser Option können Sie nach dem Parameter suchen, der die optimale Verlustfunktion innerhalb der definierten Parameterauswahl und -grenzen bietet. Es gibt jedoch eine Einschränkung.
Parameterauswahl, der Bereich wird mit dict geschrieben und Typ: kontinuierlich und Typ: diskret definieren kontinuierlichen Wert oder Auswahl.
Wenn Sie hier nicht in der Reihenfolge kontinuierlich und diskret schreiben, tritt ein Fehler mit "opt_mnist = GPyOpt.methods.BayesianOptimization (f = f, domain = bounds)" auf.
Ich wusste nicht, wie ich das schreiben sollte, und ich war ungefähr zwei Tage lang süchtig danach.
Finden Sie den besten Parameter mit opt_mnist.run_optimization (max_iter = 10).
Geben Sie die Obergrenze für die Anzahl der Lernausführungen für die Suche mit "max_iter" an.
Wir werden hier bis zu 10 Mal suchen, aber wenn es früh konvergiert, wird es in einer geringeren Anzahl von Malen abgeschlossen.
Das Ausführungsergebnis des Programms ist wie folgt.
Hier sehen Sie, dass die Suche in 4 Mal abgeschlossen ist. Die Bayes'sche Optimierung kann verwendet werden, um die Parametereinstellung zu automatisieren und den Aufwand zu reduzieren.
Recommended Posts