[PYTHON] Introduction au Deep Learning ~ Propagation vers l'avant ~

Personne cible

Ceci est un article de [Deep Learning Series](#Deep Learning Series). L'article précédent était ici. Ici, nous allons d'abord expliquer la théorie de la propagation directe en scalaire, puis l'étendre à une matrice. Il sera ajouté ou modifié au code introduit dans l'article précédent, veuillez donc d'abord récupérer le code de l'article précédent ~

table des matières

• [Propagation avant avec scalaire](# Propagation avant avec scalaire)
• [Théorie de la propagation directe en scalaire](# Théorie de la propagation directe en scalaire)
• [Implémentation de propagation avant en scalaire](implémentation de propagation #Forward en scalaire)
• [Propagation vers l'avant dans la matrice](# Propagation vers l'avant dans la matrice)
• [Théorie de la propagation directe en matrice](# Théorie de la propagation directe en matrice)
• [Implémentation de propagation directe dans la matrice](# Implémentation de propagation directe dans la matrice)
• [Implémentation de la méthode __init__](Implémentation de la méthode #init)
• [À propos du fonctionnement de la matrice](# À propos du fonctionnement de la matrice)
• [Somme de la matrice](# Somme de la matrice)
• [Produit élément Matrix](# Produit élément Matrice)
• [Produit Matrix](# Produit Matrix)
• Transfert

Propagation vers l'avant en scalaire

Cette section décrit la théorie et l'implémentation de la propagation directe en scalaires (nombres réels). Cependant, c'est presque comme déjà mentionné dans Basics.

Théorie de la propagation directe en scalaire

La première est la théorie. Commençons par ce modèle neuronal. Lorsque cela est formulé, $ f (x) = \ sigma (wx + b) $ est obtenu comme décrit dans [ici](https://qiita.com/kuroitu/items/221e8c477ffdd0774b6b#activation function). est. En passant la fonction d'activation $ \ sigma (•) $, elle est rendue non linéaire et a le sens de couches superposées. Alors, à quoi ressemblerait cette opération dans un graphe de calcul?

Je me sens comme cela. Jusqu'à présent, l'entrée n'était que de $ x $ et d'autres éléments étaient omis, mais dans le graphique de calcul, ** poids $ w $ ** et ** biais (seuil) $ b $ ** sont également décrits correctement et actifs. Il peut être réécrit en sortie via une fonction de conversion. Ces variables $ x, w, b, y $ sont les variables que devraient avoir les objets neurones. De plus, en ce qui concerne les fonctions d'activation, Python peut stocker des fonctions et des classes en tant qu'objets dans des variables, il semble donc bon que l'implémentation puisse être encapsulée en l'incluant dans un objet neurone. C'est tout pour la théorie de la propagation directe dans les scalaires. C'est simple et agréable ~.

Implémentation de propagation directe en scalaire

Mettons-le en œuvre. Le code à implémenter est [baselayer.py](https://qiita.com/kuroitu/items/884c62c48c2daa3def08#layer préparation du code du module).

    def forward(self, x):
        """
Mise en œuvre de la propagation directe
        """
        #Souvenez-vous de votre entrée
        self.x = x.copy()

        #Propagation vers l'avant
        y = self.w * x + self.b
        self.y = self.act.forward(y)
        
        return self.y

La propagation vers l'avant elle-même est extrêmement facile, n'est-ce pas? Selon la formule. C'est tout pour l'implémentation scalaire. Ensuite, considérons l'implémentation avec un vecteur (plutôt qu'une matrice).

Propagation directe dans une matrice

Ensuite, considérez la propagation vers l'avant dans une matrice. La matrice est stricte si vous ne connaissez pas le concept de produit matriciel de l'algèbre linéaire, donc si vous ne le connaissez pas, je l'expliquerai brièvement dans [ici](# About Matrix operation).

Théorie de la propagation directe dans une matrice

Tout d'abord, pensons à un objet de couche qui ressemble à une pile de deux objets neurones. Je ne pouvais pas penser à une bonne expression de la figure, alors je vais l'expliquer un instant. Tout d'abord, les flèches noires acceptent la compréhension que ce sont des objets neuronaux. Ce sont les flèches d'autres couleurs. La flèche bleu clair </ font> représente la synapse qui relie le neurone supérieur au neurone inférieur. Multipliez le poids bleu clair $ w_ {1, 2} $ </ font> lorsqu'il passe par le nœud de multiplication du milieu et joignez-le au nœud d'addition inférieur. La même chose est vraie pour flèche rouge </ font>. Multipliez le poids rouge $ w_ {2, 1} $ </ font> lorsqu'il passe par le nœud de multiplication du milieu et joignez-le au nœud d'addition supérieur. L'entrée du nœud d'addition est devenue trois, mais elle peut être décomposée en deux entrées en utilisant plusieurs nœuds d'addition, veuillez donc considérer qu'elle est omise. Suivons cela avec une formule mathématique. Dans ce qui suit, pour simplifier, $ \ sigma_i (•) $ est une fonction égale. Tout d'abord, je vais l'écrire.

y_1 = w_{1, 1}x_1 + w_{2, 1}x_2 + b_1 \\
y_2 = w_{1, 2}x_1 + w_{2, 2}x_2 + b_2

\left(
  \begin{array}{c}
    y_1 \\
    y_2
  \end{array}
\right)
=
\left(
  \begin{array}{cc}
    w_{1, 1} & w_{2, 1} \\
    w_{1, 2} & w_{2, 2}
  \end{array}
\right)
\left(
  \begin{array}{c}
    x_1 \\
    x_2
  \end{array}
\right)
+
\left(
  \begin{array}{c}
    b_1 \\
    b_2
  \end{array}
\right)

\left(
  \begin{array}{c}
    y_1 \\
    y_2
  \end{array}
\right)
=
\left(
  \begin{array}{cc}
    w_{1, 1} & w_{1, 2} \\
    w_{2, 1} & w_{2, 2}
  \end{array}
\right)^{\top}
\left(
  \begin{array}{c}
    x_1 \\
    x_2
  \end{array}
\right)
+
\left(
  \begin{array}{c}
    b_1 \\
    b_2
  \end{array}
\right) \\
\Leftrightarrow
\boldsymbol{Y} = \boldsymbol{W}^{\top}\boldsymbol{X} + \boldsymbol{B}

\boldsymbol{Y} = \boldsymbol{W}^{\top}\boldsymbol{X} + \boldsymbol{B}

\underbrace{\boldsymbol{Y}}_{N \times 1} = \underbrace{\boldsymbol{W}^{\top}}_{N \times M}\underbrace{\boldsymbol{X}}_{M \times 1} + \underbrace{\boldsymbol{B}}_{N \times 1}

    def forward(self):
        """
Mise en œuvre de la propagation directe
        """
        #Souvenez-vous de votre entrée
        self.x = x.copy()

        #Propagation vers l'avant
        y = self.w.T @ x + self.b
        self.y = self.act.forward(y)
        
        return self.y

        y = self.w * x + self.b

        y = self.w.T @ x + self.b

x = np.array([1, 2])
w = np.array([[1, 0], [0, 1]])
b = np.array([1, 1])

y = w.T @ x + b
print(y)
print(y == np.dot(w.T, x) + b)

#----------
#La sortie est
# [2 3]
# [ True  True]
#Ce sera.

x = np.matrix([1, 2]).reshape(2, -1)
w = np.matrix([[1, 0], [0, 1]])
b = np.matrix([1, 1]).reshape(2, -1)

y = w.T @ x + b
print(y)
print(y == np.dot(w.T, x) + b)

#----------
#La sortie est
# [[2]
#  [3]]
# [[ True]
#  [ True]]
#Ce sera.

    def __init__(self, *, prev=1, n=1, 
                 name="", wb_width=1,
                 act="ReLU",
                 **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)

\left(
  \begin{array}{cc}
    a & b \\
    c & d
 \end{array}
\right)
+
\left(
  \begin{array}{cc}
    A & B \\
    C & D
  \end{array}
\right)
=
\left(
  \begin{array}{cc}
    a + A & b + B \\
    c + C & d + D
  \end{array}
\right)

\left(
  \begin{array}{cc}
    a & b \\
    c & d
 \end{array}
\right)
\otimes
\left(
  \begin{array}{cc}
    A & B \\
    C & D
  \end{array}
\right)
=
\left(
  \begin{array}{cc}
    aA & bB \\
    cC & dD
  \end{array}
\right)

\left(
  \begin{array}{cc}
    a & b \\
    c & d
 \end{array}
\right)
\left(
  \begin{array}{cc}
    A & B \\
    C & D
  \end{array}
\right)
=
\left(
  \begin{array}{cc}
    aA + bC & aB + bD \\
    cA + dC & cB + dD
  \end{array}
\right)

\left(
  \begin{array}{cc}
    a & b & c \\
    d & e & f
 \end{array}
\right)^{\top}
=
\left(
  \begin{array}{cc}
    a & d \\
    b & e \\
    c & f
 \end{array}
\right)