What is the architecture of a stacked convolutional autoencoder? So I am trying to do pretraining on images of humans using convolutional nets. I read the papers (Paper1 and Paper2) and this stackoverflow link, but I am not sure I am understand the structure of the nets (it is not well defined in the papers).
Questions:


*

*I can have my input followed by a noise layer followed by a conv layer, followed by a pooling layer - there after - do I de-pool before I give my output (which is same a my input image)? 
Say I have several (135,240) images. If I use 32, (12,21) kernels, followed by (2,2) pooling, I will end up with 32 (62, 110) feature maps. Now do I de-pool to get 32 (124, 220) feature maps and then flatten them? before giving my (135,240) output layer?

*If I have multiple such conv-pool layers, should I train them one by one - like in stacked denoised autoencoders? Or - can I have something like input-conv-pool-conv-pool-conv-pool-output(output being same as input)? In that case, how is the pooling, depooling supposed to be managed? Should I only de-pool in the last pool layer before output? And again - what should be the resize factor of that de-pooling? Is the intention to bring the feature maps back to the shape of the input?

*Should I be introducing noise layers after every conv-pool-depool layer?

*And then when fine tuning - am I supposed to just remove the de-pooling layers and leave the rest the same. Or should I remove both the noise layers and de-pooling layers 

*Can any one point me to a url / paper which has detailed the architecture of such a stacked convolutional auto encoder to do pre training on images?
 A: I have also been searching for fully explained model of Stacked Convolutional Autoencoders.
I came across three different architectures. I am still studying them and I thought these might help others who are also starting to explore CAEs. Any further references to papers or implementations would greatly help.  


*

*The one mentioned by you using pooling - unpooling.

*The layers of (convolve)__x_times -> (deconvolve)__x_times,
and get the same size as input.

*(convolve -> pool)__x_times -> (strided deconvolution)__y_times


*

*the padding and strides are selected such that the final image size is same as original image.

*Reference
A: I am currently exploring stacked-convolutional autoencoders.
I will try and answer some of your questions to the best of my knowledge. Mind you, I might be wrong so take it with a grain of salt.


*

*Yes, you have to "reverse" pool and then convolve with a set of filters to recover your output image. A standard neural network (considering MNIST data as input, i.e. 28x28 input dimensions) would be:
    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)


*My understanding is that conventionally that is what one should do, i.e. train each layer separately. After that you stack the layers and train the entire network once more using the pre-trained weights. However, Yohsua Bengio has some research (the reference escapes my memory) showcasing that one could construct a fully-stacked network and train from scratch.

*My understanding is that "noise layer" is there to introduce robustness/variability in the input so that the training does not overfit. 

*As long as you are still "training" pre-training or fine-tuning, I think the  reconstruction part (i.e. reversePooling, de-convolution etc) is necesary. Otherwise how should one perform error-back-propagation to tune weights?

*I have tried browsing through numerous papers, but the architecture is never explained in full. If you find any please do let me know.  
A: I don't think the layer-wised training method is correct. For example, the architecture of convolutional auto-encoder is:
input->conv->max_poo->de_max_pool->de_conv->output.
This is a auto-encoder, and should be trained with the entire architecture. Furthermore, there is no strict criterion whether one convolutional auto-encoder needs pool and un_pool. usually, one pool but without un_pool. Here is a experimental comparisons with the absence of pool and un_pool.
https://arxiv.org/pdf/1701.04949.pdf 
