Contractive, Stacked, Deep & Convolutional Autoencoders + Applications

Three more ways to stop an autoencoder from cheating, a recipe for scaling it to many layers and images, a first glimpse of generative modeling, and where all of this actually gets used.

• Derive and compute the contractive autoencoder penalty (Frobenius norm of the encoder Jacobian) and contrast it mechanistically with denoising autoencoders (Lecture 23).
• Explain greedy layer-wise pretraining of stacked autoencoders and its direct parallel to DBN pretraining (Lecture 22).
• Contrast deep (jointly trained) vs. stacked (greedy) autoencoders, and describe standard fixes for vanishing gradients, overfitting, and initialization sensitivity.
• Describe convolutional autoencoders (Conv2D encoder, transposed-convolution decoder) and, at a conceptual level, variational autoencoders.
• Compute and interpret MSE and PSNR as reconstruction-quality metrics, and describe SSIM and PCA/t-SNE latent-space visualization.
• Identify three applications of autoencoders — anomaly detection, denoising, and data compression — with the concrete mechanism behind each.

1. Contractive Autoencoders

Lecture 23 blocked the identity-mapping shortcut two ways: sparsity constrained the latent code, denoising corrupted the input. Contractive autoencoders take a third, more direct route: penalize the encoder's local sensitivity itself. The goal is to make the encoder locally insensitive — "contractive" — to small perturbations of the input, so that nearby inputs map to nearby (or identical) latent codes. This gives a smoother, more robust latent space, since the representation doesn't jump around in response to noise-scale changes in the input.

For a single-layer sigmoid encoder \(z=\sigma(Wx+b)\), this has a clean closed form that requires no numerical differentiation — it is directly computable from the encoder's own weights and activations:

$$\|J_f(x)\|_F^2=\sum_j\big(z_j(1-z_j)\big)^2\sum_iW_{ji}^2$$

2. Stacked Autoencoders: Greedy Layer-Wise Pretraining

