Qual é a arquitetura de um autoencoder convolucional empilhado?

23

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?

Run2
fonte

Respostas:

12

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.

user2979010
fonte
Se você concluir o pré-treinamento, não precisará mais da parte do decodificador, e o ajuste fino ainda ajustará o codificador, desta vez para uma melhor classificação.
JWAlker
2
Como é possível "reverse-maxPool"? Você nunca pode reconstruir um conjunto de números dado apenas o máximo ...?
Fequish #
1
@Fequish, um seu aproximado reversa-maxpool por exemplo: se piscina = 2x2, i reter a posição de máximo e inserir o máximo em que posição particular em 2x2, sendo descansar 0
user2979010
1
@jwalker, meu objetivo final não era a classificação daí ajuste fino com uma rede desenrolado
user2979010
@Fequish, com o objetivo de decodificar o reverso é apenas o vizinho mais próximo de gama alta.
JWAlker
2

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
Ankitp
fonte
2
Bem vindo ao site. Isso foi planejado como uma resposta à pergunta do OP, um comentário solicitando esclarecimentos ao OP ou a um dos respondentes ou uma nova pergunta sua? Por favor, use apenas o campo "Sua resposta" para fornecer respostas para a pergunta original. Você poderá comentar em qualquer lugar quando sua reputação for> 50. Se você tiver uma nova pergunta, clique no cinza ASK QUESTION na parte superior da página e faça a pergunta lá, podemos ajudá-lo adequadamente. Como você é novo aqui, convém fazer um tour , que contém informações para novos usuários.
gung - Restabelece Monica
1
Ele foi planejado como uma resposta à pergunta do OP, embora possa não se qualificar para ser uma resposta completa. Eu estava respondendo a última parte . Tentei navegar em vários documentos, mas a arquitetura nunca é explicada na íntegra. Se encontrar algum, por favor me avise.
Ankitp
OK obrigado. A maneira como sai é ambígua. Por exemplo: "Eu também estive pesquisando ..." e "Quaisquer outras referências a documentos ou implementações ajudariam muito". Esteja ciente de que o CV é um site puro de perguntas e respostas, não um fórum de discussão. Por que não fazer nosso tour e aprender mais sobre o site?
gung - Restabelece Monica
-1

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

Kevin Sun
fonte