pooling
/ POOL-ing /
Pooling is the step where a network zooms out. After a layer has produced detailed feature maps, pooling shrinks them by summarizing each little neighborhood into a single number — keeping the gist, throwing away the fine print. It is like making a thumbnail of a photo: you lose the pixel-level detail, but the overall shapes survive, and the file gets much smaller and quicker to handle.
The most common kind is max pooling: slide a small window (often 2×2) across a feature map and, at each stop, keep only the largest value inside it. Since a large value means "this feature was strongly present somewhere in this patch," max pooling records that the feature showed up while forgetting its exact pixel. Average pooling instead keeps the average of the window — a gentler summary. Either way the feature map comes out smaller, typically halved in width and height, so the deeper layers do less work and can take in a wider view of the image at once.
Pooling buys two things. It makes the network cheaper, and it grants a little translation invariance: if the cat slides a few pixels to the left, the pooled summary barely changes, so recognition is steadier. The honest catch is that pooling deliberately discards spatial precision — fine for "is there a cat?" but a problem when you need exactly where every edge sits, as in pixel-level tasks. For that reason many modern architectures pool less, or replace it with strided convolutions that shrink the map while still learning how to do the summarizing.
2×2 max pooling on a patch [ [1, 5], [3, 2]] keeps just the 5. A 4×4 feature map becomes a 2×2 one, four times smaller, holding only the strongest signal from each corner.
Max pooling: keep the strongest, drop the rest — a deliberate, lossy shrink.
Pooling has no numbers to learn — it is a fixed summarizing rule, not a trainable layer. Its job is to shrink and to add a little tolerance to position; it is not where the network's knowledge lives.