Question bank — Convolutional neural networks — convolution operation, pooling

False. Parameters are $F(k^{2}C+1)$ — they depend only on filter size, channels, and filter count, never on $W_{in}$. That size-independence is the point of weight sharing.

True. Impose locality (weights zero outside a $k\times k$ neighbourhood) and weight sharing (same weights everywhere) on a fully-connected weight matrix and it collapses into a single slid kernel — see Fully-connected neural networks.

False. Pooling has zero learnable weights, so it regularizes nothing directly. It fights overfitting indirectly by shrinking the representation and adding local invariance.

False. It only gives local invariance — a shift within one pooling window is absorbed, but a large shift moves the feature into a different window and the output changes. See Translation equivariance vs invariance.

True. Shift the input by one pixel and the whole feature map shifts by one pixel — the response moves with the feature rather than ignoring the move.

False. Stride directly shrinks output: $W_{out}=\lfloor (W_{in}-k+2p)/s\rfloor +1$. Stride 2 roughly halves each spatial dimension; it is not a free speed knob.

False. True convolution flips the kernel first. A learned kernel doesn't care, but a hand-designed one must be flipped to match textbook math.

True. $F$ sets the number of output channels; spatial size is governed only by $k$, $p$, $s$, and $W_{in}$.

False. Max keeps the strongest "did this feature fire?" signal (good for detection); average retains overall magnitude and smooths (good when you care about typical intensity). They encode different priors.

Wrong — it has $k^{2}C+1=9\cdot 3+1=28$. You must sum over all $C=3$ channels and add the bias, so the filter is $3\times 3\times 3$, not $3\times 3$.

Wrong — $(28-3+0)/1+1=26$. Without padding the kernel can't overhang the edge, so valid convolution shrinks the map by $k-1=2$.

Wrong (usually) — the receptive field grows only by roughly $k-1$ per layer. Seeing the whole image needs many layers, pooling, or larger strides. See Feature maps and receptive fields.

Wrong — halving needs stride = window size (stride 2). Stride-1 pooling barely shrinks the map ($W_{out}=W_{in}-1$) and the windows overlap.

Wrong padding for this kernel — "same" padding needs $p=(k-1)/2=1$ for $k=3$. With $p=2$ you get $W_{out}=W_{in}+2$, an over-padded, larger map.

Wrong — each filter has one learnable bias $b$, giving $k^{2}C+1$ per filter. The $+1$ in $F(k^{2}C+1)$ is exactly that bias.

Because the kernel's starting position 0 must be counted in addition to the strided positions after it — it's an off-by-one fencepost, not a fudge factor.

Because the kernel is learned, so whether we flip it or not the network simply learns whichever weights make the outputs correct — the flip is absorbed into training.

The same weights are applied at every position, so a feature appearing anywhere produces the identical response, just at a shifted location. See Translation equivariance vs invariance.

It applies a fixed function (max or average) with nothing to learn — it transforms data like a rule, not like a trainable layer.

A fully-connected layer ignores spatial structure and needs a separate weight per pixel pair (millions of them); convolution encodes the "nearby pixels matter" prior and reuses tiny kernels, drastically cutting parameters.

Max over a window returns the same value if the peak shifts within that window (invariance to small moves), rather than moving the response along with the feature (which would be equivariance).

$W_{out}=(1-1+0)/1+1=1$. A $1\times 1$ kernel with $C$ channels is just a per-pixel linear mix across channels — a channel-wise fully-connected layer.

The kernel can't fit even once — the formula gives no valid position. In practice this is an invalid layer configuration and libraries throw a size error.

It drops the final partial window that would overhang the edge, keeping only fully-covered kernel positions — hence $\lfloor \cdot \rfloor$ rather than rounding.

Output is $5$, and it stays $5$ under any shift of that flat patch — a degenerate case where max-pooling is trivially invariant because there's no peak to move.

Returns $0$, faithfully signalling "nothing fired here." Max-pooling also returns $0$, so on all-zero patches the two agree.

A single value — one $1\times 1$ output covering the whole input, effectively global pooling / global convolution over that map.

Slightly — zero borders create artificial edges the kernel may respond to, which is why some aerospace inspection pipelines prefer reflection padding to avoid phantom edge activations near panel boundaries. See Image classification for aerospace inspection.