Como exatamente as redes neurais convolucionais usam a convolução no lugar da multiplicação da matriz?

Eu estava lendo o livro de Yoshua Bengio sobre aprendizado profundo e está escrito na página 224:

As redes convolucionais são simplesmente redes neurais que usam a convolução no lugar da multiplicação geral da matriz em pelo menos uma de suas camadas.

no entanto, eu não tinha 100% de certeza de como "substituir a multiplicação de matrizes por convolução" em um sentido matematicamente preciso.

O que realmente me interessa é defini-lo para vetores de entrada em 1D (como em $x \in \mathbb{R}^d$ ), para não ter entrada como imagem e tentar evitar a convolução em 2D.

Assim, por exemplo, em redes neurais "normais", as operações e o padrão da ala de alimentação podem ser expressos de forma concisa, como nas 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)}$

onde é o vetor calculado antes de passar pela não linearidade . A não linearidade atua pero entrada no vetor e é a saída / ativação de unidades ocultas para a camada em questão. $z^{(l)}$ $f$ $z^{(l)}$ $a^{(l+1)}$

Esse cálculo é claro para mim porque a multiplicação de matrizes é claramente definida para mim, no entanto, apenas substituir a multiplicação de matrizes por convolução parece pouco claro para mim. ie

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

Quero ter certeza de que entendo matematicamente a equação acima.

O primeiro problema que tenho ao substituir a multiplicação de matrizes por convolução é que, geralmente, identifica-se uma linha de com um produto escalar. Portanto, sabe-se claramente como o todo se relaciona com os pesos e que mapeia para um vetor da dimensão, conforme indicado por . No entanto, quando se substitui por convoluções, não é claro a ME que fileiras ou pesos corresponde a qual entradas em $W^{(l)}$ $a^{(l)}$ $z^{(l+1)}$ $W^{(l)}$ $a^{(l)}$ . Nem sequer está claro para mim que faz sentido representar mais os pesos como uma matriz (vou fornecer um exemplo para explicar esse ponto mais adiante)

No caso em que as entradas e saídas estão todas em 1D, calcula-se a convolução de acordo com sua definição e depois passa-a por uma singularidade?

Por exemplo, se tivéssemos o seguinte vetor como entrada:

x = [1, 2, 3, 4]

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

e tivemos os seguintes pesos (talvez tenhamos aprendido com backprop):

W = [5, 6, 7]

$W = [5,6,7]$

então a convolução é:

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

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

seria correto apenas passar a não linearidade por meio disso e tratar o resultado como a camada / representação oculta (suponha que não haja pool no momento)? isto é:

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

( acho que o tutorial UDLF de Stanford apara as bordas em que a convolução convoca com 0 por algum motivo, precisamos aparar isso?)

É assim que deve funcionar? Pelo menos para um vetor de entrada em 1D? O não é mais um vetor? $W$

Eu até desenhei uma rede neural de como isso deve parecer:

insira a descrição da imagem aqui

machine-learning neural-networks deep-learning convolution Charlie Parker
fonte

Respostas:

Parece-me que você está no caminho certo, mas talvez eu possa ajudar a esclarecer.

Saída única

Vamos imaginar uma camada de rede neural tradicional com unidades de entrada e 1 saída (vamos também assumir que não há viés). Esta camada tem um vetor de pesos que pode ser aprendido utilizando vários métodos (Retropropagação, algoritmos genéticos, etc.), mas vamos ignorar a aprendizagem e se concentrar apenas na propagação para a frente. $n$ $w\in\mathbb{R}^n$

$x\in\mathbb{R}^n$ $a\in\mathbb{R}$ $x$ $w$ $\sigma$

a = σ (x \cdot w)

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

$w$ $x$ $x$ $w$

$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*}$

$w$

Você já colocou isso basicamente em sua pergunta, mas estou tentando percorrer a conexão com as camadas de rede neural baunilha usando o produto escalar para fazer uma observação. A principal diferença com as camadas de rede de baunilha é que, se o vetor de entrada for maior que o vetor de peso, uma convolução transforma a saída da camada de rede em um vetor - nas redes de convolução, são vetores até o fim! Esse vetor de saída é chamado de "mapa de recursos" para a unidade de saída nesta camada.

Múltiplas saídas

$n$ $w^1\in\mathbb{R}^n$ $w^2\in\mathbb{R}^n$

$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}]$ $A = [a^1 a^2]$

A = σ (X * W)

$A = \sigma(X * W)$

X

$X$

W

$W$

Espero que seja útil!

lmjohns3
fonte

Uma camada convolucional é um subconjunto estrito de uma rede totalmente conectada, isto é, uma multiplicação de matrizes. Uma camada convolucional na passagem para frente é de fato equivalente a uma multiplicação de matrizes em que:

alguns pesos estão amarrados / compartilhados
alguns pesos são zero

No passe para trás, os pesos serão atualizados de acordo com os pesos que contribuíram com o quanto no passe para frente. ou seja, os pesos que eram zero ainda são zero. Os pesos amarrados em várias saídas receberão gradiente de todas essas saídas (cujos gradientes são somados, para produzir a atualização final do gradiente para esse peso).

Hugh Perkins
fonte

Não, não é assim que deve funcionar. A operação de convolução sempre torna a entrada menor (para filtros com tamanho> 1), não maior como no seu exemplo.

$1∗5+2∗6+3∗7=38$

pir
fonte

você tentou conv ([1, 2, 3, 4], [5,6,7]) no matlab? Vá para o terminal e verifique você mesmo. Se você usar a definição convencional de convolução, poderá calcular manualmente o vetor [5,16,34,52,45,28]. O vetor nem sempre encolhe. Depende de onde você começa a fazer a convolução e se você trata as coisas fora do intervalo do índice como zero. Se você fizer como sugeri neste post, você obterá um vetor de tamanho

N + n - 1

$N+n -1$ . Se você cortar as arestas (porque o índice está fora do intervalo), você obtém um vetor de tamanho

N - n + 1

$N-n+1$ , onde N e n são o tamanho dos vetores em questão.

Charlie Parker

A convolução usada nesse webapge não é a definição da convolução matemática.

Charlie Parker

Sim, a convolução usada para a CNN não é a convolução usual. Isso é confuso para todos, mas é assim que as coisas são :) Dada a natureza da CNN, ou seja, analisar uma imagem, ela sempre começará com a primeira.

n

$n$ elementos, onde

n

$n$ é o tamanho do filtro e depois passa sobre a entrada. No entanto, não será estendido além do final, portanto a produção será reduzida por

n - 1

$n-1$ .

Pir

Entendo, acho que faz sentido agora que procurei. No entanto, há um pequeno erro. A entrada nem sempre a torna menor, eu estou ciente dos diferentes tipos de convoluções agora e até na CNN, de acordo com o livro de Yoshua Bengio, existem 3 tipos de convoluções (completas, válidas, iguais) iro.umontreal.ca/ ~ bengioy / dlbook . Eu não os entendo em detalhes, mas pelo menos estou ciente deles! Obrigado Felbo. A comunidade de visão não deve usar a palavra convoluções, é confusa e irritante. De qualquer forma, obrigado.

Charlie Parker

@CharlieParker A função conv no Matlab tem os mesmos 3 tipos de "formas" (completa, válida, igual), o Matlab assume o padrão "cheio" - consulte a documentação em mathworks.com/help/matlab/ref/conv.html . Uma convolução sem virar o kernel é uma correlação cruzada xcorr(x, y) = conv(x, fliplr(y)). A comunidade NN tende a dizer convolução quando está realmente fazendo uma correlação cruzada, mas é bem parecida.

lmjohns3