What is Convolution?

अगर आप Image Processing, Computer Vision, Deep Learning या Convolutional Neural Network (CNN) पढ़ रहे हैं, तो सबसे important concepts में से एक है Convolution।

पहली बार convolution देखने पर students को यह थोड़ा mathematical और confusing लग सकता है। एक image होती है, उसके ऊपर एक छोटा matrix move करता है, multiplication होती है, values add होती हैं और एक नया matrix बन जाता है।

लेकिन basic idea बहुत simple है।

Convolution एक operation है जिसमें एक छोटा matrix, जिसे Kernel या Filter कहते हैं, input data पर slide करता है और useful patterns या features निकालता है।

Image के case में convolution का use edges, lines, corners, textures और दूसरे visual patterns detect करने के लिए किया जाता है।

Example के लिए, suppose हमारे पास एक image है।

Human उस image को ऐसे देख सकता है:

“यह एक cat की image है।”

लेकिन computer image को इस तरह नहीं देखता। Computer image को pixel values के form में देखता है:

12   20   30   40
15   25   35   45
20   30   40   50
25   35   45   55

Convolution इन pixel values पर एक छोटे filter को apply करके useful information निकालता है।

Basic flow:

Input Image
     ↓
   Kernel
     ↓
Convolution Operation
     ↓
Feature Map
     ↓
Detected Features

CNN में यही operation बार-बार apply होता है और network धीरे-धीरे simple features से complex features learn करता है।

---

Why Do We Need Convolution?

Suppose हमारे पास एक image है:

Cat Image

Computer के लिए image सिर्फ pixels का collection है।

हमें model को यह पता लगाना है कि image में:

• edges कहां हैं,
• shape कैसी है,
• texture क्या है,
• eyes कहां हैं,
• ears कहां हैं,
• object का overall structure क्या है।

अगर हम directly हर pixel को individually process करें, तो image की local structure को समझना difficult हो सकता है।

Convolution का main advantage यह है कि यह image के small local regions को देखकर patterns detect करता है।

For example:

Image
 ↓
Edges
 ↓
Curves
 ↓
Shapes
 ↓
Object Parts
 ↓
Complete Object

इसलिए CNN में शुरुआती convolution layers simple patterns detect करती हैं, जबकि deeper layers more meaningful patterns learn कर सकती हैं।

---

Convolution को Simple Example से समझें

Suppose हमारे पास एक grayscale image का छोटा part है:

1   1   1   0   0
1   1   1   0   0
1   1   1   0   0
0   0   0   1   1
0   0   0   1   1

यह हमारी Input Matrix है।

अब एक 3 × 3 Kernel लेते हैं:

1   0  -1
1   0  -1
1   0  -1

Kernel का काम image के एक छोटे region को examine करना है।

अब kernel input image के ऊपर रखा जाएगा।

First region:

Input Region

1   1   1
1   1   1
1   1   1

Kernel:

1   0  -1
1   0  -1
1   0  -1

अब corresponding values को multiply करते हैं:

(1×1) + (1×0) + (1×-1)
+
(1×1) + (1×0) + (1×-1)
+
(1×1) + (1×0) + (1×-1)

Result:

1 + 0 - 1
+
1 + 0 - 1
+
1 + 0 - 1

Final result:

0

यह एक output value बन जाती है।

फिर kernel एक position आगे move करता है।

यही process पूरी image पर repeat होती है।

---

Basic Convolution Operation

Convolution को simple form में ऐसे समझ सकते हैं:Output=∑(Input Region×Kernel)

मतलब:

1. Kernel को image के एक region पर रखो।
2. Corresponding values multiply करो।
3. सभी multiplied values add करो।
4. Result को output matrix में रखो।
5. Kernel को next position पर move करो।
6. Process repeat करो।

इसी process से Feature Map बनता है।

---

What is a Kernel?

Kernel एक छोटा matrix होता है जो input image पर move करता है।

इसे कई बार:

• Kernel
• Filter
• Convolution Filter

कहा जाता है।

Example:

1   0  -1
1   0  -1
1   0  -1

यह 3 × 3 kernel है।

Kernel size commonly हो सकती है:

3 × 3
5 × 5
7 × 7

