Li recentemente Redes totalmente convolucionais para segmentação semântica de Jonathan Long, Evan Shelhamer, Trevor Darrell. Não entendo o que as "camadas desconvolucionais" fazem / como elas funcionam.

A parte relevante é

3.3 Upsampling é convolução para trás

Outra maneira de conectar saídas grosseiras a pixels densos é a interpolação. Por exemplo, a interpolação bilinear simples calcula cada saída das quatro entradas mais próximas por um mapa linear que depende apenas das posições relativas das células de entrada e saída. Em certo sentido, a ampliação do fator f é convolução com um passo de entrada fracionário de 1 / f. Desde que f seja integral, uma maneira natural de aumentar a amostra é, portanto, a convolução reversa (às vezes chamada deconvolução) com um passo de saída de f . Tal operação é trivial de implementar, uma vez que simplesmente inverte os passes de convolução para frente e para trás.$y_{ij}$
$f$$f$$f$
Assim, o upsampling é realizado em rede para aprendizado de ponta a ponta por retropropagação a partir da perda de pixel.
Observe que o filtro de deconvolução em uma camada desse tipo não precisa ser corrigido (por exemplo, para amostragem bilinear), mas pode ser aprendido. Uma pilha de camadas de desconvolução e funções de ativação pode até aprender uma upsampling não linear.
Em nossas experiências, descobrimos que a amostragem na rede é rápida e eficaz para aprender previsões densas. Nossa melhor arquitetura de segmentação usa essas camadas para aprender a fazer um upsample para previsões refinadas na Seção 4.2.

Acho que não entendi como as camadas convolucionais são treinadas.

O que eu acho que entendi é que as camadas convolucionais com um tamanho de núcleo aprendem filtros do tamanho k × k . A saída de uma camada convolucional com tamanho de kernel K , passo s ∈ N e n filtros de dimensão é $k$$k \times k$$k$$s \in \mathbb{N}$$n$. No entanto, não sei como funciona o aprendizado de camadas convolucionais. (Entendo como os MLPs simples aprendem com descida de gradiente, se isso ajudar).$\frac{\text{Input dim}}{s^2} \cdot n$

Portanto, se meu entendimento das camadas convolucionais está correto, não tenho idéia de como isso pode ser revertido.

Alguém poderia me ajudar a entender as camadas desconvolucionais?

Camada de desconvolução é um nome muito infeliz e deveria ser chamada de camada convolucional transposta .

Visualmente, para uma convolução transposta com passo um e sem preenchimento, apenas preenchemos a entrada original (entradas em azul) com zeros (entradas em branco) (Figura 1).

No caso do passo dois e do preenchimento, a convolução transposta ficaria assim (Figura 2):

Você pode encontrar mais (ótimas) visualizações de aritmética convolucional aqui .

Eu acho que uma maneira de obter uma intuição de nível realmente básico por trás da convolução é que você está deslizando os filtros K, que podem ser considerados K ​​stencils, sobre a imagem de entrada e produzindo ativações K - cada uma representando um grau de correspondência com um estêncil específico . A operação inversa disso seria pegar as ativações de K e expandi-las para uma pré-imagem da operação de convolução. A explicação intuitiva da operação inversa é, portanto, aproximadamente, a reconstrução da imagem, considerando os estênceis (filtros) e as ativações (o grau de correspondência de cada estêncil) e, portanto, no nível intuitivo básico, queremos explodir cada ativação pela máscara do estêncil e adicione-os.

Outra maneira de abordar o entendimento do deconv seria examinar a implementação da camada de deconvolução no Caffe, consulte os seguintes bits de código relevantes:

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

Você pode ver que ele é implementado no Caffe exatamente como backprop para uma camada convolucional direta regular (para mim, era mais óbvio depois que eu comparei a implementação do backprop na camada conv cuDNN vs ConvolutionLayer :: Backward_gpu implementado usando o GEMM). Portanto, se você trabalhar com o modo como a retropropagação é feita para convolução regular, você entenderá o que acontece no nível da computação mecânica. O modo como esse cálculo funciona corresponde à intuição descrita no primeiro parágrafo deste resumo.

No entanto, não sei como funciona o aprendizado de camadas convolucionais. (Entendo como os MLPs simples aprendem com descida de gradiente, se isso ajudar).

Para responder sua outra pergunta na sua primeira pergunta, há duas diferenças principais entre a propagação traseira do MLP (camada totalmente conectada) e as redes convolucionais:

1) a influência dos pesos está localizada; portanto, primeiro descubra como fazer backprop para, digamos, um filtro 3x3 convoluído com uma pequena área 3x3 de uma imagem de entrada, mapeando para um único ponto na imagem resultante.

