[PYTHON] "Deep Learning from Grund" Memo zum Selbststudium (Nr. 10-2) Anfangswert des Gewichts

Während ich "Deep Learning von Grund auf neu" lese (geschrieben von Yasuki Saito, veröffentlicht von O'Reilly Japan), werde ich die Websites notieren, auf die ich verwiesen habe. Teil 10 ← → Teil 11

Ich habe den Quellcode ch06 / optimizer_compare_mnist.py, der beim Vergleich der Aktualisierungsmethode unter Verwendung des MNIST-Datasets verwendet wurde, ein wenig geändert und verschiedene Möglichkeiten ausprobiert, um den Anfangswert festzulegen.

# 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,
        activation='relu',weight_init_std='relu', 
        weight_decay_lambda=0)
    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)

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

Geben Sie "Relu" für die Aktivierungsfunktion an und setzen Sie "Anfangswert von He".

activation='relu', weight_init_std='he', 

Ergebnis der Verarbeitung von Testdaten

SGD Accuracy:0.9325 Momentum Accuracy:0.966 AdaGrad Accuracy:0.9707 Adam Accuracy:0.972

Geben Sie das Sigma für die Aktivierungsfunktion an und setzen Sie "Anfangswert von Xavier".

activation='sigmoid', weight_init_std='xavier', 

Ergebnis der Verarbeitung von Testdaten

SGD Accuracy:0.1135 Momentum Accuracy:0.1028 AdaGrad Accuracy:0.9326 Adam Accuracy:0.9558

SGD und Momentum hatten eine schlechte Erkennungsrate, daher habe ich die Anzahl der Chargen auf 10000 festgelegt.

SGD Accuracy:0.1135 Momentum Accuracy:0.9262 AdaGrad Accuracy:0.9617 Adam Accuracy:0.9673

Die Erkennungsrate von Momentum ist in angemessenem Maße gestiegen, aber SGD ist völlig nutzlos.

Geben Sie "Relu" als Aktivierungsfunktion an und stellen Sie die Normalverteilung mit einer Standardabweichung von 0,01 als Anfangswert ein.

activation='relu', weight_init_std=0.01, 

Ergebnis der Verarbeitung von Testdaten

SGD Accuracy:0.1135 Momentum Accuracy:0.1135 AdaGrad Accuracy:0.9631 Adam Accuracy:0.9713

SGD und Momentum scheinen überhaupt nicht zu lernen.

Teil 10 ← → Teil 11