[PYTHON] "Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
En lisant "Deep Learning from scratch" (écrit par Yasuki Saito, publié par O'Reilly Japan), je prendrai note des sites auxquels j'ai fait référence. Partie 8 ←
Le chapitre 5 implémente les composants du réseau neuronal sous forme de couches et le chapitre 6 les utilise. Les différentes couches sont expliquées au chapitre 5, mais la classe MultiLayerNet implémentée n'est pas expliquée dans le livre. La source se trouve dans le dossier common, multi_layer_net.py.
Jetons donc un coup d'œil au contenu de la classe MultiLayerNet.
6.1.8 La classe MultiLayerNet est référencée dans le code source ch06 / optimizer_compare_mnist.py utilisé dans la comparaison des méthodes de mise à jour utilisant l'ensemble de données MNIST.
# 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)
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)
Parce qu'il utilise le jeu de données MNIST input_size = 784 L'entrée est des données d'image de 784 colonnes (à l'origine 28 x 28) output_size = 10 Probabilité de prédiction dont la sortie est 0-9 hidden_size_list = [100, 100, 100, 100] Il y a 4 couches cachées et le nombre de neurones est de 100 chacune. Et batch_size La taille du mini-lot (nombre de lignes de données d'entrée) est de 128
Puisque ce paramètre crée un réseau neuronal multicouche avec un couplage complet, Un tableau est créé comme ceci.
Ce qui suit concerne un tableau ou un objet dans l'objet réseaux.
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
Le nombre de couches intermédiaires spécifié est de 4, mais après cela, une cinquième couche est créée en tant que couche de sortie.
networks['SGD'].layers['Affine5'].x.shape
(128, 100)
networks['SGD'].layers['Affine5'].W.shape
(100, 10)
networks['SGD'].layers['Affine5'].b.shape
(10,)
La fonction d'activation de la couche de sortie est définie dans last_layer. La fonction softmax est utilisée ici.
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)
Je l'ai testé avec les résultats d'apprentissage
P177 Dans cette expérience, un réseau de neurones à 5 couches a 100 neurones dans chaque couche. Ciblé le réseau. Nous avons également utilisé ReLU comme fonction d'activation. En regardant les résultats de la figure 6-9, nous pouvons voir que d'autres méthodes apprennent plus rapidement que SGD. Je vais. Les trois méthodes restantes semblent être formées de la même manière. Si vous regardez de près L'apprentissage d'AdaGrad semble être un peu plus rapide. En guise de note de cette expérience Est l'hyperparamètre du coefficient d'apprentissage et la structure du réseau neuronal (combien de couches de profondeur) Le résultat changera en fonction de la situation. Cependant, généralement plus que SGD Les trois méthodes de sont plus rapides à apprendre et ont parfois de meilleures performances de reconnaissance finale.
J'ai donc examiné la différence de performance de reconnaissance avec les données de test.
#É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)))
SGD Accuracy:0.934 Momentum Accuracy:0.9676 AdaGrad Accuracy:0.97 Adam Accuracy:0.9701
Certes, le taux de reconnaissance des SGD semble faible.
J'ai changé le nombre de mini-lots de 2000 à 5000, appris et testé, et il s'est avéré comme ça.
max_iterations = 5000
SGD Accuracy:0.9557 Momentum Accuracy:0.9754 AdaGrad Accuracy:0.9755 Adam Accuracy:0.9752
À mesure que le nombre de fois augmentait, le taux de reconnaissance augmentait pour les quatre. La SGD a également augmenté, mais reste inférieure à 2000 fois par rapport aux autres méthodes.
J'ai réduit le nombre de couches intermédiaires à deux et j'ai essayé d'apprendre avec un réseau neuronal à trois couches.
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
Le taux de reconnaissance des quatre est d'environ 1% pire.
J'ai augmenté le nombre de couches intermédiaires à huit et j'ai essayé d'apprendre avec un réseau neuronal à neuf couches.
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
Le taux de reconnaissance de SGD a augmenté, mais les autres sont identiques ou légèrement pires. Vaut-il mieux penser que la vitesse d'apprentissage a augmenté plutôt que le taux de reconnaissance augmenté en augmentant le nombre de couches?
J'ai essayé de réduire le nombre de neurones dans la couche intermédiaire à 50
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
J'ai essayé d'augmenter le nombre de neurones dans la couche intermédiaire à 200
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
Partie 8 ←
Recommended Posts