Fonctions d'apprentissage en profondeur / d'activation

1.Tout d'abord

En termes simples, la riche expressivité des réseaux de neurones provient de l'imbrication de fonctions d'activation simples dans des hiérarchies profondes.

Cette fois, je vais résumer ce que j'ai appris sur la fonction d'activation utilisée dans les réseaux de neurones.

2. Fonction sigmoïde

#Fonction Sigmaid
def sigmoid(x):
    return 1 / (1 + np.exp(-x))   

#Différenciation de la fonction sigmoïde
def sigmoid_d(x):
    return (1 / (1 + np.exp(-x))) * ( 1- (1 / (1 + np.exp(-x))))

#affichage graphique
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, sigmoid(x), label='sigmoid')
plt.plot(x, sigmoid_d(x), label='sigmoid_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** fonction sigmoïde: **

sigmoid(x) = \frac{1}{1+e^{-x}}

** Différenciation de la fonction sigmoïde: **

sigmoid'(x) = \frac{1}{1+e^{-x}} * ( 1 - \frac{1}{1+e^{-x}})

La fonction sigmoïde a toujours été incluse dans les manuels des réseaux neuronaux depuis longtemps, et bien qu'elle ait une belle forme qui ne change guère même lorsqu'elle est différenciée, elle est rarement utilisée comme fonction d'activation de nos jours.

La raison en est que, comme vous pouvez le voir sur le graphique, à mesure que la valeur de x augmente, y reste à 1 et reste bloqué. En effet, le réseau de neurones différencie y pour obtenir la pente et optimise le paramètre de poids, donc lorsque la différenciation devient presque 0, il a le problème qu'il ne peut pas s'approcher de la solution optimale (disparition du gradient).

** Dérivation de la différenciation de la fonction sigmoïde **

sigmoid'(x) = ((1 + e^{-x})^{-1})'\\

En différenciant la fonction composite, u= 1+e^{-x}Si vous mettez\frac{dy}{dx}=\frac{dy}{du}\frac{du}{dx}Alors\\

= -(1 + e^{-x})^{-2} * (1+e^{-x})'\\

= -\frac{1}{(1+e^{-x})^2} * -e^{-x}\\

= \frac{1}{1+e^{-x}} * \frac{e^{-x}}{1+e^{-x}} \\

= \frac{1}{1+e^{-x}} * (\frac{1+e^{-x}}{1+e^{-x}} - \frac{1}{1+e^{-x}})\\

= \frac{1}{1+e^{-x}} * ( 1 - \frac{1}{1+e^{-x}})

3. fonction tanh

#Fonction Tanh
def tanh(x):
    return (np.exp(x) -np.exp(-x)) / (np.exp(x) + np.exp(-x))

#Différenciation de la fonction Tanh
def tanh_d(x):
    return 1- ( (np.exp(x) -np.exp(-x)) / (np.exp(x) + np.exp(-x)) )**2

#affichage graphique
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, tanh(x), label='tanh')
plt.plot(x, tanh_d(x), label='tanh_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** Fonction Tanh: **

tanh(x) = \frac{e^x-e^{-x}}{e^x+e^{-x}}

** Différenciation de la fonction Tanh: **

tanh(x) = \frac{4}{(e^x + e^{-x})^2}\\

La fonction Tanh a été utilisée comme une version améliorée de la fonction sigmoïde (la valeur maximale lorsqu'elle est différenciée est supérieure à sigmoïde), mais le problème fondamental selon lequel y reste à 1 lorsque x augmente n'a pas été amélioré. ..

** Dérivation de la différenciation de la fonction Tanh **

Formule de différenciation du quotient(\frac{f(x)}{g(x)})' = \frac{f'(x)*g(x) - f(x)*g'(x)}{g(x)^2}Avec\\

tanh'(x) = \frac{(e^x+e^{-x})^2 - (e^x - e^{-x})^2}{(e^x + e^{-x})^2}\\

= \frac{e^{2x}+2+e^{-2x} - (e^{2x} -2 + e^{-2x})}{(e^x + e^{-x})^2}\\

= \frac{4}{(e^x + e^{-x})^2}\\

Ou

tanh'(x) = \frac{(e^x+e^{-x})^2 - (e^x - e^{-x})^2}{(e^x + e^{-x})^2}\\

= 1 - \frac{(e^x - e^{-x})^2}{(e^x + e^{-x})^2}\\

= 1 - (\frac{e^x - e^{-x}}{e^x + e^{-x}})^2\\

4. Fonction ReLU

#Fonction ReLU
def relu(x):
    return np.maximum(0, x)

#Différenciation de la fonction ReLU
def relu_d(x):
    return np.array(x > 0, dtype=np.int)

#affichage graphique
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, relu(x), label='relu')
plt.plot(x, relu_d(x), label='relu_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** Fonction ReLU: **

** Différenciation de la fonction ReLU: **

La fonction ReLU a été créée pour éliminer le problème fondamental de la fonction sigmoïde. Même si x augmente, y augmente également proportionnellement, et s'il est toujours différencié, il reste un terme constant. Quand j'entends quelque chose maintenant, cela semble naturel, mais cela n'a été utilisé qu'en 2012 environ.

Le professeur Yutaka Matsuo de l'Université de Tokyo a déclaré que la fonction sigmoïde était une fonction magnifique pour les ingénieurs scientifiques et ingénieurs parce qu'elle était simple et que sa forme ne changeait guère même lorsqu'elle était différenciée. D'un autre côté, ReLU n'est pas cool, et il y a un point où il ne peut pas être différencié en (0,0), donc personne n'a voulu l'utiliser.

Autrefois, l'apprentissage profond ne fonctionnait pas bien, alors tout le monde utilisait la belle fonction Sigmoïde comme expression. Cependant, après avoir été en mesure de le déplacer, certaines personnes ont essayé diverses choses, et on dit que ReLU est devenu utilisé dans une telle situation.

Fonction 5.Leaky ReLU

#Fonction Leaky ReLU
def leaky_relu(x):
    return np.where(x > 0, x , 0.01 * x)

#Différenciation de la fonction Leaky ReLU
def leaky_relu_d(x):
    return np.where(x>0,1,0.01)

#affichage graphique
x = np.arange(-5.0, 5.0, 0.01)
plt.plot(x, leaky_relu(x), label='leaky_relu')
plt.plot(x, leaky_relu_d(x), label='leaky_relu_d')
plt.ylim(-1.1, 1.1)  
plt.legend()  
plt.grid()
plt.show()

** Fonction Leaky ReLU: ** ** Différenciation de la fonction Leaky ReLU: **

La fonction Leaky ReLU est dérivée de la fonction ReLU et a un gradient de 0,01x même si x est égal ou inférieur à 0. On s'attendait à ce que l'optimisation soit plus avancée que la fonction ReLU, mais elle semble assez limitée si l'optimisation fonctionne mieux que la fonction ReLU.

6. Découvrez la différence dans les performances de la fonction d'activation

Enfin, réalisons à quel point les performances d'optimisation diffèrent en fonction de la fonction d'activation.

[TensorFlow PlayGround](http://playground.tensorflow.org/#activation=relu&batchSize=10&dataset=circle&regDataset=reg-plane&learningRate=0.03&régularizationRate=0&noise=0&networkShape=3,3&seed=0.3est4380&showetercase=falseed=0.3est4380&showetercalize True & xTimesY = false & xSquared = false & ySquared = false & cosX = false & sinX = false & cosy = false & sinY = false & collectStats = false & problem = classification & initZero = false & hideText = false)

Vérifions le temps de convergence en définissant un réseau de neurones à deux couches avec ces trois neurones, en commutant l'activation (fonction d'activation) dans le cadre rouge.

Il y a quelques problèmes probabilistes, mais il y a quelques variations, mais le temps de convergence est généralement environ 10 fois plus rapide pour Tanh que pour Sigmoid, et environ 2 fois plus rapide pour ReLU que Tanh.