Autoencoder for images in Computer Vision - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Model Choice

intermediate

Choosing the right architecture for an image autoencoder

You want to build an autoencoder to compress and reconstruct 28x28 grayscale images. Which model architecture is best suited for this task?

A A convolutional neural network with convolutional layers followed by a bottleneck and deconvolutional layers

B A fully connected neural network with input size 784 and a bottleneck layer of size 32

C A recurrent neural network with LSTM layers to process the image pixels sequentially

D A decision tree model trained to predict pixel values from other pixels

💡 Hint

Think about which model type can capture spatial patterns in images effectively.

Convolutional autoencoders use convolutional layers to capture spatial features in images, making them better for image compression and reconstruction than fully connected or sequential models.

❓ Predict Output

intermediate

Output shape after encoding in a convolutional autoencoder

Given the following encoder code for 28x28 grayscale images, what is the shape of the encoded output?

Computer Vision

import torch
import torch.nn as nn

class Encoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 16, 3, stride=2, padding=1)  # output: 16 x 14 x 14
        self.conv2 = nn.Conv2d(16, 8, 3, stride=2, padding=1)  # output: 8 x 7 x 7
    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        return x

encoder = Encoder()
input_tensor = torch.randn(1, 1, 28, 28)
encoded = encoder(input_tensor)
print(encoded.shape)

A torch.Size([1, 16, 14, 14])

B torch.Size([1, 8, 7, 7])

C torch.Size([1, 8, 14, 14])

D torch.Size([1, 1, 28, 28])

💡 Hint

Calculate output size after each convolution using stride and padding.

First conv reduces 28x28 to 14x14 with 16 channels, second conv reduces 14x14 to 7x7 with 8 channels, so output shape is [1, 8, 7, 7].

❓ Hyperparameter

advanced

Choosing the right latent dimension size in an autoencoder

You are training an autoencoder on 64x64 RGB images. What is the effect of choosing a very small latent dimension size?

A The model will compress images too much, causing blurry or poor reconstructions

B The model will overfit and memorize training images exactly

C The model will run faster but use more memory

D The model will reconstruct images perfectly with no loss

💡 Hint

Think about what happens if the compressed representation is too small to hold enough information.

A very small latent space forces the model to lose important details, leading to blurry or inaccurate reconstructions.

❓ Metrics

advanced

Evaluating autoencoder reconstruction quality

Which metric is best to measure how well an autoencoder reconstructs images?

A F1 score of reconstructed image pixels

B Accuracy of predicted class labels

C Cross-entropy loss between input and output pixels

D Mean Squared Error (MSE) between original and reconstructed images

💡 Hint

Consider a metric that measures pixel-wise difference between images.

MSE measures the average squared difference between original and reconstructed pixels, making it suitable for image reconstruction quality.

🔧 Debug

expert

Identifying the cause of poor autoencoder training

You trained an autoencoder on 32x32 grayscale images but the loss does not decrease and reconstructions are random noise. What is the most likely cause?

A The batch size is too large causing slow convergence

B The input images are not normalized before training

C The learning rate is too high causing unstable training

D The autoencoder has too many layers causing overfitting

💡 Hint

Think about what causes training loss to not improve and outputs to be random.

A very high learning rate can cause the model weights to update too aggressively, preventing loss from decreasing and producing noisy outputs.