Modern CNN architectures में 3 × 3 kernels बहुत commonly देखने को मिलते हैं।

---

Kernel का काम क्या होता है?

Different kernels अलग-अलग patterns detect कर सकते हैं।

For example:

Vertical Edge Kernel

-1   0   1
-1   0   1
-1   0   1

यह vertical edges highlight कर सकता है।

Horizontal Edge Kernel

-1  -1  -1
 0   0   0
 1   1   1

यह horizontal changes detect कर सकता है।

Blur Kernel

1/9  1/9  1/9
1/9  1/9  1/9
1/9  1/9  1/9

यह nearby pixel values को average करके image को blur कर सकता है।

Sharpen Kernel

 0  -1   0
-1   5  -1
 0  -1   0

यह image details को sharpen कर सकता है।

Traditional Image Processing में ऐसे kernels manually design किए जाते हैं।

लेकिन CNN में एक important difference है:

CNN खुद useful kernel values learn करता है।

यही Deep Learning को powerful बनाता है।

---

Traditional Convolution vs CNN Convolution

Traditional Image Processing में हम manually decide कर सकते हैं कि कौन-सा filter use करना है।

For example:

Image
  ↓
Sobel Filter
  ↓
Edge Image

लेकिन CNN में:

Image
  ↓
Learnable Filters
  ↓
Training
  ↓
Useful Features Automatically Learned

CNN को यह manually नहीं बताया जाता कि “यह filter eye detect करे” या “यह filter ear detect करे।”

Training के दौरान model weights update होते हैं और filters धीरे-धीरे useful patterns सीखते हैं।

---

What is a Feature Map?

Convolution operation के बाद जो output matrix मिलता है उसे commonly Feature Map कहा जाता है।

Example:

Input Image
5 × 5

Kernel:

3 × 3

Convolution के बाद output कुछ ऐसा हो सकता है:

2   4   1
3   5   0
1   2   6

यह output matrix एक feature map है।

Feature map में high या low values यह indicate कर सकती हैं कि filter द्वारा detect किया जाने वाला pattern किसी particular location पर कितना strong है।

---

Convolution Step-by-Step Example

अब पूरा numerical example देखते हैं।

Input Matrix

1   2   3   0   1
0   1   2   3   1
1   2   1   0   2
2   1   0   1   3
1   0   2   2   1

Kernel:

1   0  -1
1   0  -1
1   0  -1

सबसे पहले top-left 3 × 3 region लेते हैं:

1   2   3
0   1   2
1   2   1

Kernel:

1   0  -1
1   0  -1
1   0  -1

Element-wise multiplication:

1×1     2×0     3×(-1)

0×1     1×0     2×(-1)

1×1     2×0     1×(-1)

Values:

1 + 0 - 3
+
0 + 0 - 2
+
1 + 0 - 1

Result:

-4

तो output feature map का पहला element होगा:

-4

अब kernel one step right move करेगा:

2   3   0
1   2   3
2   1   0

फिर same multiplication और addition होगी।

यही process पूरी image पर repeat होती है।

---

What is Sliding Window?

Kernel input image पर एक fixed position पर नहीं रहता।

यह image पर move करता है।

इस movement को हम simple language में Sliding Window Operation की तरह समझ सकते हैं।

Position 1

[K K K] X X
[K K K] X X
[K K K] X X
X X X X X
X X X X X

फिर:

Position 2

X [K K K] X
X [K K K] X
X [K K K] X
X X X X X
X X X X X

Kernel पूरे input पर इसी तरह slide करता है।

Kernel कितने steps move करेगा, इसे Stride control करता है।

---

What is Stride?

Stride बताता है कि kernel एक operation के बाद कितने pixels move करेगा।

Stride = 1

Kernel एक pixel move करेगा।

Position 1 → Position 2 → Position 3

Stride = 2

Kernel दो pixels jump करेगा।

Position 1 →→ Position 2 →→ Position 3

Simple rule:

Larger stride → Smaller output feature map

अगर stride बढ़ाते हैं, तो kernel कम positions पर calculate करेगा।

---

Example of Stride

Suppose:

Input Size = 7 × 7
Kernel = 3 × 3

Stride = 1 पर filter बहुत positions पर move करेगा।

