¿Cómo utilizan exactamente las redes neuronales convolucionales la convolución en lugar de la multiplicación de matrices?

Estaba leyendo el libro de Yoshua Bengio sobre aprendizaje profundo y dice en la página 224:

Las redes convolucionales son simplemente redes neuronales que usan la convolución en lugar de la multiplicación matricial general en al menos una de sus capas.

sin embargo, no estaba 100% seguro de cómo "reemplazar la multiplicación de matrices por convolución" en un sentido matemáticamente preciso.

Lo que realmente me interesa es definir esto para los vectores de entrada en 1D (como en $x \in \mathbb{R}^d$ ), por lo que no tendré entrada como imágenes e intentaré evitar la convolución en 2D.

Entonces, por ejemplo, en las redes neuronales "normales", las operaciones y el patrón de la sala de alimentación se pueden expresar de manera concisa como en las notas de Andrew Ng:

W^{(l)} a^{(l)} = z^{(l + 1)}

$W^{(l)} a^{(l)} = z^{(l+1)}$

f (z^{(l + 1)}) = a^{(l + 1)}

$f(z^{(l+1)}) = a^{(l+1)}$

donde $z^{(l)}$ es el vector calculado antes de pasarlo por la no linealidad $f$ . La no linealidad actúa pero la entrada en el vector $z^{(l)}$ y $a^{(l+1)}$ es la salida / activación de unidades ocultas para la capa en cuestión.

Este cálculo es claro para mí porque la multiplicación de matrices está claramente definida para mí, sin embargo, el simple reemplazo de la multiplicación de matrices por convolución me parece poco claro. es decir

W^{(l)} * a^{(l)} = z^{(l + 1)}

$W^{(l)} * a^{(l)} = z^{(l+1)}$

f (z^{(l + 1)}) = a^{(l + 1)}

$f(z^{(l+1)}) = a^{(l+1)}$

Quiero asegurarme de entender la ecuación anterior matemáticamente con precisión.

El primer problema que tengo con solo reemplazar la multiplicación de matrices con convolución es que, por lo general, uno identifica una fila de $W^{(l)}$ con un producto de puntos. Entonces, uno sabe claramente cómo todo $a^{(l)}$ relaciona con los pesos y eso se asigna a un vector $z^{(l+1)}$ de la dimensión como lo indica $W^{(l)}$ . Sin embargo, cuando uno lo reemplaza por convoluciones, no me queda claro qué fila o pesos corresponden a qué entradas en $a^{(l)}$ . Ni siquiera es claro para mí que tenga sentido representar los pesos como una matriz, de hecho (proporcionaré un ejemplo para explicar ese punto más adelante)

En el caso en que la entrada y las salidas están todas en 1D, ¿se calcula la convolución de acuerdo con su definición y luego se pasa por una singularidad?

Por ejemplo, si tuviéramos el siguiente vector como entrada:

x = [1, 2, 3, 4]

$x = [1,2,3,4]$

y tuvimos los siguientes pesos (tal vez lo aprendimos con backprop):

W = [5, 6, 7]

$W = [5,6,7]$

entonces la convolución es:

x * W = [5, 16, 34, 52, 45, 28]

$x * W = [5, 16, 34, 52, 45, 28]$

¿sería correcto simplemente pasar la no linealidad a través de eso y tratar el resultado como la capa / representación oculta (supongamos que no hay agrupación por el momento)? es decir, de la siguiente manera:

f (x * W) = f ([5, 16, 34, 52, 45, 28]) = [f (5), f (16), f (34), f (52), f (45), f (28)])

$f(x * W) = f([5, 16, 34, 52, 45, 28]) = [f(5), f(16), f(34), f(52), f(45), f(28)])$

(el tutorial de Stanford UDLF creo que recorta los bordes donde los convov de convolución con 0 por alguna razón, ¿necesitamos recortar eso?)

¿Es así como debería funcionar? ¿Al menos para un vector de entrada en 1D? ¿El no es un vector? $W$

Incluso dibujé una red neuronal de cómo se supone que debe verse esto, creo:

ingrese la descripción de la imagen aquí

— Charlie Parker
fuente

Respuestas:

Me parece que estás en el camino correcto, pero tal vez pueda ayudarte a aclarar.

Salida única

Imaginemos una capa de red neuronal tradicional con unidades de entrada y 1 salida (supongamos también que no hay sesgo). Esta capa tiene un vector de pesos $n$ $w\in\mathbb{R}^n$ que se puede aprender usando varios métodos (backprop, algoritmos genéticos, etc.), pero ignoraremos el aprendizaje y nos centraremos en la propagación hacia adelante.

La capa toma una entrada y la asigna a una activación calculando el producto de punto de con y luego aplicando una no linealidad : $x\in\mathbb{R}^n$ $a\in\mathbb{R}$ $x$ $w$ $\sigma$

a = σ (x \cdot w)

$a = \sigma(x\cdot w)$

Aquí, los elementos de especifican cuánto ponderar los elementos correspondientes de para calcular la activación general de la unidad de salida. Incluso podría pensar en esto como una "convolución" donde la señal de entrada ( ) tiene la misma longitud que el filtro ( ). $w$ $x$ $x$ $w$

En un entorno convolucional, hay más valores en que en ; supongamos ahora nuestra entrada para . Podemos calcular la activación de la unidad de salida en esta configuración calculando el producto punto de con subconjuntos contiguos de : $x$ $w$ $x\in\mathbb{R}^m$ $m>n$ $w$ $x$

\begin{array}{rcl} a_{1} & = & σ (x_{1 : n} \cdot w) \\ a_{2} & = & σ (x_{2 : n + 1} \cdot w) \\ a_{3} & = & σ (x_{3 : n + 2} \cdot w) \\ \dots \\ a_{m - n + 1} & = & σ (x_{m - n + 1 : m} \cdot w) \end{array}

