When you glance at a photo of your dog, your eyes don’t study every pixel one at a time. They get pulled straight toward the things that matter — the edge where an ear meets the head, the dark circle of a nose, the curve of a tail. Convolutional neural networks try to copy that exact trick, and the two tools they use to pull it off are called filters (also known as kernels) and feature maps.

In technical terms, a filter is a small two-dimensional grid of learnable weights — numbers the network adjusts during training. Most filters in modern networks are just 3×3 in size, though 5×5 filters show up too. As that tiny grid is dragged across every position of an image, it multiplies its own numbers against the pixels underneath it and adds the results together. Each of those sums lands in a new grid called a feature map (sometimes called an activation map, or a convolved feature) — and that feature map becomes the input the very next layer works with.

Three Names, Two Ideas

People studying computer vision tend to use a handful of overlapping words for the same two concepts. It helps to untangle them early:

It’s worth being precise about one more distinction that trips people up: a feature map is not quite the same thing as an embedding. A feature map keeps its spatial shape — it still has a height and a width that line up with the original image — while an embedding is usually flattened into a single long list of numbers that throws spatial position away in exchange for a compact summary. Feature maps are for “what’s where”; embeddings are for “what’s this, overall.”

Before convolutional networks took over computer vision, engineers tried feeding images into the same kind of network used for things like predicting house prices — a densely connected, fully-connected network. For images, that approach ran into trouble almost immediately.

A fully-connected network treats every single pixel as its own separate input. A modest color photo of 224×224 pixels with three colour channels already contains 150,528 individual numbers. Connect that to even a few modest hidden layers and the number of trainable weights can balloon into the hundreds of billions before the network has learned anything useful at all. Training a model that large is painfully slow, and with so many free parameters relative to the amount of training data available, it tends to memorize the training images rather than learning anything that generalizes.

There’s a second, sneakier problem: fully-connected networks have no built-in sense of position. If the exact same object shifts a few pixels to the left in a photo, a dense network may treat the shifted image as something completely unfamiliar, because a different set of input neurons is now “lit up.” Convolutional networks solve both problems with one elegant trick: instead of learning a separate rule for every pixel location, they learn one small filter and reuse it — sliding it across every part of the image. This is called parameter sharing, and it’s the single biggest reason CNNs are practical at all.

Strip away the jargon and a convolution is really just repeated multiplication and addition, performed in a small moving window. Here is exactly what happens, one step at a time.

1. The filter is placed over a small patch of the input — this patch is called the receptive field, and for a 3×3 filter it’s simply a 3×3 block of pixels.
2. Every one of the filter’s nine numbers is multiplied by the pixel value sitting directly beneath it.
3. All nine of those products are added together into a single number — this is the dot product.
4. That single number is written into the matching cell of the new feature map.
5. The filter then slides over by a fixed number of pixels (the stride) and the whole process repeats.
6. Once the filter reaches the end of a row, it drops down to the next row and starts again from the left, until the entire image has been scanned.

Three quiet little settings decide exactly how big and how deep every feature map will turn out to be. Get comfortable with these three and the rest of a CNN’s architecture starts to make sense at a glance.

The Three Flavours of Padding

A single filter can only ever look for one thing. Real convolutional layers stack dozens — sometimes hundreds — of filters side by side, each hunting for something a little different, and pile their outputs into one tall block of feature maps.

This matters because the number of filters in a layer directly decides the depth of its output. Three different filters produce three separate feature maps, which are stacked together into an output volume that is three layers deep. There’s one strict rule every filter has to obey, though: the depth of a filter must always match the depth of whatever it’s scanning. A filter looking at a colour image with red, green, and blue channels needs a depth of three, with one 3×3 “slice” — called a kernel — for each colour channel. A filter scanning the output of an earlier layer with 64 channels needs a depth of 64 to match.

The other half of the magic is parameter sharing: the same nine weights inside a 3×3 filter are reused at every single position as it slides across the entire image, rather than learning a fresh set of weights for every pixel location. This is precisely why CNNs need so many fewer trainable parameters than a fully-connected network would for an image of the same size, and why a pattern learned in one corner of an image is automatically recognised everywhere else too.