Stride = 2 करने पर:

1st position
↓
2 pixels move
↓
next position

इससे output dimensions कम हो जाती हैं।

---

What is Padding?

जब kernel image के border पर पहुंचता है, तो problem होती है क्योंकि kernel का कुछ हिस्सा image के बाहर जा सकता है।

इस problem को handle करने के लिए Padding use की जाती है।

Padding में input के around extra values add की जाती हैं।

Most commonly zero padding use होती है।

Original input:

1  2  3
4  5  6
7  8  9

Zero padding के बाद:

0  0  0  0  0
0  1  2  3  0
0  4  5  6  0
0  7  8  9  0
0  0  0  0  0

यहां border के आसपास zeros add किए गए हैं।

---

Why Do We Use Padding?

Padding के दो major benefits हैं।

1. Border Information Preserve करना

Without padding, border pixels comparatively कम convolution operations में participate करते हैं।

Padding border information को better preserve करने में help करती है।

2. Output Size Control करना

Padding की help से convolution के बाद spatial dimensions को maintain किया जा सकता है।

For example:

Input = 5 × 5
Kernel = 3 × 3
Padding = 1
Stride = 1

Output size भी:

5 × 5

रखी जा सकती है।

---

Valid and Same Convolution

Students अक्सर Valid और Same convolution terms देखते हैं।

Valid Convolution

No padding.

Example:

Input = 5 × 5
Kernel = 3 × 3

Output:

3 × 3

Same Convolution

Padding ऐसी रखी जाती है कि commonly stride 1 के case में input और output की height-width same रखी जा सके।

Input = 5 × 5
Output = 5 × 5

---

Output Size Formula

Convolution layer की output size calculate करने के लिए general formula है:O=⌊SN+2P−K​⌋+1

जहां:

• O = Output size
• N = Input size
• P = Padding
• K = Kernel size
• S = Stride

Example:

Input = 7
Kernel = 3
Padding = 0
Stride = 1

तो:

Output = (7 - 3)/1 + 1
       = 5

इसलिए:

7 × 7 Input
     ↓
3 × 3 Kernel
     ↓
5 × 5 Output

---

Convolution on RGB Images

अब तक हमने grayscale image assume की थी।

Grayscale image में typically एक channel होता है।

लेकिन RGB image में तीन channels होते हैं:

Red
Green
Blue

Image shape conceptually:

Height × Width × 3

या PyTorch tensor representation में commonly:

Channels × Height × Width

For example:

3 × 224 × 224

यहां:

3   = RGB Channels
224 = Height
224 = Width

RGB image पर convolution kernel की depth input channels से match करती है।

Example:

Input Channels = 3
Kernel Size = 3 × 3

तो एक filter effectively:

3 × 3 × 3

values use करेगा।

हर channel पर operation होगा और results combine होकर एक output feature map देंगे।

---

Multiple Filters in CNN

CNN में normally केवल एक filter नहीं होता।

Suppose convolution layer में:

64 Filters

हैं।

हर filter अलग pattern learn कर सकता है।

Conceptually:

Input Image
    ↓
--------------------------------
Filter 1 → Feature Map 1
Filter 2 → Feature Map 2
Filter 3 → Feature Map 3
...
Filter 64 → Feature Map 64
--------------------------------

Output में:

64 Feature Maps

मिल सकते हैं।

इसी कारण CNN architecture में आप ऐसा code देखते हैं:

nn.Conv2d(
    in_channels=3,
    out_channels=64,
    kernel_size=3
)

यहां:

in_channels = 3

मतलब input RGB image है।

और:

out_channels = 64

मतलब layer 64 filters learn करेगी और 64 output channels produce करेगी।

---

Convolution in PyTorch

PyTorch में 2D convolution के लिए commonly nn.Conv2d() use किया जाता है।

Simple example:

import torch
import torch.nn as nn

conv = nn.Conv2d(
    in_channels=3,
    out_channels=16,
    kernel_size=3
)

print(conv)

इसका meaning:

RGB Input
3 Channels
    ↓
16 Learnable Filters
    ↓
16 Output Feature Maps

---

Complete PyTorch Example

import torch
import torch.nn as nn

