[PYTHON] "Deep Learning from Grund" Memo zum Selbststudium (Nr. 9) MultiLayerNet-Klasse
Während ich "Deep Learning from Grund" (gelesen von Yasuki Saito, veröffentlicht von O'Reilly Japan) lese, werde ich die Websites notieren, auf die ich mich bezog. Teil 8 ←
Kapitel 5 implementiert die Komponenten des neuronalen Netzwerks als Schichten und Kapitel 6 verwendet sie. Die einzelnen Ebenen werden in Kapitel 5 erläutert, die implementierte MultiLayerNet-Klasse wird im Buch jedoch nicht erläutert. Die Quelle befindet sich im allgemeinen Ordner multi_layer_net.py.
Schauen wir uns also den Inhalt der MultiLayerNet-Klasse an.
6.1.8 Auf die MultiLayerNet-Klasse wird im Quellcode ch06 / optimizer_compare_mnist.py verwiesen, der beim Vergleich von Aktualisierungsmethoden unter Verwendung des MNIST-Datasets verwendet wird.
# coding: utf-8
import os
import sys
sys.path.append(os.pardir) #Einstellungen zum Importieren von Dateien in das übergeordnete Verzeichnis
import matplotlib.pyplot as plt
from dataset.mnist import load_mnist
from common.util import smooth_curve
from common.multi_layer_net import MultiLayerNet
from common.optimizer import *
# 0:MNIST-Daten lesen==========
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)
train_size = x_train.shape[0]
batch_size = 128
max_iterations = 2000
# 1:Experimentelle Einstellungen==========
optimizers = {}
optimizers['SGD'] = SGD()
optimizers['Momentum'] = Momentum()
optimizers['AdaGrad'] = AdaGrad()
optimizers['Adam'] = Adam()
#optimizers['RMSprop'] = RMSprop()
networks = {}
train_loss = {}
for key in optimizers.keys():
networks[key] = MultiLayerNet(
input_size=784, hidden_size_list=[100, 100, 100, 100],
output_size=10)
train_loss[key] = []
# 2:Beginn des Trainings==========
for i in range(max_iterations):
batch_mask = np.random.choice(train_size, batch_size)
x_batch = x_train[batch_mask]
t_batch = t_train[batch_mask]
for key in optimizers.keys():
grads = networks[key].gradient(x_batch, t_batch)
optimizers[key].update(networks[key].params, grads)
loss = networks[key].loss(x_batch, t_batch)
train_loss[key].append(loss)
Weil es den MNIST-Datensatz verwendet input_size = 784 Eingabe sind Bilddaten von 784 Spalten (ursprünglich 28 x 28) output_size = 10 Vorhersagewahrscheinlichkeit, deren Ausgabe 0-9 ist hidden_size_list = [100, 100, 100, 100] Es gibt 4 versteckte Schichten und die Anzahl der Neuronen beträgt jeweils 100. Und batch_size Die Mini-Batch-Größe (Anzahl der Zeilen mit Eingabedaten) beträgt 128
Da diese Einstellung ein mehrschichtiges neuronales Netzwerk mit vollständiger Kopplung erstellt, So wird ein Array erstellt.
Das Folgende ist, wenn auf ein Array oder Objekt im Netzwerkobjekt verwiesen wird.
networks
{'SGD': common.multi_layer_net.MultiLayerNet at 0x8800d50, 'Momentum': common.multi_layer_net.MultiLayerNet at 0x8800a50, 'AdaGrad': common.multi_layer_net.MultiLayerNet at 0x8800710, 'Adam': common.multi_layer_net.MultiLayerNet at 0x88003d0}
networks['SGD']
common.multi_layer_net.MultiLayerNet at 0x8800d50
networks['SGD'].layers
OrderedDict([('Affine1', common.layers.Affine at 0x8800c30), ('Activation_function1', common.layers.Relu at 0x8800c70), ('Affine2', common.layers.Affine at 0x8800bf0), ('Activation_function2', common.layers.Relu at 0x8800bd0), ('Affine3', common.layers.Affine at 0x8800b90), ('Activation_function3', common.layers.Relu at 0x8800b70), ('Affine4', common.layers.Affine at 0x8800ab0), ('Activation_function4', common.layers.Relu at 0x8800b30), ('Affine5', common.layers.Affine at 0x8800af0)])
networks['SGD'].layers['Affine1'].x
array([[0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.], ..., [0., 0., 0., ..., 0., 0., 0.], [0., 0., 0., ..., 0., 0., 0.]], dtype=float32)
networks['SGD'].layers['Affine1'].x.shape
(128, 784)
networks['SGD'].layers['Affine1'].W
array([[-0.04430735, -0.00916858, -0.05385046, ..., -0.01356, 0.0366878, -0.04629992], [-0.0974915 , 0.01896 , 0.0016755 , ..., 0.00820512, -0.01012246, -0.04869024], ..., [ 0.03065034, -0.02653425, -0.00433941, ..., -0.06933382, 0.03986452, 0.06821553], [ 0.01673732, 0.04850334, -0.0291053 , ..., -0.05045292, 0.00599257, 0.08265754]])
networks['SGD'].layers['Affine1'].W.shape
(784, 100)
networks['SGD'].layers['Affine1'].b
array([ 0.01646891, 0.01467293, 0.02892796, 0.02414651, 0.02259769, -0.00919552, -0.01567924, 0.0039934 , 0.00693527, 0.03932801, ..., -0.00536202, 0.00508444, 0.00204647, 0.01040528, 0.00355356, -0.00960685, 0.06204312, 0.02886584, 0.06678846, 0.0186539 ])
networks['SGD'].layers['Affine1'].b.shape
(100,)
networks['SGD'].layers['Activation_function1']
common.layers.Relu at 0x8800c70
networks['SGD'].layers['Affine2'].x.shape
(128, 100)
networks['SGD'].layers['Affine2'].W.shape
(100, 100)
networks['SGD'].layers['Affine2'].b.shape
(100,)
networks['SGD'].layers['Activation_function2']
common.layers.Relu at 0x8800bd0
networks['SGD'].layers['Affine3'].x.shape
(128, 100)
networks['SGD'].layers['Affine3'].W.shape
(100, 100)
networks['SGD'].layers['Affine3'].b.shape
(100,)
networks['SGD'].layers['Activation_function3']
common.layers.Relu at 0x8800b70
networks['SGD'].layers['Affine4'].x.shape
(128, 100)
networks['SGD'].layers['Affine4'].W.shape
(100, 100)
networks['SGD'].layers['Affine4'].b.shape
(100,)
networks['SGD'].layers['Activation_function4']
common.layers.Relu at 0x8800b30
Die Anzahl der angegebenen Zwischenebenen beträgt 4, danach wird eine fünfte Ebene als Ausgabeebene erstellt.
networks['SGD'].layers['Affine5'].x.shape
(128, 100)
networks['SGD'].layers['Affine5'].W.shape
(100, 10)
networks['SGD'].layers['Affine5'].b.shape
(10,)
Die Aktivierungsfunktion der Ausgabeschicht ist in last_layer definiert. Hier wird die Softmax-Funktion verwendet.
networks['SGD'].last_layer
common.layers.SoftmaxWithLoss at 0x8800770
networks['SGD'].last_layer.y
array([[2.08438091e-05, 2.66555051e-09, 1.29436456e-03, ..., 1.83391350e-07, 9.98317338e-01, 6.77137764e-05], [5.68871828e-04, 1.59787427e-06, 3.60265866e-03, ..., 7.25385216e-05, 1.80220134e-03, 4.95014520e-02], ..., [3.01731618e-03, 5.57601184e-03, 1.40908372e-02, ..., 8.49627989e-02, 5.44208078e-03, 2.32114245e-01], [9.82201047e-07, 3.01213101e-07, 1.05657504e-03, ..., 1.03584551e-05, 9.92242677e-01, 5.06642654e-03]])
networks['SGD'].last_layer.y.shape
(128, 10)
Ich habe es mit den Lernergebnissen getestet
P177 In diesem Experiment hat ein 5-Schicht-Neuronales Netzwerk 100 Neuronen in jeder Schicht. Ziel des Netzwerks. Wir haben auch ReLU als Aktivierungsfunktion verwendet. Wenn wir uns die Ergebnisse in Abbildung 6-9 ansehen, können wir sehen, dass andere Methoden schneller lernen als SGD. Ich werde. Die restlichen drei Methoden scheinen auf die gleiche Weise trainiert zu sein. Wenn man genau hinschaut Das Erlernen von AdaGrad scheint etwas schneller zu sein. Als Anmerkung zu diesem Experiment Ist der Hyperparameter des Lernkoeffizienten und der Struktur des neuronalen Netzwerks (wie viele Tiefenschichten) Das Ergebnis ändert sich je nach Situation. Im Allgemeinen jedoch mehr als SGD Die drei Methoden von sind schneller zu erlernen und haben manchmal eine bessere endgültige Erkennungsleistung.
Also habe ich den Unterschied in der Erkennungsleistung anhand von Testdaten untersucht.
#Mit Testdaten auswerten
x = x_test
t = t_test
for key in optimizers.keys():
network = networks[key]
y = network.predict(x)
accuracy_cnt = 0
for i in range(len(x)):
p= np.argmax(y[i])
if p == t[i]:
accuracy_cnt += 1
print(key + " Accuracy:" + str(float(accuracy_cnt) / len(x)))
SGD Accuracy:0.934 Momentum Accuracy:0.9676 AdaGrad Accuracy:0.97 Adam Accuracy:0.9701
Sicherlich scheint die Erkennungsrate von SGD niedrig zu sein.
Ich habe die Anzahl der Mini-Batches von 2000 auf 5000 geändert, sie gelernt und getestet, und es hat sich so herausgestellt.
max_iterations = 5000
SGD Accuracy:0.9557 Momentum Accuracy:0.9754 AdaGrad Accuracy:0.9755 Adam Accuracy:0.9752
Mit zunehmender Häufigkeit stieg die Erkennungsrate für alle vier. Der SGD ist ebenfalls gestiegen, bleibt aber 2000-mal niedriger als bei anderen Methoden.
Ich reduzierte die Anzahl der Zwischenschichten auf zwei und versuchte, mit einem dreischichtigen neuronalen Netz zu lernen.
networks[key] = MultiLayerNet(
input_size=784, hidden_size_list=[100, 100],
output_size=10)
SGD Accuracy:0.922 Momentum Accuracy:0.9633 AdaGrad Accuracy:0.9682 Adam Accuracy:0.9701
Die Erkennungsrate aller vier ist um etwa 1% schlechter.
Ich erhöhte die Anzahl der Zwischenschichten auf acht und versuchte, mit einem neunschichtigen neuronalen Netz zu lernen.
networks[key] = MultiLayerNet(
input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100, 100, 100],
output_size=10)
SGD Accuracy:0.9479 Momentum Accuracy:0.9656 AdaGrad Accuracy:0.9692 Adam Accuracy:0.9701
Die Erkennungsrate von SGD hat zugenommen, aber die anderen sind gleich oder etwas schlechter. Ist es besser zu glauben, dass die Lerngeschwindigkeit gestiegen ist, als dass die Erkennungsrate durch Erhöhen der Anzahl der Schichten erhöht wurde?
Ich habe versucht, die Anzahl der Neuronen in der mittleren Schicht auf 50 zu reduzieren
networks[key] = MultiLayerNet(
input_size=784, hidden_size_list=[50, 50, 50, 50],
output_size=10)
SGD Accuracy:0.9275 Momentum Accuracy:0.9636 AdaGrad Accuracy:0.962 Adam Accuracy:0.9687
Ich habe versucht, die Anzahl der Neuronen in der mittleren Schicht auf 200 zu erhöhen
networks[key] = MultiLayerNet(
input_size=784, hidden_size_list=[200, 200, 200, 200],
output_size=10)
SGD Accuracy:0.9372 Momentum Accuracy:0.9724 AdaGrad Accuracy:0.9775 Adam Accuracy:0.9753
Teil 8 ←
Recommended Posts