$\begin{eqnarray*} a_1 &=& \sigma(x_{1:n} \cdot w) \\ a_2 &=& \sigma(x_{2:n+1} \cdot w) \\ a_3 &=& \sigma(x_{3:n+2} \cdot w) \\ \dots \\ a_{m-n+1} &=& \sigma(x_{m-n+1:m} \cdot w) \end{eqnarray*}$

(Aquí estoy repitiendo la misma confusión molesta entre correlación cruzada y convolución que hacen muchos autores de redes neuronales; si tuviéramos que hacer estas convoluciones apropiadas, cambiaríamos los elementos de . También estoy asumiendo que es "válido" convolución que solo retiene elementos computados donde la señal de entrada y el filtro se superponen por completo, es decir, sin ningún relleno). $w$

Ya has puesto esto en tu pregunta básicamente, pero estoy tratando de caminar a través de la conexión con las capas de red neuronal de vainilla usando el producto punto para hacer un punto. La principal diferencia con las capas de red vainilla es que si el vector de entrada es más largo que el vector de peso, una convolución convierte la salida de la capa de red en un vector: en redes de convolución, ¡son vectores completamente hacia abajo! Este vector de salida se denomina "mapa de características" para la unidad de salida en esta capa.

Salidas múltiples

Bien, imaginemos que agregamos una nueva salida a nuestra capa de red, de modo que tenga entradas y 2 salidas. Habrá un vector para la primera salida, y un vector $n$ $w^1\in\mathbb{R}^n$ $w^2\in\mathbb{R}^n$ para la segunda salida. (Estoy usando superíndices para denotar salidas de capa).

$W = [w^1 w^2]$

\begin{array}{rcl} a^{1} & = & σ (x \cdot w^{1}) \\ a^{2} & = & σ (x \cdot w^{2}) \end{array}

$\begin{eqnarray*} a^1 &=& \sigma(x \cdot w^1) \\ a^2 &=& \sigma(x \cdot w^2) \end{eqnarray*}$

a = [a^{1} a^{2}] = σ (x \cdot W)

$a = [a^1 a^2] = \sigma(x \cdot W)$

$w^1$ $w^2$ $a^1 = [a^1_1 a^1_2 \dots a^1_{m-n+1}]$ $a^2 = [a^2_1 a^2_2 \dots a^2_{m-n+1}]$ (again assuming "valid" convolutions). These filter maps, one for each layer output, are commonly stacked together into a matrix $A = [a^1 a^2]$ .

If you think of it, the input in the convolutional case could also be thought of as a matrix, containing just one column ("one input channel"). So we could write the transformation for this layer as

A = σ (X * W)

$A = \sigma(X * W)$ where the "convolution" is actually a cross-correlation and happens only along the columns of

X

$X$ and

W

$W$ .

These notation shortcuts are actually quite helpful, because now it's easy to see that to add another output to the layer, we just add another column of weights to $W$ .

Hopefully that's helpful!

— lmjohns3
fuente

A convolutional layer is a strict subset of a fully connected network, ie a matrix multiplication. A convolutional layer in the forward pass is in fact equivalent to a matrix multiplication where:

some weights are tied/shared
some weights are zero

In the backward pass, the weights will be updated in accordance with which weights have contributed how much in the forward pass. ie, the weights which were zero are still zero. The weights which were tied across multiple outputs will receive gradient from all of those outputs (which gradients are summed together, to produce the final gradient update for that weight).

— Hugh Perkins
fuente

No, that is not how it is supposed to work. The convolution operation always make the input smaller (for filters with size > 1), not larger as in your example.

It is simply an elementwise multiplication. When doing convolution on the first 3 elements of the input, the output would be $1∗5+2∗6+3∗7=38$ . (see deeplearning.stanford.edu for an example)

— pir
fuente

did you try conv([1, 2, 3, 4], [5,6,7] ) in matlab? Go to the terminal and check it yourself. If you use the conventional definition of convolution you can compute by hand the vector [5,16,34,52,45,28]. The Vector does not always shrink. It depends where you start doing the convolution and if you treat things outside the index range as zero. If you do it as I suggested in this post you get a vector of size

N + n - 1

$N+n -1$ . If you trim the edges (cuz of index that go out the range) you get a vector of size

N - n + 1

$N-n+1$ , where N and n are the size of the vectors in question.

— Charlie Parker

The convolution used in that webapge is not the definition of the mathematical convolution.

— Charlie Parker

Yes, the convolution used for CNN is not the usual convolution. That's confusing to everyone, but that's just how it is :) Given the nature of CNN i.e. analyze an image it will always start with the first

n

$n$ elements, where

n

$n$ is the filter size and then be passed over the input. However, it will not be extended beyond the end, so the output will be shrinked by

n - 1

$n-1$ .

— pir

I see, I think that makes sense now that I looked it up. However, there is one tiny mistake. The input doesn't always make it smaller, I am aware of the different type of convolutions now and even in the CNN, according to Yoshua Bengio's book there are 3 types of convolutions (full, valid, same) iro.umontreal.ca/~bengioy/dlbook. I don't understand them in detail but at least I am aware of them! Thanks Felbo. The vision community should not be using the word convolutions, its confusing and irritating. Anyway, thanks.

— Charlie Parker

@CharlieParker The conv function in Matlab has the same 3 types of "shapes" (full, valid, same), Matlab just defaults to "full" -- see docs at mathworks.com/help/matlab/ref/conv.html. A convolution without flipping the kernel is a cross-correlation, so xcorr(x, y) = conv(x, fliplr(y)). The NN community tends to say convolution when they are actually doing a cross-correlation, but it's pretty similar.

— lmjohns3