2) os pesos dos filtros convolucionais são compartilhados para invariância espacial. O que isso significa na prática é que, na passagem direta, o mesmo filtro 3x3 com os mesmos pesos é arrastado por toda a imagem com os mesmos pesos para que a computação direta produza a imagem de saída (para esse filtro específico). O que isso significa para o backprop é que os gradientes do backprop para cada ponto na imagem de origem são somados em todo o intervalo que arrastamos esse filtro durante a passagem para frente. Observe que também existem gradientes diferentes de perda wrt x, we viés, pois o dLoss / dx precisa ser retropropagado, e o dLoss / dw é como atualizamos os pesos. we viés são entradas independentes no DAG de computação (não há entradas anteriores), portanto não há necessidade de retropropagação nelas.

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

Matemática passo a passo, explicando como a transposição da convolução faz o upsampling 2x com filtro 3x3 e passo de 2:

O trecho mais simples do TensorFlow para validar a matemática:

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

As notas que acompanham a classe CS231n de Stanford CS : Redes neurais convolucionais para reconhecimento visual, de Andrej Karpathy , fazem um excelente trabalho na explicação de redes neurais convolucionais.

A leitura deste documento deve fornecer uma idéia aproximada sobre:

• Redes deconvolucionais Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor e Rob Fergus Dept. de Ciência da Computação, Courant Institute, New York University

Esses slides são ótimos para as redes deconvolucionais.

Acabei de encontrar um ótimo artigo no site da theaon sobre este tópico [1]:

A necessidade de convoluções transpostas geralmente surge do desejo de usar uma transformação na direção oposta a uma convolução normal, [...] para projetar mapas de características para um espaço de maior dimensão. [...] isto é, mapeie de um espaço 4-dimensional para um espaço 16-dimensional, mantendo o padrão de conectividade da convolução.

As convoluções transpostas - também chamadas convoluções fracionadas - funcionam trocando as passagens para frente e para trás de uma convolução. Uma maneira de colocar isso é observar que o kernel define uma convolução, mas se é uma convolução direta ou uma convolução transposta é determinada pela maneira como as passagens para frente e para trás são calculadas.

A operação de convolução transposta pode ser pensada como o gradiente de alguma convolução em relação à sua entrada, que geralmente é como as convoluções transpostas são implementadas na prática.

Por fim, observe que sempre é possível implementar uma convolução transposta com uma convolução direta. A desvantagem é que geralmente envolve adicionar muitas colunas e linhas de zeros à entrada, resultando em uma implementação muito menos eficiente.

Portanto, em linguagem simples, uma "convolução transposta" é uma operação matemática usando matrizes (como a convolução), mas é mais eficiente que a operação de convolução normal no caso em que você deseja voltar dos valores convoluídos para o original (direção oposta). É por isso que é preferível nas implementações a convolução ao computar na direção oposta (ou seja, para evitar muitas multiplicações 0 desnecessárias causadas pela matriz esparsa que resulta do preenchimento da entrada).

Image ---> convolution ---> Result

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

Às vezes, você salva alguns valores no caminho da convolução e reutiliza essas informações ao "voltar":

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

Essa é provavelmente a razão pela qual é chamada erroneamente de "deconvolução". No entanto, tem algo a ver com a transposição da matriz da convolução (C ^ T), daí o nome mais apropriado "convolução transposta".

Portanto, faz muito sentido ao considerar o custo da computação. Você pagaria muito mais pelo Amazon Gpus se não usasse a convolução transposta.

Leia e assista as animações aqui com atenção: http://deeplearning.net/software/theano_versions/dev/tutorial/conv_arithmetic.html#no-zero-padding-unit-strides-transposed

Algumas outras leituras relevantes:

A transposição (ou mais geralmente, a transposição hermitiana ou conjugada) de um filtro é simplesmente o filtro correspondente [3]. Isso é encontrado ao reverter o kernel e pegar o conjugado de todos os valores [2].

Eu também sou novo nisso e ficaria grato por quaisquer comentários ou correções.

[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

Poderíamos usar o PCA para analogia.

Ao usar conv, a passagem direta é extrair os coeficientes dos componentes principais da imagem de entrada, e a passagem traseira (que atualiza a entrada) é usar (o gradiente) os coeficientes para reconstruir uma nova imagem de entrada, nova imagem de entrada possui coeficientes de PC que melhor correspondem aos coeficientes desejados.

Ao usar deconv, o passe para frente e para trás são revertidos. O passe para frente tenta reconstruir uma imagem a partir dos coeficientes do PC, e o passo para trás atualiza os coeficientes do PC dados (o gradiente) da imagem.

O passo de deconv forward faz exatamente o cálculo do gradiente de convenção fornecido neste post: http://andrew.gibiansky.com/blog/machine-learning/convolutional-neural-networks/

É por isso que, na implementação caffe do deconv (consulte a resposta de Andrei Pokrovsky), o passe de deconv chama backward_cpu_gemm () e o passe de retorno chama forward_cpu_gemm ().

Além da resposta de David Dao: Também é possível pensar o contrário. Em vez de focar em quais pixels de entrada (baixa resolução) são usados ​​para produzir um único pixel de saída, você também pode focar em quais pixels de entrada individuais contribuem para qual região dos pixels de saída.

Isso é feito nesta publicação destilada , incluindo uma série de visualizações muito intuitivas e interativas. Uma vantagem de pensar nessa direção é que é fácil explicar os artefatos do tabuleiro de damas.

Convoluções da perspectiva do DSP

Estou um pouco atrasado para isso, mas ainda gostaria de compartilhar minha perspectiva e idéias. Minha formação é em física teórica e processamento de sinais digitais. Em particular, estudei wavelets e convolutions estão quase na minha espinha dorsal;)

