[Deep Learning from scratch] Implémentez le traitement de rétropropagation dans le réseau neuronal par la méthode de propagation de retour d'erreur

introduction

Cet article est une sortie facile à comprendre de ** Deep Learning from scratch Chapter 6 Error back propagation method **. J'ai pu le comprendre moi-même, j'espère donc que vous pourrez le lire confortablement. De plus, je serais plus qu'heureux si vous pouviez vous y référer lors de l'étude de ce livre.

Implémentation du traitement de rétropropagation dans le réseau neuronal

Dans l'article précédent, j'ai pu implémenter toutes les parties nécessaires à la méthode de propagation des erreurs. Par conséquent, cette fois, je voudrais implémenter le processus de propagation arrière dans le réseau neuronal en utilisant réellement la pièce et en exécutant la méthode de propagation d'erreur.

** 1, initialisation des paramètres / création de couches **

from collections import OrderedDict
class LayerNet:
    def __init__(self, input_size, hiden_size, output_size, weight_init_std = 0.01):
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hiden_size)
        self.params['b1'] = np.zeros(hiden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hiden_size, output_size)
        self.params['b2'] = np.zeros(output_size)
    
        #Génération de couches
        self.layers = OrderedDict()#Dictionnaire ordonné
        self.layers['Affine1'] = Affine(self.params['W1'],self.params['b1']) #Créez tous les calques affines sur le premier calque du calque du milieu
        self.layers['Relu1'] = Relu()#Créez tous les calques Relu sur le premier calque du calque du milieu
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2']) #Créez tous les calques affines dans le deuxième calque du calque du milieu
        self.layers['Relu2'] = Relu() #Créez tous les calques Relu pour le deuxième calque du calque du milieu
        self.lastLayer = SoftmaxWithLoss() #Création de couche de la couche de sortie à la fonction de perte
    

Veuillez vous référer à l'initialisation des paramètres, qui est la même que pour le réseau neuronal de différenciation numérique.

Dans la partie de génération de couche suivante, nous créons d'abord un dictionnaire ordonné ** OrderDict ** pour stocker les couches et le stocker dans une variable d'instance.

Ensuite, placez les couches dans le OrderDict créé dans l'ordre à partir du côté gauche du réseau neuronal. Les calques sont gérés dans l'ordre en les plaçant dans OrderDict. Ce faisant, vous pouvez facilement effectuer un traitement de propagation avant en utilisant l'instruction for pour extraire les couches une par une et le traitement de propagation inverse en utilisant l'instruction for dans l'ordre inverse.

** 2, méthode de prédiction, méthode de perte, méthode de précision, implémentation de l'expression de gradient à l'aide de la couche **

from collections import OrderedDict
class LayerNet:
    def __init__(self, input_size, hiden_size, output_size, weight_init_std = 0.01):
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hiden_size)
        self.params['b1'] = np.zeros(hiden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hiden_size, output_size)
        self.params['b2'] = np.zeros(output_size)

        #Génération de couches
        self.layers = OrderedDict()#Dictionnaire ordonné
        self.layers['Affine1'] = Affine(self.params['W1'],self.params['b1']) #Créez tous les calques affines sur le premier calque du calque du milieu
        self.layers['Relu1'] = Relu()#Créez tous les calques Relu sur le premier calque du calque du milieu
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2']) #Créez tous les calques affines dans le deuxième calque du calque du milieu
        self.layers['Relu2'] = Relu() #Créez tous les calques Relu pour le deuxième calque du calque du milieu
        self.lastLayer = SoftmaxWithLoss() #Création de couche de la couche de sortie à la fonction de perte

    def predict(self, x): #Effectue un traitement de propagation avant vers la couche intermédiaire du réseau neuronal
        for layer in self.layers.values():
            x = layer.forward(x) #Traitez les couches ordonnées dans l'ordre avec l'instruction for
        
        return x
    
    def loss(self, x, t): #Effectue le traitement de propagation avant du réseau neuronal à la fonction de perte
        y = self.predict(x) #Produire des données de prévision
        
        return self.lastLayer.forward(y,t) #Effectue le traitement de propagation avant de la couche de sortie à la fonction de perte
    
    def accuracy(self,x, t): #Donnez le taux de réponse correct
        y = self.predict(x)
        y = np.argmax(y, axis=1) #Mettez l'étiquette de la prédiction de réponse correcte à partir des données de prédiction
        if t.ndim != 1 : t = np.argmax(t, axis=1) #Les bonnes réponses en sont une_S'il fait chaud, changez-le en un tableau unidimensionnel
        
        accuracy = np.sum(y == t) /float(x.shape[0]) #Donnez le taux de réponse correct
        
        return accuracy
    
    def gradient(self, x, t): #Formule de dégradé utilisant la rétropropagation des calques
        #forward
        self.loss(x, t)
        
        #backward
        dout = 1
        dout = self.lastLayer.backward(dout) #Rétropropagation des couches de la couche de sortie à la fonction de perte
        
        layers = list(self.layers.values())
        layers.reverse() #Inverser l'ordre
        
        for layer in layers: #Effectuer le traitement de rétropropagation de la couche à droite de la couche intermédiaire
            dout = layer.backward(dout)
        
        #Récupération de gradient
        grads = {}
        grads['W1'] = self.layers['Affine1'].dW
        grads['b1'] = self.layers['Affine1'].db
        grads['W2'] = self.layers['Affine2'].dW
        grads['b2'] = self.layers['Affine2'].db
        
        return grads
    

