Feature maps and receptive fields — Hinglish notes

3.4.4 · AI-ML › Convolutional Neural Networks

Core Intuition

Intuition The Big Picture: Hierarchical Visual Understanding

Socho tum ek "interpreters ki tower" bana rahe ho. Pehla level sirf chhote patches dekh sakta hai—shayad edges detect karta hai. Doosra level un patches ko corners aur textures mein combine karta hai. Teesra level unhe shapes mein assemble karta hai jaise aankhein ya wheels. Har level original image ka zyada bada area dekhta hai lekin higher-level concepts mein sochta hai.

Feature map ek layer mein ek filter ki "raay" hoti hai—ek poori grid jo dikhati hai ki woh filter image mein kahaan "fire" karta hai. Receptive field yeh hota hai ki original image ka kitna hissa uss feature map ke ek pixel ko influence karta hai. Jaise-jaise tum deeper jaate ho, receptive fields exponentially badhte hain, jisse neurons "is edge ka context ek face ka hissa hai, koi random line nahi" jaisi cheezein samajh paate hain.

What Are Feature Maps?

Yeh formula kyun hai? Padded input size $H + 2 p$ se shuru karo. Filter ki "reach" $k$ subtract karo taaki last valid position mile. Stride $s$ se divide karo ki kitne steps fit hote hain. 1 add karo kyunki positions fencepost-counted hain (agar tum filter ko positions 0, 1, 2 par rakh sakte ho, toh 3 outputs hain, 2 nahi).

Agar ek convolutional layer mein $C_{out}$ filters hain, toh tum $C_{out}$ feature maps produce karte ho jo $(C_{out}, H_{out}, W_{out})$ shape ke 3D tensor ke roop mein stack hote hain. Har channel ek filter ki "raay" hai.

What Is a Receptive Field?

Key insight: Layer $L$ ka ek neuron input ko directly "nahi dekhta." Woh layer $L - 1$ dekhta hai, jisne layer $L - 2$ dekha tha, aur aise aage. Receptive field is chain ko accumulate karta hai.

Formula Receptive Field Calculation (Sequential Convolutions)

Convolutional layers ke stack ke liye, layer $l$ par receptive field $R_{l}$ recursively compute hota hai:

R_{l} = R_{l - 1} + (k_{l} - 1) \cdot i = 1 \prod l - 1 s_{i}

jahaan:

$R_{0} = 1$ (input pixel khud ko dekhta hai),
$k_{l}$ layer $l$ par kernel size hai (ismein pooling windows bhi shamil hain!),
$s_{i}$ layer $i$ par stride hai.

Kyun? Har layer $l$ receptive field ko layer- $l - 1$ space mein $(k_{l} - 1)$ pixels se expand karti hai. Lekin woh pixels input space mein $\prod_{i = 1}^{l - 1} s_{i}$ pixels correspond karte hain (cumulative downsampling). Important: pooling layers bhi count hoti hain—stride $s_{p}$ wala $k_{p} \times k_{p}$ pool receptive field ko $(k_{p} - 1) \cdot \prod_{i = 1}^{l - 1} s_{i}$ se expand karta hai aur cumulative stride product mein $s_{p}$ contribute karta hai.

Scratch se derivation:

Base case: Layer 0 (input) par, $R_{0} = 1$ (ek pixel khud ko dekhta hai).
Layer 1: Stride $s_{1}$ wala $k_{1} \times k_{1}$ filter input mein $k_{1}$ consecutive pixels dekhta hai. Center pixel ka receptive field $k_{1}$ wide hai. Agar stride $s_{1} > 1$ ho, toh adjacent outputs $s_{1}$ input pixels skip karte hain, lekin pehli layer ke liye receptive field size phir bhi $k_{1}$ hai: $R_{1} = k_{1}$ .
Layer 2: Layer 1 mein har pixel ka $R_{1} = k_{1}$ hai. Layer 2 ka $k_{2} \times k_{2}$ filter layer 1 mein $k_{2}$ pixels span karta hai. Un layer-1 pixels mein se har ek $k_{1}$ input pixels cover karta hai, aur layer-1 ne stride $s_{1}$ use kiya. Toh layer-2 receptive field hai: $R_{2} = R_{1} + (k_{2} - 1) \cdot s_{1} = k_{1} + (k_{2} - 1) s_{1}$ $(k_{2} - 1)$ center se pare "extra" layer-1 pixels hain, $s_{1}$ se input space mein scale kiye gaye.
General: Layer $l$ par, extra coverage layer- $(l - 1)$ space mein $(k_{l} - 1)$ hai, jo input space mein $(k_{l} - 1) \prod_{i = 1}^{l - 1} s_{i}$ map hoti hai.

