Intento comprender el papel de la derivada de la función sigmoidea en las redes neuronales.

Primero trazo la función sigmoide y la derivada de todos los puntos de la definición usando python. ¿Cuál es exactamente el papel de este derivado?

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

El uso de derivados en redes neuronales es para el proceso de entrenamiento llamado retropropagación . Esta técnica utiliza el descenso de gradiente para encontrar un conjunto óptimo de parámetros del modelo con el fin de minimizar una función de pérdida. En su ejemplo, debe usar la derivada de un sigmoide porque esa es la activación que están usando sus neuronas individuales.

La función de pérdida

La esencia del aprendizaje automático es optimizar una función de costo de manera que podamos minimizar o maximizar alguna función objetivo. Esto generalmente se llama la función de pérdida o costo. Por lo general, queremos minimizar esta función. La función de costo, , asocia una penalización basada en los errores resultantes al pasar datos a través de su modelo en función de los parámetros del modelo.$C$

Veamos el ejemplo en el que intentamos etiquetar si una imagen contiene un gato o un perro. Si tenemos un modelo perfecto, podemos darle una imagen al modelo y nos dirá si es un gato o un perro. Sin embargo, ningún modelo es perfecto y cometerá errores.

Cuando entrenamos nuestro modelo para poder inferir el significado de los datos de entrada, queremos minimizar la cantidad de errores que comete. Por lo tanto, utilizamos un conjunto de entrenamiento, estos datos contienen muchas imágenes de perros y gatos y tenemos la etiqueta de verdad básica asociada con esa imagen. Cada vez que ejecutamos una iteración de entrenamiento del modelo, calculamos el costo (la cantidad de errores) del modelo. Queremos minimizar este costo.

Existen muchas funciones de costo, cada una de las cuales cumple su propio propósito. Una función de costo común que se usa es el costo cuadrático que se define como

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

Este es el cuadrado de la diferencia entre la etiqueta predicha y la etiqueta de verdad básica para el imágenes sobre las que hemos entrenado. Queremos minimizar esto de alguna manera.$N$

Minimizando una función de pérdida

De hecho, la mayoría del aprendizaje automático es simplemente una familia de marcos que son capaces de determinar una distribución minimizando alguna función de costo. La pregunta que podemos hacer es "¿cómo podemos minimizar una función"?

Minimicemos la siguiente función

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

Si trazamos esto, podemos ver que hay un mínimo en . Para hacer esto analíticamente podemos tomar la derivada de esta función como$x = 2$

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

$x = 2$ .

Sin embargo, muchas veces encontrar un mínimo global analíticamente no es factible. Entonces, en cambio, usamos algunas técnicas de optimización. Aquí también existen muchas formas diferentes, tales como: Newton-Raphson, búsqueda de cuadrícula, etc. Entre ellas está el descenso de gradiente . Esta es la técnica utilizada por las redes neuronales.

Descenso de gradiente

Usemos una analogía famosa para entender esto. Imagine un problema de minimización en 2D. Esto es equivalente a estar en una caminata montañosa en el desierto. Desea volver a la aldea que sabe que está en el punto más bajo. Incluso si no conoce las direcciones cardinales de la aldea. Todo lo que necesitas hacer es tomar el camino más empinado hacia abajo y llegarás al pueblo. Entonces descenderemos por la superficie en función de la pendiente de la pendiente.

Tomemos nuestra función

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

determinaremos la para la cual$x$ se minimiza. El algoritmo de descenso de gradiente primero dice que elegiremos un valor aleatorio para x . Inicialicemos en x = 8 . Luego, el algoritmo hará lo siguiente de forma iterativa hasta que alcancemos la convergencia.$y$$x$$x=8$

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

donde es la tasa de aprendizaje, podemos establecer esto en el valor que queramos. Sin embargo, hay una forma inteligente de elegir esto. Demasiado grande y nunca alcanzaremos nuestro valor mínimo, y demasiado grande desperdiciaremos mucho tiempo antes de llegar allí. Es análogo al tamaño de los escalones que desea bajar por la pendiente empinada. Pequeños pasos y morirás en la montaña, nunca bajarás. Un paso demasiado grande y te arriesgas a disparar al pueblo y terminar al otro lado de la montaña. La derivada es el medio por el cual viajamos por esta pendiente hacia nuestro mínimo.$\nu$

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

$\nu = 0.1$

Iteración 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 ( 2 ∗ 5.07 - 4 $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 n e w = 3.25 - 0.1 ( 2 ∗ 3.25 x n e w$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 ) = $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$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 n e w = 2.16 - 0.1 ( 2 ∗ 2,16 - 4 ) = 2,13 x $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 $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 n e w = 2.03 - 0.1 ( 2 ∗ 2.03 - 4 ) $x^{new} = 2.04 - 0.1(2 * 2.04 - 4) = 2.03$
x n e w = 2.02 - 0.1 ( 2 ∗ 2.02 - 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 ( $x^{new} = 2.03 - 0.1(2 * 2.03 - 4) = 2.02$
$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 n e w = $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 ∗ 2.00 $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$

¡Y vemos que el algoritmo converge en ! Hemos encontrado el mínimo.$x = 2$

Aplicado a redes neuronales

$x$$\hat{y}$ . Una función común utilizada es la función sigmoidea

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

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

where $w$ is the associated weight for each input $x$ and we have a bias $b$. We then want to minimize our cost function

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

How to train the neural network?

We will use gradient descent to train the weights based on the output of the sigmoid function and we will use some cost function $C$ and train on batches of data of size $N$.

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

$\hat{y}$ is the predicted class obtained from the sigmoid function and $y$ is the ground truth label. We will use gradient descent to minimize the cost function with respect to the weights $w$. To make life easier we will split the derivative as follows

$\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$

and we have that $\hat{y} = \sigma(w^Tx)$ and the derivative of the sigmoid function is $\frac{\partial \sigma(z)}{\partial z} = \sigma(z)(1-\sigma(z))$ thus we have,

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

So we can then update the weights through gradient descent as

$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