Why architecture design impacts performance in Computer Vision - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple convolutional layer in a neural network.

Computer Vision

conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=[1])

Drag options to blanks, or click blank then click option'

A1

B5

C7

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Choosing kernel size 1 which is too small to capture features.

Using kernel size 7 which may be too large for simple tasks.

The kernel size defines the size of the filter that slides over the image. A kernel size of 5 is commonly used to capture features effectively.

2fill in blank

medium

Complete the code to add a ReLU activation after a convolutional layer.

Computer Vision

model = nn.Sequential(
    nn.Conv2d(3, 16, 5),
    [1]()
)

Drag options to blanks, or click blank then click option'

ASoftmax

BSigmoid

CReLU

DTanh

Attempts:

3 left

💡 Hint

Common Mistakes

Using Sigmoid which can cause vanishing gradients.

Using Softmax which is for output layers in classification.

ReLU is a common activation function that helps the model learn non-linear features effectively.

3fill in blank

hard

Fix the error in the code to correctly flatten the output before a fully connected layer.

Computer Vision

x = x.view(x.size(0), [1])

Drag options to blanks, or click blank then click option'

A-1

B1

C0

Dx.size(1)

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 or 0 which causes shape mismatch errors.

Using x.size(1) which only flattens one dimension.

Using -1 lets PyTorch automatically calculate the correct size for flattening all dimensions except the batch size.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps layer names to their output sizes if size is greater than 100.

Computer Vision

layer_sizes = {name: size for name, size in layers.items() if size [1] 100 and 'conv' [2] name}

Drag options to blanks, or click blank then click option'

A>

B<

Cin

Dnot in

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' which selects smaller sizes.

Using 'not in' which excludes 'conv' layers.

The comprehension filters layers with size greater than 100 and names containing 'conv'.

5fill in blank

hard

Fill all three blanks to create a dictionary of layer outputs where output size is less than 50 and layer name contains 'pool'.

Computer Vision

filtered_outputs = { [1]: [2] for [3] in outputs.items() if [2] < 50 and 'pool' in [1] }

Drag options to blanks, or click blank then click option'

Aname

Boutput

Cname, output

Dlayer

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'layer' which is undefined.

Mixing variable names inconsistently.

The comprehension iterates over (name, output) pairs, filters outputs less than 50, and checks if 'pool' is in the layer name.

Practice

1. Why does the design of a neural network architecture affect its performance on image tasks?

easy

A. Because it controls the size of the training dataset

B. Because it determines how well the model can learn important features from images

C. Because it decides the file format of the images

D. Because it changes the color of the images

Solution

1. Step 1: Understand the role of architecture in feature learning

   The architecture defines layers and connections that extract patterns from images.

2. Step 2: Connect architecture to model performance

   Better feature extraction leads to improved accuracy and generalization on tasks.

3. Final Answer:

   Because it determines how well the model can learn important features from images -> Option B

4. Quick Check:

   Architecture affects feature learning = D [OK]

Hint: Think about how model structure helps find image patterns [OK]

Common Mistakes:

• Confusing architecture with image properties
• Thinking architecture changes data format
• Believing architecture controls dataset size

2. Which of the following is the correct way to define a convolutional layer in a deep learning model using Python and PyTorch?

easy

A. nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)

B. nn.Linear(in_features=3, out_features=16)

C. nn.Conv1d(in_channels=3, out_channels=16, kernel_size=3)

D. nn.MaxPool2d(kernel_size=2, stride=2)

Solution

1. Step 1: Identify the convolutional layer syntax

   In PyTorch, Conv2d is used for 2D image convolutions with parameters for channels and kernel size.

2. Step 2: Check each option's layer type

   nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1) correctly uses nn.Conv2d with proper parameters; others define different layers.

3. Final Answer:

   nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1) -> Option A

4. Quick Check:

   Correct Conv2d syntax = B [OK]

Hint: Look for Conv2d with correct parameters for image layers [OK]

Common Mistakes:

• Confusing Conv2d with Linear or Conv1d layers
• Missing stride or padding parameters
• Choosing pooling layers instead of convolution

3. Consider this simplified CNN architecture for image classification:

model = nn.Sequential(
  nn.Conv2d(3, 8, 3, padding=1),
  nn.ReLU(),
  nn.MaxPool2d(2),
  nn.Conv2d(8, 16, 3, padding=1),
  nn.ReLU(),
  nn.MaxPool2d(2),
  nn.Flatten(),
  nn.Linear(16*8*8, 10)
)

If the input images are 32x32 pixels, what is the size of the feature map before flattening?

medium

A. 8 channels with 8x8 spatial size

B. 8 channels with 16x16 spatial size

C. 16 channels with 16x16 spatial size

D. 16 channels with 8x8 spatial size

Solution

1. Step 1: Calculate size after first Conv2d and MaxPool2d

   Input 32x32, Conv2d with padding=1 keeps size 32x32, MaxPool2d(2) halves to 16x16 with 8 channels.

2. Step 2: Calculate size after second Conv2d and MaxPool2d

   Conv2d keeps size 16x16 with 16 channels, MaxPool2d halves to 8x8 with 16 channels.

3. Final Answer:

   16 channels with 8x8 spatial size -> Option D

4. Quick Check:

   Pooling halves size twice = 8x8 with 16 channels [OK]

Hint: Each MaxPool2d(2) halves spatial size [OK]

Common Mistakes:

• Forgetting padding keeps size after convolution
• Not halving size after pooling
• Mixing channel counts with spatial dimensions

4. You have a CNN model that overfits training data but performs poorly on new images. Which architecture change can help reduce overfitting?

medium

A. Remove all pooling layers to keep more details

B. Increase the number of convolutional filters drastically

C. Add dropout layers to randomly ignore some neurons during training

D. Use a smaller batch size during training

Solution

1. Step 1: Understand overfitting and regularization

   Overfitting means the model memorizes training data; dropout helps by randomly ignoring neurons to generalize better.

2. Step 2: Evaluate options for reducing overfitting

   Adding dropout (A) is a common fix; increasing filters (B) may worsen overfitting; removing pooling (C) increases parameters; batch size (D) affects training stability but less impact on overfitting.

3. Final Answer:

   Add dropout layers to randomly ignore some neurons during training -> Option C

4. Quick Check:

   Dropout reduces overfitting = A [OK]

Hint: Use dropout to prevent memorizing training data [OK]

Common Mistakes:

• Thinking bigger models always reduce overfitting
• Removing pooling increases parameters and overfitting
• Confusing batch size effects with architecture changes

5. You want to design a model for real-time object detection on a mobile device. Which architectural choice best balances accuracy and speed?

hard

A. Use a lightweight architecture like MobileNet with depthwise separable convolutions

B. Use a very deep ResNet with 152 layers for highest accuracy

C. Use a fully connected network without convolutions

D. Use a large kernel size (e.g., 11x11) in all convolution layers

Solution

1. Step 1: Identify requirements for mobile real-time detection

   Mobile devices need fast, efficient models with good accuracy and low computation.

2. Step 2: Evaluate architectural options

   MobileNet uses depthwise separable convolutions to reduce computation while keeping accuracy; very deep ResNet is slow; fully connected networks lack spatial understanding; large kernels increase computation.

3. Final Answer:

   Use a lightweight architecture like MobileNet with depthwise separable convolutions -> Option A

4. Quick Check:

   MobileNet balances speed and accuracy = C [OK]

Hint: Choose lightweight models designed for mobile use [OK]

Common Mistakes:

• Picking very deep models ignoring speed constraints
• Using fully connected layers for images
• Choosing large kernels that slow down inference