This is the one formula that tells you how big a convolution's output will be — before you ever run it. Give it the input size, the kernel size, the stride and the padding, and it hands back the width and height of the feature map.

Where you meet it

• Designing a CNN and needing each layer's output shape so the next layer fits.
• Debugging a PyTorch or TensorFlow shape mismatch — the classic one right before a flatten into a linear layer.
• Working out how much an image shrinks through several conv and pooling layers (downsampling, receptive field).
• The exam question: "input 32×32, kernel 5×5, stride 1, padding 2 — what's the output?"

What it does

It counts how many places the kernel can stop as it slides across the input. That count is the output width (and, the same way, the height). No weights, no training — this is pure geometry of a window moving over a grid.

The output size is just the number of places the kernel can stand. Count the stops, and you already have it.

How it works

Lay the F-wide kernel on a W-wide row. The first stop puts its left edge at position 0; the last stop that still fully fits has its left edge at W−F. If you move by S each time, the left-edge stops are 0, S, 2S, … up to W−F — so the count is (W−F)/S, plus one for that very first stop. Padding adds P cells of border on each side, so the width grows by 2P. Put it together and round down:

out = ⌊(W − F + 2P) / S⌋ + 1

W=5, F=3, P=0
  S=1  →  stops at 0,1,2      out = ⌊(5−3+0)/1⌋+1 = 3   → 3×3
  S=2  →  stops at 0,2        out = ⌊(5−3+0)/2⌋+1 = 2   → 2×2
                                (a stop at 4 would hang off the edge → floor drops it)

W=5, F=3, P=1
  S=1  →  out = ⌊(5−3+2)/1⌋+1 = 5   → 5×5   ("same" size)

The floor ⌊⌋ is not decoration: a partial stop at the end — where the kernel would hang off the edge — simply does not count. And P=1 with a 3×3 kernel gives back the original size, which is why it is called same-padding.

Watch out

Count the kernel's stops — floored, plus one — and that's your feature map, in each dimension.

Go deeper

• Stanford CS231n — Convolutional Networks (where this formula comes from)
• Dumoulin & Visin — A guide to convolution arithmetic for deep learning
• PyTorch — Conv2d (the exact output-shape formula every framework uses)

Das ist die eine Formel, die dir sagt, wie groß die Ausgabe einer Faltung wird — noch bevor du sie ausführst. Gib ihr Eingabegröße, Kernelgröße, Stride und Padding, und sie liefert Breite und Höhe der Feature Map.

Wo es vorkommt

• Beim Entwerfen eines CNN, wenn du die Ausgabegröße jeder Schicht brauchst, damit die nächste passt.
• Beim Debuggen eines Shape-Mismatch in PyTorch oder TensorFlow — der Klassiker direkt vor dem Flatten in eine Linear-Schicht.
• Wenn du ausrechnest, wie stark ein Bild durch mehrere Conv- und Pooling-Schichten schrumpft (Downsampling, rezeptives Feld).
• Die Klausurfrage: "Eingabe 32×32, Kernel 5×5, Stride 1, Padding 2 — was ist die Ausgabe?"

Was es tut

Es zählt, an wie vielen Stellen der Kernel anhalten kann, während er über die Eingabe gleitet. Diese Anzahl ist die Ausgabebreite (und genauso die Höhe). Keine Gewichte, kein Training — reine Geometrie eines Fensters, das über ein Gitter wandert.

Die Ausgabegröße ist nichts anderes als die Zahl der Stellen, an denen der Kernel stehen kann. Zähl die Stopps, und du hast sie schon.

Wie es funktioniert

Leg den F breiten Kernel auf eine W breite Zeile. Der erste Stopp setzt seine linke Kante auf Position 0; der letzte, der noch ganz passt, hat die linke Kante bei W−F. Springst du je um S, liegen die Stopps bei 0, S, 2S, … bis W−F — die Anzahl ist also (W−F)/S, plus eins für den allerersten Stopp. Padding legt P Randzellen an jede Seite, die Breite wächst also um 2P. Zusammengesetzt und abgerundet:

out = ⌊(W − F + 2P) / S⌋ + 1

W=5, F=3, P=0
  S=1  →  Stopps bei 0,1,2    out = ⌊(5−3+0)/1⌋+1 = 3   → 3×3
  S=2  →  Stopps bei 0,2      out = ⌊(5−3+0)/2⌋+1 = 2   → 2×2
                                (ein Stopp bei 4 ragt über den Rand → Abrunden wirft ihn weg)

W=5, F=3, P=1
  S=1  →  out = ⌊(5−3+2)/1⌋+1 = 5   → 5×5   ("gleiche" Größe)

Das Abrunden ⌊⌋ ist keine Kosmetik: ein halber Stopp am Ende — wo der Kernel über den Rand ragen würde — zählt einfach nicht. Und P=1 mit 3×3-Kernel gibt die ursprüngliche Größe zurück — deshalb heißt es Same-Padding.

Worauf achten

Zähl die Stopps des Kernels — abgerundet, plus eins — und das ist deine Feature Map, in jeder Dimension.

Mehr dazu

• Stanford CS231n — Convolutional Networks (woher diese Formel kommt)
• Dumoulin & Visin — A guide to convolution arithmetic for deep learning
• PyTorch — Conv2d (die exakte Ausgabegrößen-Formel, die jedes Framework nutzt)