J'essaie de comprendre le rôle de la dérivée de la fonction sigmoïde dans les réseaux de neurones.

Je trace d'abord la fonction sigmoïde et la dérivée de tous les points de la définition à l'aide de python. Quel est exactement le rôle de ce dérivé?

import numpy as np
import matplotlib.pyplot as plt

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

def derivative(x, step):
    return (sigmoid(x+step) - sigmoid(x)) / step

x = np.linspace(-10, 10, 1000)

y1 = sigmoid(x)
y2 = derivative(x, 0.0000000000001)

plt.plot(x, y1, label='sigmoid')
plt.plot(x, y2, label='derivative')
plt.legend(loc='upper left')
plt.show()

L'utilisation de dérivés dans les réseaux de neurones est destinée au processus d'apprentissage appelé rétropropagation . Cette technique utilise la descente de gradient afin de trouver un ensemble optimal de paramètres de modèle afin de minimiser une fonction de perte. Dans votre exemple, vous devez utiliser le dérivé d'un sigmoïde car c'est l'activation que vos neurones individuels utilisent.

La fonction de perte

L'essence de l'apprentissage automatique est d'optimiser une fonction de coût de sorte que nous puissions minimiser ou maximiser une fonction cible. C'est ce qu'on appelle généralement la fonction de perte ou de coût. Nous voulons généralement minimiser cette fonction. La fonction de coût, , associe une certaine pénalité en fonction des erreurs résultantes lors du passage de données dans votre modèle en fonction des paramètres du modèle.$C$

Regardons l'exemple où nous essayons d'étiqueter si une image contient un chat ou un chien. Si nous avons un modèle parfait, nous pouvons lui donner une photo et il nous dira s'il s'agit d'un chat ou d'un chien. Cependant, aucun modèle n'est parfait et il fera des erreurs.

