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