** << Attention >> ** ** Parce que les hauteurs sont alignées de force, "$ \ frac {} {} $" est mélangé à certains endroits. S'il vous plaît laissez-moi savoir s'il existe un bon moyen. De plus, il existe d'autres façons d'ajouter de la couleur à la formule ... **

Ce sera. Si l'erreur $ E $ de l'amont est passée par là, la propagation arrière sera comme indiqué sur la figure. Après tout, il existe de nombreuses formules et cela semble compliqué, c'est-à-dire qu'il ne multiplie le différentiel partiel qu'en passant par le nœud de calcul **. ** ** Même ceci est un scalaire, donc cela peut être plus facile.

Implémentation de la rétropropagation en scalaire

Mettons-le en œuvre. Codez selon la formule. Le code de destination de l'implémentation est [ici](https://qiita.com/kuroitu/items/884c62c48c2daa3def08#layer préparation du code du module).

baselayer.py

    def backward(self, grad):
        """
Mise en œuvre de la rétropropagation
        """
        dact = grad*self.act.backward(self.x, self.y)
        self.dw = dact*self.x
        self.db = dact
        self.dx = dact*self.w

        return self.dx

La couche intermédiaire est correcte telle quelle, mais il est nécessaire d'ajouter un traitement pour la couche de sortie. J'y reviendrai plus tard.

Rétropropagation dans une matrice

Ensuite, considérons la rétro-propagation dans une matrice. C'est beaucoup de formules et difficile, mais vous pouvez le voir si vous le suivez correctement. Comme précédemment, j'ajouterai de la couleur à la formule pour qu'elle soit visible en un coup d'œil. ~~ Je me sens lourd ... ~~

Théorie de la rétropropagation dans une matrice

Considérez le graphique de calcul suivant. C'est le même que celui utilisé dans [Forward Propagation](https://qiita.com/kuroitu/items/d22c8750e34d5d75fb6c# Forward Propagation in Matrix). C'est un modèle de couche avec seulement 2 neurones, mais comme vous pouvez le voir, il y a pas mal de formules. Tout d'abord, trouvons la différenciation partielle de chaque partie comme dans le cas du scalaire.

\Rightarrow
\boldsymbol{dW} =
\left(
  \begin{array}{cc}
    \cfrac{\partial y_1}{\partial w_{1, 1}} & \cfrac{\partial y_2}{\partial w_{1, 2}} \\
    \cfrac{\partial y_1}{\partial w_{2, 1}} & \cfrac{\partial y_2}{\partial w_{2, 2}}
  \end{array}
\right)
=
\left(
  \begin{array}{c}
    x_1 \\
    x_2
  \end{array}
\right)
\left(
  \begin{array}{cc}
    \sigma'_1(m) & \sigma'_2(q)
  \end{array}
\right)
=
\boldsymbol{X}^{\top}\boldsymbol{\sigma'}

\Rightarrow
\boldsymbol{dB} =
\left(
  \begin{array}{cc}
    \cfrac{\partial y_1}{\partial b_1} & \cfrac{\partial y_2}{\partial b_2}
  \end{array}
\right)
=
\left(
  \begin{array}{cc}
     \sigma'_1(m) & \sigma'_2(q)
  \end{array}
\right)

\Rightarrow
\boldsymbol{dX} =
\left(
  \begin{array}{cc}
    \cfrac{\partial y_1}{\partial x_1} + \cfrac{\partial y_2}{\partial x_1} & \cfrac{\partial y_1}{\partial x_2} + \cfrac{\partial y_2}{\partial x_2}
  \end{array}
\right)
=
\left(
  \begin{array}{cc}
    \sigma'_1(m) & \sigma'_2(q)
  \end{array}
\right)
\left(
  \begin{array}{cc}
    w_{1, 1} & w_{2, 1} \\
    w_{1, 2} & w_{2, 2}
  \end{array}
\right)
=
\boldsymbol{\sigma'}\boldsymbol{W}^{\top}

On dirait. Ajoutez l'erreur en amont à ces [élément produit](https://qiita.com/kuroitu/items/d22c8750e34d5d75fb6c#%E8%A1%8C%E5%88%97%E3%81%AE%E8%A6%81 En multipliant par% E7% B4% A0% E7% A9% 8D), l'erreur comme indiqué dans la figure ci-dessus se propage. Comme vous pouvez le voir du fait que $ x_1 $ et $ x_2 $ ont été branchés et que les valeurs ont été envoyées à d'autres nœuds de calcul, les différentiels partiels qui ont coulé doivent être ajoutés et calculés. Donc </ font>

\left(
  \begin{array}{cc}
    \cfrac{\partial y_1}{\partial x_1} + \cfrac{\partial y_2}{\partial x_1} & \cfrac{\partial y_1}{\partial x_2} + \cfrac{\partial y_2}{\partial x_2}
  \end{array}
\right)

\begin{align}
  \underbrace{\boldsymbol{dW}}_{L \times M} &= \underbrace{\boldsymbol{X}^{\top}}_{L \times N} \underbrace{\boldsymbol{\sigma'}}_{N \times M} \\
  \underbrace{\boldsymbol{dB}}_{1 \times M} &= \underbrace{\boldsymbol{\sigma'}}_{N\times M} \\
  \underbrace{\boldsymbol{dX}}_{N \times L} &= \underbrace{\boldsymbol{\sigma'}}_{N \times M} \underbrace{\boldsymbol{W}^{\top}}_{M \times L}
\end{align}

\underbrace{\boldsymbol{dB}}_{1 \times M} = \sum_{i=1}^{N}{\underbrace{\boldsymbol{\sigma'}_i}_{1\times M}} \xrightarrow{\textrm{coding}} \textrm{sum}(\boldsymbol{\sigma'}, \textrm{axis}=0)

    def backward(self, grad):
        """
Mise en œuvre de la rétropropagation
        """
        dact = grad*self.act.backward(self.x, self.y)
        self.dw = self.x.T@dact
        self.db = np.sum(dact, axis=0)
        self.dx = [email protected]

        return self.dx

    def backward(self, t):
        """
Mise en œuvre de la rétropropagation
        """
        #Lorsque la fonction d'activation de la couche de sortie est la fonction softmax et la fonction de perte est l'erreur d'entropie croisée
        #Cas séparés de propagation d'erreur
        if isinstance(self.act, Softmax) \
        and isinstance(self.errfunc, CrossEmtropy):
            dact = self.y - t
            self.dw = self.x.T@dact
            self.db = np.sum(dact, axis=0)
            self.dx = [email protected]
            
            return self.dx
        else:
            grad = self.errfunc.backward(self.y, t)
            return super().__init__(grad)

    def __init__(self, *, prev=1, n=1, 
                 name="", wb_width=1,
                 act="ReLU", err_func="square",
                 **kwds):
        self.prev = prev  #Nombre de sorties de la couche précédente=Nombre d'entrées dans cette couche
        self.n = n        #Nombre de sorties dans cette couche=Nombre d'entrées vers la couche suivante
        self.name = name  #Le nom de cette couche

        #Définir le poids et le biais
        self.w = wb_width*np.random.randn(prev, n)
        self.b = wb_width*np.random.randn(n)

        #Fonction d'activation(classe)Avoir
        self.act = get_act(act)

        #Fonction de perte(classe)Avoir
        self.errfunc = get_errfunc(err_func)