Convolutional Neural Networks

A convolutional neural network (CNN) is a neural network in which at least some layers apply the same small learned filter at every position of a grid-structured input, such as an image, so that each output depends only on a local neighbourhood and the filter's weights are shared across positions. This design builds in the assumption that useful patterns are local and can appear anywhere in the input.

A fully connected layer applied to an image treats each pixel as an unrelated input, so a layer connecting a modest image to a modest hidden layer already needs a very large weight matrix, and it has no built-in notion that neighbouring pixels are related. Convolutional layers address both issues with two structural constraints: local connectivity (each unit sees a small window) and weight sharing (the same filter is reused at all positions). Together they cut the number of parameters sharply and make the layer's response translation equivariant: shifting the input shifts the output in the same way.

CNNs were the dominant architecture for computer vision from the early 2010s, and the 2012 ImageNet result of Krizhevsky, Sutskever and Hinton (2017) is commonly treated as the event that brought deep learning to wide attention in the field (see [HIST-005]). Since 2020, attention-based vision models (Dosovitskiy et al., 2020) have been competitive, and convolutional networks remain in wide use, often in hybrid designs. The CNN is also the clearest example of how a structural assumption (an inductive bias) can be built into a network (see [TECH-NN-001]).

Biological and early computational precursors. Hubel and Wiesel (1962) described cells in the cat visual cortex with localized receptive fields and a layered organization. Fukushima (1980) proposed the neocognitron, a multilayer network with alternating feature-extracting and position-tolerance stages, inspired by that work. It was trained with a self-organizing procedure rather than backpropagation.

Trained convolutional networks. LeCun et al. (1989) applied backpropagation (see [TECH-BACKPROP-001]) to a network with constrained, shared weights for handwritten zip code digit recognition. LeCun, Bottou, Bengio and Haffner (1998) described LeNet-style networks for document recognition and argued for training the whole recognition pipeline end to end with gradient-based learning.

Scale-up. Krizhevsky, Sutskever and Hinton (2017; the journal version of the 2012 NeurIPS paper) trained a deep convolutional network with five convolutional layers on the ImageNet data set using GPUs. Their abstract and results reported performance considerably better than the previous state of the art on the benchmark they used. He et al. (2015) introduced residual connections, which allowed much deeper convolutional networks to be trained.

Challenge from attention. Dosovitskiy et al. (2020) applied a standard transformer to sequences of image patches and reported that, when pre-trained on large amounts of data and transferred to recognition benchmarks, it attains excellent results compared with state-of-the-art convolutional networks while requiring substantially fewer computational resources to train. Liu et al. (2022) re-examined the convolutional design space, built a modernized pure-convolutional model (ConvNeXt), and reported that it competes favorably with transformers in accuracy and scalability.

#4.1 The convolution operation

For a single-channel two-dimensional input $X$ and a filter (kernel) $K$ of size $k \times k$, a convolutional layer computes, for each output position $(i,j)$,

Strictly, this formula is cross-correlation; true convolution flips the kernel. Deep learning libraries conventionally implement cross-correlation and still call it convolution, which is harmless because the kernel is learned.

With multiple channels, each filter spans all $C_{\text{in}}$ input channels, and a layer has $C_{\text{out}}$ such filters, producing $C_{\text{out}}$ output feature maps. The number of weights is $C_{\text{out}}\, C_{\text{in}}\, k^2$ (plus biases), independent of the image height and width.

#4.2 Stride, padding and receptive field

Stride $s$ moves the filter by $s$ positions between evaluations, reducing the output resolution. Padding adds border values so that the output size can match the input size. For input size $n$, kernel size $k$, padding $p$ and stride $s$ per dimension, the output size is

The receptive field of a unit is the region of the input that can influence it. It grows with each stacked layer, so deeper units integrate over larger regions. Stacking small filters is a common way to obtain a large receptive field with few parameters.

#4.3 Nonlinearity and pooling

A nonlinearity (commonly ReLU) follows each convolution. Pooling summarizes small windows, for example with their maximum or average, which reduces resolution and provides some tolerance to small shifts. Many modern networks replace pooling with strided convolutions.

#4.4 Weight sharing, equivariance and invariance

Because the same filter is used at every position, shifting the input produces a correspondingly shifted feature map (equivariance, ignoring boundary effects). Invariance to position, as needed for classification, comes from subsequent operations such as pooling or a final global aggregation. A convolutional network is not automatically invariant to rotation, scale or other transformations unless it is trained on varied examples or designed for them.

#4.5 A typical classification network

A standard design alternates convolution, nonlinearity and downsampling, with the number of channels increasing as spatial resolution decreases, and ends with a pooled feature vector fed to a linear classifier with softmax. Residual networks add skip connections of the form $y = x + F(x)$ around blocks of convolutions (He et al., 2015). The overall network is trained end to end by minimizing a classification loss with backpropagation, where the gradient for a shared filter is the sum of its gradients over all positions (LeCun et al., 1989).

#4.6 Other dimensions

The same construction applies to one-dimensional data (audio waveforms, text, time series) and three-dimensional data (volumes, video). In sequence modelling, convolutions provide an alternative to recurrence (see [TECH-RNN-001]).