Uniform layers ke liye simplification: Agar sabhi layers mein kernel $k$ aur stride $s$ hai:

R_{l} = k + (k - 1) i = 0 \sum l - 2 s^{i} = k + (k - 1) \frac{s ^{l - 1} - 1}{s - 1}

$s = 1$ ke liye (no downsampling): $R_{l} = 1 + l (k - 1)$ (linear growth). $s = 2$ ke liye: $R_{l} = k + (k - 1) (2^{l - 1} - 1)$ (exponential growth).

Figure — Feature maps and receptive fields

Worked Examples

Worked example Example 2: Receptive Field in a 3-Layer CNN

Architecture:

Conv1: $3 \times 3$ kernel, stride 1.
MaxPool: $2 \times 2$ window, stride 2.
Conv2: $3 \times 3$ kernel, stride 1. Layer-by-layer (yaad raho: pooling ek "layer" ki tarah count hoti hai kernel size $k_{p}$ aur stride $s_{p}$ ke saath):

Conv1: $R_{1} = 3$ (ek $3 \times 3$ filter 3×3 input pixels dekhta hai). Cumulative stride abhi tak $= 1$ .
MaxPool ( $k_{p} = 2$ , $s_{p} = 2$ ): Pool receptive field expand karta hai kyunki uski $2 \times 2$ window 2 conv1 outputs cover karti hai.

R_{2} = R_{1} + (k_{p} - 1) \cdot s_{1} = 3 + (2 - 1) \cdot 1 = 4

Cumulative stride ab $= s_{1} \cdot s_{p} = 1 \cdot 2 = 2$ ho gaya.

Conv2 ( $k = 3$ , stride 1): $3 \times 3$ filter 3 post-pool pixels span karta hai. Har post-pool pixel input space mein cumulative stride 2 correspond karta hai.

R_{3} = R_{2} + (k - 1) \cdot (s_{1} \cdot s_{p}) = 4 + (3 - 1) \cdot 2 = 4 + 4 = 8

Interpretation: Conv2 mein ek neuron original input ke $8 \times 8$ patch se influenced hota hai. Dekho pooling window ne khud 1 pixel receptive field add kiya, aur uske stride ne Conv2 ki expansion ko amplify kiya. Jaise-jaise hum pooling ke saath aur layers add karte hain, yeh exponentially badhta hai.

Worked example Example 3: Why Dilated Convolutions Help

Standard 3-layer stack ( $3 \times 3$ , stride 1, no pooling):

R_{3} = 1 + 3 \cdot (3 - 1) = 1 + 6 = 7

Dilated 3-layer stack ( $3 \times 3$ , dilation rates 1, 2, 4). Dilation $d$ ke liye effective kernel size $k_{eff} = k + (k - 1) (d - 1)$ hai:

Layer 1: $d = 1$ , toh $k_{eff} = 3 + (3 - 1) (1 - 1) = 3$ . Isliye $R_{1} = 3$ .
Layer 2: $d = 2$ , toh $k_{eff} = 3 + (3 - 1) (2 - 1) = 5$ . Phir $R_{2} = R_{1} + (k_{eff} - 1) \cdot s_{1} = 3 + (5 - 1) \cdot 1 = 7$ .
Layer 3: $d = 4$ , toh $k_{eff} = 3 + (3 - 1) (4 - 1) = 9$ . Phir $R_{3} = R_{2} + (k_{eff} - 1) \cdot 1 = 7 + (9 - 1) \cdot 1 = 15$ .

