Super-resolution basics in Computer Vision - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main goal of super-resolution in computer vision?

Super-resolution is a technique used in computer vision. What is its main goal?

A To increase the resolution of an image by adding more pixels and details

B To reduce the size of an image without losing quality

C To convert a color image into grayscale

D To detect objects within an image

💡 Hint

Think about what happens when you zoom into a blurry photo and want it clearer.

Super-resolution aims to create a higher resolution image from a low resolution one by adding details and pixels.

❓ Model Choice

intermediate

Which model type is commonly used for image super-resolution?

Which of the following model types is most commonly used to perform image super-resolution?

A Convolutional Neural Networks (CNNs)

B K-Nearest Neighbors (KNN)

C Support Vector Machines (SVMs)

D Recurrent Neural Networks (RNNs)

💡 Hint

Think about models good at processing images and spatial data.

CNNs are designed to handle image data and are widely used for super-resolution tasks.

❓ Predict Output

advanced

Output shape after upsampling in super-resolution model

Consider this PyTorch code snippet for a super-resolution model. What is the shape of the output tensor?

Computer Vision

import torch
import torch.nn as nn

class SimpleSR(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Conv2d(3, 64, kernel_size=3, padding=1)
        self.upsample = nn.PixelShuffle(upscale_factor=2)
        self.conv_out = nn.Conv2d(16, 3, kernel_size=3, padding=1)

    def forward(self, x):
        x = self.conv(x)  # shape: (batch, 64, H, W)
        x = self.upsample(x)  # shape: (batch, 16, 2*H, 2*W)
        x = self.conv_out(x)  # shape: (batch, 3, 2*H, 2*W)
        return x

input_tensor = torch.randn(1, 3, 24, 24)
model = SimpleSR()
output = model(input_tensor)
output.shape

A torch.Size([1, 64, 48, 48])

B torch.Size([1, 3, 24, 24])

C torch.Size([1, 3, 48, 48])

D torch.Size([1, 16, 48, 48])

💡 Hint

PixelShuffle with upscale_factor=2 doubles height and width but reduces channels accordingly.

The input has shape (1,3,24,24). After conv, channels=64. PixelShuffle with factor 2 converts 64 channels to 16 channels and doubles height and width to 48. Then conv_out outputs 3 channels with same height and width.

❓ Metrics

advanced

Which metric best measures super-resolution image quality?

Which metric is most commonly used to measure the quality of super-resolution images compared to the original high-resolution images?

A F1 Score

B Peak Signal-to-Noise Ratio (PSNR)

C Mean Squared Error (MSE)

D Accuracy

💡 Hint

Think about a metric that compares pixel differences but on a logarithmic scale.

PSNR measures the ratio between the maximum possible power of a signal and the power of corrupting noise, commonly used for image quality assessment in super-resolution.

🔧 Debug

expert

Why does this super-resolution model training loss not decrease?

Given the following training loop for a super-resolution model, why might the loss not decrease during training?

Computer Vision

import torch
import torch.nn as nn
import torch.optim as optim

model = nn.Sequential(
    nn.Conv2d(3, 64, 3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 3, 3, padding=1)
)

criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

input_lr = torch.randn(1, 3, 24, 24)  # low-res input
target_hr = torch.randn(1, 3, 48, 48)  # high-res target

for epoch in range(5):
    optimizer.zero_grad()
    output = model(input_lr)
    loss = criterion(output, target_hr)
    loss.backward()
    optimizer.step()
    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

A The optimizer Adam is not compatible with Conv2d layers

B The learning rate is too high causing unstable training

C The loss function MSELoss is not suitable for super-resolution

D The model output shape (1,3,24,24) does not match target shape (1,3,48,48), causing poor learning

💡 Hint

Check if the model output size matches the target size for loss calculation.

The model outputs a tensor with shape (1,3,24,24) but the target is (1,3,48,48). This mismatch means the loss compares tensors of different sizes, preventing meaningful learning.

Practice

1. What is the main goal of super-resolution in computer vision?

easy

A. To convert images into black and white

B. To reduce the size of images for faster loading

C. To make small or blurry images clearer and bigger

D. To detect objects within an image

Solution

1. Step 1: Understand the purpose of super-resolution

   Super-resolution aims to improve image quality by increasing resolution and clarity.

2. Step 2: Compare options with the goal

   Only To make small or blurry images clearer and bigger describes making images clearer and bigger, which matches super-resolution.

3. Final Answer:

   To make small or blurry images clearer and bigger -> Option C

4. Quick Check:

   Super-resolution = clearer, bigger images [OK]

Hint: Super-resolution = clearer + bigger images [OK]

Common Mistakes:

• Confusing super-resolution with image compression
• Thinking it only changes image color
• Mixing it up with object detection

2. Which of the following is the correct Python syntax to resize an image using OpenCV for super-resolution preprocessing?

easy

A. resized = cv2.scale(image, width, height)

B. resized = cv2.resize(image, (width, height))

C. resized = cv2.transform(image, width, height)

D. resized = cv2.changeSize(image, width, height)

Solution

1. Step 1: Recall OpenCV resize function syntax

   The correct function to resize images is cv2.resize with parameters (image, (width, height)).

2. Step 2: Check each option

   Only resized = cv2.resize(image, (width, height)) uses cv2.resize correctly; others use invalid function names.

3. Final Answer:

   resized = cv2.resize(image, (width, height)) -> Option B

4. Quick Check:

   OpenCV resize = cv2.resize(image, (w, h)) [OK]

Hint: OpenCV resize uses cv2.resize(image, (w, h)) [OK]

Common Mistakes:

• Using wrong function names like scale or transform
• Passing width and height as separate arguments instead of a tuple
• Confusing resize with other image operations

3. Given the following Python code using a simple super-resolution model, what will be the shape of the output image if the input image shape is (64, 64, 3) and the model upscales by a factor of 2?

input_shape = (64, 64, 3)
upscale_factor = 2
output_shape = (input_shape[0] * upscale_factor, input_shape[1] * upscale_factor, input_shape[2])
print(output_shape)

medium

A. (128, 128, 3)

B. (64, 64, 6)

C. (32, 32, 3)

D. (128, 64, 3)

Solution

1. Step 1: Understand the input shape and upscale factor

   The input image is 64x64 pixels with 3 color channels. Upscale factor is 2, meaning width and height double.

2. Step 2: Calculate output shape

   Output height = 64 * 2 = 128, output width = 64 * 2 = 128, channels remain 3.

3. Final Answer:

   (128, 128, 3) -> Option A

4. Quick Check:

   Upscale doubles height and width, channels unchanged [OK]

Hint: Multiply height and width by upscale factor only [OK]

Common Mistakes:

• Multiplying channels by upscale factor
• Halving instead of doubling dimensions
• Mixing width and height values

4. You have this Python code snippet for a super-resolution model input preprocessing:

def preprocess(image):
    resized = cv2.resize(image, (128, 128))
    normalized = resized / 255.0
    return normalized

image = cv2.imread('input.jpg')
output = preprocess(image)
print(output.max())

What is the likely error or issue in this code?

medium

A. Division by 255.0 causes a type error on integer arrays

B. print(output.max()) will always print 255 instead of normalized max

C. cv2.resize requires a tuple with height and width reversed

D. cv2.imread reads image in BGR, but normalization expects RGB

Solution

1. Step 1: Analyze image reading and preprocessing

   cv2.imread loads images in BGR format, but many models expect RGB format for correct color interpretation.

2. Step 2: Check normalization and output

   Division by 255.0 is valid for normalization; print(output.max()) will print a value ≤ 1.0, so no error there.

3. Final Answer:

   cv2.imread reads image in BGR, but normalization expects RGB -> Option D

4. Quick Check:

   OpenCV uses BGR, models expect RGB [OK]

Hint: Remember OpenCV loads BGR, convert to RGB if needed [OK]

Common Mistakes:

• Assuming cv2.imread loads RGB images
• Thinking division by 255 causes errors
• Confusing width and height order in resize

5. You want to improve a low-resolution medical image using a super-resolution neural network. Which approach best combines super-resolution with preserving important medical details?

hard

A. Use a deep learning model trained on medical images with a loss function emphasizing edge preservation

B. Apply simple bicubic interpolation to enlarge the image quickly

C. Convert the image to grayscale before super-resolution to reduce complexity

D. Use a generic super-resolution model trained on natural images without fine-tuning

Solution

1. Step 1: Consider the importance of domain-specific training

   Medical images have unique features; models trained on similar data preserve details better.

2. Step 2: Evaluate methods for detail preservation

   Using a loss function that emphasizes edges helps keep important structures clear during super-resolution.

3. Final Answer:

   Use a deep learning model trained on medical images with a loss function emphasizing edge preservation -> Option A

4. Quick Check:

   Domain-specific training + edge loss = best detail preservation [OK]

Hint: Train on similar data and preserve edges for best results [OK]

Common Mistakes:

• Using generic models without fine-tuning
• Relying on simple interpolation only
• Ignoring color or detail importance in medical images