Qual é a arquitetura de um autoencoder convolucional empilhado?

Então, eu estou tentando treinar imagens de humanos usando redes convolucionais. Leio os jornais ( Paper1 e paper2 ) e esta ligação stackoverflow , mas eu não estou certo que eu sou entender a estrutura das redes (não é bem definida nos jornais).

Questões:

• Posso fazer com que minha entrada seja seguida por uma camada de ruído seguida por uma camada de conv, seguida por uma camada de pool - depois disso - desassocio antes de fornecer minha saída (que é igual à minha imagem de entrada)?

  Digamos que eu tenha várias (135.240) imagens. Se eu usar 32, (12,21) núcleos, seguidos por (2,2) agrupamentos, terminarei com 32 (62, 110) mapas de recursos. Agora, removo o pool para obter 32 (124, 220) mapas de recursos e depois aplainá-los? antes de dar a minha (135.240) camada de saída?

• Se eu tiver várias dessas camadas de conv-pool, devo treiná-las uma a uma - como em autoencodificadores empilhados? Ou - posso ter algo como input-conv-pool-conv-pool-conv-pool-output (a saída é igual à entrada)? Nesse caso, como o pool e o depool devem ser gerenciados? Devo cancelar o pool apenas na última camada do pool antes da saída? E, novamente - qual deve ser o fator de redimensionamento dessa remoção de pool? A intenção é trazer os mapas de recursos de volta à forma da entrada?

• Devo introduzir camadas de ruído após cada camada de conv-pool-depool?

• E então, quando o ajuste fino - devo remover as camadas de remoção do pool e deixar o resto da mesma forma. Ou devo remover as camadas de ruído e de remoção de pool

• Alguém pode me indicar um URL / artigo que tenha detalhado a arquitetura de um codificador automático convolucional empilhado para fazer um pré-treinamento em imagens?

Atualmente, estou explorando autoencodificadores convolucionais empilhados.

Tentarei responder a algumas de suas perguntas da melhor maneira possível. Veja bem, eu posso estar errado, então leve-o com um grão de sal.

1. Sim, você precisa "reverter" o pool e convolver com um conjunto de filtros para recuperar sua imagem de saída. Uma rede neural padrão (considerando os dados MNIST como entrada, ou seja, dimensões de entrada de 28x28) seria:

       28x28(input) -- convolve with 5 filters, each filter 5x5 -->  5 @ 28 x 28 maps -- maxPooling --> 5 @ 14 x 14 (Hidden layer) -- reverse-maxPool --> 5 @ 28 x 28 -- convolve with 5 filters, each filter 5x5 --> 28x28 (output)
   

2. Meu entendimento é que convencionalmente é isso que se deve fazer, ou seja, treinar cada camada separadamente. Depois disso, você empilha as camadas e treina toda a rede mais uma vez usando os pesos pré-treinados. No entanto, Yohsua Bengio tem algumas pesquisas (a referência escapa à minha memória) mostrando que é possível construir uma rede totalmente empilhada e treinar do zero.

3. Meu entendimento é que a "camada de ruído" existe para introduzir robustez / variabilidade na entrada, para que o treinamento não se ajuste demais.

4. Enquanto você ainda estiver "treinando" antes do treinamento ou aperfeiçoando, acho que a parte da reconstrução (ou seja, reversePooling, desconvolução etc.) é necessária. Caso contrário, como executar a propagação de retorno de erro para ajustar pesos?

5. Eu tentei navegar por vários documentos, mas a arquitetura nunca é explicada na íntegra. Se você encontrar algum, por favor me avise.

Também procurei um modelo totalmente explicado de Autoencodificadores Convolucionais Empilhados.

Me deparei com três arquiteturas diferentes. Ainda os estou estudando e achei que isso poderia ajudar outras pessoas que também estão começando a explorar os CAEs. Quaisquer outras referências a documentos ou implementações ajudariam bastante.

1. O mencionado por você usando pooling - unpool.

2. As camadas de (convolve) __ x_times -> (deconvolve) __ x_times,

   e obtenha o mesmo tamanho da entrada.

3. (convolve -> pool) __ x_times -> (deconvolução strided) __ y_times
   • o preenchimento e as passadas são selecionados de forma que o tamanho final da imagem seja igual ao da imagem original.
   • Referência

Eu não acho que o método de treinamento baseado em camadas esteja correto. Por exemplo, a arquitetura do codificador automático convolucional é:

input-> conv-> max_poo-> de_max_pool-> de_conv-> output.

Este é um codificador automático e deve ser treinado com toda a arquitetura. Além disso, não existe um critério estrito para saber se um codificador automático convolucional precisa de pool e un_pool. geralmente, um pool, mas sem un_pool. Aqui está uma comparação experimental com a ausência de pool e un_pool.

https://arxiv.org/pdf/1701.04949.pdf