[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.

w6-a.jpg

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

Glossaire illisible

Recommended Posts

"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
Mémo d'auto-apprentissage «Deep Learning from scratch» (10) Classe MultiLayerNet
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
Mémo d'auto-apprentissage "Deep Learning from scratch" (glossaire illisible)
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 11) CNN
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
Apprentissage profond à partir de zéro
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
Deep learning / Deep learning made from scratch Chapitre 6 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [Chapitre 5]
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 6]
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 18) One! Miaou! Grad-CAM!
Deep learning / Deep learning made from scratch Chapitre 7 Mémo
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 13) Essayez d'utiliser Google Colaboratory
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Apprentissage profond à partir de zéro 1 à 3 chapitres
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Apprentissage profond à partir de zéro (calcul des coûts)
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 8 Mémo
Deep learning / Deep learning made from scratch Chapitre 5 Mémo
Deep learning / Deep learning made from scratch Chapitre 4 Mémo
Deep learning / Deep learning from scratch 2 Chapitre 3 Mémo
Mémo d'apprentissage profond créé à partir de zéro
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 16) J'ai essayé de créer SimpleConvNet avec Keras
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 17) J'ai essayé de créer DeepConvNet avec Keras
Apprentissage profond à partir de zéro (propagation vers l'avant)
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
"Deep Learning from scratch" avec Haskell (inachevé)
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 14) Exécutez le programme du chapitre 4 sur Google Colaboratory
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 8) J'ai dessiné le graphique du chapitre 6 avec matplotlib
Classe Python (mémo d'apprentissage Python ⑦)
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
GitHub du bon livre "Deep Learning from scratch"
Django memo n ° 1 à partir de zéro
Résumé Python vs Ruby "Deep Learning from scratch"
[Deep Learning from scratch] J'ai implémenté la couche Affine
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
[Deep Learning from scratch] J'ai essayé d'expliquer le décrochage
Apprentissage profond / code de travail LSTM
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 2
Créez un environnement pour "Deep Learning from scratch" avec Docker
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 3
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 7
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 5