CNN - Como funciona a retropropagação com compartilhamento de peso exatamente?

Considere uma Rede Neural Convolucional (CNN) para classificação de imagens. Para detectar recursos locais, o compartilhamento de peso é usado entre unidades na mesma camada convolucional. Nessa rede, os pesos do kernel são atualizados através do algoritmo de retropropagação.

Uma atualização para o peso do kernel $h_j$ na camada $l$ seria o seguinte:

$h_j^l = h_j^l - \eta \cdot \frac{\delta R}{\delta h_j^l} = h_j^l - \eta \cdot \frac{\delta R}{\delta x_j^{L}} \cdot \frac{\delta x_j^{L}}{\delta x_j^{L - 1}} \cdot ... \cdot \frac{\delta x_j^{l}}{\delta h_j^l}$

Como os pesos do kernel podem ser atualizados e ainda serem os mesmos (= compartilhados)?

Eu tenho 2 explicações possíveis:

1. Os pesos da mesma camada, que são inicializados com o mesmo valor, permanecerão os mesmos (independentemente da entrada). Isso implicaria que a expressão$\frac{\delta R}{\delta h_j^l}$ é o mesmo para todos esses pesos $h_1^l$ para $h_J^l$. Isso não faz sentido, já que$x_j^l$é diferente para diferentes j's. Ou estou faltando alguma coisa aqui?

2. Existe um truque, por exemplo, após a atualização da propagação de retorno, os pesos compartilhados são definidos para sua média.

EDIT A confusão que tive foi que não considerava que se um peso fosse compartilhado, seu parâmetro$h_j^l$aparece várias vezes na função de perda. Ao diferenciar por$h_j^l$, vários termos (considerando as entradas correspondentes) "sobreviverão". Portanto, as atualizações serão as mesmas.

Eu acho que você está entendendo mal o que significa "compartilhamento de peso" aqui. Uma camada convolucional é geralmente composta de muitos "filtros", que geralmente são 2x2 ou 3x3. Esses filtros são aplicados em uma "janela deslizante" em toda a entrada da camada. O "compartilhamento de peso" está usando pesos fixos para esse filtro em toda a entrada. Isso não significa que todos os filtros são equivalentes.

Para ser concreto, vamos imaginar um filtro 2x2 $F$ caminhando uma entrada 3x3 $X$com preenchimento, para que o filtro seja aplicado 4 vezes. Vamos denotar o filtro desenrolado$\beta$.

$$X = \begin{bmatrix} x_{11} & x_{12} & x_{13} \\ x_{21} & x_{22} & x_{23} \\ x_{31} & x_{32} & x_{33} \end{bmatrix}$$

$$F = \begin{bmatrix} w_{11} & w_{12} \\ w_{21} & w_{22} \end{bmatrix}$$

$$\beta= [w_{11}, w_{12}, w_{21}, w_{22} ]$$

$$F*X = \begin{bmatrix} \beta \cdot [x_{11}, x_{12}, x_{21}, x_{22}] & \beta \cdot [x_{12}, x_{13}, x_{22}, x_{23}] \\ \beta \cdot [x_{21}, x_{22}, x_{31}, x_{32}] & \beta \cdot [x_{22}, x_{23}, x_{32}, x_{33}] \end{bmatrix}$$

"Compartilhamento de peso" significa que, quando aplicamos esse filtro 2x2 em nossa entrada 3x3, reutilizamos os mesmos quatro pesos dados pelo filtro em toda a entrada. A alternativa seria cada aplicativo de filtro com seu próprio conjunto de entradas (que seria realmente um filtro separado para cada região da imagem), fornecendo um total de 16 pesos ou uma camada densa com 4 nós, com 36 pesos.

Compartilhar pesos dessa maneira reduz significativamente o número de pesos que precisamos aprender, facilitando o aprendizado de arquiteturas muito profundas e, além disso, permite aprender recursos que são independentes da região em que a entrada está sendo considerada.

EDIT: Para motivar ainda mais, aqui está uma animação de um filtro 3x3 aplicado a uma entrada 5x5

Não tenho certeza se você pode alterar as respostas aceitas, mas como a única resposta para sua pergunta sobre propagação traseira é sobre propagação direta, decidi tentar.

Essencialmente, você trata o delta do peso ($\frac{\delta R}{\delta h_j^l}$) da mesma forma que faria com um delta de peso para um neurônio linear, mas treine-o uma vez para cada vez que sobrepor seu filtro (kernel) na entrada, tudo em uma única passagem de backprop. O resultado é a soma dos deltas para todas as superposições do seu filtro. Eu acho que na sua notação, isso seria$\frac{\delta R}{\delta h_j^l} = \sum_{i=1}^nx_i^{l-1}\frac{\delta R}{\delta x_j^{l+1}}$ Onde $x^{l-1}$ é uma entrada que foi multiplicada por $h_j^l$ para uma de suas sobreposições durante a propagação direta e $x^{l+1}$ é a saída que resultou dessa sobreposição.

Entre os dois resultados do backprop por meio de uma camada convolucional (deltas de parâmetros e deltas de entrada), parece que você está mais interessado em deltas de parâmetros ou, mais especificamente, nos deltas da matriz de peso ($\frac{\delta R}{\delta h_j^l}$) Por uma questão de exaustividade, examinarei os dois, com o seguinte como nossa camada de exemplo:

Se você tiver um conjunto de entradas 1D $[1, 2, 3]$e um filtro $[0.3, 0.5]$ aplicada com passo 1, sem preenchimento, com desvio zero e sem função de ativação, a ativação do seu filtro teria a aparência de $[1*0.3+2*0.5, 2*0.3+3*0.5] = [1.3, 2.1]$. Quando você volta a essa camada em seu passe de backprop, digamos que os deltas de ativação usados ​​para seus cálculos sejam$[-0.1, 0.2]$.

Deltas de peso:

Quando você apareceu no passe para frente, armazenou em cache suas entradas $[1, 2, 3]$, vamos chamá-lo de A_prev, pois provavelmente é a ativação da sua camada anterior. Para cada sobreposição em potencial do seu filtro (nesse caso, você só pode sobrepor na entrada em dois locais [ 1,2 , 3] e [1, 2,3 ]), pegue essa fatia da entrada A_slice, multiplique cada elemento pela saída associada delta dZ e adicione-o ao seu peso delta dW para esta passagem. Neste exemplo, você adicionaria$[1*-0.1, 2*-0.1]$ dW para a primeira sobreposição e adicione $[2*0.2, 3*0.2]$para a segunda sobreposição. No total, seu dW para essa camada convolucional neste passe de backprop é$[0.3, 0.4]$.

Deltas de viés:

O mesmo que para deltas de peso, mas apenas adicione seu delta de saída sem multiplicar pela matriz de entrada.

Deltas de entrada:

Reconstrua a forma da entrada para essa camada, chame-a de dA_prev, inicialize com zeros e percorra as configurações nas quais você sobrepôs o filtro na entrada. Para cada sobreposição, multiplique sua matriz de ponderação pelo delta de saída associado a essa sobreposição e adicione-a à fatia de dA_prev associada a essa sobreposição. Ou seja, a sobreposição 1 adicionará$[0.3 * -0.1, 0.5 * -0.1] = [-0.03, -0.05]$ para dA_prev resultando em $[-0.03, -0.05, 0]$, a sobreposição 2 adicionará $[0.3 * 0.2, 0.5 * 0.2] = [0.06, 0.1]$, resultando em $[-0.03, 0.01, 0.1]$ para dA_prev.

Esta é uma fonte muito boa se você quiser ler a mesma resposta em termos diferentes: Link