Quelle est l'architecture d'un auto-encodeur convolutionnel empilé?

J'essaie donc de faire de la pré-formation sur des images d'humains en utilisant des filets convolutionnels. Je lis les journaux ( article1 et Epais2 ) et ce lien stackoverflow , mais je ne suis pas sûr que je suis comprendre la structure des filets (il est pas bien défini dans les journaux).

Des questions:

• Je peux avoir mon entrée suivie d'une couche de bruit suivie d'une couche conv, suivie d'une couche de regroupement - là après - dois-je désassocier avant de donner ma sortie (qui est la même que mon image d'entrée)?

  Disons que j'ai plusieurs (135 240) images. Si j'utilise 32, (12,21) noyaux, puis (2,2) la mise en commun, je me retrouverai avec 32 (62, 110) cartes de fonctionnalités. Est-ce que maintenant je désassemble pour obtenir 32 (124, 220) cartes d'entités et ensuite les aplatir? avant de donner ma (135 240) couche de sortie?

• Si j'ai plusieurs de ces couches de pool de conv, dois-je les former une par une - comme dans les autoencodeurs débruits empilés? Ou - puis-je avoir quelque chose comme input-conv-pool-conv-pool-conv-pool-output (la sortie étant la même que l'entrée)? Dans ce cas, comment le pooling, le dépooling est-il censé être géré? Dois-je uniquement désassembler la dernière couche de pool avant la sortie? Et encore une fois - quel devrait être le facteur de redimensionnement de cette mise en commun? L'intention est-elle de ramener les cartes d'entités à la forme de l'entrée?

• Dois-je introduire des couches de bruit après chaque couche conv-pool-depool?

• Et puis, lors du réglage fin - suis-je censé simplement supprimer les couches de désagrégation et laisser le reste inchangé. Ou dois-je supprimer à la fois les couches de bruit et les couches de désassemblage

• Quelqu'un peut-il m'indiquer une URL / papier qui a détaillé l'architecture d'un tel encodeur automatique convolutionnel empilé pour faire une pré-formation sur les images?

J'explore actuellement les encodeurs automatiques à convolution empilée.

Je vais essayer de répondre à certaines de vos questions au meilleur de ma connaissance. Attention, je peux me tromper, alors prenez-le avec un grain de sel.

1. Oui, vous devez "inverser" le pool puis convoluer avec un ensemble de filtres pour récupérer votre image de sortie. Un réseau neuronal standard (en considérant les données MNIST en entrée, c'est-à-dire les dimensions d'entrée 28x28) serait:

       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. Ma compréhension est que, classiquement, c'est ce que l'on devrait faire, c'est-à-dire former chaque couche séparément. Après cela, vous empilez les couches et entraînez à nouveau l'ensemble du réseau à l'aide des poids pré-formés. Cependant, Yohsua Bengio a des recherches (la référence échappe à ma mémoire) montrant que l'on pourrait construire un réseau entièrement empilé et s'entraîner à partir de zéro.

3. Ma compréhension est que la "couche de bruit" est là pour introduire une robustesse / variabilité dans l'entrée afin que la formation ne soit pas trop adaptée.

4. Tant que vous êtes toujours en train de "vous entraîner" avant la formation ou le réglage fin, je pense que la partie reconstruction (ie reversePooling, déconvolution etc.) est nécessaire. Sinon, comment doit-on effectuer une propagation de retour d'erreur pour régler les poids?

5. J'ai essayé de parcourir de nombreux articles, mais l'architecture n'est jamais expliquée en détail. Si vous en trouvez, faites-le moi savoir.

J'ai également recherché un modèle entièrement expliqué de codeurs automatiques convolutionnels empilés.

Je suis tombé sur trois architectures différentes. Je les étudie toujours et je pensais que cela pourrait aider d'autres personnes qui commencent également à explorer les CAE. Toute autre référence à des articles ou à des implémentations serait très utile.

1. Celui que vous avez mentionné en utilisant la mise en commun - le désengagement.

2. Les couches de (convolution) __ x_times -> (déconvolution) __ x_times,

   et obtenir la même taille que l'entrée.

3. (convolution -> pool) __ x_times -> (déconvolution stridée) __ y_times
   • le rembourrage et les foulées sont sélectionnés de telle sorte que la taille finale de l'image soit la même que l'image d'origine.
   • Référence

Je ne pense pas que la méthode d'entraînement en couches soit correcte. Par exemple, l'architecture de l'auto-encodeur convolutionnel est:

entrée-> conv-> max_poo-> de_max_pool-> de_conv-> sortie.

Il s'agit d'un encodeur automatique et doit être formé à l'ensemble de l'architecture. De plus, il n'y a pas de critère strict pour déterminer si un codeur automatique convolutionnel a besoin d'un pool et d'un_pool. généralement, un pool mais sans un_pool. Voici une comparaison expérimentale avec l'absence de pool et un_pool.

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