Convolutions Explained: How CNNs Extract Features from Images

Identity statement: a convolutional layer slides a small, learnable filter (also called a kernel) across a grid-shaped input, computing a weighted sum at each position — the same filter, reused at every position, producing a new grid of outputs called a feature map. [GROUND TRUTH] (Sources/nca-genm/domain-1-core-ml-ai.md) states this directly: "Convolutional layers slide learnable filters over grid-like data (images, spectrograms) to extract local, translation-invariant features."

When it matters: any scenario involving image or spectrogram data, or any question that names "CNN," "convolutional layer," or asks why an image-processing architecture does not use plain fully-connected layers.

L1 — Intuition

Imagine looking at a photograph through a small magnifying loupe that only reveals a 3-by-3 patch of pixels at a time. You slide that loupe across the entire photograph, left to right, top to bottom, and at every position you apply the exact same simple rule — say, "does this patch look like an edge" — to whatever patch is currently visible. A convolutional filter is that loupe and that rule, combined: a small grid of learned weights that gets applied, unchanged, to every local patch of the input in turn.

L2 — Mechanism

A filter (kernel) is a small grid of learned weights — commonly 3×3 or 5×5 for image data. The filter is placed over a patch of the input the same size as the filter, each filter weight is multiplied by the corresponding input value underneath it, and the products are summed into a single number — exactly the same weighted-sum arithmetic as the neuron from M1-05, just applied to a small spatial patch rather than a flat vector of inputs. That single number becomes one entry in the output feature map. The filter then slides to the next position — typically shifting by a fixed stride (commonly 1 or 2 pixels) — and repeats the same computation, producing the next entry in the feature map. This repeats across the entire input, producing a full grid of outputs.

Because the same filter weights are reused at every position, a convolutional layer with, say, a 3×3 filter on a single-channel image has only 9 weights (plus a bias) to learn, no matter how large the input image is — a dramatic reduction compared to a fully-connected layer, which would need one weight per input pixel per output unit.

L3 — Translation invariance and why it is a direct consequence

Translation invariance means the layer detects the same feature (an edge, a corner, a particular texture) regardless of where in the image that feature appears. This property is not a separate design choice bolted on top of convolution — it falls directly out of sliding the identical filter across every position: if a filter has learned to respond strongly to a vertical edge, it will respond strongly to a vertical edge wherever in the image that edge happens to sit, because the exact same weights are doing the detecting at every location. Contrast this with a fully-connected layer, whose weights are position-specific by construction — a fully-connected layer that had learned to detect an edge in the top-left corner of an image has no mechanism guaranteeing it will detect the same edge shifted to the bottom-right, because a completely different set of weights handles that region.

The case for convolutions over fully-connected layers on image data rests on two related but distinct advantages, worth separating because a scenario question can test either one independently.

Parameter efficiency. A fully-connected layer processing a modest 224×224 RGB image (a common input size) as a flat vector has 224 × 224 × 3 = 150,528 input values; connecting every one of those to just a single output neuron already requires 150,528 weights, and a layer with many output neurons multiplies that number further. A convolutional layer with a 3×3 filter across the same three color channels needs only 3 × 3 × 3 = 27 weights (plus a bias) per filter, regardless of how large the input image is — the parameter count is decoupled from the input's spatial size, because the same small filter is reused everywhere rather than each output unit needing its own complete set of input-sized weights.

Local, spatially-relevant feature extraction. A convolutional filter only ever looks at a small local patch at a time, which matches how meaningful visual structure actually tends to appear — edges, corners, and textures are local phenomena, defined by a pixel's relationship to its near neighbors, not by comparing pixels from opposite corners of an image. A fully-connected layer, in contrast, treats every input pixel as equally related to every other pixel from the start, with no built-in notion that nearby pixels are more likely to be relevant to each other than distant ones — it has to learn that locality matters from data, rather than having it built into the architecture the way a convolutional layer does.

A single convolutional layer detects simple, local patterns — edges, corners, color transitions. Stacking multiple convolutional layers lets a network build up increasingly complex, larger-scale features from those simple ones, because each successive layer's filters operate on the feature maps the previous layer produced, not on the raw pixels directly.

The typical progression, informally: early layers (closest to the raw input) tend to learn to detect simple, low-level features like edges and color gradients. Middle layers combine those simple features into more complex local patterns — a curve, a texture, a simple shape. Later layers combine those into high-level, object-relevant features — something resembling an eye, a wheel, a specific texture pattern associated with a category the network is trying to recognize. This hierarchical buildup — simple to complex, local to more global — is a direct consequence of stacking convolutions, and it is why convolutional architectures dominate vision tasks: the network does not need to be told in advance what an "eye" or a "wheel" looks like; stacking convolutional layers and training end-to-end lets those higher-level detectors emerge from data.