image = torch.randn(
    1,
    3,
    32,
    32
)

conv = nn.Conv2d(
    in_channels=3,
    out_channels=16,
    kernel_size=3,
    stride=1,
    padding=1
)

output = conv(image)

print("Input Shape:", image.shape)
print("Output Shape:", output.shape)

Output approximately:

Input Shape:
torch.Size([1, 3, 32, 32])

Output Shape:
torch.Size([1, 16, 32, 32])

अब shape समझते हैं।

Input:

1 × 3 × 32 × 32

जहां:

1  = Batch Size
3  = Input Channels
32 = Height
32 = Width

Output:

1 × 16 × 32 × 32

जहां:

1  = Batch Size
16 = Output Feature Maps
32 = Height
32 = Width

Padding = 1 होने के कारण spatial size 32 × 32 maintain हुई।

---

nn.Conv2d() Parameters

PyTorch में:

nn.Conv2d(
    in_channels,
    out_channels,
    kernel_size,
    stride,
    padding
)

common parameters हैं।

in_channels

Input में कितने channels हैं।

RGB image:

in_channels=3

Grayscale:

in_channels=1

---

out_channels

कितने filters learn करने हैं।

Example:

out_channels=32

तो output में 32 feature maps होंगे।

---

kernel_size

Filter size।

kernel_size=3

means:

3 × 3 Kernel

---

stride

Kernel कितने pixels move करेगा।

stride=1

---

padding

Input के border पर कितनी padding add होगी।

padding=1

---

Convolution + Activation Function

CNN में convolution के बाद अक्सर activation function use किया जाता है।

Common example:

Convolution
    ↓
ReLU
    ↓
Feature Map

PyTorch:

import torch.nn as nn

conv = nn.Conv2d(3, 32, 3, padding=1)

relu = nn.ReLU()

Forward:

x = conv(x)

x = relu(x)

या:

x = relu(conv(x))

---

Why ReLU After Convolution?

Convolution mainly linear operation है।

अगर network में केवल linear operations हों, तो बहुत सारी layers add करने के बाद भी model की ability limited रह सकती है।

ReLU non-linearity introduce करता है।

ReLU basic form:

If x > 0:
    output = x

If x <= 0:
    output = 0

Example:

Input:

-3  -1   2
 4  -5   6

ReLU:

0   0   2
4   0   6

इससे neural network complex patterns learn करने की capability develop करता है।

---

Convolution and Pooling

CNN में convolution के बाद कई architectures में pooling भी use की जाती है।

Basic flow:

Input Image
    ↓
Convolution
    ↓
ReLU
    ↓
Pooling
    ↓
Feature Map

Pooling का काम feature map की spatial size reduce करना हो सकता है।

Example:

Feature Map
4 × 4

Max Pooling:

2 × 2

के बाद output:

2 × 2

हो सकता है।

Important difference:

Convolution features detect करता है, जबकि pooling commonly feature map को summarize/downsample करता है।

---

What Does CNN Learn Through Convolution?

CNN की सबसे interesting property यह है कि अलग-अलग layers different levels के visual features learn कर सकती हैं।

Early Layers

Simple patterns:

• Horizontal edges
• Vertical edges
• Lines
• Color changes
• Basic textures

Middle Layers

More complex patterns:

• Curves
• Corners
• Texture combinations
• Object parts

Deep Layers

High-level patterns:

• Face parts
• Wheels
• Eyes
• Ears
• Object structures

Concept:

Pixels
  ↓
Edges
  ↓
Lines & Corners
  ↓
Shapes
  ↓
Object Parts
  ↓
Complete Object

यही hierarchical feature learning CNN की major strength है।

---

Parameter Sharing in Convolution

Convolution का एक बहुत important concept है Parameter Sharing।

Suppose हमने 3 × 3 kernel लिया।

इस kernel के same weights पूरी image पर use होते हैं।

Kernel:

w1 w2 w3
w4 w5 w6
w7 w8 w9

इसे top-left पर भी use किया जाता है, center पर भी और bottom-right पर भी।

इसका मतलब हर image position के लिए separate weights learn नहीं करने पड़ते।

यही parameter sharing model को efficient बनाती है।

---

Local Connectivity

