Tengo una ligera confusión sobre el algoritmo de retropropagación utilizado en el perceptrón multicapa (MLP).

El error se ajusta mediante la función de costo. En la retropropagación, estamos tratando de ajustar el peso de las capas ocultas. El error de salida que puedo entender, es decir, e = d - y[Sin los subíndices].

Las preguntas son:

¿Cómo se obtiene el error de la capa oculta? ¿Cómo se calcula?
Si lo propago hacia atrás, ¿debería usarlo como una función de costo de un filtro adaptativo o debería usar un puntero (en C / C ++) sentido de programación, para actualizar el peso?

machine-learning neural-networks backpropagation

— HIGGINS
fuente

NN es más bien una tecnología obsoleta, por lo que me temo que no obtendrá una respuesta porque aquí nadie los está utilizando ...

@mbq: No dudo de tus palabras, pero ¿cómo llegas a la conclusión de que NN son "tecnología obsoleta"?

— steffen

@steffen Por observación; Quiero decir que es obvio que nadie importante de la comunidad de NN saldrá y dirá "¡Hola chicos, dejemos nuestro trabajo de la vida y juguemos con algo mejor!", Pero tenemos herramientas que logran la misma o mejor precisión sin toda esta ambivalencia y nunca final de entrenamiento. Y la gente deja caer NN a favor de ellos.

Esto tenía algo de verdad cuando lo dijiste, @mbq, pero ya no.

— jerad

@jerad Bastante fácil: simplemente todavía no he visto una comparación justa con otros métodos (Kaggle no es una comparación justa debido a la falta de intervalos de confianza para las precisiones, especialmente cuando los resultados de todos los equipos de alta puntuación están tan cerca como en el concurso de Merck), ni ningún análisis de robustez de la optimización de parámetros, que es mucho peor.

Pensé que respondería una publicación independiente aquí para cualquiera que esté interesado. Esto usará la notación descrita aquí .

Introducción

La idea detrás de la propagación hacia atrás es tener un conjunto de "ejemplos de capacitación" que usamos para capacitar a nuestra red. Cada uno de estos tiene una respuesta conocida, por lo que podemos conectarlos a la red neuronal y descubrir cuánto estuvo mal.

Por ejemplo, con el reconocimiento de escritura a mano, tendría muchos caracteres escritos a mano junto a lo que realmente eran. Luego, la red neuronal se puede entrenar a través de la propagación hacia atrás para "aprender" cómo reconocer cada símbolo, de modo que cuando se presente más tarde con un carácter escrito a mano desconocido pueda identificar qué es correctamente.

Específicamente, ingresamos alguna muestra de entrenamiento en la red neuronal, vemos qué tan bien funcionó, luego "goteamos hacia atrás" para encontrar cuánto podemos cambiar los pesos y el sesgo de cada nodo para obtener un mejor resultado, y luego ajustarlos en consecuencia. A medida que continuamos haciendo esto, la red "aprende".

También hay otros pasos que pueden incluirse en el proceso de capacitación (por ejemplo, abandono), pero me enfocaré principalmente en la propagación hacia atrás ya que de eso se trataba esta pregunta.

Derivadas parciales

Una derivada parcial es una derivada decon respecto a alguna variable. $\frac{\partial f}{\partial x}$ $f$ $x$

Por ejemplo, si , $f(x, y)=x^2 + y^2$ , porquees simplemente una constante con respecto a. Del mismo modo, $\frac{\partial f}{\partial x}=2x$ $y^2$ $x$ , porquees simplemente una constante con respecto a. $\frac{\partial f}{\partial y}= 2y$ $x^2$ $y$

Un gradiente de una función, designada , es una función que contiene la derivada parcial para cada variable en f. Específicamente: $\nabla f$

\nabla f (v_{1}, v_{2}, . . ., v_{n}) = \frac{\partial f}{\partial v_{1}} e_{1} + \dots + \frac{\partial f}{\partial v_{norte}} e_{norte}

$\nabla f(v_1, v_2, ..., v_n) = \frac{\partial f}{\partial v_1 }\mathbf{e}_1 + \cdots + \frac{\partial f}{\partial v_n }\mathbf{e}_n$

donde es un vector unitario que apunta en la dirección de la variable . $e_i$ $v_1$

Ahora, una vez que hemos calculado la para alguna función , si estamos en la posición , podemos "slide abajo" yendo en la dirección . $\nabla f$ $f$ $(v_1, v_2, ..., v_n)$ $f$ $-\nabla f(v_1, v_2, ..., v_n)$

Con nuestro ejemplo de , los vectores unitarios son y , porque y , y esos vectores apuntan en la dirección de los ejes e . Por lo tanto, $f(x, y)=x^2 + y^2$ $e_1=(1, 0)$ $e_2=(0, 1)$ $v_1=x$ $v_2=y$ $x$ $y$ . $\nabla f(x, y) = 2x (1, 0) + 2y(0, 1)$

