Faltungsfilter — die Bausteine der CNNs
Entwirf 3×3-Kernel und sieh in Echtzeit, wie sie Bilder verändern
+ positiv (verstärkt) − negativ (zieht ab) • Anker (Ziel-Pixel)
Erweiterte Optionen
Was diese Demo zeigt
Ein Filter ist ein winziges Gitter aus neun Zahlen, das über ein Bild wandert und es Stück für Stück neu zeichnet — je nach Zahlen wird das Ergebnis weich, kantig oder geprägt.
- Was du siehst
- Ein Bild, über das ein leuchtender Rahmen läuft: das kleine 3×3-Fenster. Hinter ihm steht schon das gefilterte Ergebnis, vor ihm noch das Ausgangsbild. Dazu die Rechnung an dieser Stelle: Bildausschnitt mal Kernel — ein Gitter aus neun Zahlen — ergibt einen neuen Pixel.
- Was passiert
- Das Fenster wandert Pixel für Pixel über das Bild. Je nach den Zahlen im Kernel wird das Bild weich und verwaschen (Weichzeichner), oder die Flächen verschwinden und nur helle Konturen bleiben (Kantenfilter, Sobel), oder Kanten treten härter hervor (Schärfen), oder das Motiv wirkt in Graustufen wie in Stein geprägt (Relief).
- Was du tun kannst
- Tippe einen der acht Vorgabe-Filter an, wähle ein anderes Motiv oder trage eigene Zahlen ins Gitter ein. Mit „Abspielen“ und „Pause“ steuerst du den Lauf des Fensters; per Klick oder Ziehen im Bild setzt du es an eine beliebige Stelle.
- Worauf du achtest
- Es ist immer derselbe Rechenschritt — allein die neun Zahlen entscheiden, ob das Bild weichgezeichnet, in Kanten zerlegt oder geprägt wird. Genau solche kleinen Filter stapeln Bild-KIs (CNNs) übereinander, um sehen zu lernen.
Definition
Was ist eine Faltung?
Analogie
Stell dir eine Schablone vor, die du über jeden einzelnen Pixel des Bildes legst. Was unter der Schablone liegt, wird gewichtet aufaddiert — und das Ergebnis ist der neue Pixel. Schiebe die Schablone weiter, mach das gleiche an der nächsten Stelle, und so weiter.
Mit verschiedenen Schablonen (Kerneln) bekommst du verschiedene Effekte: eine Schablone, die links negative und rechts positive Werte hat, findet senkrechte Kanten. Eine Schablone mit lauter gleich positiven Werten zeichnet das Bild weich. Convolutional Neural Networks (CNNs) bauen auf genau diesem Prinzip auf.
Definition
Mathematisch ist das eine diskrete 2D-Faltung. Für jedes Output-Pixel an Position (x,y) summiert man die Produkte aus Kernel-Werten K(i,j) und benachbarten Bild-Pixeln I(x+i, y+j). Bei einem 3×3-Kernel laufen i und j von −1 bis +1.
out(x,y) = ΣᵢΣⱼ K(i,j) · I(x+i, y+j). Bei normalisierten Kerneln teilt man zusätzlich durch die Summe aller Kernel-Werte, damit die Bildhelligkeit erhalten bleibt. CNNs lernen die K(i,j)-Werte aus Daten — statt sie wie hier von Hand zu setzen.
Eine Faltung sind ein paar einfache Schritte, die für jeden Pixel des Bildes wiederholt werden:
- Kernel — die Schablone Der Kernel ist eine kleine Matrix (hier 3×3 — also 9 Zellen). Warum 3×3 und nicht 100×100? Weil ein winziger Ausschnitt um den Ziel-Pixel reicht, um lokale Eigenschaften wie Kanten zu erkennen — und 9 Werte sind schnell zu rechnen. In echten CNNs sind 3×3, 5×5 oder 7×7 Standard. Jeder Wert gewichtet einen Nachbar-Pixel: positive Werte verstärken, negative ziehen ab. Die Mitte ist der Ziel-Pixel (Anker).
- Sliding — Pixel für Pixel Schiebe den Kernel über jeden Pixel des Bildes. An jeder Position: multipliziere jeden Kernel-Wert mit dem darunterliegenden Pixel, summiere alle 9 Produkte — das ist der neue Pixel-Wert. Am Rand wird der äußerste Pixel repliziert, damit nichts abgeschnitten wird.
- Divisor & Offset — Helligkeit kontrollieren Nach dem Summieren wird das Ergebnis noch zwei Mal angepasst: durch den Divisor geteilt (damit ein Blur-Kernel mit 9 Einsen das Bild nicht 9-fach überstrahlt) und mit einem Offset verschoben (damit z.B. Prägen-Kernel um den Wert 128 in den sichtbaren Mittelgrau-Bereich rutschen, statt schwarz zu clippen). Die Stats-Anzeige rechts zeigt beide Werte live an.
- CNNs lernen die Kernel In einem CNN gibt der Mensch nicht mehr die Werte vor — das Netz lernt sie automatisch aus Trainingsdaten. Ein erstes Layer lernt einfache Kernel wie Kanten und Ecken. Spätere Layer kombinieren diese zu komplexeren Features (Texturen, Gesichtsmerkmale, Objekte).
Aus dieser simplen Operation entsteht die ganze Bildverarbeitungs-Kunst: Photoshop-Filter, Edge-Detection in alten Computer-Vision-Pipelines, und — am wichtigsten — das Fundament moderner KI-Bilderkennung. Dieselbe Mathematik, ob du eine Schablone für Sobel-X von Hand entwirfst oder ein neuronales Netz Millionen davon trainiert.
- Stelle alle 9 Kernel-Werte auf +1 (lauter Einsen). Das ist Box-Sum, NICHT Box-Blur. Beobachte: das Bild wird massiv überstrahlt. Schalte dann "Normalisieren" in Erweiterte Optionen ein — schwupps, Helligkeit wie vorher. Das ist der Sinn von Normalisieren.
- Sobel-X findet senkrechte Kanten, Sobel-Y findet waagerechte. Welcher Preset findet alle Kanten gleichzeitig — egal in welcher Richtung? (Tipp: Es ist nicht Sobel-X+Sobel-Y, sondern ein eigener Kernel.)
- Aktiviere "Filter stapeln". Füge erst Gauß-Blur hinzu, dann Sharpen. Vergleiche mit nur-Sharpen. Was beobachtest du? Schärfen holt nur einen Teil der Details zurück, die der Weichzeichner gelöscht hat.
- Lade ein eigenes Foto hoch (oder nimm das Portrait). Welcher Preset gefällt dir am besten — und WARUM? Achte auf Kanten, Texturen, Farbe.
- Verändere im Sobel-X-Kernel nur die linke Spalte von -1, -2, -1 zu -2, -4, -2. Das ist eine stärkere Variante. Was passiert? Was lernen wir über Kernel-Skalierung?
Was eine Faltung wirklich tut
Eine Faltung (englisch convolution) ist eine punktweise lineare Operation: für jeden Output-Pixel summierst du gewichtete Beiträge aus einer kleinen Nachbarschaft des Quellbildes. Die Gewichte stehen in einer kleinen Matrix — dem Kernel.
Mathematisch: out(x, y) = ΣᵢΣⱼ K(i, j) · I(x+i, y+j). Für einen 3×3-Kernel laufen i und j von −1 bis +1. Die so berechnete Summe wird optional durch einen Divisor geteilt (Helligkeitserhaltung) und durch einen Offset verschoben (z.B. +128 bei Emboss, damit negative Werte sichtbar bleiben).
Replicate-Padding am Rand
Am Bildrand fehlen Nachbar-Pixel — der Kernel ragt über das Bild hinaus. Naiver Ansatz: Nullen einsetzen (zero-padding) → das gibt schwarze Ränder. Besser: den äußersten Pixel des Bildes wiederholen (replicate). Das nutzt diese Demo: kein sichtbarer Rand-Artefakt.
Komplexität
- Zeit: O(W · H · k²) pro Layer — bei einem 3×3-Kernel auf einem 192×192-Bild sind das ~330.000 Multiplikationen-Additionen. Auf moderner CPU unter 10 ms.
- Speicher: O(W · H) für das Output-Buffer. Plus k² Werte für den Kernel.
- Parallelisierbar: jede Output-Position ist unabhängig — GPUs (und CNNs) verarbeiten sie alle gleichzeitig.
Klassische Anwendungen
- Edge-Detection: Sobel-X/Y, Laplace — Vorstufe für Objekterkennung
- Glättung: Box-Blur, Gauß-Blur — Rauschen reduzieren vor anderen Schritten
- Schärfung: Unsharp-Masking
- Embossing: reliefartige Effekte
- CNNs: dieselbe Operation, aber die Kernel-Werte werden gelernt — Grundlage moderner Computer-Vision
Probier es in der Demo aus! Stell den Kernel auf Identity — das Bild bleibt unverändert. Klick auf Sobel-X — plötzlich leuchten senkrechte Kanten weiß auf schwarz. Editiere einzelne Zellen — und sieh, wie kleine Änderungen das Ergebnis komplett umkrempeln.
1
# Conv-Filter — 2D-Faltung mit 3×3-Kernel
2
funktion faltung(bild, kernel, divisor, offset):
3
# Für jeden Pixel des Bildes
4
für y in 0..bild.höhe:
5
für x in 0..bild.breite:
6
7
# 1. Sammle 3×3-Nachbarn (Replicate am Rand)
8
nachbarn = hole_patch(bild, x, y, replicate=true)
9
10
# 2. Elementweise multiplizieren + summieren
11
summe = 0
12
für i in 0..9:
13
summe += nachbarn[i] * kernel[i]
14
15
# 3. Divisor anwenden, Offset addieren
16
out[x, y] = summe / divisor + offset
17
18
# 4. Auf gültigen Pixel-Bereich begrenzen
19
out[x, y] = clamp(out[x, y], 0, 255)
20
21
gib out zurück
🔲 Pixel-Iteration
Laufe über alle Pixel des Quellbildes (zwei verschachtelte Schleifen über y und x). Für jeden Pixel berechnest du den neuen Output-Wert separat. Das macht die Faltung trivial parallelisierbar — auf einer GPU laufen alle Pixel gleichzeitig.
# Für jeden Pixel des Bildes
für y in 0..bild.höhe:
für x in 0..bild.breite:
🔲 Iteration
Schleife über alle Pixel (x, y).
🔍 Patch holen
3×3-Nachbarschaft sammeln, Replicate-Padding.
✖️ Faltung
Patch · Kernel elementweise, Summe.
📐 Normalisieren
Durch Divisor teilen, Offset addieren.
🎚️ Clamp
Auf [0, 255] begrenzen.
✅ Output
Pixel ist fertig — nächste Position.
Prüfen
Teste dein Verständnis
Was tut ein Edge-Detection-Kernel wie Sobel-X grundsätzlich?
Wähle eine Antwort
1. Was tut ein Edge-Detection-Kernel wie Sobel-X grundsätzlich?
2. Warum werden Blur-Kernel (Box-Blur, Gauß-Blur) üblicherweise normalisiert, sodass die Kernel-Summe 1 ergibt?
3. Was ist der entscheidende Unterschied zwischen einem klassischen Bildfilter wie hier und einem Convolutional Neural Network?
4. Was passiert, wenn ein CNN mehrere Conv-Layer hintereinander stapelt (Stacking)?