Fully Connected layer में एक neuron बहुत सारे input values के साथ connected हो सकता है।

Convolution layer में एक output location केवल input के small local region को देखती है।

Example:

3 × 3 Kernel

एक time पर केवल 3 × 3 region examine करता है।

इस concept को Local Connectivity से समझ सकते हैं।

Image में nearby pixels generally related होते हैं, इसलिए local pattern detection बहुत useful है।

---

Receptive Field

Receptive Field बताता है कि network का कोई neuron original input के कितने region की information से affected है।

Starting convolution layer में receptive field small हो सकता है।

Deep layers में multiple convolutions के कारण effective receptive field बढ़ता जाता है।

Example:

Layer 1
↓
Small Local Pattern

Layer 2
↓
Larger Pattern

Layer 3
↓
Even Larger Structure

इसलिए deeper CNN layers larger context understand कर सकती हैं।

---

1D, 2D and 3D Convolution

Convolution केवल images के लिए नहीं है।

Different data के लिए अलग convolution forms use हो सकती हैं।

1D Convolution

Sequence data के लिए।

Example:

Signal
Audio
Time-Series
Sequential Features

PyTorch:

nn.Conv1d()

---

2D Convolution

Images के लिए सबसे common।

Height × Width

PyTorch:

nn.Conv2d()

---

3D Convolution

3D or volumetric data और video-related cases में use हो सकता है।

Depth × Height × Width

PyTorch:

nn.Conv3d()

---

Convolution vs Fully Connected Layer

दोनों neural network operations हैं, लेकिन दोनों का behaviour अलग है।

Convolution Layer	Fully Connected Layer
Local regions को देखता है	Usually complete input features को connect करता है
Kernel use करता है	Weight matrix use करता है
Parameter sharing करता है	Different connections के separate weights हो सकते हैं
Image structure preserve कर सकता है	Input often vector form में होता है
CNN में important	Traditional ANN/classifier में common

Convolution especially image data के लिए useful है क्योंकि spatial relationships important होती हैं।

---

Is CNN Convolution Exactly Mathematical Convolution?

यह एक important technical point है।

Deep Learning libraries में जिसे commonly convolution कहा जाता है, वह कई implementations में mathematically cross-correlation के ज्यादा close होता है।

Traditional mathematical convolution में kernel flip किया जाता है।

CNN implementation में generally kernel को बिना flip किए slide कराया जाता है।

लेकिन Deep Learning literature और practice में इसे conventionally convolution layer ही कहा जाता है।

Beginner level पर आप इसे convolution operation के रूप में ही समझ सकते हैं।

---

Simple CNN Example Using Convolution

अब एक basic CNN देखते हैं:

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):

    def __init__(self):
        super().__init__()

        self.conv1 = nn.Conv2d(
            3,
            16,
            kernel_size=3,
            padding=1
        )

        self.relu = nn.ReLU()

        self.pool = nn.MaxPool2d(2)

    def forward(self, x):

        x = self.conv1(x)

        x = self.relu(x)

        x = self.pool(x)

        return x

इसका flow:

Input Image
3 × H × W
      ↓
Convolution
16 Feature Maps
      ↓
ReLU
      ↓
Max Pooling
      ↓
Smaller Feature Maps

अगर input:

3 × 32 × 32

है, तो convolution के बाद:

16 × 32 × 32

और 2 × 2 max pooling के बाद:

16 × 16 × 16

हो सकता है।

---

Real-Life Example of Convolution

Suppose आपको एक large photograph में किसी specific pattern को find करना है।

आपके हाथ में एक छोटा transparent template है।

आप उस template को:

Top Left
↓
Middle
↓
Right
↓
Bottom

पूरी photograph पर move करते हैं।

हर location पर check करते हैं:

“यह region मेरे pattern से कितना match करता है?”

Convolution लगभग इसी concept पर काम करता है।

Kernel एक pattern detector की तरह image पर move करता है और हर location पर response calculate करता है।

Difference यह है कि CNN में useful pattern detector training से learn किया जा सकता है।

---

Convolution in Image Classification

Suppose task है:

Cat vs Dog Classification

Possible CNN flow:

Input Image
     ↓
Convolution Layer 1
     ↓
Basic Edges
     ↓
