Based on the above data, answer the given subquestions.
Using the actual flattened feature size from previous question number 2, how many learnable
parameters (weights + bias) would a fully connected layer with 10 outputs have?
A published solution is not available for this question yet.
for transpose Convolution ).
The corresponding encoder to the above decoder downsampled an original 120×120 input via 3
stride-2 stages down to 15×15.
Based on the above data, answer the given subquestions.
What is the output height after
? The width is the same; enter one integer only.
A published solution is not available for this question yet.
for transpose Convolution ).
The corresponding encoder to the above decoder downsampled an original 120×120 input via 3
stride-2 stages down to 15×15.
Based on the above data, answer the given subquestions.
What is the output height after
? The width is the same; enter one integer only.
A published solution is not available for this question yet.
for transpose Convolution ).
The corresponding encoder to the above decoder downsampled an original 120×120 input via 3
stride-2 stages down to 15×15.
Based on the above data, answer the given subquestions.
Which layer is responsible for the decoder failing to reach the target 120×120 output, and why?
6406537370028.
, because its kernel size is too small.
6406537370029.
, because it uses the wrong number of input channels.
6406537370030.
, because it uses
instead of
, so it fails to double the
spatial resolution.
6406537370031.
None of the layers — the decoder already produces a 120×120 output.
A published solution is not available for this question yet.
for transpose Convolution ).
The corresponding encoder to the above decoder downsampled an original 120×120 input via 3
stride-2 stages down to 15×15.
Based on the above data, answer the given subquestions.
Suppose instead the decoder's input
had spatial size 30×30 (instead of 15×15).
After applying the correction identified in previous question, what would the final output height
be? The width is the same; enter one integer only.
A published solution is not available for this question yet.
Consider an input of size **32×32×32** (32 channels), a standard
, and the
module above. Ignore bias
terms throughout, and assume spatial size is preserved (32×32 output) in both cases.
Based on the above data, answer the given subquestions.
How many learnable parameters does the standard
have?
A published solution is not available for this question yet.
Consider an input of size **32×32×32** (32 channels), a standard
, and the
module above. Ignore bias
terms throughout, and assume spatial size is preserved (32×32 output) in both cases.
Based on the above data, answer the given subquestions.
How many total learnable parameters does
have (depthwise +
pointwise combined)?
A published solution is not available for this question yet.
Consider an input of size **32×32×32** (32 channels), a standard
, and the
module above. Ignore bias
terms throughout, and assume spatial size is preserved (32×32 output) in both cases.
Based on the above data, answer the given subquestions.
What is the parameter compression ratio (standard ÷ depthwise-separable), rounded to 2 decimal
places?
A published solution is not available for this question yet.
Consider an input of size **32×32×32** (32 channels), a standard
, and the
module above. Ignore bias
terms throughout, and assume spatial size is preserved (32×32 output) in both cases.
Based on the above data, answer the given subquestions.
Which of the following statements about
are correct?
6406537370036.
The depthwise layer must use
so that each input channel is
convolved with its own separate filter.
6406537370037.
The pointwise layer uses a 1×1 kernel to mix information across channels after
the depthwise step.
6406537370038.
Replacing a standard convolution with a depthwise-separable convolution
always improves model accuracy.
6406537370039.
The compression ratio achieved depends on both the kernel size and the
number of output channels.
A published solution is not available for this question yet.
architecture itself has already been corrected so that its classifier input size
matches the feature output. Focus only on the training/checkpoint/inference pipeline below.
Based on the above data, answer the given subquestions.
Which of the following statements correctly identify a real bug in the given code ?
6406537370017.
is never called, so gradients accumulate across
batches instead of being reset before each step.
6406537370018.
saves the full model object, but the reload code
calls
, which expects a state dict rather than a
model instance.
6406537370019.
is never moved to
, so
will raise a device-
mismatch error whenever
is a GPU.
6406537370020.
is the wrong loss function for a 10-class
classification problem.
A published solution is not available for this question yet.
architecture itself has already been corrected so that its classifier input size
matches the feature output. Focus only on the training/checkpoint/inference pipeline below.
Based on the above data, answer the given subquestions.
Suppose the device-mismatch bug is fixed, but
is still never called before
inference. Given that
uses BatchNorm, what is the most likely consequence?
6406537370021.
No effect — BatchNorm behaves identically in train and eval mode.
6406537370022.
BatchNorm continues to use statistics from the current inference batch
instead of the stored running statistics, so predictions can differ from proper evaluation-mode
inference and can depend on batch composition.
6406537370023.
The model automatically switches to eval mode whenever
is used.
6406537370024.
The prediction will be correct but computed twice as slowly.
A published solution is not available for this question yet.
architecture itself has already been corrected so that its classifier input size
matches the feature output. Focus only on the training/checkpoint/inference pipeline below.
Based on the above data, answer the given subquestions.
In the fully corrected pipeline, if
yields 20 batches per epoch over 5 epochs, how
many total times should
be called?
A published solution is not available for this question yet.
A convolutional layer receives a feature map with **16 input channels** and applies **32 filters**, each
of spatial size **5 × 5**. Following the "generic level of CNN" view (a filter spans all input channels),
calculate the total number of **weights (excluding bias)** in this layer.
A published solution is not available for this question yet.
A convolutional layer is applied to a **32 × 32** input using a **5 × 5** filter with **zero-padding of 2** and
**stride 2**. Using the standard convolution output-size formula, calculate the **output width (one**
**spatial dimension)**. The height is the same; enter one integer only.
A published solution is not available for this question yet.
The final classification head applies a **softmax** over the pre-activation scores (logits). For a 3-class
problem, the logits produced for a particular image are **[3, 1, 0]**. Compute the softmax **probability**
**assigned to the first class** (round to 2 decimal places).
A published solution is not available for this question yet.
Following the VGG design philosophy of replacing a single large-kernel convolution with a cascade
of small **3 × 3, stride-1** convolutions, how many such 3 × 3 layers must be **stacked** so that the
resulting stack has the same effective (one-dimensional) receptive field as a **single 11 × 11**
**convolution** (the kernel size used in AlexNet's first layer)?
A published solution is not available for this question yet.
A YOLOv1-style detector divides the input image into an **S = 14** grid. Each grid cell predicts **B = 3**
bounding boxes (each with
) and a single set of class scores over **C =**
**25** classes.
Compute the **total number of scalar values** in the final output tensor of the network.
A published solution is not available for this question yet.
The decoder of a depth-estimation network upsamples feature maps using a **transposed**
**convolution** ("up-convolution") with **kernel size 4, stride 2, and padding 1**. If the input feature
map has spatial size **30 × 30**, what is the output height? The width is the same; enter one integer
only.
A published solution is not available for this question yet.
In the original U-Net used for dense prediction (and adaptable to depth estimation), each encoder
stage applies **two successive 3×3 convolutions with no padding (stride 1)**, followed by a **2×2**
**max-pooling with stride 2**. If the input feature map to one such encoder stage has spatial size
**140 × 140**, what is the output height of the feature map **after both convolutions and the max-**
**pooling** of that stage? The width is the same; enter one integer only.
A published solution is not available for this question yet.
The SRGAN discriminator is a stack of **8 convolutional layers**, all using **3 × 3 kernels with**
**padding 1**, and strides alternating as **s = 1, 2, 1, 2, 1, 2, 1, 2** across the eight layers (the stride-1
layers preserve spatial size; the stride-2 layers downsample).
If the input image is **96 × 96**, what is the output height of the feature map **after the last (8th)**
**convolutional layer**, just before the dense layers? The width is the same; enter one integer only.
A published solution is not available for this question yet.
Efficient restoration networks (e.g., LaKDNet) replace standard convolutions with **depth-wise**
**separable convolutions** (a depth-wise convolution followed by a point-wise 1×1 convolution).
An input feature map of size **32 × 32 × 16** (16 channels) is processed by a depth-wise separable
convolution that uses **3 × 3** depth-wise kernels and produces **32 output channels**, with stride 1
and padding 1 (so the spatial size is preserved).
Calculate the **total number of multiplications** for the full depth-wise separable operation (depth-
wise + point-wise). Give the answer in millions (e.g., if 1,234,567 write 1.23).
A published solution is not available for this question yet.
Compared with the sigmoid activation, which of the following are **correct** reasons for preferring
the **ReLU** activation in deep CNNs?
6406537370043.
For positive inputs, ReLU does not saturate, so it avoids the gradient-killing
that occurs in the flat tails of the sigmoid.
6406537370044.
ReLU is preferred because it bounds every activation to the interval [0, 1],
preventing activations from growing large.
6406537370045.
ReLU is cheaper to evaluate — a simple thresholding at zero — whereas
sigmoid/tanh require expensive exponentials.
6406537370046.
The sigmoid's derivative peaks at only **0.25**, so multiplying many such small
factors across layers pushes gradients toward zero (vanishing gradient).
A published solution is not available for this question yet.
VGGNet replaces large convolution kernels with stacks of small 3 × 3 convolutions. Which of the
following statements correctly describe the **advantages** of this design choice?
6406537370047.
A stack of three 3 × 3 conv layers (stride 1) has the same effective receptive
field as one 7 × 7 conv layer.
6406537370048.
For C channels per layer, three stacked 3 × 3 layers use fewer parameters than
a single 7 × 7 layer.
6406537370049.
A single 3 × 3 convolution by itself already spans the same receptive field as a
7 × 7 convolution, so stacking is unnecessary.
6406537370050.
Inserting a ReLU non-linearity between successive 3 × 3 layers makes the
composite function more discriminative than a single linear projection over the same region.
A published solution is not available for this question yet.
Consider the multi-task loss used to train the original **YOLOv1** model. Which of the following
statements about it are correct?
6406537370056.
The loss predicts the **square roots** of width and height so that a fixed absolute
error is penalized **more** for small boxes than for large boxes.
6406537370057.
The hyperparameters are set to **λ_coord = 5** (upweighting localization error)
and **λ_noobj = 0.5** (downweighting confidence error for cells with no object).
6406537370058.
The **classification** term for a cell is only penalized when an object is actually
present in that grid cell.
6406537370059.
For the predictor "responsible" for an object, the target **confidence** value is
fixed at 1, independent of the box's IoU with the ground truth.
A published solution is not available for this question yet.
Regarding the **channel-attention module in CBAM**, which of the following are correct?
6406537370067.
It exploits the **inter-channel** relationship of features, learning "what" is
meaningful by re-weighting feature channels.
6406537370068.
It produces a **spatial** attention map of size H × W × 1 that highlights where to
focus, discarding all channel information.
6406537370069.
The spatial dimensions of the input feature map are squeezed using **both**
**average-pooling and max-pooling**, producing two channel descriptors.
6406537370070.
The pooled descriptors are passed through a **shared MLP**, combined, and a
sigmoid produces the channel attention weights that rescale the input feature map.
A published solution is not available for this question yet.
SRGAN performs photo-realistic super-resolution using a GAN. Which of the following statements
are correct?
6406537370071.
Its **perceptual loss** combines a **content loss** and an **adversarial loss**, rather
than relying on pixel-wise MSE alone.
6406537370072.
The **content loss** is computed on **feature maps of a pre-trained VGG**
**network** (perceptual similarity), not purely in pixel space.
6406537370073.
Purely MSE-optimized solutions tend to be **overly smooth** because they
approximate a pixel-wise average of many plausible HR solutions, losing high-frequency texture.
6406537370074.
The adversarial term makes SRGAN maximize PSNR, which is why it always
achieves a **higher PSNR** than the MSE-based SRResNet.
A published solution is not available for this question yet.
In the **multi-scale deep network** for single-image depth estimation (Eigen et al.), the architecture
is split into a **coarse network** and a **fine network**. Which statement best explains their respective
roles?
6406537370061.
The coarse network uses a large receptive field (via deeper layers and fully-
connected layers) to predict the global scene depth, while the fine network refines this prediction
locally using input-image details.
6406537370062.
The fine network predicts the global scene structure, and the coarse network
only sharpens edges.
6406537370063.
Both networks are architecturally identical and their outputs are simply
averaged (ensembled).
6406537370064.
The coarse network processes each pixel independently and therefore ignores
global scene context.
A published solution is not available for this question yet.