O modo como as pessoas da comunidade de aprendizado profundo falam sobre convoluções também foi confuso para mim. Na minha perspectiva, o que parece estar faltando é uma separação adequada de preocupações. Vou explicar as convoluções de aprendizado profundo usando algumas ferramentas DSP.

aviso Legal

Minhas explicações serão um pouco onduladas e não serão rigorosas em termos matemáticos, a fim de esclarecer os principais pontos.

Definições

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

e

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

Convoluções de Deep Learning por peças

$\mathbf{q}$$\mathbf{x}$

• $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 pode ver, é a operação transposta, portanto, o nome.

Conexão com o Upsampling de vizinho mais próximo

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

ou seja, podemos substituir um upsampler repetido pelo fator 2 e uma convolução com um núcleo de tamanho 3 por uma convolução transposta com tamanho de núcleo 4. Essa convolução transposta tem a mesma "capacidade de interpolação", mas seria capaz de aprender melhor interpolações correspondentes.

Conclusões e considerações finais

Espero poder esclarecer algumas convoluções comuns encontradas no aprendizado profundo, desmembrando-as nas operações fundamentais.

Eu não cobri piscina aqui. Mas este é apenas um downsampler não linear e também pode ser tratado nessa notação.

Eu tive muitos problemas para entender o que exatamente aconteceu no artigo até me deparar com esta postagem do blog: http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -com-tensorflow-e-tf-slim /

Aqui está um resumo de como eu entendo o que está acontecendo em uma upsampling 2x:

Informações do papel

• O que é upsampling?
  • "upsampling com fator f é convolução com passo de entrada fracionário de 1 / f"
  • → convoluções fracionadas também são conhecidas como convolução transposta de acordo com, por exemplo, http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html
• Quais são os parâmetros dessa convolução?
  • fator f = 2
  • → passo de entrada de 1 / f = 1/2
  • → tamanho do kernel = 2 * fator - fator% 2 = 2 * 2 -0 = 4 de acordo com http://warmspringwinds.github.io/tensorflow/tf-slim/2016/11/22/upsampling-and-image-segmentation -com-tensorflow-e-tf-slim /
• Os pesos são fixos ou treináveis?
  • O artigo afirma "inicializamos a amostragem 2x para interpolação bilinear, mas permitimos que os parâmetros sejam aprendidos [...]".
  • No entanto, a página correspondente do github declara "Em nossos experimentos originais, as camadas de interpolação foram inicializadas em núcleos bilineares e depois aprendidas. Nas experiências subsequentes e nesta implementação de referência, os núcleos bilineares são fixos"
  • → pesos fixos

Exemplo simples

1. imagine a seguinte imagem de entrada:

2. As convulsões fracionadas funcionam por meio da inserção de fator-1 = 2-1 = 1 zeros entre esses valores e assumindo a passada = 1 posteriormente. Assim, você recebe a seguinte imagem acolchoada 6x6

3. O filtro bilinear 4x4 se parece com isso. Seus valores são escolhidos de forma que os pesos utilizados (= todos os pesos que não estão sendo multiplicados com um zero inserido) somam 1. Seus três valores únicos são 0,56, 0,19 e 0,06. Além disso, o centro do filtro é por convenção o pixel na terceira linha e terceira coluna.

4. A aplicação do filtro 4x4 na imagem preenchida (usando padding = 'same' e stride = 1) gera a seguinte imagem ampliada de 6x6:

5. Esse tipo de upsampling é realizado para cada canal individualmente (consulte a linha 59 em https://github.com/shelhamer/fcn.berkeleyvision.org/blob/master/surgery.py ). No final, a ampliação de 2x é realmente um redimensionamento muito simples usando interpolação bilinear e convenções sobre como lidar com as bordas. A upsampling de 16x ou 32x funciona da mesma maneira, acredito.

O artigo a seguir discute as camadas desconvolucionais. Do ponto de vista da arquitetura e do treinamento. Redes desconvolucionais