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()

スクリーンショット 2020-02-10 09.13.52.png

** 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()

スクリーンショット 2020-02-10 09.15.39.png ** 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()

スクリーンショット 2020-02-10 09.17.50.png

** Fonction ReLU: ** スクリーンショット 2020-02-10 21.46.11.png

** Différenciation de la fonction ReLU: ** スクリーンショット 2020-02-10 21.39.13.png

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()

スクリーンショット 2020-02-10 09.19.25.png

** Fonction Leaky ReLU: ** スクリーンショット 2020-02-10 21.45.58.png ** Différenciation de la fonction Leaky ReLU: ** スクリーンショット 2020-02-10 21.39.25.png

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)

スクリーンショット 2020-02-11 14.32.09.png 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.

Recommended Posts

Fonctions d'apprentissage en profondeur / d'activation
L'apprentissage en profondeur
Mémorandum d'apprentissage profond
Commencer l'apprentissage en profondeur
Apprentissage en profondeur Python
Apprentissage profond × Python
Premier apprentissage profond ~ Lutte ~
Apprentissage profond à partir de zéro
Deep learning 1 Pratique du deep learning
Apprentissage profond / entropie croisée
Premier apprentissage profond ~ Préparation ~
Liste des fonctions d'activation (2020)
Première solution d'apprentissage en profondeur ~
[AI] Apprentissage métrique profond
J'ai essayé le deep learning
Python: réglage du Deep Learning
Technologie d'apprentissage en profondeur à grande échelle
Fonction d'apprentissage profond / softmax
Pourquoi le Deep Metric Learning basé sur la fonction Softmax fonctionne
Apprentissage profond à partir de zéro 1 à 3 chapitres
Essayez l'apprentissage en profondeur avec TensorFlow
<Cours> Apprentissage en profondeur: Day2 CNN
Visualisez les fonctions d'activation côte à côte
Reconnaissance d'image par apprentissage profond 1 théorie
Deep running 2 Réglage de l'apprentissage profond
Apprentissage profond / code de travail LSTM
<Cours> Apprentissage en profondeur: Jour 1 NN
Apprentissage profond du noyau avec Pyro
Essayez le Deep Learning avec FPGA
Apprentissage profond pour la formation composée?
Présentation d'Udacity Deep Learning Nanodegree
Sujets> Deep Learning: Day3 RNN
Introduction au Deep Learning ~ Règles d'apprentissage ~
Apprentissage par renforcement profond 1 Introduction au renforcement de l'apprentissage
Apprentissage par renforcement profond 2 Mise en œuvre de l'apprentissage par renforcement
Générez des Pokémon avec Deep Learning
Introduction au Deep Learning ~ Rétropropagation ~
Syntaxe de contrôle Python, fonctions (mémo d'apprentissage Python ②)
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Essayez le Deep Learning avec les concombres FPGA-Select
Identification de la race de chat avec Deep Learning
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
Faites de l'art ASCII avec l'apprentissage en profondeur
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Implémenter le deep learning / VAE (Variational Autoencoder)
Introduction à l'apprentissage en profondeur ~ Approximation des fonctions ~
Essayez l'apprentissage en profondeur avec TensorFlow Partie 2
Apprentissage profond à partir de zéro (calcul des coûts)
À propos de la gestion de projet de deep learning (DNN)
Apprentissage profond pour démarrer sans GPU
Introduction à l'apprentissage profond ~ Préparation au codage ~
Organisez des plateformes d'apprentissage automatique et d'apprentissage en profondeur
Apprentissage profond appris par l'implémentation 1 (édition de retour)
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 8 Mémo
Didacticiel "CNTK" de la bibliothèque d'apprentissage en profondeur de Microsoft
Deep learning / Deep learning made from scratch Chapitre 5 Mémo
Vérifiez la forme de squat avec l'apprentissage en profondeur