Yeh step kyun? Dilation $d$ filter taps ko space out karta hai, effective kernel size $k + (k - 1) (d - 1)$ banata hai. $d = 1$ par koi spacing nahi toh $k_{eff} = k$ . Yeh receptive field growth ko blast karta hai (7 → 15) bina parameters add kiye.

Use case: Semantic segmentation (resolution lose kiye bina global context chahiye).

Common Mistakes

Common mistake Mistake 3: Ignoring Stride (and Pooling) in Receptive Field

Galat soch: Sequential convs ke liye $R_{l} = k_{1} + k_{2} + \dots + k_{l} - (l - 1)$ calculate karna, aur pooling ko sirf ek stride treat karna bina kisi kernel expansion ke. Kyun sahi lagta hai: Tum kernel sizes add kar rahe ho, jo intuitive lagta hai, aur pooling "bas downsample karta hai." Steel-man: Additive formula sirf tab kaam karta hai jab saare strides 1 hon, aur yeh bhoolna aasaan hai ki pooling window bhi multiple pixels span karti hai. Sahi baat: Stride $s > 1$ har layer- $l$ pixel ko previous-layer ke zyada pixels se correspond karata hai; expansion $(k_{l} - 1)$ ko cumulative stride product $\prod_{i = 1}^{l - 1} s_{i}$ se multiply karo. Saath hi, ek $k_{p} \times k_{p}$ pool receptive field ko $(k_{p} - 1) \times (cumulative previous strides)$ se expand karta hai AUR apne stride $s_{p}$ se future layers ki saari expansions multiply karta hai. Example: Conv1 (3×3, s1) → Pool (2×2, s2) → Conv2 (3×3, s1) $R = 8$ deta hai, 7 nahi.

Feynman Explain-to-a-12-Year-Old

Recall Feature Maps aur Receptive Fields ko 12 saal ke bachche ko samjhao

Socho tumhare paas beach scene ka ek bada poster hai. Tum ek art detective ho jo patterns dhundh rahe ho—jaise "umbrellas kahaan hain?" Tum ek saath poora poster nahi dekh sakte, toh tum ek magnifying glass use karte ho jo sirf ek chhota sa square dikhata hai.

Feature map: Tum apna magnifying glass poster par row by row slide karte ho. Jab bhi tumhe umbrella jaisa kuch dikhta hai, tum ek alag kaagaz par same position par ek checkmark lagate ho. Jab ho jaata hai, tumhara kaagaz checkmarks se bhara hota hai jo "umbrella locations" dikhate hain. Woh kaagaz ek feature map hai—yeh ek "umbrella detector" filter ka output hai.

Ab socho tumhare paas 100 alag detectors (alag colored lenses wale magnifying glasses) hain—ek umbrellas ke liye, ek waves ke liye, ek logon ke liye, aur aise aage. Tumhe 100 alag kagaaz milte hain (feature maps), har ek dikhata hai ki woh pattern kahaan appear hota hai.

Receptive field: Pehle, tumhara magnifying glass poster ka sirf $3 \times 3$ square dikhata hai (bahut chhota!). Tum sirf tiny edges detect kar sakte ho. Phir ek aur detective tumhare upar aata hai: woh tumhare checkmark paper ko apne magnifying glass se dekhta hai. Ab woh tumhari tiny detections ko bade patterns mein combine kar raha hai—shayad "checkmarks ka yeh cluster ek circle bana raha hai." Kyunki woh tumhara paper dekh raha hai (jisne $3 \times 3$ patches summarize kiye the), woh indirectly original poster ka $5 \times 5$ dekh raha hai. Woh $5 \times 5$ unka receptive field hai—original poster ka kitna hissa unke ek decision ko influence karta hai.

