Convolutional Filters and Feature Maps

A convolutional filter performs a mathematical operation called a cross-correlation: it slides across the input, and at each position multiplies its values element-wise with the overlapping patch of the input, then sums everything up into a single number.

Explanation: At position (i,j) in the output feature map, we multiply each element of the kernel K with the corresponding element of the image patch at that location, then sum all those products into one number.

• $S(i,j)$ — the single output value (one pixel in the feature map) at row $i$, column $j$
• $I$ — the input image (or input feature map from a previous layer)
• $K$ — the kernel / filter (a small matrix of learned weights, e.g. 3×3)
• $m, n$ — index variables stepping over the kernel's rows and columns

After the convolution, a bias term is added and an activation function (usually ReLU) is applied:

Explanation: We shift the raw score by a learned bias b, then clip any negative values to zero — this introduces nonlinearity and lets the network decide "yes, this pattern is present" (positive) vs. "no" (zero).

• $A(i,j)$ — the activated output pixel in the feature map
• $b$ — a learned scalar bias, one per filter
• $\text{ReLU}(x) = \max(0, x)$ — the Rectified Linear Unit activation

The output feature map size depends on the input size, kernel size, padding, and stride:

Explanation: This tells you exactly how tall the output feature map will be given an input of height H_in, a kernel of size K, padding P rows of zeros around the border, and a stride S (how many pixels the filter jumps each step).

• $H_{out}$ — output height (width formula is identical, using $W_{in}$)
• $H_{in}$ — input height in pixels
• $K$ — kernel size (e.g. 3 for a 3×3 kernel)
• $P$ — padding (0 = "valid", $\lfloor K/2 \rfloor$ = "same" to preserve size)
• $S$ — stride (1 = move one pixel at a time, 2 = skip every other pixel)

Here is the complete operation in Python using NumPy, then PyTorch: ```python import numpy as np def convolve2d(image, kernel): """Manual 2D convolution (no padding, stride=1).""" H, W = image.shape K = kernel.shape[0] # assume square kernel H_out = H - K + 1 W_out = W - K + 1 feature_map = np.zeros((H_out, W_out)) for i in range(H_out): for j in range(W_out): patch = image[i:i+K, j:j+K] # extract local patch feature_map[i, j] = np.sum(patch * kernel) # element-wise multiply & sum return feature_map

# A hand-crafted vertical edge detector (Sobel filter) vertical_edge_kernel = np.array([ [-1, 0, 1], [-2, 0, 2], [-1, 0, 1] ], dtype=float)

# Tiny 5x5 grayscale image (values 0–255) image = np.array([ [10, 10, 80, 80, 80], [10, 10, 80, 80, 80], [10, 10, 80, 80, 80], [10, 10, 80, 80, 80], [10, 10, 80, 80, 80], ], dtype=float) fmap = convolve2d(image, vertical_edge_kernel) print("Feature map:\n", fmap)

# High values appear where the vertical edge (column 1→2) exists ``` ```python import torch import torch.nn as nn

# Define a Conv layer: 1 input channel, 8 output filters, 3x3 kernel conv = nn.Conv2d(in_channels=1, out_channels=8, kernel_size=3, padding=1)

# Fake grayscale image: batch of 1, 1 channel, 28x28 pixels x = torch.randn(1, 1, 28, 28)

# Forward pass feature_maps = conv(x) print(feature_maps.shape)

# → torch.Size([1, 8, 28, 28])

# 1 image, 8 feature maps (one per filter), same 28x28 size (padding=1) ``` ```python import torch import torch.nn as nn import matplotlib.pyplot as plt

# A simple CNN to visualize feature maps class TinyCNN(nn.Module): def __init__(self): super().__init__() self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1) self.relu = nn.ReLU() self.pool = nn.MaxPool2d(2) # halves spatial size self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1) def forward(self, x): x = self.pool(self.relu(self.conv1(x))) # → [B, 16, 14, 14] x = self.pool(self.relu(self.conv2(x))) # → [B, 32, 7, 7] return x model = TinyCNN() dummy_input = torch.randn(1, 1, 28, 28) output = model(dummy_input) print("Final feature map shape:", output.shape)

# → torch.Size([1, 32, 7, 7]) ```