# 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?

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.

1. 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)

2. 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.

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

4. 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?

5. I have tried browsing through numerous papers, but the architecture is never explained in full. If you find any please do let me know.

• If you're done with pre-training, you no longer need the decoder part, and the fine tuning will still adjust the encoder, this time for better classification. – jwalker Oct 5 '15 at 13:26
• How is "reverse-maxPool" possible? You can never reconstruct a set of numbers given only the maximum...? – Fequish Oct 6 '15 at 13:43
• @Fequish, its an approximate reverse-maxpool e.g.: if pool = 2x2, i retain the position of the max and insert the max into that particular position in 2x2, rest being 0 – user2979010 Oct 7 '15 at 10:05
• @jwalker, my end goal was not classification hence fine-tuning with an unrolled network – user2979010 Oct 7 '15 at 10:06
• @Fequish, for the purpose of decoding the reverse is just a nearest neighbor upscale. – jwalker Oct 7 '15 at 12:05

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.

1. The one mentioned by you using pooling - unpooling.
2. The layers of (convolve)__x_times -> (deconvolve)__x_times,

and get the same size as input.

3. (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
• Welcome to the site. Was this intended as an answer to the OP's question, a comment requesting clarification from the OP or one of the answerers, or a new question of your own? Please only use the "Your Answer" field to provide answers to the original question. You will be able to comment anywhere when your reputation is >50. If you have a new question, click the gray ASK QUESTION at the top of the page & ask it there, then we can help you properly. Since you're new here, you may want to take our tour, which has information for new users. – gung Dec 6 '15 at 14:09
• It was intended as an answer to the OP's question though it may not qualify to be a complete answer. I was answering the last part 'I have tried browsing through numerous papers, but the architecture is never explained in full. If you find any please do let me know.' – Ankitp Dec 8 '15 at 6:20
• OK thanks. The way it comes off is ambiguous. Eg "I have also been searching..." & "Any further references to papers or implementations would greatly help". Be aware that CV is a pure Q&A site, not a discussion forum. Why not take our tour & learn more about the site? – gung Dec 8 '15 at 13:13

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.