Long before neural networks existed, image-processing engineers hand-designed filters to find edges, soften photos, or sharpen them. A CNN never needs to be told which filters to use — it discovers similar (and sometimes much stranger) ones automatically during training — but seeing a few hand-crafted classics makes the whole idea click immediately.

And here’s the satisfying part: when researchers peek inside the very first convolutional layer of a trained network like VGG16 and plot its filters as little grayscale images, many of them really do look like simple gradient and edge detectors — almost identical in spirit to the hand-designed kernels above. The network rediscovered, on its own, ideas that image-processing engineers had worked out decades earlier.

A freshly computed feature map is just a grid of plain numbers — some positive, some negative, some sitting right at zero. Before it gets handed to the next layer, almost every CNN pushes that grid through an activation function. Strictly speaking, the result of that step is called an activation map, though in everyday conversation people often use “feature map” loosely for both the raw and the activated version.

The activation function used most often by far is ReLU — short for Rectified Linear Unit. Its rule could not be simpler: keep every positive value exactly as it is, and replace every negative value with zero. That simple snap introduces something a stack of pure convolutions could never produce on its own — non-linearity. Without it, no matter how many convolutional layers were stacked together, the entire network would mathematically collapse into nothing more than one giant linear operation, incapable of learning the curved, complicated decision boundaries that real-world recognition tasks demand.

Feature maps can pile up fast, both in number and in size. Pooling layers step in right after activation to shrink them down, without throwing away the most important signal hiding inside.

A pooling filter slides across the input just like a convolutional filter does — but it carries no learnable weights at all. Instead, at every position it simply applies a fixed aggregation rule to whatever values fall underneath it.

Stack enough convolution-activation-pooling blocks together, one after another, and something remarkable happens: the feature maps stop looking like simple lines and start looking like entire object parts — and then, eventually, whole objects.

A landmark 2013 paper on visualizing convolutional networks demonstrated this hierarchy directly. The researchers built a technique to reconstruct, pixel by pixel, exactly which input patches caused the strongest activation in different feature maps throughout a trained network. Early-layer filters, they found, responded mostly to simple edges and patches of colour. Filters several layers deeper responded to far more complex, compositional structures — recognisable parts of objects rather than raw geometry.

There’s a helpful way to picture why this happens. Think of an everyday object — say, a bicycle — as a sum of its parts: a frame, two wheels, handlebars, pedals. Each individual part forms a relatively low-level pattern that an early-to-middle layer can pick up on its own. Combine several of those parts together in the right arrangement, and a much later layer can recognise the higher-level pattern they form together: a bicycle, sitting whole, in the photograph.

CNNs are sometimes called “black boxes,” but they’re more transparent than people assume — researchers have developed two simple, complementary ways to actually open one up and look.

Researchers experimenting with a well-known pretrained network like VGG16 typically find a consistent, almost reassuring pattern: feature maps pulled from layers close to the input retain a lot of fine detail — recognisable outlines, textures, the rough silhouette of whatever was photographed. Feature maps pulled from layers near the output, on the other hand, look increasingly abstract and blocky, trading recognisable shape for compressed, high-level meaning. By the final convolutional block, a human glancing at the raw feature maps usually can’t tell what object the network saw anymore — yet the network can still classify it correctly, because it isn’t looking for a picture any more. It’s looking for a pattern of numbers that has, time and again, meant “this is a bird” or “this is a bicycle.”

Filters and feature maps unlocked modern computer vision, but the approach is not without real, practical trade-offs that every team building with CNNs eventually runs into.

Once trained, the filters and feature maps inside a CNN aren’t just an academic curiosity — they quietly power a huge slice of the visual technology people interact with every single day.

The idea of a small, sliding, learnable filter has powered roughly four decades of computer-vision progress — refined, scaled, and reinvented by a handful of landmark architectures along the way.

Today’s architectures keep building on this same foundation while optimising for different trade-offs. Inception-style modules use small 1×1 convolutions to shrink feature-map depth before applying larger, more expensive filters, squeezing more accuracy out of less compute. Lightweight designs aimed at phones and embedded devices trim filter counts and depth for speed. Even newer vision transformer architectures, which process images quite differently, still often pair with convolutional layers at the front end to do the early, efficient pattern-spotting that filters have always been good at.