La méthode de prédiction effectue un traitement de propagation directe du réseau neuronal. Comme je l'ai écrit un peu plus tôt, le traitement de propagation vers l'avant peut être effectué en utilisant l'instruction for dans OrderDict, en exécutant la méthode de transfert dans l'ordre et en renvoyant la valeur de sortie avec return.

Étant donné que la méthode de perte exécute la méthode de prédiction plus la fonction d'activation et la fonction de perte de la couche de sortie, elle peut être mise en œuvre en utilisant le résultat comme l'avant de la dernière couche après avoir exécuté la méthode de prédiction.

La précision est la même que pour la différenciation numérique, veuillez donc vous y référer.

Étant donné que l'expression de gradient utilisant des couches peut être rétropropagée par le réseau de neurones, elle est implémentée en inversant d'abord l'ordre de OrderDict avec la méthode inverse, puis en procédant à l'envers avec l'instruction for dans l'ordre, et en retournant le résultat avec return. pouvez.

Recommended Posts

[Deep Learning from scratch] Implémentez le traitement de rétropropagation dans le réseau neuronal par la méthode de propagation de retour d'erreur
[Deep Learning from scratch] À propos des couches requises pour implémenter le traitement de rétropropagation dans un réseau neuronal
[Deep Learning from scratch] Accélération du réseau de neurones J'ai expliqué le traitement de la propagation arrière
Version Lua Apprentissage profond à partir de zéro Partie 6 [Traitement d'inférence de réseau neuronal]
Apprentissage profond à partir de zéro (propagation vers l'avant)
"Deep Learning from scratch" avec Haskell (inachevé)
Apprentissage profond / rétropropagation d'erreur de la fonction sigmoïde
[Python] [Traitement du langage naturel] J'ai essayé le Deep Learning ❷ fait de toutes pièces en japonais ①
[Deep Learning from scratch] Valeur initiale du poids du réseau neuronal utilisant la fonction sigmoïde
Méthode de propagation des erreurs (rétro-propagation)
Apprentissage profond à partir de zéro
Implémenter le réseau neuronal à partir de zéro
[Deep Learning] Exécuter la console de réseau neuronal SONY à partir de CUI
[Deep Learning from scratch] Poids initial du réseau neuronal lors de l'utilisation de la fonction Relu
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Apprentissage profond à partir de zéro 1 à 3 chapitres
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 1
Chapitre 3 Réseau de neurones Ne découpez que les bons points de Deeplearning à partir de zéro
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
Un amateur a trébuché dans le Deep Learning à partir de zéro.
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 2
J'ai essayé d'implémenter Perceptron Part 1 [Deep Learning from scratch]
Chapitre 7 [Méthode de propagation des erreurs] P275 ~ (Milieu) [Apprenez en vous déplaçant avec Python! Nouveau manuel d'apprentissage automatique]
[Deep Learning from scratch] Principales méthodes de mise à jour des paramètres pour les réseaux neuronaux
Pourquoi ModuleNotFoundError: Aucun module nommé'dataset.mnist 'n'apparaît dans "Deep Learning from scratch".
Apprentissage profond à partir de zéro (calcul des coûts)
Mémo d'apprentissage profond créé à partir de zéro
Apprentissage en profondeur / rétropropagation de l'erreur de produit matriciel
[Deep Learning from scratch] J'ai essayé d'implémenter la couche sigmoïde et la couche Relu
Python vs Ruby «Deep Learning from scratch» Chapitre 2 Circuit logique par Perceptron
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
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]
Deep learning / Deep learning made from scratch Chapitre 7 Mémo
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
Version Lua Deep Learning from scratch Part 5.5 [Rendre les fichiers pkl disponibles dans Lua Torch]
[Pour les débutants] Après tout, qu'est-ce qui est écrit dans Deep Learning fait à partir de zéro?
Mémo d'auto-apprentissage "Deep Learning from scratch" (glossaire illisible)
[Python / Machine Learning] Pourquoi le Deep Learning # 1 Perceptron Neural Network
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
GitHub du bon livre "Deep Learning from scratch"
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 ~
Python: apprentissage profond du traitement du langage naturel: principes de base
Résumé Python vs Ruby "Deep Learning from scratch"
Mémo d'auto-apprentissage «Deep Learning from scratch» (10) Classe MultiLayerNet
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 11) CNN