Convolutional neural networks — convolution operation, pooling: Question bank

5.6.11 · D5 · Coding › Machine Learning (Aerospace Applications) › Convolutional neural networks — convolution operation, pooli

Shuru karne se pehle, ek shared vocabulary reminder taaki koi symbol unexplained na rahe:

Definition Quick symbol refresher

Kernel / filter $K$ : numbers ka ek chhota $k \times k$ grid jo hum image ke upar slide karte hain — ye numbers learned hote hain.
Feature map $S$ : wo output grid jo hume $K$ ko har jagah slide karne ke baad milti hai — dekho Feature maps and receptive fields.
Stride $s$ : kernel har slide mein kitne pixels jump karta hai. Padding $p$ : zeros ka border jo hum add karte hain — dekho Padding and stride.
Channels $C$ : input ki depth (jaise RGB ke liye 3). $F$ : filters ki number (= output channels).
Sizing law: $W_{o u t} = ⌊ \frac{W _{in} - k + 2 p}{s} ⌋ + 1$ .
Equivariance (feature input ke saath move karta hai) vs invariance (output move ko ignore karta hai) — dekho Translation equivariance vs invariance.

True or false — justify

A conv layer mein jab image badi hoti hai toh zyada parameters hote hain.

False. Parameters hote hain

F (k^{2} C + 1)

— ye sirf filter size, channels, aur filter count par depend karte hain, kabhi bhi

W_{in}

par nahi. Ye size-independence hi weight sharing ka point hai.

Convolution ek fully-connected layer ka special case hai.

True. Ek fully-connected weight matrix par locality (weights

k \times k

neighbourhood ke bahar zero) aur weight sharing (same weights har jagah) impose karo aur wo collapse hokar ek single slid kernel ban jaata hai — dekho Fully-connected neural networks.

Pooling network ki help karta hai apne weights ko regularize karke.

False. Pooling ke paas zero learnable weights hain, isliye ye directly kuch bhi regularize nahi karta. Ye overfitting se indirectly ladhta hai representation ko shrink karke aur local invariance add karke.

Max-pooling ek CNN ko fully translation-invariant bana deta hai.

False. Ye sirf local invariance deta hai — ek pooling window ke andar shift absorb ho jaata hai, lekin ek bada shift feature ko ek alag window mein move kar deta hai aur output badal jaata hai. Dekho Translation equivariance vs invariance.

Ek pure convolution layer (no pooling) translation equivariant hai, invariant nahi.

True. Input ko ek pixel shift karo aur poori feature map ek pixel shift ho jaati hai — response feature ke saath move karta hai na ki move ko ignore karta hai.

Stride 1 ki jagah stride 2 use karne se output same size rehta hai lekin faster run karta hai.

False. Stride directly output ko shrink karta hai:

W_{o u t} = ⌊(W_{in} - k + 2 p) / s ⌋ + 1

. Stride 2 roughly har spatial dimension ko half kar deta hai; ye koi free speed knob nahi hai.

Kyunki libraries cross-correlation compute karti hain, ek hand-designed textbook kernel ko directly daala ja sakta hai bina kisi change ke.

False. True convolution pehle kernel ko flip karta hai. Ek learned kernel ke liye koi fark nahi padta, lekin ek hand-designed kernel ko textbook math se match karne ke liye flip karna padega.

Zyada filters

F

add karne se output depth badhti hai lekin spatial height aur width nahi.

True.

F

output channels ki number set karta hai; spatial size sirf

k

p

s

, aur

W_{in}

se govern hoti hai.

Average-pooling aur max-pooling interchangeable hain — koi bhi choose karo.

False. Max strongest "kya ye feature fire hua?" signal rakhta hai (detection ke liye achha); average overall magnitude retain karta hai aur smooth karta hai (tab achha jab typical intensity ki zaroorat ho). Ye alag priors encode karte hain.

Spot the error

"Mera

3 \times 3

filter ek RGB image par 9 parameters rakhta hai."

Galat — iske

k^{2} C + 1 = 9 \cdot 3 + 1 = 28

parameters hain. Tumhe saare

C = 3

channels par sum karna hoga aur bias add karna hoga, isliye filter

3 \times 3 \times 3

hai, na ki

3 \times 3

"Input 28, kernel 3, no padding, stride 1 se output 28 milta hai."

Galat —

(28 - 3 + 0) /1 + 1 = 26

. Padding ke bina kernel edge ke upar overhang nahi kar sakta, isliye valid convolution map ko

k - 1 = 2

se shrink karta hai.

"Maine do conv layers stack ki hain, isliye har output neuron poori image dekhta hai."

Galat (usually) — receptive field sirf roughly

k - 1

per layer badhta hai. Poori image dekhne ke liye bahut saari layers, pooling, ya bade strides chahiye. Dekho Feature maps and receptive fields.

"Stride 1 aur

2 \times 2

window wala pooling map ko half kar deta hai."

