Recientemente leí Redes totalmente convolucionales para la segmentación semántica por Jonathan Long, Evan Shelhamer, Trevor Darrell. No entiendo qué hacen las "capas deconvolucionales" / cómo funcionan.

La parte relevante es

3.3. El muestreo ascendente es una convolución hacia atrás

Otra forma de conectar salidas gruesas a píxeles densos es la interpolación. Por ejemplo, la interpolación bilineal simple calcula cada salida $y_{ij}$ de las cuatro entradas más cercanas mediante un mapa lineal que depende solo de las posiciones relativas de las celdas de entrada y salida.
En cierto sentido, el muestreo ascendente con factor $f$ es una convolución con un paso de entrada fraccional de 1 / f. Siempre que $f$ sea ​​integral, una forma natural de muestreo ascendente es, por lo tanto, convolución hacia atrás (a veces llamada deconvolución) con un paso de salida de $f$ . Tal operación es trivial de implementar, ya que simplemente invierte los pasos de convolución hacia adelante y hacia atrás.
Por lo tanto, el muestreo ascendente se realiza dentro de la red para el aprendizaje de extremo a extremo mediante retropropagación a partir de la pérdida de píxeles.
Tenga en cuenta que el filtro de deconvolución en una capa de este tipo no necesita ser reparado (p. Ej., Al muestreo ascendente bilineal), pero puede ser aprendido. Una pila de capas de desconvolución y funciones de activación pueden incluso aprender un muestreo ascendente no lineal.
En nuestros experimentos, encontramos que el muestreo en la red es rápido y efectivo para aprender predicciones densas. Nuestra mejor arquitectura de segmentación utiliza estas capas para aprender a muestrear para una predicción refinada en la Sección 4.2.

No creo haber entendido realmente cómo se entrenan las capas convolucionales.

Lo que creo que he entendido es que las capas convolucionales con un tamaño de núcleo aprenden filtros de tamaño k × k . La salida de una capa convolucional con el tamaño del núcleo k , zancada s ∈ N y n filtros es de dimensión $k$$k \times k$$k$$s \in \mathbb{N}$$n$. Sin embargo, no sé cómo funciona el aprendizaje de capas convolucionales. (Entiendo cómo los MLP simples aprenden con el descenso de gradiente, si eso ayuda).$\frac{\text{Input dim}}{s^2} \cdot n$

Entonces, si mi comprensión de las capas convolucionales es correcta, no tengo idea de cómo se puede revertir esto.

¿Alguien podría ayudarme a comprender las capas deconvolucionales?

La capa de desconvolución es un nombre muy desafortunado y debería llamarse una capa convolucional transpuesta .

Visualmente, para una convolución transpuesta con paso uno y sin relleno, simplemente rellenamos la entrada original (entradas azules) con ceros (entradas blancas) (Figura 1).

En el caso del paso dos y el relleno, la convolución transpuesta se vería así (Figura 2):

Puede encontrar más (excelentes) visualizaciones de aritmética convolucional aquí .

Creo que una forma de obtener una intuición de nivel realmente básica detrás de la convolución es que estás deslizando filtros K, que puedes considerar como plantillas K, sobre la imagen de entrada y producen activaciones K, cada una representando un grado de coincidencia con una plantilla particular . La operación inversa de eso sería tomar activaciones de K y expandirlas en una preimagen de la operación de convolución. La explicación intuitiva de la operación inversa es, por lo tanto, más o menos, la reconstrucción de imágenes dadas las plantillas (filtros) y las activaciones (el grado de coincidencia para cada plantilla) y, por lo tanto, en el nivel intuitivo básico, queremos volar cada activación por la máscara de la plantilla. y sumarlos.

Otra forma de abordar la comprensión de deconv sería examinar la implementación de la capa de deconvolución en Caffe, consulte los siguientes bits de código relevantes:

DeconvolutionLayer<Dtype>::Forward_gpu
ConvolutionLayer<Dtype>::Backward_gpu
CuDNNConvolutionLayer<Dtype>::Backward_gpu
BaseConvolutionLayer<Dtype>::backward_cpu_gemm