Ek teesra detective doosre ka paper dekhe, aur ab woh original poster ka $7 \times 7$ dekhte hain. Jitna upar jaate ho, utna hi bada "field of view" original scene mein hota hai. Isliye CNNs context samjhte hain—low layers pixels dekhte hain, high layers objects dekhte hain.

Mnemonic

Connections

3.4.01-Convolutional-layers: Feature maps convolutional layers ke outputs hain; receptive field conv parameters par depend karta hai.
3.4.02-Pooling-layers: Pooling apni window size aur stride dono se receptive field badhata hai, lekin koi learnable parameters add nahi karta.
3.4.03-Padding-and-stride: Padding spatial size preserve karta hai; stride downsampling aur receptive field growth rate control karta hai.
3.4.05-CNN-architectures: Deep architectures (ResNet, VGG) parameters control karte hue receptive fields efficiently badhane ke liye design ki gayi hain.
3.3.02-Activation-functions: Feature maps nonlinearity introduce karne ke liye ReLU/etc. se pass kiye jaate hain.
4.2.01-Object-detection: Large objects ko context mein detect karne ke liye large receptive fields critical hain.

Active Recall Flashcards

#flashcards/ai-ml

CNN mein feature map kya hota hai?

Woh 2D output jo tab produce hota hai jab ek single convolutional filter input par slide karta hai. Yeh dikhata hai ki filter kin spatial locations par strongly respond karta hai. Agar tumhare paas

C_{out}

filters hain, toh tumhe

C_{out}

feature maps milte hain.

Feature map ki spatial size kaise calculate karte hain?

H_{out} = ⌊(H + 2 p - k) / s ⌋ + 1

, jahaan

H

input height hai,

p

padding hai,

k

kernel size hai,

s

stride hai. Width ke liye bhi same formula.

CNN mein ek neuron ka receptive field kya hota hai?

Original input image mein woh region jo uss neuron ki activation value ko influence kar sakta hai. Yeh depth ke saath badhta hai kyunki convolutions stack hoti hain.

Stride receptive field growth ko kaise affect karta hai?

Stride

s

receptive field expansion ko multiply karta hai. Formula:

R_{l} = R_{l - 1} + (k_{l} - 1) \prod_{i = 1}^{l - 1} s_{i}

. Stride-2 pooling exponential growth karti hai; stride-1 linear growth karti hai.

Kya pooling layer receptive field ko affect karti hai, aur kaise?

Haan. Stride

s_{p}

wala

k_{p} \times k_{p}

pool receptive field ko

(k_{p} - 1) \times

(cumulative previous strides) se expand karta hai, AUR uska stride

s_{p}

sabhi future layers ki expansions ko multiply karta hai.

Ek single

3 \times 3

conv layer (stride 1) ka receptive field kya hai?

R_{1} = 3

(kernel size khud, kyunki yeh directly input dekhta hai).

Agar tum do

3 \times 3

convs (stride 1) stack karo, toh layer 2 par receptive field kya hai?

R_{2} = 3 + (3 - 1) \cdot 1 = 5

. Har layer-2 pixel input ka

5 \times 5

patch dekhta hai.

Deeper CNNs ka context understanding kyun behtar hota hai?

Deeper layers ke receptive fields exponentially bade hote hain (khaaskar pooling ke saath), toh neurons original image ka zyada hissa "dekhte" hain—large-scale patterns aur spatial relationships ko recognize karna enable hota hai.

Padding

p = (k - 1) /2

aur stride 1 ke saath feature map size ka kya hota hai?

Output size input size ke barabar hoti hai (spatial dimensions preserved). Example:

k = 3, p = 1

H_{out} = H

rehta hai.

Dilated convolution effective kernel size aur receptive field ko kaise affect karta hai?

Effective kernel size dilation

d

ke liye

k_{eff} = k + (k - 1) (d - 1)

hai.

d = 1

par yeh

k

ke barabar hai; bada

d

bina parameters add kiye receptive field inflate karta hai. Example: Dilation 2 ke saath

3 \times 3

ki effective size

5 \times 5

hai.