Galat — half karne ke liye stride = window size chahiye (stride 2). Stride-1 pooling map ko barely shrink karta hai (

W_{o u t} = W_{in} - 1

) aur windows overlap karte hain.

"Maine padding

p = 2

set ki hai

3 \times 3

kernel ke saath size keep karne ke liye — lekin output bada ho gaya."

Is kernel ke liye padding galat hai — "same" padding ke liye

k = 3

mein

p = (k - 1) /2 = 1

chahiye.

p = 2

ke saath tum

W_{o u t} = W_{in} + 2

paate ho, ek over-padded, bada map.

"Bias parameter nahi count hota, isliye ek filter mein

k^{2} C

weights hain."

Galat — har filter mein ek learnable bias

b

hota hai, jo

k^{2} C + 1

per filter deta hai.

F (k^{2} C + 1)

mein

+ 1

exactly wahi bias hai.

Why questions

Sizing formula mein end mein

+ 1

kyun hota hai?

Kyunki kernel ki starting position 0 ko uske baad wali strided positions ke alawa count karna padta hai — ye ek off-by-one fencepost hai, koi fudge factor nahi.

Hum ML mein cross-correlation ko "convolution" kyun kehte hain?

Kyunki kernel learned hota hai, isliye chahe hum use flip karein ya na karein, network simply wahi weights seekh leta hai jo outputs ko correct banate hain — flip training mein absorb ho jaata hai.

Weight sharing translation equivariance kyun deta hai?

Same weights har position par apply hote hain, isliye koi bhi feature kahin bhi appear ho, identical response produce karta hai, bas ek shifted location par. Dekho Translation equivariance vs invariance.

Pooling ko "no parameters" kyun kaha jaata hai jab ye clearly data ko change karta hai?

Ye ek fixed function apply karta hai (max ya average) jisme seekhne ke liye kuch nahi hota — ye data ko ek rule ki tarah transform karta hai, ek trainable layer ki tarah nahi.

Hum images ke liye fully-connected layer ki jagah convolution kyun prefer karte hain?

Ek fully-connected layer spatial structure ignore karta hai aur har pixel pair ke liye alag weight chahiye (millions mein); convolution "nearby pixels matter" prior encode karta hai aur tiny kernels reuse karta hai, parameters drastically cut karta hai.

Max-pooling kuch translation invariance kyun deta hai lekin equivariance nahi?

Window par max same value return karta hai agar peak us window ke andar shift ho (chhote moves ke liye invariance), na ki response ko feature ke saath aage badhata hai (jo equivariance hota).

Edge cases

Conv layer ek single-pixel input (

W_{in} = 1

k = 1

) ke saath kya karta hai?

W_{o u t} = (1 - 1 + 0) /1 + 1 = 1

. Ek

1 \times 1

kernel

C

channels ke saath sirf ek per-pixel linear mix across channels hai — ek channel-wise fully-connected layer.

Agar

W_{in} - k + 2 p

negative ho toh kya hota hai?

Kernel ek baar bhi fit nahi ho sakta — formula koi valid position nahi deta. Practice mein ye ek invalid layer configuration hai aur libraries size error throw karti hain.

Agar numerator

W_{in} - k + 2 p

stride se divisible na ho, toh floor kya karta hai?

Ye us final partial window ko drop kar deta hai jo edge ke upar overhang karta, sirf fully-covered kernel positions rakhta hai — isliye

⌊ \cdot ⌋

hai na ki rounding.

Ek window ko max-pool karo jo sab equal values rakhta ho, maano sab

5

s — kya output aata hai, aur kya ye invariant hai?

Output

5

hai, aur wo us flat patch ke kisi bhi shift ke under

5

rehta hai — ek degenerate case jahan max-pooling trivially invariant hai kyunki koi peak hai hi nahi move karne ke liye.

Average-pooling ek window of all zeros (ek dead feature) ke saath kya karta hai?

0

return karta hai, faithfully signal deta hai "yahan kuch fire nahi hua." Max-pooling bhi

0

return karta hai, isliye all-zero patches par dono agree karte hain.

Agar stride input size ke barabar ho same-size kernel ke saath, toh output kya hoga?

Ek single value — ek

1 \times 1

output jo poore input ko cover karta hai, effectively global pooling / global convolution us map par.

Kya zeros se padding kabhi border par false "features" inject karta hai?

Thoda sa — zero borders artificial edges create karte hain jis par kernel respond kar sakta hai, isliye kuch aerospace inspection pipelines panel boundaries ke paas phantom edge activations avoid karne ke liye reflection padding prefer karte hain. Dekho Image classification for aerospace inspection.

Recall One-line survival kit

Params $= F (k^{2} C + 1)$ (image-size-free) · Size $= ⌊(W_{in} - k + 2 p) / s ⌋ + 1$ · Conv = equivariant, Pool = locally invariant · Pooling ke 0 params hain · Kernel flip training mein learn ho jaata hai.

Connections

Parent topic
Padding and stride · Feature maps and receptive fields · Translation equivariance vs invariance
Fully-connected neural networks · Backpropagation · Image classification for aerospace inspection