[PYTHON] Comparaison de la régularisation L1 et Leaky Relu

Nous avons comparé les effets de la régularisation L1 et Leaky Relu sur la rétropropagation des erreurs. Il est expliqué que la régularisation L1 est utilisée pour la compression de dimension qui élimine les variables explicatives inutiles dans l'apprentissage automatique. D'autre part, LeakyRelu est une fonction d'activation qui empêche l'apprentissage de s'arrêter même dans plusieurs couches en donnant une légère inclinaison même lorsque x est négatif. Je ne sais même pas pourquoi j'ai comparé ces choses totalement indépendantes.

Rétropropagation de l'accouplement complet normal

python

x1 = Input(shape=(124,))
x2 = Dense(100)(x1)
x3 = Activation('relu')(x2)
y = Dense(10)(x3)

model.compile(loss='mean_squared_error')

\begin{align}
x_1 &= input\\
x_2 &= Ax_1 + B\\
x_3 &= relu(x_2)\\
y &= Cx_3+D\\
L_{mse} &= \frac{1}{2}(t-y)^2\\
\end{align}

On suppose que la fonction de perte, la fonction d'activation et le calcul de la connexion totale sont exécutés comme décrit ci-dessus. Dans ce cas, chaque formule différentielle partielle est

\begin{align}
\frac{\partial L_{mse}}{\partial y} &= -(t - y)\\
\frac{\partial y}{\partial C} &= x_3\\
\frac{\partial y}{\partial D} &= 1\\
\frac{\partial y}{\partial x_3} &= C\\
\frac{\partial x_3}{\partial x_2} &= H(x_2)\\
 H(x)&=\left\{
\begin{array}{ll}
1 & (x \geq 0) \\
0 & (x \lt 0)
\end{array}
\right.\\
\frac{\partial x_2}{\partial A} &= x_1\\
\frac{\partial x_2}{\partial B} &= 1\\
\end{align}

À partir des poids du modèle $ A, B, C, D $ sont mis à jour à l'aide de la règle de chaîne

\begin{align}
\frac{\partial L_{mse}}{\partial A} &= \frac{\partial L_{mse}}{\partial y}\frac{\partial y}{\partial x_3}\frac{\partial x_3}{\partial x_2}\frac{\partial x_2}{\partial A}\\
&=-(t - y)\cdot C \cdot H(x_2) \cdot x_1\\ 
\frac{\partial L_{mse}}{\partial B} &= \frac{\partial L_{mse}}{\partial y}\frac{\partial y}{\partial x_3}\frac{\partial x_3}{\partial x_2}\frac{\partial x_2}{\partial B}\\
&=-(t - y)\cdot C \cdot H(x_2) \\ 
\frac{\partial L_{mse}}{\partial C} &= \frac{\partial L_{mse}}{\partial y}\frac{\partial y}{\partial C}\\
&=-(t - y)\cdot x_3 \\
\frac{\partial L_{mse}}{\partial D} &= \frac{\partial L_{mse}}{\partial y}\frac{\partial y}{\partial D}\\
&=-(t - y)\\
\end{align}

Peut être affiché comme.

Rétropropagation de couches entièrement connectées de régularisation L1

À Keras, la régularisation a les trois suivants. ・ Kenel_regularizer ・ Bias_regularizer ・ Activity_regularizer https://keras.io/ja/regularizers/

En termes de coefficients de la première couche entièrement connectée $ x_2 = Ax_1 + B $ dans la section précédente, kernel_regularizer a un poids de $ A $, bias_regularizer a un poids de $ B $, et activity_regularizer a une régularisation de la sortie $ x_2 $. Je le ferai. Dans ce cas, la régularisation L1 ajoute la valeur absolue de la variable multipliée par un petit coefficient supplémentaire $ \ lambda $ à la fonction de perte. Chaque\lambda |A|、\lambda |B|、\lambda |x_2|。 En revanche, la régularisation L2 ajoute le carré de la variable multiplié par un petit coefficient $ \ lambda $ à la fonction de perte. $ \ Lamb A ^ 2 $, $ \ lambda B ^ 2 $, $ \ lambda x_2 ^ 2 $, respectivement.

Voici l'activité de régularisation L1_regularizer、\lambda |x_2|Penser à. Considérant la fonction de perte supplémentaire comme suit|x|Différenciation dex>0alors1、x<0alors-1Alors

L_{L1} = \lambda |x_2| \\
\frac{\partial |x|}{\partial x} = \left\{
\begin{array}{ll}
1 & (x \geq 0) \\
-1 & (x \lt 0)
\end{array}
\right.\\
 H(x)=\left\{
\begin{array}{ll}
1 & (x \geq 0) \\
0 & (x \lt 0)
\end{array}
\right.\\
\frac{\partial L_{L1}}{\partial x_2} = \lambda(2H(x_2)-1)\\

Par conséquent, le changement du montant de mise à jour des pondérations du modèle $ A, B, C, D $ dû à l'activité_réguliseur de régularisation L1 est

\begin{align}
\frac{\partial L_{L1}}{\partial A} &= \frac{\partial L_{L1}}{\partial x_2}\frac{\partial x_2}{\partial A}\\
&=\lambda(2H(x_2)-1) \cdot x_1\\ 
\frac{\partial L_{L1}}{\partial B} &= \frac{\partial L_{L1}}{\partial x_2}\frac{\partial x_2}{\partial B}\\
&=\lambda(2H(x_2)-1) \\ 
\frac{\partial L_{L1}}{\partial C} &= 0\\
\frac{\partial L_{L1}}{\partial D} &= 0\\
\end{align}

L'explication que la régularisation L1 est utilisée pour la compression de dimension est l'activité._noyau au lieu de régulariseur_de régularisateurL_{L1} = \lambda |A|Ceci est une explication lorsque l'on considère le terme de perte de régularisation L1 de.

python

x1 = Input(shape=(124,))
x2 = Dense(100, activity_regularizer=regularizers.l1(0.01))(x1)
x3 = Activation('relu')(x2)
y = Dense(10)(x3)

model.compile(loss='mean_squared_error')

Rétropropagation de la couche entièrement connectée de Leaky Relu

LeakyRelu est une fonction d'activation comme suit. Généralement $ \ alpha ≪1 $

 LeakyRelu(x)=\left\{
\begin{array}{ll}
x & (x \geq 0) \\
\alpha x & (x \lt 0)
\end{array}
\right.\\
\frac{\partial LeakyRelu(x)}{\partial x}
 =\left\{
\begin{array}{ll}
1 & (x \geq 0) \\
\alpha  & (x \lt 0)
\end{array}
\right.\\

De

 H(x)=\left\{
\begin{array}{ll}
1 & (x \geq 0) \\
0 & (x \lt 0)
\end{array}
\right.\\

Leaky Relu et la différence de gradient Relu normale en utilisant

\begin{align}
\frac{\partial LeakyRelu(x)}{\partial x} &=(1-\alpha )H(x) + \alpha \\
\frac{\partial LeakyRelu(x)}{\partial x}-\frac{\partial Relu(x)}{\partial x} 
 &=((1-\alpha )H(x) + \alpha )-H(x)\\
&=-\alpha (H(x) -1)\\
\end{align}

Peut être écrit. Par conséquent, la modification du montant de mise à jour des pondérations du modèle $ A, B, C, D $ due à Relu => LeakyRelu est

\begin{align}
\frac{\partial L_{mse}}{\partial A} &=(t - y)\cdot C \cdot \alpha (H(x_2)-1) \cdot x_1\\ 
\frac{\partial L_{mse}}{\partial B} &=(t - y)\cdot C \cdot \alpha (H(x_2)-1) \\ 
\frac{\partial L_{mse}}{\partial C} &= 0\\
\frac{\partial L_{mse}}{\partial D} &= 0\\
\end{align}

Peut être affiché comme. Aussi, si vous osez transformer cela, ce sera comme suit. Ici, les deux éléments ne sont que la rétropropagation d'erreur normale multipliée par $ \ alpha $, ils seront donc ignorés à partir de maintenant.

\begin{align}
\frac{\partial L_{mse}}{\partial A} &=(t - y)\cdot C \cdot \alpha (2H(x_2)-1) \cdot x_1-[\alpha (t - y)\cdot C \cdot H(x_2) \cdot x_1]\\ 
\frac{\partial L_{mse}}{\partial B} &=(t - y)\cdot C \cdot \alpha (2H(x_2)-1)-[\alpha (t - y)\cdot C \cdot H(x_2)] \\ 
\frac{\partial L_{mse}}{\partial C} &= 0\\
\frac{\partial L_{mse}}{\partial D} &= 0\\
\end{align}

python

x1 = Input(shape=(124,))
x2 = Dense(100)(x1)
x3 = LeakyReLU(alpha=0.01)(x2)
y = Dense(10)(x3)

model.compile(loss='mean_squared_error')

Comparaison

Comparons les changements par rapport à la rétropropagation normale. Ici, $ \ lambda << 1, \ alpha << 1 $ sont tous les deux suffisamment inférieurs à 1.

• Modifications dues à activity_regularizer de la régularisation L1

\begin{align}
\frac{\partial L_{L1}}{\partial A} &=\lambda(2H(x_2)-1) \cdot x_1\\ 
\frac{\partial L_{L1}}{\partial B} &=\lambda(2H(x_2)-1) \\ 
\frac{\partial L_{L1}}{\partial C} &= 0\\
\frac{\partial L_{L1}}{\partial D} &= 0\\
\end{align}

--Relu => Changements dus à Leaky Relu

\begin{align}
\frac{\partial L_{mse}}{\partial A} &=(t - y)\cdot C \cdot \alpha (2H(x_2)-1) \cdot x_1\\ 
\frac{\partial L_{mse}}{\partial B} &=(t - y)\cdot C \cdot \alpha (2H(x_2)-1) \\ 
\frac{\partial L_{mse}}{\partial C} &= 0\\
\frac{\partial L_{mse}}{\partial D} &= 0\\
\end{align}

Ici, le changement dû à Relu => LeakyRelu ne peut pas être considéré comme nul car $ (t --y) \ cdot C $ ne peut pas être considéré comme nul. En revanche, si l'apprentissage progresse suffisamment et que $ (t --y) \ cdot C $ s'approche de zéro, peut-on considérer que le activity_regularizer de régularisation L1 s'affaiblit? J'y ai pensé. Cependant, le changement dans activity_regularizer de la régularisation L1 est lié uniquement au calque auquel la régularisation est appliquée, mais le changement dû à Relu => LeakyRelu est également transmis au calque avant la fonction d'activation.

De plus, s'il n'y a que deux éléments qui changent en raison de Relu => LeakyRelu, ce sera le montant obtenu en multipliant la propagation normale de l'erreur par $ \ alpha $.

--Relu => Leaky Relu change en deux éléments

\begin{align}
\frac{\partial L_{mse}}{\partial A} &=-\alpha (t - y)\cdot C \cdot H(x_2) \cdot x_1\\ 
\frac{\partial L_{mse}}{\partial B} &=-\alpha (t - y)\cdot C \cdot H(x_2) \\ 
\frac{\partial L_{mse}}{\partial C} &= 0\\
\frac{\partial L_{mse}}{\partial D} &= 0\\
\end{align}

Combiné au dégradé d'origine et multiplié par la fonction d'activation de LeakyRelu, tous les dégradés précédents sont $ (1 + \ alpha) $ fois plus grands. Il est suggéré que si le modèle est profond, le remplacement de toutes les fonctions Relu par des fonctions LeakyRelu peut augmenter le gradient de la couche peu profonde plus proche de l'entrée de manière logicielle de $ (1 + \ alpha) ^ n $.

Résumé:

Nous avons comparé la régularisation L1 et Leaky Relu. Je pensais que le changement dû à Relu => LeakyRelu était le changement dû à la régularisation L1 de activity_regularizer et le gradient avant que la fonction d'activation soit multiplié par $ (1 + \ alpha) $. Cette interprétation suppose que LeakyRel est la somme des fonctions suivantes.

\begin{align}
 LeakyRelu(x)&=\left\{
\begin{array}{ll}
x & (x \geq 0) \\
\alpha x & (x \lt 0)
\end{array}
\right.\\
&=\left\{
\begin{array}{ll}
(1+\alpha )x & (x \geq 0) \\
0 & (x \lt 0)
\end{array}
\right.  - \alpha|x|\\
&=(1+\alpha )Relu(x)- \alpha|x|
\end{align}