A convolution slides a small filter across an image and, at every position, scores how well the patch underneath matches that filter. Stack many of these layers and a network learns to see — edges first, then textures, then objects.
Where you meet it
- Every image classifier, object detector, and segmentation model — the C in CNN.
- Classic image filters: blur, sharpen, edge detection are all convolutions with hand-picked kernels.
- 1D convolutions over audio and text; 3D over video and volumetric scans.
What it does
A convolutional layer learns a stack of small filters (kernels) and applies each one everywhere on the input. Each filter produces one feature map — a 2D grid that lights up wherever that filter's pattern appears. The network never hand-codes "find an edge here"; it learns which filters are worth having from the data.
Nine numbers, reused across the whole image — that's the trick: a conv layer learns patterns, not pixel positions.
How it works
Take one kernel — say 3×3. Park it on the top-left of the image, multiply each kernel weight by the pixel it covers, and add up all nine products. That single number is one cell of the feature map. Slide the kernel one step right and repeat, then down, until you've covered the image. The operation at each spot is just a dot product:
out[i,j] = Σ input[i+u, j+v] · kernel[u,v]
u,vTwo ideas make this powerful. Local connectivity: each output cell looks only at a small patch, not the whole image. Parameter sharing: the same kernel weights are reused at every position — so a 3×3 filter is just 9 numbers no matter how big the image is. Because the filter is reused everywhere, a pattern it has learned is detected wherever it appears in the frame — this is translation equivariance.
Two knobs set the output size. Stride is how far the kernel jumps each step (stride 2 halves the map). Padding adds a border of zeros so the kernel can sit on the edges; with the right padding the output keeps the input's size. The full formula for one spatial dimension:
out = (W − F + 2P) / S + 1
# W input size, F kernel size, P padding, S strideWatch out
- It is not a fully connected layer. A dense layer wires every input to every output (millions of weights); a conv layer reuses one tiny kernel — orders of magnitude fewer parameters. That's the whole point.
- Depth and channels. A kernel spans the full depth of its input — a
3×3filter on an RGB image is really3×3×3. A layer withKfilters outputsKchannels, which become the depth the next layer reads. - Mind stride and padding. Wrong values silently shrink your maps or drop edge pixels; plug numbers into the formula above before trusting a shape.
- Receptive field grows with depth. One layer sees a tiny patch; stack layers (or add stride/pooling) and a deep cell indirectly depends on a large region of the original image — that's how small kernels build up to whole objects.
Go deeper
Eine Faltung schiebt einen kleinen Filter über ein Bild und misst an jeder Stelle, wie gut der darunterliegende Ausschnitt zu diesem Filter passt. Stapelt man viele solcher Schichten, lernt ein Netz zu sehen — erst Kanten, dann Texturen, dann Objekte.
Wo es vorkommt
- Jeder Bildklassifikator, Objektdetektor und jedes Segmentierungsmodell — das C in CNN.
- Klassische Bildfilter: Weichzeichnen, Schärfen, Kantenerkennung sind alle Faltungen mit fest gewählten Kerneln.
- 1D-Faltung über Audio und Text; 3D über Video und volumetrische Scans.
Was es tut
Eine Faltungsschicht lernt einen Stapel kleiner Filter (Kernel) und wendet jeden davon überall auf den Input an. Jeder Filter erzeugt eine Feature Map — ein 2D-Raster, das aufleuchtet, wo immer das Muster dieses Filters auftaucht. Das Netz codiert nie von Hand „finde hier eine Kante"; es lernt aus den Daten, welche Filter sich lohnen.
Neun Zahlen, über das ganze Bild wiederverwendet — das ist der Trick: eine Conv-Schicht lernt Muster, keine Pixelpositionen.
Wie es funktioniert
Nimm einen Kernel — sagen wir 3×3. Setze ihn oben links aufs Bild, multipliziere jedes Kernel-Gewicht mit dem Pixel darunter und summiere alle neun Produkte. Diese eine Zahl ist eine Zelle der Feature Map. Schiebe den Kernel einen Schritt nach rechts und wiederhole, dann nach unten, bis das Bild abgedeckt ist. Die Operation an jeder Stelle ist nur ein Skalarprodukt:
out[i,j] = Σ input[i+u, j+v] · kernel[u,v]
u,vZwei Ideen machen das stark. Lokale Konnektivität: jede Ausgabezelle schaut nur auf einen kleinen Ausschnitt, nicht aufs ganze Bild. Parameter-Sharing: dieselben Kernel-Gewichte werden an jeder Position wiederverwendet — ein 3×3-Filter sind also nur 9 Zahlen, egal wie groß das Bild ist. Weil der Filter überall wiederverwendet wird, wird ein gelerntes Muster überall im Bild erkannt — das ist Translationsäquivarianz.
Zwei Stellschrauben legen die Ausgabegröße fest. Der Stride ist, wie weit der Kernel pro Schritt springt (Stride 2 halbiert die Map). Das Padding legt einen Rand aus Nullen an, damit der Kernel auf den Rändern sitzen kann; mit dem richtigen Padding behält die Ausgabe die Eingabegröße. Die volle Formel für eine Raumdimension:
out = (W − F + 2P) / S + 1
# W Eingabegröße, F Kernelgröße, P Padding, S StrideWorauf achten
- Es ist keine voll verbundene Schicht. Eine Dense-Schicht verdrahtet jeden Eingang mit jedem Ausgang (Millionen Gewichte); eine Conv-Schicht verwendet einen winzigen Kernel wieder — Größenordnungen weniger Parameter. Genau das ist der Sinn.
- Tiefe und Kanäle. Ein Kernel reicht über die volle Tiefe seines Inputs — ein
3×3-Filter auf einem RGB-Bild ist eigentlich3×3×3. Eine Schicht mitKFiltern gibtKKanäle aus, die zur Tiefe werden, die die nächste Schicht liest. - Achte auf Stride und Padding. Falsche Werte schrumpfen die Maps stillschweigend oder verlieren Randpixel; setz die Zahlen in die Formel oben ein, bevor du einer Form traust.
- Das rezeptive Feld wächst mit der Tiefe. Eine Schicht sieht einen winzigen Ausschnitt; staple Schichten (oder ergänze Stride/Pooling) und eine tiefe Zelle hängt indirekt von einer großen Region des Originalbilds ab — so bauen sich kleine Kernel zu ganzen Objekten auf.