Motivation: just like a deep network learns increasingly abstract features layer by layer (Lectures 12–14's CNN filters go from edges to object parts), we would like an autoencoder's latent representation to be built up hierarchically, across several stacked encoding stages rather than one. Training such a stack directly, end-to-end, from scratch can be unstable — so the classical solution is greedy layer-wise pretraining, a direct parallel to Lecture 22's DBN pretraining (there, RBMs were stacked and trained one at a time; here, the same idea is applied to autoencoders instead):

You can replay the same five stages interactively below — useful for testing yourself before moving on:

After greedy pretraining, the stacked encoders are connected end-to-end and, optionally, topped with a softmax classifier (Lecture 14's softmax + cross-entropy). The whole stack is then fine-tuned jointly via standard backpropagation (Lecture 8) on a labeled task. This was historically one of the earliest successful "unsupervised pretraining, then supervised fine-tuning" recipes for deep networks — the same historical role played by DBN pretraining (Lecture 22) — and while it has been largely superseded today by better initialization schemes, normalization, and architectures, it remains conceptually important and is still used for genuinely label-scarce problems.

3. Deep Autoencoders: Joint Training & Practical Challenges

Contrast Section 2's approach with a deep autoencoder: many encoder/decoder layers trained jointly, end-to-end, from random initialization — not greedily, layer by layer. Training a deep AE this way runs into exactly the challenges covered earlier in the course, just applied to a deep encoder–decoder pipeline instead of an RNN or a plain classifier:

• Vanishing gradients through many stacked layers (Lecture 16's problem).
• Overfitting, especially with a large bottleneck relative to dataset size.
• Initialization sensitivity — a poor starting point can stall training before it gets anywhere.

The standard fixes should already sound familiar:

• Dropout — randomly zero a fraction of units during training to prevent co-adaptation.
• Batch normalization — Lecture 14's exact recipe applies here too: normalize each layer's pre-activations to zero mean and unit variance using the current mini-batch's statistics, then apply a learnable scale \(\gamma\) and shift \(\beta\) so the layer can still represent its ideal distribution. This keeps activations well-scaled through a deep encoder–decoder stack the same way it does through a deep CNN classifier.
• Early stopping — halt training when validation reconstruction loss stops improving, before it starts overfitting to training-set noise.

4. Convolutional Autoencoders

For image data, flattening pixels into a dense bottleneck throws away spatial structure. A convolutional autoencoder keeps that structure throughout: the encoder uses Conv2D layers (Lecture 13's convolution operation) to shrink the spatial resolution while increasing channel depth, and the decoder uses transposed convolution ("deconvolution") layers to expand back toward the original resolution.

Because every layer stays spatially organized (a 2D grid of activations, not a flat vector), convolutional autoencoders preserve local structure — edges, textures, shapes — far better than a dense encoder/decoder would, making them the standard choice for image reconstruction, denoising, and compression tasks.

5. Variational Autoencoders — A Conceptual Preview

One more variant, at a purely conceptual level (no derivation — this is intentionally out of scope here, consistent with the course's own treatment): a Variational Autoencoder (VAE) encodes an input not to a single fixed latent point \(z\), but to a probability distribution over latent space — typically a Gaussian, parameterized by a predicted mean and variance. It then decodes by sampling from that distribution rather than reading off a fixed code. This small change has a large consequence: it makes the latent space smooth and generative — you can sample a brand-new latent point that was never produced by encoding any real input, and decode it into a plausible new data sample. A standard autoencoder's latent space carries no such guarantee; nothing stops it from having "holes" that decode to nonsense.

6. Evaluating Reconstructions: MSE, PSNR & SSIM

MSE is both the usual training loss (Lecture 23, Section 3) and a perfectly valid evaluation metric on its own — lower is better. For images specifically, two further standard metrics are common:

SSIM (Structural Similarity Index) compares luminance, contrast, and structure between two images rather than raw pixelwise error, and is better correlated with human perceptual judgment than MSE or PSNR — the concept matters here, not the full formula.

Applying the PSNR formula mechanically to Lecture 23's worked-example MSE values (treating \(MAX_I=1\) for illustration, even though our toy 3-feature vector isn't literally pixel data):

7. Visualizing the Latent Space & Applications

The latent code \(z\) is typically much lower-dimensional than the input, but often still more than 2 or 3 dimensions — too many to plot directly. Two standard tools project it down further, for human-interpretable plotting:

• PCA (Lecture 23, Section 1) — a linear projection maximizing variance; fast, but only captures linear structure in the latent space.
• t-SNE — nonlinear; preserves local neighborhood structure and similarity better than PCA does, which is why it's the more common choice specifically for visualization (not necessarily for downstream computation).

8. Pitfalls & Practical Notes

9. Summary

10. Code: Contractive Penalty & Convolutional Autoencoder Skeleton

The NumPy portion below reproduces the contractive-penalty worked example exactly (0.29). The Keras portion is a runnable architecture skeleton for a convolutional autoencoder on MNIST-shaped input.

import numpy as np

# ==============================================================
# Part 1 -- Contractive penalty: Frobenius norm of the encoder Jacobian
#           (reproduces the lecture's linear-encoder example: 0.29)
# ==============================================================
We = np.array([0.4, 0.3, -0.2])          # same linear encoder as Lecture 23

def contractive_penalty_linear(W):
    """For a LINEAR encoder z = Wx + b, the Jacobian is just W itself
    (constant, independent of x), so ||J||_F^2 = sum(W_ji^2)."""
    return np.sum(W ** 2)

def contractive_penalty_sigmoid(W, z):
    """For a sigmoid encoder z = sigmoid(Wx + b):
    ||J||_F^2 = sum_j (z_j(1-z_j))^2 * sum_i W_ji^2   (per latent unit j)."""
    local_grad_sq = (z * (1 - z)) ** 2          # elementwise sigmoid'(z)^2
    row_norms_sq  = np.sum(W ** 2, axis=-1)     # sum_i W_ji^2 per row j
    return np.sum(local_grad_sq * row_norms_sq)

jf_linear = contractive_penalty_linear(We)
print("Linear-encoder contractive penalty ||J_f||_F^2 =", round(jf_linear, 5))
# expected: 0.29

# same weights, imagining instead a sigmoid encoder currently outputting z=0.75
z_example  = np.array([0.75])
jf_sigmoid = contractive_penalty_sigmoid(We.reshape(1, -1), z_example)
print("Sigmoid-encoder contractive penalty at z=0.75:", round(jf_sigmoid, 5))

# ==============================================================
# Part 2 -- Convolutional autoencoder skeleton (Keras), MNIST-shaped input
#           Full training belongs on Colab/GPU -- see the box above.
# ==============================================================
def build_conv_autoencoder():
    from tensorflow.keras import layers, models
    inp = layers.Input(shape=(28, 28, 1))

    # ---- encoder: Conv2D with stride to shrink spatial size ----
    x = layers.Conv2D(16, 3, activation='relu', padding='same', strides=2)(inp)   # 28->14
    x = layers.Conv2D(8,  3, activation='relu', padding='same', strides=2)(x)     # 14->7
    encoded = x                                                                    # bottleneck feature map

    # ---- decoder: Conv2DTranspose ("deconvolution") to upsample back ----
    x = layers.Conv2DTranspose(8,  3, activation='relu', padding='same', strides=2)(encoded)  # 7->14
    x = layers.Conv2DTranspose(16, 3, activation='relu', padding='same', strides=2)(x)         # 14->28
    decoded = layers.Conv2D(1, 3, activation='sigmoid', padding='same')(x)                     # 28x28x1

    autoencoder = models.Model(inp, decoded)
    autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
    return autoencoder

if __name__ == "__main__":
    try:
        model = build_conv_autoencoder()
        model.summary()
    except ImportError:
        print("TensorFlow/Keras not installed -- run this part on Colab (see the lecture's resource link).")

⬇ Download lecture-24-contractive-conv.py   More resources for this lecture →