Output Shape Arithmetic

## What the formula counts A 2D convolution slides a `k x k` window over the (optionally padded) input and emits one number per valid window position. So the output size on an axis is just **how many window positions fit**, and that is a counting argument, not a division. On one axis, let `n` be the input size, `p` the zero padding added to *each* side, `k` the kernel size and `s` the stride. The padded axis has length `n + 2p`. A window occupying positions `[i, i + k - 1]` fits as long as `i <= n + 2p - k`. Valid starts are `0, s, 2s, ...`, so the count is ``` out = floor((n + 2p - k) / s) + 1 ``` The `+ 1` is the fence-post term for the window starting at 0. The `floor` is what happens when `(n + 2p - k)` is not a multiple of `s`: the leftover input at the far edge is simply never covered by any window and is silently dropped. Height and width are computed independently with their own `n`, `p`, `k`, `s` — nothing couples them. The formula is also silent about channels. Each filter spans **all** input channels, and the number of output channels equals the number of filters. Depth is a property of the layer definition, not of the sliding-window arithmetic. ## Valid and same padding **Valid** means `p = 0`. At stride 1 this gives `out = n - k + 1`, so every layer shaves `k - 1` off each axis. Stack ten 3x3 valid convolutions and you have lost 20 pixels per axis, which is why deep valid-padded stacks need generous input margins. **Same** at stride 1 means you want `out = n`. Setting `n = n + 2p - k + 1` gives `p = (k - 1)/2`. That is an integer only for **odd** `k`, which is the practical reason 3x3 (p = 1), 5x5 (p = 2) and 7x7 (p = 3) dominate over 2x2 and 4x4. At stride greater than 1, "same" is redefined as `out = ceil(n / s)`. The total padding required is `max((out - 1) * s + k - n, 0)`, split between the two sides. When that total is odd — for instance a 4x4 kernel at stride 1 needs a total of 3 — it cannot be split symmetrically, so one side receives the extra row or column and the output grid sits half a pixel off centre. The same asymmetry appears with an even stride when `n` is not a multiple of `s`. ## Dilation Dilation `d` inserts `d - 1` gaps between kernel taps. The window still holds `k x k` weights, but it *spans* ``` k_eff = k + (k - 1) * (d - 1) ``` input positions. A 3x3 kernel at dilation 4 has `k_eff = 3 + 2 * 3 = 9`: it reads from a 9x9 footprint while still costing nine weights per input channel. Substituting `k_eff` for `k` gives the general form `out = floor((n + 2p - k_eff)/s) + 1`, and preserving the size at stride 1 now needs `p = 4`, not `p = 1`. Forgetting this is the usual cause of a map that unexpectedly shrinks by eight pixels. ## Asymmetric strides Because the axes are independent, the stride and kernel may differ per axis. Take an audio input of 128 mel bins by 401 frames, a 3x3 kernel with `p = 1` and a stride of `(2, 1)`. The frequency axis gives `floor((128 + 2 - 3)/2) + 1 = 63 + 1 = 64`, while the time axis gives `floor((401 + 2 - 3)/1) + 1 = 401`. Frequency halves at every stage and time is preserved exactly — a deliberate design when you need frame-level output alignment. ## Working it by hand The reliable habit is to write the chain out before training: input size, then one line per layer with `k`, `s`, `p`, `d` and the resulting size. Two checks catch nearly every mistake. First, is the numerator `n + 2p - k` non-negative? If not, the kernel is larger than the padded input and the layer is invalid. Second, is `(n + 2p - k)` divisible by `s`? If not, the floor is discarding input, which is legal but is exactly where a later shape mismatch is born. Common errors: rounding up instead of down; forgetting that `p` is added on both sides, so the numerator gains `2p` and not `p`; dropping the `+ 1`; applying the formula to the channel axis; and assuming a 3x3 with one pixel of padding preserves size at *any* stride, when it only does so at stride 1.