Puede ver que está implementado en Caffe exactamente como backprop para una capa convolucional hacia adelante regular (para mí fue más obvio después de comparar la implementación de backprop en cuDNN conv layer vs ConvolutionLayer :: Backward_gpu implementado usando GEMM). Entonces, si trabaja a través de cómo se realiza la propagación hacia atrás para una convolución regular, comprenderá lo que sucede a nivel de cálculo mecánico. La forma en que funciona este cálculo coincide con la intuición descrita en el primer párrafo de esta propaganda.

Sin embargo, no sé cómo funciona el aprendizaje de capas convolucionales. (Entiendo cómo los MLP simples aprenden con el descenso de gradiente, si eso ayuda).

Para responder a su otra pregunta dentro de su primera pregunta, hay dos diferencias principales entre la retropropagación MLP (capa totalmente conectada) y las redes convolucionales:

1) la influencia de los pesos está localizada, así que primero descubra cómo hacer backprop para, digamos, un filtro 3x3 convolucionado con un área pequeña de 3x3 de una imagen de entrada, mapeando a un solo punto en la imagen resultante.

2) los pesos de los filtros convolucionales se comparten para la invariancia espacial. Lo que esto significa en la práctica es que en el paso hacia adelante, el mismo filtro 3x3 con los mismos pesos se arrastra a través de toda la imagen con los mismos pesos para el cálculo hacia adelante para producir la imagen de salida (para ese filtro en particular). Lo que esto significa para backprop es que los gradientes de backprop para cada punto de la imagen de origen se suman en todo el rango que arrastramos ese filtro durante el paso hacia adelante. Tenga en cuenta que también hay diferentes gradientes de pérdida wrt x, w y sesgo ya que dLoss / dx necesita propagarse hacia atrás, y dLoss / dw es la forma en que actualizamos los pesos. w y sesgo son entradas independientes en el DAG de cálculo (no hay entradas anteriores), por lo que no hay necesidad de hacer propagación hacia atrás en ellas.

(my notation here assumes that convolution is y = x*w+b where '*' is the convolution operation)

Matemáticas paso a paso que explican cómo la convolución de transposición hace un muestreo ascendente 2x con un filtro 3x3 y un paso de 2:

El fragmento de TensorFlow más simple para validar las matemáticas:

import tensorflow as tf
import numpy as np

def test_conv2d_transpose():
    # input batch shape = (1, 2, 2, 1) -> (batch_size, height, width, channels) - 2x2x1 image in batch of 1
    x = tf.constant(np.array([[
        [[1], [2]], 
        [[3], [4]]
    ]]), tf.float32)

    # shape = (3, 3, 1, 1) -> (height, width, input_channels, output_channels) - 3x3x1 filter
    f = tf.constant(np.array([
        [[[1]], [[1]], [[1]]], 
        [[[1]], [[1]], [[1]]], 
        [[[1]], [[1]], [[1]]]
    ]), tf.float32)

    conv = tf.nn.conv2d_transpose(x, f, output_shape=(1, 4, 4, 1), strides=[1, 2, 2, 1], padding='SAME')

    with tf.Session() as session:
        result = session.run(conv)

    assert (np.array([[
        [[1.0], [1.0],  [3.0], [2.0]],
        [[1.0], [1.0],  [3.0], [2.0]],
        [[4.0], [4.0], [10.0], [6.0]],
        [[3.0], [3.0],  [7.0], [4.0]]]]) == result).all()

Las notas que acompañan a la clase CS231n de Stanford CS : Redes neuronales convolucionales para el reconocimiento visual, por Andrej Karpathy , hacen un excelente trabajo al explicar las redes neuronales convolucionales.

Leer este documento debería darle una idea aproximada sobre:

• Redes desconvolucionales Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor y Rob Fergus Departamento de Informática, Courant Institute, Universidad de Nueva York

Estas diapositivas son excelentes para las redes deconvolucionales.

Acabo de encontrar un gran artículo del sitio web de Theaon sobre este tema [1]:

La necesidad de convoluciones transpuestas generalmente surge del deseo de usar una transformación que vaya en la dirección opuesta a una convolución normal, [...] para proyectar mapas de características en un espacio de dimensiones superiores. [...] es decir, mapear desde un espacio de 4 dimensiones a un espacio de 16 dimensiones, manteniendo el patrón de conectividad de la convolución.

Las convoluciones transpuestas, también llamadas convoluciones de paso fraccionado, funcionan intercambiando los pasos hacia adelante y hacia atrás de una convolución. Una forma de decirlo es notar que el núcleo define una convolución, pero si se trata de una convolución directa o una convolución transpuesta se determina por cómo se calculan los pases hacia adelante y hacia atrás.