Convolution Layer 2
     ↓
Textures and Shapes
     ↓
Convolution Layer 3
     ↓
Object Parts
     ↓
Feature Representation
     ↓
Classifier
     ↓
Cat / Dog

Convolution layers image से visual evidence extract करती हैं।

---

Convolution in Other Computer Vision Tasks

Convolution का use केवल classification में नहीं होता।

यह कई computer vision problems में useful है:

Image Classification

Image किस class की है?

Cat
Dog
Car
Person

Object Detection

Image में object कहां है और क्या है?

Image
↓
Car at location X
Person at location Y

Image Segmentation

हर pixel का class predict करना।

Face Recognition

Face features extract करना।

Medical Image Analysis

X-ray, CT, MRI आदि images से important patterns identify करना।

Image Captioning

Image से visual features extract करके language model/decoder को देना।

---

Advantages of Convolution

1. Automatic Feature Extraction

Traditional methods में features manually design करने पड़ सकते हैं।

CNN में useful filters training से learn हो सकते हैं।

2. Parameter Sharing

Same kernel पूरी image पर use होता है।

इससे parameter count comparatively manageable रहता है।

3. Local Pattern Detection

Convolution nearby pixels के relationships capture करता है।

4. Spatial Structure का Use

Image का height-width structure retain किया जा सकता है।

5. Hierarchical Feature Learning

Network simple से complex patterns learn कर सकता है।

---

Limitations of Basic Convolution

Convolution बहुत useful है, लेकिन इसकी limitations भी हैं।

Limited Local View

Small kernel एक time पर limited region देखता है।

Large context understand करने के लिए multiple layers की जरूरत हो सकती है।

Computational Cost

Large images और many convolution layers significant computation require कर सकती हैं।

Information Loss

Stride या pooling aggressively use करने पर fine details lose हो सकती हैं।

Fixed Grid Operation

Standard convolution regular grid pattern पर operate करता है।

हर problem के लिए यही structure ideal नहीं होता।

इन्हीं limitations के कारण modern architectures में:

• Dilated Convolution
• Depthwise Convolution
• Separable Convolution
• Attention
• Vision Transformer

जैसे approaches भी use किए जाते हैं।

---

Common Types of Convolution

Standard Convolution

Normal convolution operation जिसमें all input channels filters के through process होते हैं।

1 × 1 Convolution

Kernel:

1 × 1

होता है।

यह spatial neighborhood के बजाय channels को mix या transform करने के लिए useful हो सकता है।

Depthwise Convolution

हर input channel पर separate filter apply किया जा सकता है।

यह computation reduce करने वाली architectures में useful है।

Dilated Convolution

Kernel elements के बीच gaps रखे जाते हैं।

इससे larger receptive field मिल सकता है without equally large kernel।

Transposed Convolution

Feature map की spatial size increase करने के लिए use हो सकती है।

Segmentation और generative architectures में देखने को मिलती है।

---

Common Mistakes While Learning Convolution

Mistake 1: Kernel और Feature Map को Same समझना

Kernel छोटा filter है।

Feature map convolution के बाद मिलने वाला output है।

---

Mistake 2: Filter का Size और Number Confuse करना

nn.Conv2d(3, 64, 3)

यहां:

3 = Input Channels
64 = Number of Output Channels / Filters
3 = Kernel Size

Last 3 का meaning 3 × 3 kernel है।

---

Mistake 3: Stride और Padding Same समझना

Stride kernel movement control करता है।

Padding border पर extra values add करती है।

---

Mistake 4: Convolution का मतलब केवल Edge Detection समझना

Edge detection convolution का एक example है।

CNN filters many different features learn कर सकते हैं।

---

Mistake 5: Output Shape Ignore करना

CNN coding में shape बहुत important है।

हर convolution के बाद check करें:

print(x.shape)

यह debugging में बहुत help करता है।

---

Quick Revision Table

Term	Easy Meaning
Convolution	Kernel को input पर slide करके features निकालना
Kernel	Small matrix/filter
Filter	Kernel का another common name
Feature Map	Convolution का output
Stride	Kernel कितने pixels move करेगा
Padding	Input border पर extra values
Channel	Image/data की depth
ReLU	Non-linear activation
Pooling	Feature map को downsample करना
Receptive Field	Input का कितना region neuron देख रहा है
Conv2d	2D convolution layer
in_channels	Input channels की संख्या
out_channels	Output feature maps की संख्या