Lorsque nous formons notre modèle pour pouvoir déduire le sens des données d'entrée, nous voulons minimiser la quantité d'erreurs qu'il fait. Nous utilisons donc un ensemble de formation, ces données contiennent beaucoup de photos de chiens et de chats et nous avons l'étiquette de vérité au sol associée à cette image. Chaque fois que nous exécutons une itération de formation du modèle, nous calculons le coût (le nombre d'erreurs) du modèle. Nous voulons minimiser ce coût.

Il existe de nombreuses fonctions de coût, chacune servant son propre objectif. Une fonction de coût commune utilisée est le coût quadratique qui est défini comme

.$C = \frac{1}{N} \sum_{i=0}^{N}(\hat{y} - y)^2$

Ceci est le carré de la différence entre l'étiquette prédite et l'étiquette de vérité terrain pour le images sur lesquelles nous nous sommes entraînés. Nous voulons minimiser cela d'une manière ou d'une autre.$N$

Minimiser une fonction de perte

En effet, la plupart du machine learning est simplement une famille de frameworks qui sont capables de déterminer une distribution en minimisant une fonction de coût. La question que nous pouvons poser est "comment pouvons-nous minimiser une fonction"?

Minimisons la fonction suivante

$y = x^2-4x+6$ .

Si nous traçons cela, nous pouvons voir qu'il y a un minimum à . Pour ce faire analytiquement, nous pouvons prendre la dérivée de cette fonction comme$x = 2$

$\frac{dy}{dx} = 2x - 4 = 0$

.$x = 2$

Cependant, il n'est souvent pas possible de trouver un minimum global analytiquement. Nous utilisons donc à la place des techniques d'optimisation. Ici aussi de nombreuses façons différentes existent comme: Newton-Raphson, recherche réseau, etc. Parmi ceux - ci est une descente de gradient . C'est la technique utilisée par les réseaux de neurones.

Descente graduelle

Utilisons une analogie connue pour comprendre cela. Imaginez un problème de minimisation 2D. Cela équivaut à une randonnée montagneuse dans le désert. Vous voulez redescendre vers le village dont vous savez qu'il est au point le plus bas. Même si vous ne connaissez pas les directions cardinales du village. Tout ce que vous avez à faire est de descendre en continu le plus raide et vous finirez par arriver au village. Nous allons donc descendre la surface en fonction de la pente de la pente.

Prenons notre fonction

$y = x^2-4x+6$

nous déterminerons le pour lequel y est minimisé. L'algorithme de descente de gradient indique d'abord que nous choisirons une valeur aléatoire pour x . Initialisons à x = 8 . Ensuite, l'algorithme procédera de manière itérative jusqu'à ce que nous atteignions la convergence.$x$$y$$x$$x=8$

$x^{new} = x^{old} - \nu \frac{dy}{dx}$

où est le taux d'apprentissage, nous pouvons le régler sur la valeur que nous voulons. Cependant, il existe un moyen intelligent de choisir cela. Trop gros et nous n'atteindrons jamais notre valeur minimale, et trop gros nous perdrons tellement de temps avant d'y arriver. C'est analogue à la taille des marches que vous souhaitez descendre sur la pente raide. De petits pas et tu mourras sur la montagne, tu ne descendras jamais. Trop grand d'une étape et vous risquez de tirer sur le village et de finir de l'autre côté de la montagne. La dérivée est le moyen par lequel nous descendons cette pente vers notre minimum.$\nu$

$\frac{dy}{dx} = 2x - 4$

$\nu = 0.1$

Itération 1:

x n e w = 6,8 - 0,1 ( 2 ∗ 6,8 - 4 ) = 5,84 x n e w = 5,84 - 0,1 ( 2 ∗ 5,84 - 4 ) = 5,07 x n e w = 5,07 $x^{new} = 8 - 0.1(2 * 8 - 4) = 6.8$
$x^{new} = 6.8 - 0.1(2 * 6.8 - 4) = 5.84$
$x^{new} = 5.84 - 0.1(2 * 5.84 - 4) = 5.07$
)x n e w = 4,45 - 0,1 ( 2 ∗ 4,45 - 4 ) = 3,96 x n e w = 3,96 - 0,1 ( 2 ∗ 3,96 - 4 ) = 3,57 x n e w = 3,57 - 0,1 ( 2 ∗ 3,57 - 4 = $x^{new} = 5.07 - 0.1(2 * 5.07 - 4) = 4.45$
$x^{new} = 4.45 - 0.1(2 * 4.45 - 4) = 3.96$
$x^{new} = 3.96 - 0.1(2 * 3.96 - 4) = 3.57$
$x^{new} = 3.57 - 0.1(2 * 3.57 - 4) = 3.25$
x n e w = 3,00 - 0,1 ( 2 ∗ 3,00 - 4 ) = 2,80 x n e w = 2,80 - 0,1 ( 2 ∗ 2,80 - 4 ) = 2,64 x n e w$x^{new} = 3.25 - 0.1(2 * 3.25 - 4) = 3.00$
$x^{new} = 3.00 - 0.1(2 * 3.00 - 4) = 2.80$
$x^{new} = 2.80 - 0.1(2 * 2.80 - 4) = 2.64$
x n e w = 2,51 - 0,1 ( 2 ∗ 2,51 - 4 ) = 2,41 x n e w = 2,41 - 0,1 ( 2 ∗ 2,41 - 4 ) = 2,32 x n e w = 2,32 - 0,1 ( 2 ∗ $x^{new} = 2.64 - 0.1(2 * 2.64 - 4) = 2.51$
$x^{new} = 2.51 - 0.1(2 * 2.51 - 4) = 2.41$
$x^{new} = 2.41 - 0.1(2 * 2.41 - 4) = 2.32$
x n e w = 2,26 - 0,1 ( 2 ∗ 2,26 - 4 ) = 2,21 x n e w = 2,21 - 0,1 ( 2 ∗ 2,21 - 4 ) = 2,16 x n e w = 2,16 - 0,1 ( 2 ∗ 2,16 - 4 ) = 2,13 x $x^{new} = 2.32 - 0.1(2 * 2.32 - 4) = 2.26$
$x^{new} = 2.26 - 0.1(2 * 2.26 - 4) = 2.21$
$x^{new} = 2.21 - 0.1(2 * 2.21 - 4) = 2.16$
$x^{new} = 2.16 - 0.1(2 * 2.16 - 4) = 2.13$
x n e w = 2,10 - 0,1 ( 2 ∗ 2,10 - 4 ) = 2,08 x n e w = 2,08 - 0,1 ( 2 ∗ 2,08 - 4 ) = 2,06 x n e w = 2,06 - 0,1 $x^{new} = 2.13 - 0.1(2 * 2.13 - 4) = 2.10$
$x^{new} = 2.10 - 0.1(2 * 2.10 - 4) = 2.08$
$x^{new} = 2.08 - 0.1(2 * 2.08 - 4) = 2.06$
x n e w = 2,05 - 0,1 ( 2 ∗ 2,05 - 4 ) = 2,04 x n e w = 2,04 - 0,1 ( 2 ∗ 2,04 - 4 ) = 2,03 x n e w = 2,03 - 0,1 ( 2 ∗ 2,03 - 4 ) $x^{new} = 2.06 - 0.1(2 * 2.06 - 4) = 2.05$
$x^{new} = 2.05 - 0.1(2 * 2.05 - 4) = 2.04$
$x^{new} = 2.04 - 0.1(2 * 2.04 - 4) = 2.03$
x n e w = $x^{new} = 2.03 - 0.1(2 * 2.03 - 4) = 2.02$
x n e w = 2,02 - 0,1 ( 2 ∗ 2,02 - 4 ) = 2,01 x n e w = 2,01 - 0,1 ( 2 ∗ 2,01 - 4 ) = 2,01 x n e w$x^{new} = 2.02 - 0.1(2 * 2.02 - 4) = 2.02$
$x^{new} = 2.02 - 0.1(2 * 2.02 - 4) = 2.01$
$x^{new} = 2.01 - 0.1(2 * 2.01 - 4) = 2.01$
-x n e w = 2,01 - 0,1 ( 2 ∗ 2,01 - 4 ) = 2,00 x n e w = 2,00 - 0,1 ( 2 ∗ 2,00 - 4 ) = 2,00 x n e w = 2,00 - 0,1 ( 2 ∗ $x^{new} = 2.01 - 0.1(2 * 2.01 - 4) = 2.01$
$x^{new} = 2.01 - 0.1(2 * 2.01 - 4) = 2.00$
$x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$
x n e w = 2,00 - 0,1 ( 2 ∗ 2,00 - 4 ) = 2,00 x n e w = 2,00 - 0,1 ( 2 ∗ 2,00 - 4 ) = $x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$
$x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$
$x^{new} = 2.00 - 0.1(2 * 2.00 - 4) = 2.00$

Et nous voyons que l'algorithme converge à ! Nous avons trouvé le minimum.$x = 2$

Appliqué aux réseaux de neurones

Les premiers réseaux de neurones avaient seulement un seul neurone qui a eu dans certains entrées et fournir un signal de sortie y . Une fonction couramment utilisée est la fonction sigmoïde$x$$\hat{y}$

$\sigma(z) = \frac{1}{1+exp(z)}$

$\hat{y}(w^Tx) = \frac{1}{1+exp(w^Tx + b)}$

où est le poids associé pour chaque entrée x et nous avons un biais b . Nous voulons ensuite minimiser notre fonction de coût$w$$x$$b$

.$C = \frac{1}{2N} \sum_{i=0}^{N}(\hat{y} - y)^2$

Comment former le réseau neuronal?

Nous utiliserons une descente de gradient pour former les poids en fonction de la sortie de la fonction sigmoïde et nous utiliserons une fonction de coût et former sur des lots de données de taille N .$C$$N$

$C = \frac{1}{2N} \sum_i^N (\hat{y} - y)^2$

est la classe prédite obtenuepartirla fonction sigmoïde etyest le label de réalité de terrain. Nous utiliserons la descente de gradient pour minimiser la fonction de coût par rapport aux poidsw. Pour vous faciliter la vie, nous diviserons le dérivé comme suit$\hat{y}$$y$$w$

$\frac{\partial C}{\partial w} = \frac{\partial C}{\partial \hat{y}} \frac{\partial \hat{y}}{\partial w}$

$\frac{\partial C}{\partial \hat{y}} = \hat{y} - y$

$\hat{y} = \sigma(w^Tx)$$\frac{\partial \sigma(z)}{\partial z} = \sigma(z)(1-\sigma(z))$

$\frac{\partial \hat{y}}{\partial w} = \frac{1}{1+exp(w^Tx + b)} (1 - \frac{1}{1+exp(w^Tx + b)})$

Nous pouvons donc mettre à jour les poids par descente de gradient comme

$w^{new} = w^{old} - \eta \frac{\partial C}{\partial w}$

where $\eta$ is the learning rate.

During the phase where the neural network generates its prediction, it feeds the input forward through the network. For each layer, the layer's input $X$ goes first through an affine transformation $W \cdot X + b$ and then is passed through the sigmoid function $σ(W \cdot X + b)$.

In order to train the network, the output $\hat y$ is then compared to the expected output (or label) $y$ through a cost function $L(y, \hat y)=L\left(y, σ(W \cdot X + b)\right)$. The goal of the whole training procedure is to minimize that cost function. In order to do that, a technique called gradient descent is performed which calculates how we should change $W$ and $b$ so that the cost reduces.

Gradient Descent requires calculating the derivative of the cost function w.r.t $W$ and $b$. In order to do that we must apply the chain rule, because the derivative we need to calculate is a composition of two functions. As dictated by the chain rule we must calculate the derivative of the sigmoid function.

One of the reasons that the sigmoid function is popular with neural networks, is because its derivative is easy to compute.

In simple words:

Derivative shows neuron's ability to learn on particular input.

For example if input is 0 or 1 or -2, the derivative (the "learning ability") is high and back-propagation will improve neuron's weights for this sample dramatically.

On other hand, if input is 20, the the derivative will be very close to 0. It means that back-propagation on this sample will not "teach" this neuron to produce a better result.

The things above are valid for a single sample.

Let's look at the bigger picture, for all samples in the training set. Here we have several situations:

• If derivative is 0 for all samples in your training set AND neuron always produces wrong results - it means the neuron is saturated (dumb) and will not improve.

• If derivative is 0 for all samples in your training set AND neuron always produces correct results - it means the neuron have been studying really well and already as smart as it could (side note: this case is good but it may indicate potential overfitting, which is not good)

• If derivative is 0 on some samples, non-0 on other samples AND neuron produces mixed results - it indicates that this neuron doing some good work and potentially may improve from further training (though not necessarily as it depends on other neurons and training data you have)

So, when you are looking at the derivative plot, you can see how much the neuron prepared to learn and absorb the new knowledge, given a particular input.

The derivative you see here is important in neural networks. It's the reason why people generally prefer something else such as rectified linear unit.

Do you see the derivative drop for the two ends? What if your network is on the very left side, but it needs to move to the right side? Imagine you're on -10.0 but you want 10.0. The gradient will be too small for your network to converge quickly. We don't want to wait, we want quicker convergence. RLU doesn't have this problem.

We call this problem "Neural Network Saturation".

Please see https://www.quora.com/What-is-special-about-rectifier-neural-units-used-in-NN-learning