Em uma rede neural convolucional (CNN), ao envolver a imagem, a operação usa o produto escalar ou a soma da multiplicação por elementos?

O exemplo abaixo é retirado das palestras em deeplearning.ai mostra que o resultado é a soma do produto elemento por elemento (ou "multiplicação elemento a elemento". Os números vermelhos representam os pesos no filtro:

$(1*1)+(1*0)+(1*1)+(0*0)+(1*1)+(1*0)+(0*1)+(0*0)+(1*1) = 1+0+1+0+1+0+0+0+1 = 4$

No entanto, a maioria dos recursos diz que é o produto escalar usado:

"... podemos reexprimir a saída do neurônio como, onde é o termo de viés. Em outras palavras, podemos calcular a saída por y = f (x * w) onde b é o termo de viés. Em outras palavras, nós pode calcular a saída executando o produto escalar dos vetores de entrada e peso, adicionando o termo de tendência para produzir o logit e aplicando a função de transformação ".

Buduma, Nikhil; Locascio, Nicholas. Fundamentos da aprendizagem profunda: projetando algoritmos de inteligência de máquina de última geração (p. 8). O'Reilly Media. Edição Kindle.

"Pegamos o filtro 5 * 5 * 3 e deslizamos sobre a imagem completa e, ao longo do caminho, pegamos o produto escalar entre o filtro e os pedaços da imagem de entrada. Para cada produto escalar obtido, o resultado é escalar."

https://medium.com/technologymadeeasy/the-best-explanation-of-convolutional-neural-networks-on-the-internet-fbb8b1ad5df8

"Cada neurônio recebe algumas entradas, executa um produto escalar e, opcionalmente, o segue com uma não linearidade".

http://cs231n.github.io/convolutional-networks/

"O resultado de uma convolução agora é equivalente a executar uma grande matriz multiplicada por np.dot (W_row, X_col), que avalia o produto escalar entre cada filtro e cada local de campo receptivo".

http://cs231n.github.io/convolutional-networks/

No entanto, quando pesquiso como calcular o produto escalar das matrizes , parece que o produto escalar não é o mesmo que somar a multiplicação elemento a elemento. Qual operação é realmente usada (multiplicação elemento a elemento ou o produto escalar?) E qual é a principal diferença?

Qualquer camada em uma CNN tem normalmente três dimensões (nós as chamaremos de altura, largura, profundidade). A convolução produzirá uma nova camada com uma nova (ou mesma) altura, largura e profundidade. A operação, porém, é realizada de maneira diferente na altura / largura e na profundidade, e é isso que acho que causa confusão.

Vamos primeiro ver como a operação de convolução na altura e largura da matriz de entrada. Este caso é executado exatamente como representado na sua imagem e é certamente uma multiplicação por elementos das duas matrizes .

Em teoria :
as convoluções bidimensionais (discretas) são calculadas pela fórmula abaixo:

Como você pode ver cada elemento de é calculada como a soma dos produtos de um único elemento de com um único elemento de . Isto significa que cada elemento de é calculado a partir da soma da multiplicação elemento a elemento de e .$C$$A$$B$$C$$A$$B$

Na prática :
você pode testar o exemplo acima com qualquer número de pacotes (usarei o scipy ):

import numpy as np
from scipy.signal import convolve2d

A = np.array([[1,1,1,0,0],[0,1,1,1,0],[0,0,1,1,1],[0,0,1,1,0],[0,1,1,0,0]])
B = np.array([[1,0,1],[0,1,0],[1,0,1]])
C = convolve2d(A, B, 'valid')
print(C)

O código acima produzirá:

[[4 3 4]
 [2 4 3]
 [2 3 4]]

Agora, a operação de convolução na profundidade da entrada pode realmente ser considerada como um produto escalar, pois cada elemento da mesma altura / largura é multiplicado pelo mesmo peso e somados. Isso é mais evidente no caso de convoluções 1x1 (normalmente usadas para manipular a profundidade de uma camada sem alterar suas dimensões). Isso, no entanto, não faz parte de uma convolução 2D (do ponto de vista matemático), mas algo que as camadas convolucionais fazem nas CNNs.

Notas :
1: Dito isto, acho que a maioria das fontes que você forneceu tem explicações enganosas para dizer o mínimo e não estão corretas. Eu não sabia que muitas fontes têm esta operação (que é a operação mais essencial nas CNNs) errada. Eu acho que tem algo a ver com o fato de que as convoluções somam o produto entre escalares e o produto entre dois escalares também é chamado de produto escalar .
2: Penso que a primeira referência se refere a uma camada totalmente conectada, em vez de uma camada convolucional. Se for esse o caso, uma camada FC executa o produto escalar conforme indicado. Não tenho o resto do contexto para confirmar isso.

tl; dr A imagem que você forneceu é 100% correta de como a operação é executada, mas essa não é a imagem completa. As camadas CNN têm três dimensões, duas das quais são tratadas como representado. Minha sugestão seria verificar como as camadas convolucionais lidam com a profundidade da entrada (o caso mais simples que você pode ver são convoluções 1x1).

A operação é chamada de convolução, que envolve uma soma de elementos por multiplicação de elementos, que, por sua vez, é o mesmo que um produto escalar em matrizes multidimensionais que as pessoas de ML chamam de tensores. Se você escrevê-lo como um loop, ele se parecerá com este pseudo código Python:

for i in 0:3:
  for j in 0:3:
    s = 0
    for k in 0:3:
      for l in 0:3:
        s += A[i+k,j+l]*C[k,l]
    Z[i,j] = s

Aqui A é sua matriz de entrada 5x5, C é filtro 3x3 e Z é matriz de saída 3x3.

A diferença sutil com um produto de ponto é que geralmente um produto de ponto está em vetores inteiros, enquanto que na convolução você faz um produto de ponto no subconjunto em movimento (janela) da matriz de entrada, você pode escrevê-lo da seguinte forma para substituir os dois aninhados mais internos loops no código acima:

Z[i,j] = dot(A[i:i+2,j:j+2],C)

Acredito que a chave é que, quando o filtro convolve parte da imagem (o "campo receptivo"), cada número no filtro (ou seja, cada peso) é primeiro achatado em formato vetorial . Da mesma forma, os pixels da imagem também são achatados em formato vetorial . ENTÃO, o produto escalar é calculado. O que é exatamente o mesmo que encontrar a soma da multiplicação elemento a elemento (elemento a elemento).

Obviamente, esses vetores achatados também podem ser combinados em um formato de matriz, como mostra a imagem abaixo. Nesse caso, a multiplicação de matriz verdadeira pode ser usada, mas é importante observar que o nivelamento dos pixels da imagem de cada convolução e também do filtro de pesos é o precursor.

crédito de imagem: TensorFlow e Deep Learning sem doutorado, Parte 1 (Google Cloud Next '17)