Pooling, often interleaved between convolutional layers, is a companion operation worth naming here: it downsamples a feature map — commonly by taking the maximum value (max pooling) within a small local window — reducing the feature map's spatial size while keeping the strongest detected signal. [VENDOR SPEC] (Sources/nca-genm/domain-6-software-development.md) names convolutions and pooling together as the primitive operations cuDNN accelerates at the GPU level, underscoring that the two operations are the standard companion pair in a vision architecture's early stages.

Sections 1 through 3 described a single filter producing a single feature map, which is the clearest way to see the core mechanism but understates how a real convolutional layer is actually structured. Two additional details — channels and multiple filters — matter enough to spell out on their own.

Channels. A color image is not a single 2D grid; it is typically three stacked grids (red, green, blue), called channels. A filter applied to a multi-channel input has a matching number of channels itself — a filter for a 3-channel RGB image is not 3×3, it is 3×3×3, with a separate 3×3 slice of weights for each color channel, and the three channels' contributions are summed together into a single number at each position, exactly as section 7's worked example summed across a filter's spatial positions. This is why section 8's parameter count used 5 × 5 × 1 for a single grayscale channel specifically — a color-image version of the same filter would need 5 × 5 × 3 weights instead, three times as many, to account for the three input channels.

Multiple filters. A convolutional layer almost never uses just one filter. Instead, it typically learns many filters simultaneously — commonly anywhere from a handful up to several hundred, depending on the layer's position in the network — each one free to learn a different pattern to detect: one filter might specialize in vertical edges, another in a particular color transition, another in a small curved shape. Each filter, applied across the entire input, produces its own separate feature map, and a layer with 32 filters therefore produces 32 separate feature maps stacked together, forming the multi-channel input the next convolutional layer will process. This is exactly how the "16 output feature maps" in section 8's worked example arose: 16 separate filters, each producing one feature map, stacked into a 16-channel output.

The generalization worth carrying forward: a convolutional layer's true parameter count is filter_height × filter_width × input_channels × number_of_filters, and every one of those four factors is a separate lever a described scenario might vary — increasing input resolution changes nothing about parameter count (section 8's core point), but increasing the number of input channels or the number of filters does increase it, proportionally and predictably.

Two more mechanics round out the picture, and one of them explains why the source material's definition names spectrograms alongside images.

Padding. Section 6's worked example noted that a 2×2 filter with stride 1 shrinks a 4×4 input down to 3×3 — each convolution without padding loses a border of pixels equal to filter_size − 1. Stacking many such layers would keep shrinking the feature map's spatial size, eventually down to nothing. Padding — commonly adding a border of zero-valued pixels around the input before applying the filter — compensates for this, letting a convolutional layer preserve the input's spatial dimensions if desired ("same" padding) rather than shrinking it every time ("valid" padding, no padding added). Which choice is appropriate depends on the architecture: a classifier that eventually collapses its feature maps down to a single decision may deliberately let dimensions shrink layer by layer, while a U-Net's decoder path — which needs to reconstruct a full-resolution output — relies on padding choices, together with the skip connections covered in the next lesson, to keep spatial dimensions properly aligned between the encoder and decoder paths.

Receptive field. As convolutional layers stack, a unit in a later feature map is influenced by a progressively larger region of the original input, even though each individual filter only ever looks at a small local patch of its own input. A first-layer filter with a 3×3 receptive field sees only a 3×3 patch of the raw image; a second-layer filter with its own 3×3 receptive field, applied to the first layer's output, is influenced by a roughly 5×5 patch of the original image, because each of the 9 positions it looks at was itself computed from a 3×3 patch of the raw input. This growing receptive field is the formal version of the "edges to objects" progression from section 3 — larger receptive fields in later layers are what let those layers represent larger-scale, more global structure, even though every individual filter, at every layer, still only performs a small, local computation.

Why the mechanism applies to spectrograms, not just images. [GROUND TRUTH] (Sources/nca-genm/domain-1-core-ml-ai.md) explicitly names spectrograms alongside images as grid-like data convolutions apply to, and the reason is structural rather than incidental: a spectrogram represents audio as a 2D grid, with one axis for time and the other for frequency, and — just as with an image — nearby cells in that grid tend to carry related information (a sustained tone occupies neighboring time-steps at a similar frequency; a chord occupies neighboring frequencies at the same time-step). Any data that can be represented as a grid with meaningful local structure is a candidate for convolutional processing, which is precisely why the mechanism this lesson describes for images transfers directly to audio once the audio has been converted into a spectrogram — the feature-engineering step named in M1-01 as audio's modality-specific preprocessing.

