Level 1 — RecognitionConvolutional Neural Networks

Convolutional Neural Networks

⏱ 20 minutes30 marksprintable — key stays hidden on paper

Chapter: 3.4 Convolutional Neural Networks Level: 1 — Recognition (MCQ, Matching, True/False with justification) Time limit: 20 minutes Total marks: 30

Section A — Multiple Choice (1 mark each, 10 marks)

Choose the single best answer.

Q1. A $5\times5$ input is convolved with a $3\times3$ filter using stride 1 and no padding. What is the output spatial size?

(a) $5\times5$
(b) $4\times4$
(c) $3\times3$
(d) $2\times2$

Q2. Which layer type has NO trainable parameters?

(a) Convolutional layer
(b) Max pooling layer
(c) Fully connected layer
(d) Batch normalization layer

Q3. The main innovation of ResNet that enables very deep networks is:

(a) Inception modules
(b) Depthwise separable convolutions
(c) Skip (residual) connections
(d) Dense concatenation of all layers

Q4. In "same" padding with stride 1, the output feature map has:

(a) Half the spatial size of the input
(b) The same spatial size as the input
(c) Twice the spatial size of the input
(d) A size depending only on filter count

Q5. VGG networks are best characterized by:

(a) Stacking small $3\times3$ convolutions repeatedly
(b) Parallel filter branches of different sizes
(c) Residual identity mappings
(d) A single large $11\times11$ first-layer filter

Q6. YOLO differs from R-CNN mainly because it:

(a) Uses selective search for region proposals
(b) Performs detection as a single-stage regression over a grid
(c) Cannot detect multiple objects
(d) Requires semantic segmentation masks

Q7. A dilation rate of 2 on a $3\times3$ filter gives an effective receptive field of:

(a) $3\times3$
(b) $4\times4$
(c) $5\times5$
(d) $7\times7$

Q8. U-Net is primarily designed for:

(a) Image classification
(b) Object detection
(c) Semantic segmentation
(d) Style transfer

Q9. In transfer learning, "freezing" early layers means:

(a) Deleting those layers
(b) Not updating their weights during training
(c) Reinitializing them randomly
(d) Converting them to pooling layers

Q10. The $1\times1$ convolution in Inception modules is mainly used to:

(a) Increase spatial resolution
(b) Reduce channel dimensionality (bottleneck)
(c) Perform max pooling
(d) Add padding

Section B — Matching (1 mark each, 8 marks)

Match each architecture/term in Column X to its defining feature in Column Y.

Column X	Column Y
Q11. LeNet-5	A. Dense connectivity: each layer receives all previous feature maps
Q12. AlexNet	B. Early CNN for handwritten digit recognition
Q13. DenseNet	C. Compound scaling of depth/width/resolution
Q14. EfficientNet	D. First deep CNN winning ImageNet (2012), used ReLU + dropout

Column X	Column Y
Q15. Max pooling	E. Random horizontal flips, crops, color jitter
Q16. Data augmentation	F. Selects the maximum value in each window
Q17. Receptive field	G. Fully convolutional network for dense prediction
Q18. FCN	H. Region of input influencing one output activation

Section C — True/False with Justification (2 marks each, 12 marks)

(1 mark correct T/F, 1 mark valid justification)

Q19. Increasing stride reduces the spatial size of the output feature map.

Q20. Average pooling and max pooling always produce identical outputs.

Q21. A convolutional filter shares its weights across all spatial positions of the input.

Q22. Fine-tuning a pretrained network typically uses a smaller learning rate than training from scratch.

Q23. Skip connections in ResNet help mitigate the vanishing gradient problem.

Q24. Adding zero-padding increases the number of trainable parameters in a convolution layer.

Answer keyMark scheme & solutions

Section A (1 mark each)

Q1 → (c) $3\times3$ . Output $= \frac{N - F}{S} + 1 = \frac{5-3}{1}+1 = 3$ . Why: valid convolution shrinks by $F-1$ .

Q2 → (b) Max pooling. Pooling only selects/averages values; it has no learnable weights.

Q3 → (c) Skip (residual) connections. They let gradients bypass layers, enabling training of very deep nets.

Q4 → (b) Same spatial size. "Same" padding is designed to preserve spatial dimensions at stride 1.

Q5 → (a) Stacking small $3\times3$ convolutions. VGG's signature is uniform small filters stacked deeply.

Q6 → (b) Single-stage grid regression. YOLO predicts boxes+classes directly, no region-proposal stage.

Q7 → (c) $5\times5$ . Effective size $= F + (F-1)(d-1) = 3 + 2(1) = 5$ .

Q8 → (c) Semantic segmentation. U-Net's encoder-decoder with skip connections outputs per-pixel labels.

Q9 → (b) Not updating their weights. Frozen layers keep pretrained weights fixed.

Q10 → (b) Reduce channel dimensionality. $1\times1$ conv acts as a channel bottleneck to cut computation.

Section B (1 mark each)

Q	Match
Q11 LeNet-5	B
Q12 AlexNet	D
Q13 DenseNet	A
Q14 EfficientNet	C
Q15 Max pooling	F
Q16 Data augmentation	E
Q17 Receptive field	H
Q18 FCN	G

Section C (2 marks each: 1 T/F + 1 justification)

Q19 — TRUE. Output size $=\frac{N-F}{S}+1$ ; larger $S$ in the denominator shrinks the output. (e.g. $N=6,F=2$ : $S=1→5$ , $S=2→3$ ).

Q20 — FALSE. Max pooling returns the maximum, average pooling returns the mean; they coincide only when all window values are equal.

Q21 — TRUE. The same filter kernel slides over the whole input (weight sharing), which reduces parameters and gives translation equivariance.

Q22 — TRUE. A small LR preserves useful pretrained features while gently adapting them, avoiding catastrophic overwriting.

Q23 — TRUE. The identity path provides a shortcut for gradient flow, keeping gradients from shrinking to zero across many layers.

Q24 — FALSE. Padding adds zeros around the input; parameter count depends on filter size and channel counts, not padding.

[
  {"claim":"Q1: 5x5 input, 3x3 filter, stride1, no pad -> 3", "code":"N,F,S=5,3,1; result=((N-F)//S+1)==3"},
  {"claim":"Q7: 3x3 filter dilation 2 -> effective 5", "code":"F,d=3,2; result=(F+(F-1)*(d-1))==5"},
  {"claim":"Q19: larger stride reduces output (N=6,F=2)", "code":"N,F=6,2; o1=(N-F)//1+1; o2=(N-F)//2+1; result=o2<o1"},
  {"claim":"Q20: max and avg pooling equal only when all equal", "code":"w=[2,5,3,5]; result=(max(w)!=sum(w)/len(w))"}
]