Ahora, para "deslizar hacia abajo" nuestra función , digamos que estamos en un punto . Entonces tendríamos que movernos en dirección $f$ $(-2, 4)$ . $-\nabla f(-2, -4)= -(2 \cdot -2 \cdot (1, 0) + 2 \cdot 4 \cdot (0, 1)) = -((-4, 0) + (0, 8))=(4, -8)$

La magnitud de este vector nos dará cuán empinada es la colina (valores más altos significan que la colina es más empinada). En este caso, tenemos . $\sqrt{4^2+(-8)^2}\approx 8.944$

Descenso de gradiente

Producto Hadamard

El producto Hadamard de dos matrices , es como la suma de matrices, excepto que en lugar de sumar las matrices en cuanto a elementos, las multiplicamos en función de elementos. $A, B \in R^{n\times m}$

Formalmente, mientras que la suma de matrices es , donde tal que $A + B = C$ $C \in R^{n \times m}$

C_{j}^{i} = A_{j}^{yo} + {si}_{j}^{yo}

$C^i_j = A^i_j + B^i_j$

El producto Hadamard , donde tal que $A \odot B = C$ $C \in R^{n \times m}$

C_{j}^{yo} = {UN}_{j}^{yo} \cdot {si}_{j}^{yo}

$C^i_j = A^i_j \cdot B^i_j$

Calcular los gradientes

(La mayor parte de esta sección es del libro de Neilsen ).

$(S, E)$ $S_r$ $E_r$ $W$ $B$ $r$ $i$ $j$ $k$

$C(W, B, S^r, E^r)$

Normalmente, lo que se usa es el costo cuadrático, que se define por

C (W, B, S^{r}, E^{r}) = 0.5 \sum_{j} (a_{j}^{L} - E_{j}^{r})^{2}

$C(W, B, S^r, E^r) = 0.5\sum\limits_j (a^L_j - E^r_j)^2$

$a^L$ $S^r$

$\frac{\partial C}{\partial w^i_j}$ $\frac{\partial C}{\partial b^i_j}$

$C$ $S^r$ $E^r$ $W$ $B$ $W$ $B$

$\delta^i_j=\frac{\partial C}{\partial z^i_j}$ $j$ $i$

$a^L$ $S^r$

$\delta^L$