Convolutions are not just the backbone of classic image classifiers — they are a foundational building block inside the U-Net architecture that this exam's Domain 6 material builds a text-to-image pipeline around. [GROUND TRUTH] (Sources/nca-genm/domain-1-core-ml-ai.md) states this connection directly: convolutions are "a key building block inside U-Nets used for image generation." [VENDOR SPEC] (Sources/nca-genm/domain-6-software-development.md) describes a U-Net as "an encoder-decoder ('U-shaped') convolutional network with skip connections" — the word "convolutional" is doing real work in that description, because both the encoder (contracting) path and the decoder (expanding) path are built from stacked convolutional layers, exactly the mechanism sections 1 through 3 of this lesson describe.

This lesson's scope stops here deliberately: the U-Net's full encoder-decoder structure, its skip connections, and its role as the denoising backbone inside a diffusion model belong to their own dedicated treatment later in this course. What is worth carrying forward from here is narrower and more foundational: whatever a U-Net or any other vision architecture eventually does with its convolutional layers, the underlying arithmetic — a small filter, slid across a grid, producing a translation-invariant feature map — is exactly the mechanism this lesson just built up from a single neuron's weighted sum.

Consider a tiny 4×4 single-channel input (values 0–9, representing pixel intensities) and a 2×2 filter, applied with stride 1 and no padding.

Input (4x4):                  Filter (2x2):
  1  2  3  0                    1  0
  4  5  6  1                    0 -1
  7  8  9  2
  0  1  2  3

Output position (0,0): filter over input[0:2, 0:2]
  = (1x1) + (2x0) + (4x0) + (5x-1) = 1 + 0 + 0 - 5 = -4

Output position (0,1): filter over input[0:2, 1:3]
  = (2x1) + (3x0) + (5x0) + (6x-1) = 2 + 0 + 0 - 6 = -4

Output position (0,2): filter over input[0:2, 2:4]
  = (3x1) + (0x0) + (6x0) + (1x-1) = 3 + 0 + 0 - 1 = 2

Output position (1,0): filter over input[1:3, 0:2]
  = (4x1) + (5x0) + (7x0) + (8x-1) = 4 + 0 + 0 - 8 = -4

This is a constructed scenario with invented numbers, not a measurement from any real image. Continuing this pattern across every valid position produces a 3×3 output feature map from the 4×4 input (a 2×2 filter with stride 1 and no padding reduces each spatial dimension by filter_size − 1 = 1). Notice the filter used here — [[1, 0], [0, -1]] — computes, at every position, the difference between a pixel and its diagonal neighbor, which is a simple edge-detecting operation: positions where the diagonal values are similar produce outputs near zero, and positions with a sharp diagonal contrast produce a larger-magnitude output. A real, trained convolutional filter's weights are learned via the training loop from M1-05 rather than hand-specified like this one, but the arithmetic — multiply, sum, slide, repeat — is identical.

A team is deciding between a fully-connected layer and a convolutional layer as the first layer of a network processing 64×64 grayscale (single-channel) images, producing 16 output feature maps.

Fully-connected layer, connecting every input pixel to every one of
16 output units:
  Input size = 64 x 64 = 4,096 pixels
  Weights needed = 4,096 x 16 = 65,536 (plus 16 biases)

Convolutional layer, 16 filters of size 5x5, single input channel:
  Weights per filter = 5 x 5 x 1 = 25
  Total weights = 25 x 16 = 400 (plus 16 biases)

Ratio: the fully-connected layer needs roughly 164x more weights
for a comparable number of output feature maps.

Constructed scenario, illustrative numbers. This gap widens further as image resolution increases — the fully-connected layer's weight count grows directly with input size, while the convolutional layer's weight count depends only on the filter size and the number of filters, entirely independent of how large the input image is. This is the parameter-efficiency argument from section 2 made concrete: two architectures aimed at a similar goal, with one requiring two orders of magnitude more learnable parameters than the other, purely as a consequence of how each connects its inputs to its outputs.

Scale the same comparison up to a more realistic 512×512 grayscale input and the gap becomes even starker: the fully-connected layer's weights needed jumps to 512 × 512 × 16 = 4,194,304, while the convolutional layer's weight count stays exactly the same 400, because a convolutional layer's weight count never depended on the input's spatial dimensions in the first place. At this resolution the fully-connected layer needs over ten thousand times as many weights as the convolutional layer for a comparable job — the ratio does not merely persist as resolution grows, it widens, because only one side of the comparison has a term for input size in its formula at all.

⭐ THE EARNED INSIGHT Convolution's efficiency and its translation invariance are the same fact, viewed from two angles, not two separate benefits that happen to coincide. Reusing one small filter everywhere is simultaneously what keeps the parameter count small (the filter's weights are the only weights, regardless of image size) and what guarantees the same feature gets detected no matter where it appears (the identical weights are doing the detecting at every position). A design choice that seems to solve a computational problem (too many weights) and a modeling problem (spatial structure) independently is, mechanically, one choice solving both at once.