• Classic stacked designs. LeNet-style networks (LeCun et al., 1998) and AlexNet-style networks (Krizhevsky et al., 2017) stack convolution, nonlinearity and pooling.
• Residual networks. Skip connections ease optimization of very deep networks (He et al., 2015).
• Fully convolutional networks. Networks with no dense layers produce spatial outputs, which suits dense prediction tasks such as segmentation.
• Dilated and depthwise-separable convolutions. Dilated convolutions support exponential expansion of the receptive field without loss of resolution or coverage (Yu & Koltun, 2015); depthwise separable convolutions are analysed by Chollet (2016) as an Inception module with a maximally large number of towers.
• Modernized convolutional networks. ConvNeXt (Liu et al., 2022) revisits convolutional design using practices associated with transformer training.
• Hybrid models. Designs that combine convolutional stages with attention (see [TECH-ATTN-001]).
• Beyond grids. Graph neural networks generalize local aggregation from grids to arbitrary graphs (see [TECH-GNN-001]).

• Handwritten digit and document recognition. An early deployed use was recognition of handwritten characters; LeCun et al. (1998) describe a document recognition system built from such networks.
• Image classification, detection and segmentation. CNN backbones are standard components in many image pipelines, and residual networks were introduced as deep backbones for image recognition (He et al., 2015). No survey of current deployment shares is cited.
• Generative models. Convolutional generators and discriminators are used in adversarial image synthesis (see [TECH-GAN-001]) and in the encoders and decoders of variational autoencoders (see [TECH-VAE-001]).
• Multimodal systems. Image encoders used inside multimodal models may be convolutional or transformer-based (see [TECH-MM-001]).

For current benchmark leaderboards and model-by-model numbers, see the Living Reference collection MODEL-001; they are intentionally not tabulated here.

#Advantages

• Parameter efficiency and data efficiency. Weight sharing and locality reduce the number of parameters relative to dense layers and encode a useful prior for images.
• Computational efficiency. Cost grows linearly with image area for fixed filter sizes, in contrast to the quadratic cost of global self-attention over all positions (see [TECH-ARCH-001]).
• Hardware fit. Convolutions map efficiently onto accelerators (see [TECH-HW-001]).

#Limitations

• Limited long-range interaction per layer. Information travels across the image only by stacking layers or downsampling.
• Limited built-in invariances. The architecture handles translation but not rotation, scale or viewpoint changes by design.
• Fixed grid assumption. The standard operation assumes regular, grid-structured data.
• Interpretability. Learned filters are inspectable in early layers, but the behaviour of deep stacks is difficult to explain (see [SAFE-INTERP-001]).

#Unresolved questions

1. Convolution versus attention. Whether convolutional inductive biases remain advantageous at very large data and compute scales, or are largely absorbed by sufficiently large attention models, is not settled. Dosovitskiy et al. (2020) and Liu et al. (2022) offer evidence pointing in different directions; differences in training recipes and data complicate comparison, and this article does not attempt to adjudicate.
2. Robustness. How reliably CNN predictions transfer under distribution shift is not assessed in the sources cited here.

As of 2026-10-19, convolutional and attention-based models both see substantial use in vision. The mathematical description of the convolution layer, weight sharing and equivariance is Established. The empirical claim that convolutional networks trained end to end outperformed earlier hand-engineered pipelines on large-scale image recognition is Well Supported by the ImageNet results (Krizhevsky et al., 2017) and the subsequent residual network work (He et al., 2015). The relative merits of convolutional and attention-based designs are Contested; head-to-head results depend on pre-training data, scale and training recipe (Dosovitskiy et al., 2020; Liu et al., 2022).

This section describes plausible directions and does not register forecasts.

• Near term (0–3 years). Continued use of convolutional components in efficiency-sensitive and embedded settings, and in hybrid designs.
• Medium term (3–10 years). The balance among convolutional, attention-based and state-space designs for vision and video depends on empirical comparisons at scale that are not yet resolved.
• Long term (10+ years). Whether strong structural priors such as convolution matter for general-purpose systems trained on very large multimodal datasets, or are replaced by learned structure, is an open question tied to the broader architecture debate in [TECH-ARCH-001].

• Foundational Concepts:
  • TECH-NN-001 Artificial Neural Networks: layers, activations and training.
  • TECH-BACKPROP-001 Backpropagation: gradient computation with shared weights.
• Related Methods & Technologies:
  • TECH-DL-001 Deep Learning: the wider practice in which CNNs rose to prominence.
  • TECH-RNN-001 Recurrent Networks and LSTM: the other early structured network family.
  • TECH-GAN-001 Generative Adversarial Networks: convolutional generators and discriminators.
  • TECH-VAE-001 Autoencoders and Variational Autoencoders: convolutional encoders and decoders.
  • TECH-GNN-001 Graph Neural Networks: generalizing local aggregation to graphs.
  • TECH-HW-001 AI Hardware & Accelerator Systems: GPUs and the scale-up of CNN training.
  • HIST-005 The Deep Learning Breakthrough: the 2012 ImageNet result in context.
• Advanced Implications & Future Trajectories:
  • TECH-ARCH-001 The Transformer Architecture: the Vision Transformer and the convolution-attention comparison.
  • TECH-MM-001 Multimodal Foundation Models: image encoders in multimodal systems.