[PYTHON] Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids

En lisant "Deep Learning from scratch" (écrit par Yasuki Saito, publié par O'Reilly Japan), je noterai les sites auxquels j'ai fait référence. Partie 10 ← → Partie 11

J'ai légèrement modifié le code source ch06 / optimizer_compare_mnist.py utilisé dans la comparaison de la méthode de mise à jour en utilisant l'ensemble de données MNIST, et j'ai essayé plusieurs façons de définir la valeur initiale.

# coding: utf-8
import os
import sys
sys.path.append(os.pardir)  #Paramètres d'importation des fichiers dans le répertoire parent
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:Lire les données MNIST==========
(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:Paramètres expérimentaux==========
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:Début de la formation==========
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)

#Évaluer avec des données de test
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))) 

Spécifiez "Relu" pour la fonction d'activation et définissez "Valeur initiale de He"

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

Résultat du traitement des données de test

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

Spécifiez «igmoïde »pour la fonction d'activation et définissez« Valeur initiale de Xavier »

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

Résultat du traitement des données de test

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

SGD et Momentum avaient un mauvais taux de reconnaissance, j'ai donc fixé le nombre de lots à 10000.

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

Le taux de reconnaissance de Momentum a tellement augmenté, mais SGD est totalement inutile.

Spécifiez "relu" comme fonction d'activation et définissez la distribution normale avec un écart type de 0,01 comme valeur initiale.

activation='relu', weight_init_std=0.01, 

Résultat du traitement des données de test

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

SGD et Momentum ne semblent pas du tout apprendre.

Partie 10 ← → Partie 11