La operación de convolución transpuesta se puede considerar como el gradiente de alguna convolución con respecto a su entrada, que generalmente es cómo se implementan las convoluciones transpuestas en la práctica.

Finalmente, tenga en cuenta que siempre es posible implementar una convolución transpuesta con una convolución directa. La desventaja es que generalmente implica agregar muchas columnas y filas de ceros a la entrada, lo que resulta en una implementación mucho menos eficiente.

Entonces, en términos simples, una "convolución transpuesta" es una operación matemática que utiliza matrices (al igual que la convolución), pero es más eficiente que la operación de convolución normal en el caso en el que desea volver de los valores convolucionados al original (dirección opuesta). Por esta razón, en las implementaciones se prefiere la convolución cuando se calcula la dirección opuesta (es decir, para evitar muchas multiplicaciones 0 innecesarias causadas por la matriz dispersa que resulta del relleno de la entrada).

Image ---> convolution ---> Result

Result ---> transposed convolution ---> "originalish Image"

A veces guarda algunos valores a lo largo de la ruta de convolución y reutiliza esa información cuando "regresa":

Result ---> transposed convolution ---> Image

Esa es probablemente la razón por la que erróneamente se llama "deconvolución". Sin embargo, tiene algo que ver con la transposición matricial de la convolución (C ^ T), de ahí el nombre más apropiado "convolución transpuesta".

Por lo tanto, tiene mucho sentido cuando se considera el costo informático. Pagaría mucho más por Amazon gpus si no utilizara la convolución transpuesta.

Lea y vea las animaciones aquí cuidadosamente: http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#no-zero-padding-unit-strides-transposed

Alguna otra lectura relevante:

La transposición (o más generalmente, la transposición hermitiana o conjugada) de un filtro es simplemente el filtro coincidente [3]. Esto se encuentra invirtiendo el núcleo en el tiempo y tomando el conjugado de todos los valores [2].

También soy nuevo en esto y agradecería cualquier comentario o corrección.

[1] http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html

[2] http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#transposed-convolution-arithmetic

[3] https://en.wikipedia.org/wiki/Matched_filter

Podríamos usar PCA por analogía.

Cuando se usa conv, el paso hacia adelante es extraer los coeficientes de los componentes principales de la imagen de entrada, y el paso hacia atrás (que actualiza la entrada) es usar (el gradiente de) los coeficientes para reconstruir una nueva imagen de entrada, de modo que La nueva imagen de entrada tiene coeficientes de PC que coinciden mejor con los coeficientes deseados.

Cuando se usa deconv, el pase hacia adelante y el pase hacia atrás se invierten. El pase hacia adelante intenta reconstruir una imagen a partir de los coeficientes de la PC, y el pase hacia atrás actualiza los coeficientes de la PC dados (el gradiente de) la imagen.

El pase hacia adelante deconv hace exactamente el cálculo de gradiente conv en este post: http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/

Es por eso que en la implementación caffe de deconv (consulte la respuesta de Andrei Pokrovsky), el pase deconv forward llama a backward_cpu_gemm (), y el pase hacia atrás llama a forward_cpu_gemm ().

Además de la respuesta de David Dao: también es posible pensar al revés. En lugar de centrarse en qué píxeles de entrada (de baja resolución) se utilizan para producir un único píxel de salida, también puede centrarse en qué píxeles de entrada individuales contribuyen a qué región de píxeles de salida.

Esto se hace en esta publicación de destilación , que incluye una serie de visualizaciones muy intuitivas e interactivas. Una ventaja de pensar en esta dirección es que explicar los artefactos del tablero de ajedrez se vuelve fácil.

Convoluciones desde una perspectiva DSP

Llego un poco tarde a esto, pero todavía me gustaría compartir mi perspectiva y mis ideas. Mi formación es física teórica y procesamiento de señales digitales. En particular, estudié las wavelets y las convoluciones están casi en mi columna vertebral;)

La forma en que la gente de la comunidad de aprendizaje profundo habla sobre las circunvoluciones también me resultaba confusa. Desde mi perspectiva, lo que parece faltar es una separación adecuada de las preocupaciones. Explicaré las convoluciones de aprendizaje profundo usando algunas herramientas DSP.

