Pooling layers (max, average): Foundations — AI-ML deep dive

Before you can read a single formula in the parent note, you need to know what each little symbol is. This page builds every one of them from nothing. Read top to bottom — each idea is used by the next.

0. What is a "feature map"? (the grid we pool)

Everything in pooling happens on a grid of numbers. This whole subject lives inside a CNN — a Convolutional Neural Network, a kind of image-processing network that stacks convolution and pooling steps. Inside a CNN this grid is called a feature map, but for now just picture a spreadsheet of numbers.

Why does the topic need this? Because pooling is nothing but an operation on such a grid — the input goes in as a grid, and a smaller grid comes out. If you don't picture the grid first, none of the symbols land anywhere. These grids are produced by convolutional layers before pooling touches them.

1. Height and width: $H$ and $W$ (and the input/output tags)

The grid has a number of rows and a number of columns.

Look at the figure above: it is $4$ rows tall and $4$ columns wide, so $H = 4$ and $W = 4$ . We say the grid is $H \times W$ , read " $H$ by $W$ ".

Pooling turns a bigger grid into a smaller one, so we need to distinguish the two:

Why the topic needs them: the output-size formula computes $H_{o u t}$ , $W_{o u t}$ from $H_{in}$ , $W_{in}$ . Without the tags you couldn't tell which height the formula is talking about.

2. Naming a single cell: $X_{i, j}$ and the subscript idea

We need a way to point at one specific cell and say "that number, right there."

Because rows are numbered $0$ up to one less than the count, the indices have a valid range:

Why the topic needs it: every pooling formula is a rule that says "take these particular cells and combine them." To say which cells, you must be able to name a cell. $X_{i, j}$ is that naming tool.

2b. Many grids stacked: the channel count $C$

Real feature maps are not one grid but a stack of grids, one per detected feature.

3. The pooling window: $p$

We never summarise the whole grid at once — we summarise it patch by patch. The patch is a small square.

Picture a $2 \times 2$ cardboard frame you lay over the grid. Only the cells inside the frame get combined into one output number. This frame idea is closely tied to the receptive field — the region of input one output neuron "sees."

Why the topic needs it: $p$ decides how many cells collapse into one, which controls how much the grid shrinks and how "local" the summary is.

4. Moving the window: stride $s$

After summarising one patch, we slide the frame over and do the next patch. How far we slide is the stride.

If $s = p$ the frames sit side by side, never overlapping (the usual case).
If $s < p$ the frames overlap — some cells get used by more than one window.
If $s > p$ the frames leave gaps — some cells are skipped entirely.

This exact same $s$ is the stride you meet in stride and padding for convolutions.

Why the topic needs it: $s$ controls where each window starts. That is why it appears inside the formula as $i \cdot s + m$ — see below.

5. Reading $X_{i \cdot s + m, j \cdot s + n}$ (the address of a windowed cell)

This is the scariest-looking symbol in the parent note. Let's earn it piece by piece.

We have two coordinate systems now:

$(i, j)$ = which output cell we are building (row/column in the small result grid),
$(m, n)$ = which cell inside the window, starting at the window's top-left corner ( $m$ down, $n$ right, both from $0$ ).

The window-local indices only run across the window, so their range is fixed by $p$ :

Read it as a two-step walk:

$i \cdot s$ jumps to where output cell $i$ 's window starts (stride $s$ times the output index).
$+ m$ then steps inside that window to the cell we want.

Why the topic needs it: without this address formula you cannot say which input cells feed which output cell. It is the bridge between the small output grid and the big input grid.

6. The output grid $Y$ and the two summary operations: $max$ and the average

We named the input grid $X$ . The result of pooling is a new, smaller grid — we give it its own name.

Now the actual summarising.

Putting the address formula together with each summary gives the two complete pooling rules:

Why these two? Because a feature map's numbers mean "how strongly a feature is present."

$max$ answers "is the feature present anywhere in this patch?" — keep the peak.
Average answers "how much feature is here on the whole?" — smooth blend.

That is the entire distinction the parent note builds on. Average pooling that summarises an entire map at once is global average pooling.

7. The floor brackets $⌊ \cdot ⌋$ and the size formula

The output-size formula is $H_{o u t} = ⌊ \frac{H _{in} - p}{s} ⌋ + 1$ . One new symbol: the floor.

Why the topic needs it: a window can only sit on the grid if it fits completely. A fractional number of windows is impossible — you can't have $2.5$ patches. Rounding down throws away the leftover strip that no full window can cover.

Where does the $+ 1$ come from? Count the starting positions the window can take.

The same reasoning runs left-to-right for the columns, so there are two size formulas — one per direction:

Prerequisite map

Equipment checklist

Test yourself — cover the right side and answer before revealing.

What does one number inside a feature map mean?

How strongly the detected feature is present at that cell — big = strongly present.

What does the acronym CNN stand for?

Convolutional Neural Network.

What is the difference between

H_{in}

and

H_{o u t}

H_{in}

is the input (pre-pooling) height;

H_{o u t}

is the output (post-pooling) height.

X_{i, j}

, what are

i

and

j

and what ranges do they take?

i

is the row and

j

the column;

0 \leq i < H_{in}

and

0 \leq j < W_{in}

What is the top-left cell of grid

X

called?

X_{0, 0}

(counting starts at zero, not one).

What is the channel count

C

, and what does pooling do to it?

The number of stacked feature-map grids; pooling acts on each channel independently and leaves

C

unchanged.

What does

p

stand for, what values may it take, and what range do

m, n

take?

p

is the window side length, a positive whole number;

m

and

n

each run

0

p - 1

(

p

values), giving

p^{2}

cells.

What does the stride

s

control and what values may it take?

How many cells the window slides between patches; a positive whole number, with

s = p

meaning non-overlapping.

What does

i \cdot s + m

compute?

The input row address = jump to window start (

i \cdot s

) then step inside (

+ m

What is the grid

Y

and what is

Y_{i, j}

Y

is the pooled output grid;

Y_{i, j}

is the single summary number replacing the window at output position

(i, j)

Write the complete max-pooling formula.

Y_{i, j} = max_{0 \leq m < p} max_{0 \leq n < p} X_{i \cdot s + m, j \cdot s + n}

Write the complete average-pooling formula.

Y_{i, j} = \frac{1}{p ^{2}} \sum_{m = 0}^{p - 1} \sum_{n = 0}^{p - 1} X_{i \cdot s + m, j \cdot s + n}

How do you turn a

\sum

over a window into an average?

Divide the sum by the number of cells, i.e. multiply by

\frac{1}{p ^{2}}

Where does the

+ 1

in the size formula come from?

It counts the first window at start position

0

; the floored quotient counts the gaps between starts, and there is always one more start than gaps.

What are BOTH output-size formulas, and what do they assume about padding?

H_{o u t} = ⌊(H_{in} - p) / s ⌋ + 1

and

W_{o u t} = ⌊(W_{in} - p) / s ⌋ + 1

; they assume no padding (

P = 0

What must be true for pooling to be defined, and what happens if

H_{in} < p

You need

H_{in} \geq p

(and

W_{in} \geq p

); if the window is bigger than the grid no valid window fits and pooling is undefined without padding.