Свёртка и фильтры: обнаружение границ и шаблонов

Convolution is a mathematical operation that slides a small matrix called a filter (or kernel) across an input (e.g., an image), computing an element-wise dot product at each position. The result is a feature map that highlights where the pattern represented by the filter appears in the input. In image processing, different filters detect different features: edges, corners, textures, or higher-level concepts when stacked in multiple layers.

Classic image processing uses hand-crafted filters: the Sobel filter detects horizontal or vertical edges; the Laplacian filter detects all edges; the Gaussian filter blurs (smooths) images. In deep learning, these filters are learned from data rather than hand-crafted. The key insight of CNNs is that the network automatically discovers which filters are useful for the task by minimising the training loss.

nn.Conv2d(in_channels, out_channels, kernel_size) is the core CNN layer. in_channels is the number of input channels (3 for RGB images); out_channels is the number of filters to learn; kernel_size is the spatial size of each filter (3 means 3x3). Each filter produces one output channel, so 64 filters produce a 64-channel feature map. The total parameters in one Conv2d layer is out_channels * in_channels * kernel_h * kernel_w + out_channels (bias).

Padding adds zeros around the input border before convolution. padding=1 with a 3x3 filter preserves the spatial dimensions of the input (same padding). Without padding, each convolution reduces width and height by kernel_size - 1. Stride controls how many pixels the filter moves at each step. stride=2 halves the output dimensions, acting like a lightweight pooling operation. Stride-2 convolutions are often used in modern CNNs instead of explicit pooling.

A colour image has 3 channels (R, G, B). Each filter in a Conv2d layer has depth equal to in_channels — it operates across all input channels simultaneously, producing a single output value per spatial position. With 64 filters you get 64 output channels. The next convolution layer then takes these 64 channels as input. This channel-stacking allows the network to progressively build more abstract representations from low-level colour edges to high-level object parts.

A key advantage of convolutions is weight sharing: the same filter is applied at every spatial location. A 3x3 filter over a 256x256 image involves 9 parameters regardless of image size, compared to a fully connected layer that would require millions of parameters. This makes CNNs far more parameter-efficient than MLPs for image data and gives them translation equivariance — a shifted version of a pattern in the input produces a correspondingly shifted feature map.

Visualising learned filters reveals a hierarchy of learned features. First layer filters typically detect oriented edges, colour gradients, and textures — similar to hand-crafted Sobel filters. Middle layer filters detect combinations: curves, corners, textures. Deep layer filters respond to object parts (eyes, wheels, feathers). This hierarchical feature learning is why deep CNNs dramatically outperform shallow models on image recognition tasks.

The receptive field of a neuron in a CNN is the region of the original input image that contributes to its activation. A single 3x3 conv layer has a 3x3 receptive field. Two stacked 3x3 layers give a 5x5 receptive field. Three give 7x7. Stacking many small filters is more parameter-efficient than one large filter while achieving the same receptive field. This is why modern CNNs use 3x3 filters almost exclusively — inspired by the VGGNet finding.

The standard CNN block follows the pattern: Conv2d -> BatchNorm2d -> ReLU -> (optional Pooling). This trio is repeated multiple times with increasing channel counts, progressively reducing spatial dimensions while increasing the number of feature channels. The spatial reduction compresses location information while the channel expansion captures more abstract features. This pattern is the backbone of ResNet, VGG, EfficientNet, and most other architectures.

After training, you can visualise feature maps (filter activations) for a specific input image to see what each filter has detected. Bright regions in a feature map indicate where the corresponding filter pattern was detected. This is useful for debugging (checking that early layers learned edge detectors) and for interpretability (showing which regions of an image activated a 'dog fur' detector or 'wheel' detector in later layers).

1x1 convolutions apply a linear combination across channels at each spatial position without any spatial mixing. They are used to reduce or expand the number of channels cheaply (as in the Inception and MobileNet bottleneck designs). A 1x1 conv from 256 to 64 channels reduces computation in the subsequent 3x3 conv by 16x. They also introduce non-linearity (via activation) between channel mixing steps, increasing model capacity at minimal parameter cost.

In this lesson you learned: convolution slides a filter across the input computing dot products to produce a feature map that highlights where the filter pattern occurs, nn.Conv2d parameters (in_channels, out_channels, kernel_size, padding, stride) control the filter bank, and weight sharing makes convolutions dramatically more parameter-efficient than fully connected layers for spatial data. Next up we explore pooling layers for spatial downsampling and translation invariance.