---

Practice Questions

Question 1

Convolution क्या है?

Answer:
Convolution एक operation है जिसमें छोटा kernel input data पर slide करता है, local multiplication और addition perform करता है और feature map generate करता है।

---

Question 2

Kernel क्या है?

Answer:
Kernel एक small matrix है जो image से particular patterns या features detect करने में use होता है।

---

Question 3

Feature Map क्या है?

Answer:
Convolution operation के बाद मिलने वाले output matrix को feature map कहते हैं।

---

Question 4

Stride का क्या काम है?

Answer:
Stride decide करता है कि convolution kernel हर step में कितने pixels move करेगा।

---

Question 5

Padding क्यों use की जाती है?

Answer:
Padding border information handle करने और output spatial size control करने के लिए use की जाती है।

---

Question 6

CNN में filter कौन बनाता है?

Answer:
CNN training के दौरान filter weights learn करता है। हमें सामान्यतः hand-crafted filter values define करने की जरूरत नहीं होती।

---

Question 7

nn.Conv2d(3, 32, 3) का क्या meaning है?

Answer:

Input Channels = 3
Output Channels = 32
Kernel Size = 3 × 3

---

Frequently Asked Questions

What is Convolution in simple words?

Convolution में एक छोटा filter input image पर move करता है और हर local area से useful feature information निकालता है।

Why is convolution used in CNN?

Convolution image में local patterns detect करने, spatial structure use करने और parameter sharing के कारण efficient feature extraction में help करता है।

What is a kernel in CNN?

Kernel एक learnable small matrix होता है जो input feature map पर slide करके patterns detect करता है।

Is kernel and filter the same?

Beginner-level CNN discussion में दोनों terms commonly interchangeably use किए जाते हैं। हालांकि deeper technical contexts में filter की full channel depth और kernel terminology को अलग तरीके से भी define किया जा सकता है।

What is stride?

Stride kernel की movement step है।

Stride = 1 का मतलब kernel एक position move करेगा।

What is padding?

Padding input के border पर extra values, commonly zeros, add करने की technique है।

What is feature map?

Filter apply करने के बाद मिलने वाला output feature map कहलाता है।

What does Conv2d mean?

Conv2d 2-dimensional convolution operation को represent करता है और images जैसी 2D spatial data के लिए commonly use होता है।

Does CNN manually use edge filters?

नहीं। CNN training के दौरान useful filters learn कर सकता है। शुरुआती layers में learned filters कई बार edge-like patterns detect कर सकते हैं।

Is convolution only used for images?

नहीं। 1D convolution signals और sequences पर, 2D convolution images पर और 3D convolution volumetric/video-type data पर use हो सकती है।

---

Conclusion

Convolution CNN और Computer Vision का fundamental concept है। इसे समझने का सबसे आसान तरीका यह है कि एक small kernel image पर slide करता है, local values को multiply करता है, उन्हें add करता है और एक feature map बनाता है।

Basic process:

Input
  ↓
Kernel
  ↓
Element-wise Multiplication
  ↓
Addition
  ↓
One Output Value
  ↓
Kernel Moves
  ↓
Complete Feature Map

CNN में यही process थोड़ा और powerful हो जाता है क्योंकि filters manually fixed होने के बजाय training के दौरान learn किए जाते हैं।

इसलिए CNN धीरे-धीरे:

Pixels
 ↓
Edges
 ↓
Textures
 ↓
Shapes
 ↓
Object Parts
 ↓
Complete Object Information

जैसे visual patterns learn कर सकता है।

Convolution को एक line में याद रखना हो तो:

Convolution = Small Filter + Sliding Operation + Feature Extraction

और CNN के context में:

Convolution का काम image को केवल pixels की तरह देखना नहीं, बल्कि उन pixels के बीच useful local patterns को identify करना है।

अगर आपको Kernel, Stride, Padding, Feature Map और Output Shape clear हो गए हैं, तो CNN का आगे का topic समझना काफी आसान हो जाता है।