Descargo de responsabilidad

Mis explicaciones serán un poco onduladas y no matemáticamente rigurosas para transmitir los puntos principales.

Definiciones

$x_n = \{x_n\}_{n=-\infty}^{\infty} = \{\dots, x_{-1}, x_{0}, x_{1}, \dots \}$

$y_n$$x_n$

$$(y * x)_n = \sum_{k=-\infty}^{\infty} y_{n-k} x_k$$

$\mathbf{q} = (q_0,q_1,q_2)$$\mathbf{x} = (x_0, x_1, x_2, x_3)^T$

$$\mathbf{q} * \mathbf{x} = \left( \begin{array}{cccc} q_1 & q_0 & 0 & 0 \\ q_2 & q_1 & q_0 & 0 \\ 0 & q_2 & q_1 & q_0 \\ 0 & 0 & q_2 & q_1 \\ \end{array} \right) \left( \begin{array}{cccc} x_0 \\ x_1 \\ x_2 \\ x_3 \end{array} \right)$$

$\downarrow$$\uparrow$$k \in \mathbb{N}$

$$\downarrow_k\!x_n = x_{nk}$$

$k$$k-1$

$$\uparrow_k\!x_n = \left \{ \begin{array}{ll} x_{n/k} & n/k \in \mathbb{Z} \\ 0 & \text{otherwise} \end{array} \right.$$

$k=3$

$$\downarrow_3\!\{ \dots, x_0, x_1, x_2, x_3, x_4, x_5, x_6, \dots \} = \{ \dots, x_0, x_3, x_6, \dots \}$$ $$\uparrow_3\!\{ \dots, x_0, x_1, x_2, \dots \} = \{ \dots x_0, 0, 0, x_1, 0, 0, x_2, 0, 0, \dots \}$$

$k=2$

$$\downarrow_2\!x = \left( \begin{array}{cc} x_0 \\ x_2 \end{array} \right) = \left( \begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ \end{array} \right) \left( \begin{array}{cccc} x_0 \\ x_1 \\ x_2 \\ x_3 \end{array} \right)$$

y

$$\uparrow_2\!x = \left( \begin{array}{cccc} x_0 \\ 0 \\ x_1 \\ 0 \end{array} \right) = \left( \begin{array}{cc} 1 & 0 \\ 0 & 0 \\ 0 & 1 \\ 0 & 0 \\ \end{array} \right) \left( \begin{array}{cc} x_0 \\ x_1 \end{array} \right)$$

$\uparrow_k = \downarrow_k^T$

Convoluciones de aprendizaje profundo por partes

$\mathbf{q}$$\mathbf{x}$ tenemos lo siguiente:

• $k$$\downarrow_k\!(\mathbf{q} * \mathbf{x})$ ,
• $k$$(\uparrow_k\!\mathbf{q}) * \mathbf{x}$ ,
• $k$$\mathbf{q} * (\uparrow_k\!\mathbf{x})$

$$\mathbf{q} * (\uparrow_k\!\mathbf{x}) \; = \; \mathbf{q} * (\downarrow_k^T\!\mathbf{x}) \; = \; (\uparrow_k\!(\mathbf{q}*)^T)^T\mathbf{x}$$

$(\mathbf{q}*)$$\mathbf{q}$

$$\begin{align} \mathbf{q} * (\uparrow_k\!\mathbf{x}) & = \left( \begin{array}{cccc} q_1 & q_0 & 0 & 0 \\ q_2 & q_1 & q_0 & 0 \\ 0 & q_2 & q_1 & q_0 \\ 0 & 0 & q_2 & q_1 \\ \end{array} \right) \left( \begin{array}{cc} 1 & 0 \\ 0 & 0 \\ 0 & 1 \\ 0 & 0 \\ \end{array} \right) \left( \begin{array}{c} x_0\\ x_1\\ \end{array} \right) \\ & = \left( \begin{array}{cccc} q_1 & q_2 & 0 & 0 \\ q_0 & q_1 & q_2 & 0 \\ 0 & q_0 & q_1 & q_2 \\ 0 & 0 & q_0 & q_1 \\ \end{array} \right)^T \left( \begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 0 & 1 & 0\\ \end{array} \right)^T \left( \begin{array}{c} x_0\\ x_1\\ \end{array} \right) \\ & = \left( \left( \begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 0 & 1 & 0\\ \end{array} \right) \left( \begin{array}{cccc} q_1 & q_2 & 0 & 0 \\ q_0 & q_1 & q_2 & 0 \\ 0 & q_0 & q_1 & q_2 \\ 0 & 0 & q_0 & q_1 \\ \end{array} \right) \right)^T \left( \begin{array}{c} x_0\\ x_1\\ \end{array} \right) \\ & = (\uparrow_k\!(\mathbf{q}*)^T)^T\mathbf{x} \end{align}$$

Como se puede ver, es la operación transpuesta, por lo tanto, el nombre.

Conexión al muestreo ascendente vecino más cercano

$\uparrow_2\!(1\;1) * \mathbf{x}$$\mathbf{q}$$\uparrow_2\!(1\;1) * \mathbf{q} * \mathbf{x}$$\mathbf{q}=(q_0\;q_1\;q_2)$

$$(1\;1) * \mathbf{q} = (q_0\;\;q_0\!\!+\!q_1\;\;q_1\!\!+\!q_2\;\;q_2),$$

es decir, podemos reemplazar un muestreador ascendente repetido con factor 2 y una convolución con un núcleo de tamaño 3 por una convolución transpuesta con un tamaño de núcleo 4. Esta convolución transpuesta tiene la misma "capacidad de interpolación" pero podría aprender mejores interpolaciones de coincidencia.

Conclusiones y observaciones finales

Espero poder aclarar algunas convoluciones comunes que se encuentran en el aprendizaje profundo un poco separándolas en las operaciones fundamentales.

No cubrí la agrupación aquí. Pero esto es solo un muestreador no lineal y también puede tratarse dentro de esta notación.

Tuve muchos problemas para comprender qué sucedió exactamente en el documento hasta que encontré esta publicación de blog: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -with-tensorflow-and-tf-slim /

Aquí hay un resumen de cómo entiendo lo que está sucediendo en un muestreo superior 2x:

Información de papel

• ¿Qué es el muestreo ascendente?
  • "el muestreo ascendente con factor f es una convolución con un paso de entrada fraccional de 1 / f"
  • → las convoluciones fraccionadas se conocen también como convoluciones transpuestas según, por ejemplo, http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html
• ¿Cuáles son los parámetros de esa convolución?
  • factor f = 2
  • → entrada de zancada de 1 / f = 1/2
  • → tamaño del grano = 2 * factor - factor% 2 = 2 * 2 -0 = 4 según http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -with-tensorflow-and-tf-slim /
• ¿Los pesos son fijos o entrenables?
  • El documento establece que "inicializamos el muestreo ascendente 2x a la interpolación bilineal, pero permitimos que se aprendan los parámetros [...]".
  • Sin embargo, la página correspondiente de github dice "En nuestros experimentos originales, las capas de interpolación se inicializaron en núcleos bilineales y luego se aprendieron. En los experimentos de seguimiento, y esta implementación de referencia, los núcleos bilineales son fijos".
  • → pesos fijos

Ejemplo simple

1. imagine la siguiente imagen de entrada:

2. Las convoluciones fraccionadamente estriadas funcionan insertando factor-1 = 2-1 = 1 ceros entre estos valores y luego asumiendo stride = 1 más adelante. Por lo tanto, recibirá la siguiente imagen acolchada de 6x6

3. El filtro bilineal 4x4 se ve así. Sus valores se eligen de tal manera que los pesos utilizados (= todos los pesos que no se multiplican con un cero insertado) suman 1. Sus tres valores únicos son 0.56, 0.19 y 0.06. Además, el centro del filtro es, por convención, el píxel en la tercera fila y la tercera columna.

4. Al aplicar el filtro 4x4 en la imagen acolchada (usando padding = 'same' y stride = 1) se obtiene la siguiente imagen muestreada 6x6:

5. Este tipo de muestreo ascendente se realiza individualmente para cada canal (consulte la línea 59 en https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py ). Al final, el muestreo ascendente 2x es realmente un cambio de tamaño muy simple usando interpolación bilineal y convenciones sobre cómo manejar los bordes. El muestreo ascendente de 16x o 32x funciona de la misma manera, creo.

El siguiente artículo analiza las capas deconvolucionales, tanto desde el punto de vista arquitectónico como de capacitación. Redes desconvolucionales