δ_{j}^{L} = \frac{\partial C}{\partial a_{j}^{L}} σ^{'} (z_{j}^{L})

$\delta^L_j = \frac{\partial C}{\partial a^L_j} \sigma^{ \prime}(z^L_j)$

Que también se puede escribir como

δ^{L} = \nabla_{a} C ⊙ σ^{'} (z^{L})

$\delta^L = \nabla_a C \odot \sigma^{ \prime}(z^L)$

$\delta^i$ $\delta^{i+1}$

δ^{i} = ((W^{i + 1})^{T} δ^{i + 1}) ⊙ σ^{'} (z^{i})

$\delta^i=((W^{i+1})^T \delta^{i+1}) \odot \sigma^{\prime}(z^i)$

Ahora que tenemos el error de cada nodo en nuestra red neuronal, es fácil calcular el gradiente con respecto a nuestros pesos y sesgos:

\frac{\partial C}{\partial w_{j k}^{i}} = δ_{j}^{i} a_{k}^{i - 1} = δ^{i} (a^{i - 1})^{T}

$\frac{\partial C}{\partial w^i_{jk}}=\delta^i_j a^{i-1}_k=\delta^i(a^{i-1})^T$

\frac{\partial C}{\partial b_{j}^{i}} = δ_{j}^{i}

$\frac{\partial C}{\partial b^i_j} = \delta^i_j$

Tenga en cuenta que la ecuación para el error de la capa de salida es la única ecuación que depende de la función de costo, por lo que, independientemente de la función de costo, las últimas tres ecuaciones son las mismas.

Como ejemplo, con costo cuadrático, obtenemos

δ^{L} = (a^{L} - E^{r}) ⊙ σ^{'} (z^{L})

$\delta ^L = (a^L - E^r) \odot \sigma ^ {\prime}(z^L)$

$L-1^{\text{th}}$ layer:

δ^{L - 1} = ((W^{L})^{T} δ^{L}) ⊙ σ^{'} (z^{L - 1})

$\delta^{L-1}=((W^{L})^T \delta^{L}) \odot \sigma^{\prime}(z^{L-1})$

= ((W^{L})^{T} ((a^{L} - E^{r}) ⊙ σ^{'} (z^{L}))) ⊙ σ^{'} (z^{L - 1})

$=((W^{L})^T ((a^L - E^r) \odot \sigma ^ {\prime}(z^L))) \odot \sigma^{\prime}(z^{L-1})$

which we can repeat this process to find the error of any layer with respect to $C$ , which then allows us to compute the gradient of any node's weights and bias with respect to $C$ .

I could write up an explanation and proof of these equations if desired, though one can also find proofs of them here. I'd encourage anyone that is reading this to prove these themselves though, beginning with the definition $\delta^i_j=\frac{\partial C}{\partial z^i_j}$ and applying the chain rule liberally.

For some more examples, I made a list of some cost functions alongside their gradients here.

Gradient Descent

Now that we have these gradients, we need to use them learn. In the previous section, we found how to move to "slide down" the curve with respect to some point. In this case, because it's a gradient of some node with respect to weights and a bias of that node, our "coordinate" is the current weights and bias of that node. Since we've already found the gradients with respect to those coordinates, those values are already how much we need to change.

We don't want to slide down the slope at a very fast speed, otherwise we risk sliding past the minimum. To prevent this, we want some "step size" $\eta$ .

Then, find the how much we should modify each weight and bias by, because we have already computed the gradient with respect to the current we have

Δ w_{j k}^{i} = - η \frac{\partial C}{\partial w_{j k}^{i}}

$\Delta w^i_{jk}= -\eta \frac{\partial C}{\partial w^i_{jk}}$

Δ b_{j}^{i} = - η \frac{\partial C}{\partial b_{j}^{i}}

$\Delta b^i_j = -\eta \frac{\partial C}{\partial b^i_j}$

Thus, our new weights and biases are

w_{j k}^{i} = w_{j k}^{i} + Δ w_{j k}^{i}

$w^i_{jk} = w^i_{jk} + \Delta w^i_{jk}$

b_{j}^{i} = b_{j}^{i} + Δ b_{j}^{i}

$b^i_j = b^i_j + \Delta b^i_j$

Using this process on a neural network with only an input layer and an output layer is called the Delta Rule.

Stochastic Gradient Descent

Now that we know how to perform backpropagation for a single sample, we need some way of using this process to "learn" our entire training set.

One option is simply performing backpropagation for each sample in our training data, one at a time. This is pretty inefficient though.

A better approach is Stochastic Gradient Descent. Instead of performing backpropagation for each sample, we pick a small random sample (called a batch) of our training set, then perform backpropagation for each sample in that batch. The hope is that by doing this, we capture the "intent" of the data set, without having to compute the gradient of every sample.

For example, if we had 1000 samples, we could pick a batch of size 50, then run backpropagation for each sample in this batch. The hope is that we were given a large enough training set that it represents the distribution of the actual data we are trying to learn well enough that picking a small random sample is sufficient to capture this information.

However, doing backpropagation for each training example in our mini-batch isn't ideal, because we can end up "wiggling around" where training samples modify weights and biases in such a way that they cancel each other out and prevent them from getting to the minimum we are trying to get to.

To prevent this, we want to go to the "average minimum," because the hope is that, on average, the samples' gradients are pointing down the slope. So, after choosing our batch randomly, we create a mini-batch which is a small random sample of our batch. Then, given a mini-batch with $n$ training samples, and only update the weights and biases after averaging the gradients of each sample in the mini-batch.

Formally, we do

Δ w_{j k}^{i} = \frac{1}{n} \sum_{r} Δ w_{j k}^{r i}

$\Delta w^{i}_{jk} = \frac{1}{n}\sum\limits_r \Delta w^{ri}_{jk}$

and

Δ b_{j}^{i} = \frac{1}{n} \sum_{r} Δ b_{j}^{r i}

$\Delta b^{i}_{j} = \frac{1}{n}\sum\limits_r \Delta b^{ri}_{j}$

where $\Delta w^{ri}_{jk}$ is the computed change in weight for sample $r$ , and $\Delta b^{ri}_{j}$ is the computed change in bias for sample $r$ .

Then, like before, we can update the weights and biases via:

w_{j k}^{i} = w_{j k}^{i} + Δ w_{j k}^{i}

$w^i_{jk} = w^i_{jk} + \Delta w^{i}_{jk}$

b_{j}^{i} = b_{j}^{i} + Δ b_{j}^{i}

$b^i_j = b^i_j + \Delta b^{i}_{j}$

This gives us some flexibility in how we want to perform gradient descent. If we have a function we are trying to learn with lots of local minima, this "wiggling around" behavior is actually desirable, because it means that we're much less likely to get "stuck" in one local minima, and more likely to "jump out" of one local minima and hopefully fall in another that is closer to the global minima. Thus we want small mini-batches.

On the other hand, if we know that there are very few local minima, and generally gradient descent goes towards the global minima, we want larger mini-batches, because this "wiggling around" behavior will prevent us from going down the slope as fast as we would like. See here.

One option is to pick the largest mini-batch possible, considering the entire batch as one mini-batch. This is called Batch Gradient Descent, since we are simply averaging the gradients of the batch. This is almost never used in practice, however, because it is very inefficient.

— Phylliida
fuente

I haven't dealt with Neural Networks for some years now, but I think you will find everything you need here:

Neural Networks - A Systematic Introduction, Chapter 7: The backpropagation algorithm

I apologize for not writing the direct answer here, but since I have to look up the details to remember (like you) and given that the answer without some backup may be even useless, I hope this is ok. However, if any questions remain, drop a comment and I'll see what I can do.

— steffen
fuente

Algoritmo de retropropagación