Each row above names a specific, checkable symptom against a specific fix.

Core Machine Learning and AI Knowledge carries 20% exam weight, and [GROUND TRUTH] (Sources/nca-genm/domain-1-core-ml-ai.md) names convolutions explicitly as "the workhorse of vision" and as "a key building block inside U-Nets used for image generation (Domain 6)" — a direct, stated bridge between this domain's foundational material and Domain 6's 15%-weighted image-generation content. Recognizing convolutions correctly here pays off again the moment a later scenario asks about U-Net structure or diffusion denoising.

The question tends to arrive in a small number of recognizable shapes.

1. Why convolutions over fully-connected layers. A scenario asks why an image-processing network uses convolutional layers rather than fully-connected ones, with the keyed answer naming parameter efficiency, local feature extraction, or both.
2. Translation invariance, defined or applied. "What does it mean for a convolutional layer to be translation-invariant?" or a scenario testing whether a described network would detect a feature regardless of its position.
3. Cross-domain U-Net connection. A scenario names a U-Net and asks what kind of layers make up its encoder and decoder paths — the keyed answer names convolutional layers.
4. Convolution-versus-pooling distinction. A scenario describes a downsampling operation and asks whether it is convolution or pooling, testing whether you know pooling has no learned weights.

What the distractors typically look like

The reliable distractor families: describing convolutional filters as position-specific rather than shared and reused; asserting convolutions require more parameters than fully-connected layers, inverting the actual efficiency advantage; and treating a U-Net as an architecture unrelated to convolutional networks, rather than a specific, structured arrangement of them.

A fifth, subtler family draws directly on the cuDNN connection covered in M1-04: a scenario names cuDNN alongside "convolutions and pooling" and asks what role it plays. [VENDOR SPEC] (Sources/nca-genm/domain-6-software-development.md) is explicit that cuDNN is a low-level primitives library providing GPU-accelerated implementations of exactly these two operations, not a model or a framework in its own right — a distractor that describes cuDNN as an alternative to a convolutional layer, rather than the accelerated implementation underneath one, is testing whether that specific layering was retained from the earlier lesson.

Because a convolutional layer's weights belong to a small filter that is reused at every spatial position, rather than each output unit needing its own complete, input-sized set of weights the way a fully-connected layer does. A 5×5 filter has 25 weights regardless of whether the input image is 64×64 or 4,096×4,096 — the same 25 weights simply slide to more positions on a larger image, producing a larger output feature map, but never requiring more weights to do so. A fully-connected layer's weight count, by contrast, grows directly with the input's total pixel count, which is why the gap between the two widens dramatically as image resolution increases.

A unit's receptive field is the region of the original input that influences its value, and it grows larger with each additional convolutional layer stacked before it, even though every individual filter only ever looks at a small local patch of its immediate input. A first layer's receptive field is exactly its filter size — a 3×3 filter sees a 3×3 patch of the raw input. A second layer's own 3×3 filter, applied to the first layer's output, is influenced by a roughly 5×5 patch of the original image, because each of the 9 positions it examines was itself computed from a 3×3 patch of the raw input one layer earlier. This growth is what lets later layers in a deep convolutional network represent increasingly large-scale, global structure — an object's overall shape rather than just a single edge — while every individual filter, at every layer, continues to perform only a small, local computation.

• A convolutional layer slides a small, learnable filter across grid-like data, computing a weighted sum at each position to produce a feature map.
• The same filter is reused at every position, which is simultaneously what makes convolutions parameter-efficient and what produces translation invariance — one mechanism, two consequences.
• Convolutions need far fewer parameters than a fully-connected layer on the same image, because the weight count depends on filter size, not input size.
• Stacking convolutional layers builds hierarchical features — simple edges in early layers, complex object-relevant patterns in later layers.
• Convolutions are a key building block inside the U-Net used for image generation, though the U-Net's full encoder-decoder structure and skip connections belong to their own dedicated treatment.
• A filter's channel count matches its input's channel count, and a layer's total parameter count is filter_height × filter_width × input_channels × number_of_filters — resolution never enters that formula.
• A unit's receptive field grows with network depth, letting later layers represent progressively larger-scale structure even though each filter still only examines a small local patch.
• The mechanism generalizes past images: any grid-shaped data with local structure — including a spectrogram — is a candidate for convolutional processing.
• cuDNN accelerates convolution and pooling at the GPU level, underneath the framework — it is a primitives library, never a competing model or a substitute for the layer itself.

This lesson covered how a network processes grid-like data efficiently. What it did not cover is what happens when a network's layers stop forming a simple, single-path stack — when branches, multiple inputs, and skip paths enter the picture, which is exactly what multimodal fusion requires. M1-07 covers nonsequential networks and residual connections next, including the mechanism that lets very deep networks — convolutional or otherwise — actually train.