Kapitel 6: Konvolutionsnetze I

Updates dieser Seite:

Überblick

In diesem Kapitel erweitern wir FNN um zwei neue Typen von Schichten, der Konvolutionsschicht (Konv-Schicht) und der Pooling-Schicht. Die Konvolutionsoperation kommt aus der Bildverarbeitung und gibt den Convolutional Neural Networks (CNNs) ihren Namen. Eine Konv-Schicht arbeitet fundamental anders als eine reguläre Schicht, die wir fortan Fully Connected (FC-Schicht) Layer nennen. Eine Konv-Schicht besteht aus einer Anzahl von Filtern, die eine Parallelität in der Verarbeitung bewirken. Wir sehen uns an, wie Konvolutionsfilter gelernt werden und wie CNNs in Keras mit dem Datensatz CIFAR-10 umgesetzt werden.

Konzepte

Konvolutionsoperation, Konvolutionsschicht, Stride, Padding, Pooling, Early Stopping

Datensätze

Name Daten Anz. Klassen Klassen Trainings-/Testdaten Ort
CIFAR-10 Farbbilder (32x32) 10 z.B. Flugzeug, Auto, Katze, Hund 50000/10000 Abschnitt 7, Übung
CIFAR-100 Farbbilder (32x32) 100 z.B. Bieber, Delphin, Apfel, Orange 50000/10000 Übung

Notation

In diesem Kapitel werden wir folgende Notation verwenden.

Symbol Bedeutung
$I$ Matrix mit Bilddaten
$F$ Filter-Matrix
$n_H$ Höhe eines Bildes (Pixel)
$n_W$ Breite eines Bildes (Pixel)
$f$ Größe des (quadratischen) Filters, also sowohl Höhe als auch Breite
$s$ Stride (Schrittweite) der Konvolution
$p$ Padding der Konvolution
$w_i$ Gewicht
$z_i$ Rohinput
$a_i$ Aktivierung
$g$ Aktivierungsfunktion
$b$ Bias
$n_c$ Anzahl der Kanäle, meistens die dritte Dimension des entsprechenden Tensors
$J$ Fehler-/Kostenfunktion (loss function)
$P$ Anzahl der Parameter einer Schicht oder eines NN

1 Convolutional Neural Networks (CNN)

Convolutional Neural Networks (CCNs) haben die aktuelle Popularitätswelle der Neuronalen Netze unter dem Begriff Deep Learning losgetreten. Besonders einflussreich war dabei das AlexNet als Gewinner der ImageNet ILSVRC Challenge im Jahr 2012 (Krizhevsky, Sutskever & Hinton 2012). Der Name AlexNet geht zurück auf den Erstautoren Alex Krizhevsky, der bei Geoffrey Hinton seine Doktorarbeit schrieb, für einige Zeit bei Google Brain arbeitete und Mitinitiator der Datensätze CIFAR-10 und CIFAR-100 war. Der Zweitautor Ilya Sutskever ist aktuell KI-Wissenschaftler bei OpenAI und Mitautor der Systeme AlphaGo und GPT-3.

Die Architektur von AlexNet lässt sich wiederum zurückführen auf LeNet-5 aus dem Jahr 1998 (LeCun et al. 1998), das sich mit der Erkennung von handgeschriebenen Postleitzahlen befasste und als das erste Convolutional Neural Network gilt. Es stammt von Yann LeCun, der - wie im letzten Kapitel erwähnt - 2018 den Turing Award für seine Arbeit auf dem Gebiet Deep Learning erhielt (zusammen mit Geoffrey Hinton und Yoshua Bengio). Aktuell ist LeCun Professor an der New York University und leitender KI-Wissenschaftler bei Meta (Facebook).

LeCun et al. (1989) stellt noch früher Konvolutionen als Bestandteil eines Netzes vor. Als weiterer Vorläufer der CNN gilt das Neocognitron von Fukushima (1980, 1983).

Herkunft

CNNs sind inspiriert von den Erkenntnissen über die visuelle Verarbeitung im Gehirn. David H. Hubel und Torsten Wiesel fanden bereits 1959 experimentell heraus, dass bei der visuellen Verarbeitung auf dem Weg von der Retina im Auge zur weiteren Verarbeitung im Hirn bestimmte "Features" erkannt werden, z.B. horizontale oder diagonale Linien. Die Verarbeitung findet dabei "lokal" statt, d.h. regional begrenzte, überlappende Sehfelder (receptive fields) auf der Retina werden vorverarbeitet. Dabei werden schicht-weise immer komplexere und nicht-lokale Features (z.B. Formen oder Bewegung) abgeleitet.

Hier die Erläuterung im lesenswerten Wikipedia-Artikel zu David H. Hubel (Abruf am 16.04.2022):

In one experiment, done in 1959, they inserted a microelectrode into the primary visual cortex of an anesthetized cat. They then projected patterns of light and dark on a screen in front of the cat. They found that some neurons fired rapidly when presented with lines at one angle, while others responded best to another angle. Some of these neurons responded to light patterns and dark patterns differently. Hubel and Wiesel called these neurons simple cells."Still other neurons, which they termed complex cells, detected edges regardless of where they were placed in the receptive field of the neuron and could preferentially detect motion in certain directions. These studies showed how the visual system constructs complex representations of visual information from simple stimulus features.

Hubel und Wiesel erhielten 1981 den Nobelpreis für ihre Forschungen "für ihre Entdeckungen über Informationsverarbeitung im Sehwahrnehmungssystem" (auch lesenswert: ein kurzer Artikel von Arvid Leyh zu den Anfängen der Forschung von Hubel und Wiesel). Die enorme Bedeutung dieser Forschung für die Neurowissenschaften kann nicht genug betont werden.

CNNs greifen die Idee auf, ein lokales Sehfeld von mehreren Neuronen auf ein einziges Neuron abzubilden und so abstraktere Features herauszubilden und die Anzahl der Parameter (Gewichte) zu reduzieren. Insbesondere werden aber gezielt Operationen aus der Bildverarbeitung (Convolution) eingesetzt, um diese Abstraktion erfolgreich umzusetzen.

Ein CNN enthält eine oder mehrere Convolutional Layers (Schichten), die diesem Netzwerktyp ihren Namen geben. Convoluational Layers können sehr kompliziert wirken, wenn man Darstellungen sieht. Deshalb gehen wir schrittweise vor und stellen zunächst die Operation der Konvolution vor.

2 Konvolution und Konvolutionsschicht

Konvolution ist eine mathematische Operation aus der Bildverarbeitung, bei der Bilddaten (Pixelmatrix) mit Filtern manipuliert werden, um im gefilterten Bild besser Objekte zu erkenen oder anderen höherwertige Probleme zu lösen.

Schöne (animierte) Visualisierungen und Erklärungen der Konvolutionsoperation findet man in dem Artikel Intuitively Understanding Convolutions for Deep Learning von Irhum Shafkat.

2.1 Konvolutionsoperator

Eine Konvolution wird auch Faltung genannt und ist eine Art Filter. Das Grundprinzip ist, dass eine kleine Matrix (z.B. 3x3) schrittweise über das Bild geschoben wird: erst pixelweise nach rechts, dann am Ende der Zeile zurück auf den Beginn der nächsten Zeile einen Pixel tiefer etc. Man nennt diese Technik auch ein Sliding Window.

Unten sehen wir ein konkretes Beispiel mit einem 3x3-Filter, diesen nennt man auch Kernel, angewandt auf die ersten zwei Felder eines 4x6-Bildes. Die Ergebnismatrix (rechts) wird zeilenweise aufgebaut.

Um die Konvolution auszudrücken, verwenden wir den Stern als Konvolutionsoperator, z.B. für Bild $I$ und Filter $F$:

$$ I * F $$

Die Berechnung in jedem Schritt ist sehr leicht. Wenn $F$ die 3x3-Filtermatrix ist und $I^1$ das erste 3x3-Feld des Bildes (in der Abbildung rot markiert), dann werden einfach alle Zellen von $F$ mit den entsprechenden Zellen von $I^1$ multipliziert und die Ergebnisse addiert:

$$ I^1 * F = \sum_{i=1}^3 \sum_{j=1}^3 I_{i, j}^1 F_{i, j} $$

Im abgebildeten Beispiel resultiert das im ersten Schritt in einer $0$. Im zweiten Schritt bekommt man eine $-30$.

Im weiteren sehen wir den Sprung nach Abarbeitung einer Zeile. Der Filter springt einen Pixel nach unten und geht erneut durch die Zeile. In der Abbildung unten zeigen wir nur den ersten und den vierten Schritt.

Das Ergebnis ist eine 2x4-Matrix.

Dieser Filter ist übrigens ein Detektor für vertikale Kanten. Sie sehen, dass im Bild zwei Flächen aufeinander stoßen (Graustufe 0 vs. Graustufe 10). Für die visuelle Verarbeitung sind solche Übergänge besonders interessant, weil sie auf den Umriss eines Objekts oder eines Lebewesens hindeuten. Der Filter ignoriert ausgefüllte Flächen (Wert 0) und hebt vertikale Kanten hervor (hier Wert -30).

Das Beispiel oben ist eine Vereinfachung eines bekannten Filters aus der Bildverarbeitung, dem Sobel-Filter. Dieser erkennt ebenfalls vertikale und horizontale Kanten:

$$F_v = \begin{pmatrix} -1&0&1 \\ -2&0&2 \\ -1&0&1 \end{pmatrix} $$$$F_h = \begin{pmatrix} -1&-2&-1 \\ 0&0&0 \\ 1&2&1 \end{pmatrix} $$

Nimmt man das folgende Ausgangsbild:

Dann resultiert die Anwendung von $F_v$ auf das Bild in folgender Ausgabe:

Die Anwendung von $F_h$ auf das Bild führt zu dieser Ausgabe:

Konvolution oder Kreuzkorrelation?

Die Konvolutionsoperation kommt aus der Signalverarbeitung. Die oben dargestellte Operation ist streng genommen aber nicht die traditionelle Konvolution, sondern die Operation der Kreuzkorrelation. In der "echten" Konvolution der Signalverarbeitung muss der Filter erst zweimal gespiegelt werden, bevor er angewandt wird.

Wir sehen das z.B. im Paket signal der Bibliothek SciPy. Dort wird die "echte" Konvolution durchgeführt und führt somit zu einem anderen Ergebnis als oben (man beachte die Vorzeichen).

Wir bereiten erstmal das Bild (image) und den Filter (filter) vor:

Jetzt wenden wir die eingebaute Konvolutionsoperation an. Der Parameter mode wird später beim Thema Padding erläutert.

Hier finden Sie eine Erklärung dazu: https://cs.stackexchange.com/questions/11591/2d-convolution-flipping-the-kernel

Im Bereich Deep Learning wird der Unterschied zwischen Konvolution und Kreuzkorrelation praktisch ignoriert: es wird also die (einfachere) Operation wie weiter oben gezeigt durchgeführt und dennoch wird von Konvolution gesprochen.

Notation

Wir führen ein wenig Notation ein. Für Höhe und Breite des obigen Bildes, eine Matrix, schreiben wir:

$$ \begin{align*} n_H &= 4\\ n_W &= 6 \end{align*} $$

Die Filtergröße ist immer quadratisch (Höhe = Breite) und wird beschrieben mit

$$f = 3$$

Dann beträgt die Größe der Ausgabematrix:

$$ \begin{align*} \bar{n}_H &= n_H - f + 1\\ \bar{n}_W &= n_W - f + 1 \end{align*} $$

In unserem Beispiel oben wäre das:

$$ \begin{align*} \bar{n}_H &= 4 - 3 + 1 = 2\\ \bar{n}_W &= 6 - 3 + 1 = 4 \end{align*} $$

Stride

Als Stride bezeichnet man die Schrittweite. Im obigen Beispiel hatten wir einen Stride von 1, denn wir haben den Filter immer um einen Pixel nach rechts bewegt bzw. um einen Pixel nach unten, wenn die Zeile abgearbeitet war.

Der Stride kann aber auch höher ausfallen, z.B. mit einem Wert von 2 oder 3. Der Stride gilt immer sowohl für die horizontale als auch für die vertikale Bewegung des Filters.

Hier ein Beispiel mit Stride 2 als Schema ohne konkrete Zahlen. Der rote Kasten zeigt den Filter. Rechts wird die Ausgabematrix dargestellt.

Wir beschreiben Stride mit dem Buchstaben $s$, also zum Beispiel

$$ s = 2 $$

Dann berechnen wir die Breite der Ausgabematrix $\bar{n}_W$ wie folgt (analog für $n_H$):

$$ \bar{n}_W = \left\lfloor \frac{n_W - f}{s} \right\rfloor + 1$$

Die Klammern mit der Kante unten bedeuten, dass der eingeklammerte Term abgerundet wird, in Englischen nennt man die Operation floor. Es gibt auch die Umkehroperation $\lceil x \rceil$ oder englisch ceiling.

In der Abbildung oben sehen wir ein Input-Bild, das 7 Pixel breit ist und 5 Pixel hoch, mit einem 3x3-Filter und einem Stride von 2. Wir setzen das in unsere Formeln ein:

$$ \begin{align*} \bar{n}_W &= \left\lfloor \frac{7 - 3}{2} \right\rfloor + 1 = 3\\ \bar{n}_H &= \left\lfloor \frac{5 - 3}{2} \right\rfloor + 1 = 2 \end{align*} $$

Die Rechnung bestätigt unsere Skizze.

Padding

Die Konvolutionsoperation hat zwei Effekte, denen wir eventuell entgegenwirken möchten:

  1. Unsere Ergebnismatrix ist kleiner als das ursprüngliche Bild. Bei einem 3x3-Filter verlieren wir in jede der vier Richtungen jeweils einen Pixel, so dass aus dem 4x6-Bild eine 2x3 Matrix wird.
  2. Pixel am Rand gehen weniger in die Ergebnismatrix ein. Das Pixel in der linken oberen Ecke wird genau 1x mit einbezogen, wohingegen ein Pixel im Inneren 9x einbezogen wird (bei einem 3x3-Filter und Stride 1).

Beim Padding werden "virtuelle" Randpixel zur Berechnung der Konvolution hinzugefügt. Dabei gibt man an, wieviele Pixel tief dieser Rand sein soll. Beim 3x3-Filter würde man ein Padding von 1 anlegen. Als Inhalt des Paddings nimmt man typischerweise Nullen, es wären aber auch andere Werte denkbar (z.B. Wert eines Nachbarpixels).

Bild und Ausgabematrix haben in diesem Beispiel die gleichen Dimensionen. Außerdem gehen die Randpixel nun häufiger in die Ergebnismatrix mit ein.

Wir bezeichnen das Padding mit dem Buchstaben $p$. Oben haben wir ein Beispiel mit $p=1$ gesehen. Wir passen unsere Formel für die Ausgabegröße $\bar{n}_W$ (analog $\bar{n}_H$) an:

$$ \bar{n}_W = \left\lfloor \frac{n_W +2p- f}{s} \right\rfloor + 1$$

Auch hier kontrollieren wir die Formel mit Hilfe des Beispiels aus der obigen Abbildung. Wir haben:

$$ \begin{align*} n_H &= 4\\ n_W &= 6\\ f &= 3\\ p &= 1\\ s &= 1\\ \end{align*} $$

Also:

$$ \begin{align*} \bar{n}_H &= \left\lfloor \frac{4 +2 \cdot 1- 3}{1} \right\rfloor + 1 = 4\\ \bar{n}_W &= \left\lfloor \frac{6 +2 \cdot 1- 3}{1} \right\rfloor + 1 = 6 \end{align*} $$

Wir sehen, dass die Ausgabematrix die gleiche Höhe und Breite hat wie die Eingabematrix.

Jetzt können wir berechnen, wie allgemein das Padding aussehen muss, damit die Ausgabematrix genauso groß ist wie die Eingabematrix (wir gehen von $s=1$ aus). Es gilt die Beziehung:

$$ \bar{n}_W =n_W +2p- f + 1 $$

Jetzt wollen wir, dass $\bar{n}_W = n_W$, also:

$$ \begin{align*} 0 &=2p- f + 1\\[2mm] p &= \frac{f-1}{2} \end{align*} $$

Filter sind in der Praxis immer ungerade, am häufigsten sieht man $f=3$ und $f=5$. Entsprechend muss man für $f=5$ auch $p=2$ wählen, wenn die Matrixgrößen erhalten bleiben sollen.

VALID vs. SAME

Beim Padding geht es im Grunde darum, dafür zu sorgen, dass die Ausgabematrix die gleiche Größe hat wie die Eingabematrix. Wenn das nicht erwünscht ist, setzt man einfach $p$ auf Null.

Daher haben sich zwei Begriffe für diese beiden Fälle eingebürgert, die z.B. auch in Keras so verwendet werden:

Oben hatte wir einen Konvolutionsoperator angesehen. Auch hier können wir als Modalität same einstellen.

2.2 Formale Definition der Konvolution

Wir möchten die Konvolutionsoperation mathematisch definieren. Der Einfachtheit halber ignorieren wir den Stride, d.h. $s$ ist immer gleich 1.

Wir haben ein Bild $I$ (Image), einen Filter $F$ und nennen den resultierenden Output $O$, also

$$ O := I * F $$

Für die Höhe und Breite von Bild $I$ haben wir die Parameter $n_H$ und $n_W$. Der Filter $F$ ist immer eine quadratische Matrix mit Höhe und Breite $f$. Die Höhe und Breite des Outputs kann wie oben gezeigt berechnet werden und wird mit $\bar{n}_H$ und $\bar{n}_W$ bezeichnet.

Die Abbildung zeigt alle relevanten Größen:

Um den Output $O$ zu berechnen, können wir folgende Formel für jede Komponente $o_{i,j}$ der Martrix $O$ wie folgt darstellen.

$$ o_{i,j} = (I * F)_{i,j}$$

Jetzt können wir die Berechnung wie folgt beschreiben:

$$ \tag{KV} o_{i,j} = \sum_{h=0}^{f-1} \sum_{k=0}^{f-1} I_{i+h, j+k} F_{h, k} $$

wobei $i = 1, \ldots, \bar{n}_H$ und $j = 1, \ldots, \bar{n}_W$.

Die folgende Abbildung zeigt die Parameter der Formel (KV) an den entsprechenden Matrizen.

Versuchen Sie, die Formel mit Hilfe der Abbildung nachzuvollziehen. Wählen Sie dazu ein Outputelement, z.B. $o_{1, 1}$ oder $o_{2, 4}$, und kontrollieren Sie, ob die korrekten Elemente von $I$ und $F$ in die Rechnung eingehen.

2.3 Konvolutionsschicht

In einer Konvolutionsschicht werden nun die oben gezeigten Filter gelernt und nicht "per Hand" von einem Ingenieur erdacht. In der Regel wird nur die Größe des Filters vorgegeben (z.B. 5x5) und die Werte durch Training optimiert.

Konvolutionsschichten haben Parameter, sind aber dennoch fundamental verschieden von herkömmlichen Schichten in FNNs. Interessant ist einerseits, dass ihre Eingabe stark begrenzt ist - ähnlich wie im Auge mit den receptive field. Das führt zu einer geringeren Anzahl an Parametern. Andererseits können Filter, da sie über das ganze Bild "geschoben" werden, auch an solchen Stellen wirken, wo sie gar nicht "angelernt" wurden. Wenn diese Schichten hintereinander geschaltet werden, können somit räumlich-hierarchische Muster gelernt werden, von lokalen Features wir Kanten zu globaleren, semantischeren Features wir Auge, Mund oder Gesicht.

Wie wir sehen werden, kommen Gewichte in einer Konvolutionsschicht mehrfach zum Einsatz, so dass lokale Muster im gesamten Bild "erkannt" werden können. Yann LeCun benutzt den Begriff weight sharing für dieses Phänomen (LeCun et al. 1989).

Filter lernen

In der nachfolgenden Abbildung sehen wir zunächst zwei typische Filter mit festen Werten und dann die entsprechende Matrix mit variablen Werten, die wir mit $w_i$ bezeichnen. Diese "Gewichte" sollen jetzt gelernt werden.

Die Anwendung des Filters resultiert in einer Ausgabematrix. Zu dieser Ausgabematrix addieren wir noch einen Bias $b$, ein Skalar, auf jedes Element der Matrix. Schließlich wenden wir eine Aktivierungsfunktion $g$ auf jedes Element an, zum Beispiel die Sigmoid- oder die ReLU-Funktion. Die folgende Abbildung zeigt das noch einmal schematisch:

Insofern ist die Konvolutionsschicht nicht unähnlich einer "normalen" Schicht. Es gibt einen linearen Teil - Konvolutionsoperation und Bias - und einen nicht-linearen Teil über die Aktivierungsfunktion.

Konvolutionsschicht vs. Fully-Connected-Schicht (FC-Schicht)

Die in der obigen Abbildung dargestellte Schicht hat als Eingabe 4x6=24 Neuronen und als Ausgabe 2x4=8 Neuronen. An Parametern zählen wir 9 Gewichte im Filter plus einen Bias, also insgesamt 10 Parameter.

Wenn man die Zahl der Parameter mit einer "normalen" Schicht vergleicht, so kann man sich die Eingabe- und Ausgabeneuronen wie folgt linearisiert vorstellen:

Wir zählen hier also 24x8=192 Gewichte an den Verbindungen plus 8 Bias-Neuronen, also insgesamt 200 Parameter.

Wir nennen eine solche Schicht ab sofort Fully Connected Layer oder FC-Schicht. Sie sehen, dass eine Konvolutionsschicht deutlich weniger Neuronen hat als eine FC-Schicht (hier: Faktor 20).

Linearisierte Sicht auf die Konvolutionsschicht

Um die Unterschiede und Gemeinsamkeiten zwischen Konvolutionsschicht und FC-Schicht besser zu verstehen, betrachten wir die beteiligten Matrizen in einer linearisierten Form (die Amerikaner sprechen hier von "unrolling", also auseinander wickeln).

Wir betrachten zunächst nur die Konvolutionsoperation mit einer 3x3-Inputmatrix, einem 2x2-Filter, ohne Padding und mit Stride 1. Die Werte der Inputmatrix sind hier linear durchnummeriert, wir nennen sie $a_1, \ldots, a_9$. Wir müssen uns diese Werte als die Aktiverung der Vorgängerschicht vorstellen. Der Filter hat die Werte $w_1, w_2, w_3, w_4$. Die Ausgabe ist analog zum Rohinput im FNN, also nennen wir die vier Zellen $z_1, \ldots, z_4$.

Jetzt stellen wir die linearisierte Eingabematrix analog zu einer Schicht in einem FNN dar. Ebenso die linearisierte Ausgabematrix. Die erste Operation der Konvolution lässt sich dann wie folgt darstellen (die Gewichte $w_1, w_2, w_3, w_4$ sind farbkodiert). Ein Pfeil zeigt, dass ein Gewicht in die Berechnung des Werts $z_1$ mit eingeht, und somit ist die Darstellung "kompatibel" zur Darstellung einer FC-Schicht.

Nach vier Schritten haben wir alle z-Werte berechnet und wir sehen hier, welche Gewichte in welche Berechnung mit eingehen.

Sehen wir uns im Vergleich eine FC-Version an. Nur für den ersten Output $z_1$ haben wir bereits 9 Parameter:

Für den zweiten Output $z_2$ dann weitere 9:

Insgesamt haben wir 4x9, also 36 Verbindungen. Jede Verbindung zeigt auf genau ein Output-Neuron.

Wenn wir Konv-Schicht und FC-Schicht vergleichen, fallen folgende Eigenschaften einer Konv-Schicht auf:

Wir möchten noch den Funktionsumfang der Konvolutionsschicht vervollständigen. Es fehlt noch der Bias-Wert. Es gibt genau einen pro Filter, d.h. auch hier wird ein Gewicht mehrfach eingesetzt. Auch hier wählen wir eine Darstellung, die analog zur FC-Schicht ist:

Zum Schluss zeigen wir die Anwendung der Aktivierungsfunktion $g$, so dass wir unsere finalen Ausgabewerte $a_1, \ldots, a_4$ bekommen:

Auch wenn wir im nächsten Abschnitt über mehrdimensionale Konvolution sprechen, ändert dies nichts an dieser Darstellung. Auch die Eingabe eines 16x16x128-Tensors kann linearisiert werden und sieht dann genauso aus wie oben dargestellt (gleiches gilt für den Filter und die Ausgabe).

3 Konv-Schicht: Kanäle und Filterzahl

Nachdem wir wissen, dass eine Konv-Schicht aus Filter, Bias und Aktivierungsfunktion besteht, wenden wir uns wieder der Konvolutionsoperation zu und erweitern diese auf mehrere Kanäle und auf mehrere parallele Filter.

Beachten Sie, dass die Verabeitung dennoch in der Hauptsache eine 2D-Verarbeitung bleibt, deshalb nennt man diese Schicht in Keras auch Conv2D.

3.1 Mehrere Kanäle

Ein 4x6-Bild mit 3 Farbkanälen (RGB) kann man sich als 3-dimensionalen 4x6x3-Tensor vorstellen. Ein Bild kann natürlich auch andere oder zusätzliche Kanäle haben, z.B. für Infrarotdaten (Satellitenbilder) oder für Tiefeninformation. Zudem kann eine Matrix aufgrund einer vorigen Verarbeitung viele Kanäle haben.

Wir benennen die Anzahl der Kanäle mit $n_c$ und bleiben aber bei den 3 Farbkanälen als Beispiel, also $n_c = 3$.

Will man auf diesen Eingabetensor eine Konvolution anwenden, kann man sich das so vorstellen, dass man dem Filter auch 3 Kanäle spendiert. Die Operation ist wie im 2D-Fall einfach eine komponentweise Multiplikation mit einer anschließenden Summenbildung. Man beachte, dass das Resultat eine 2-dimensionale 2x4-Matrix ist, d.h. ${n'}_c = 1$, wenn wir mit ${n'}_c$ die Kanäle der Ausgabematrix bezeichnen.

Der Filter kann entweder jeweils der gleiche Filter sein (hier: Detektor für vertikale Kanten) oder auch unterschiedliche Filter enthalten für den jeweiligen Kanal (R, G oder B). Ein Kanalfilter kann auch nur aus Nullen bestehen und somit den Farbkanal ignorieren.

Da wir bereits wissen, dass unser Netz die Werte des Filter lernt, können wir uns vorstellen, dass ein Netz in unterschiedlichen Farbkanälen unterschiedliche Features detektieren will.

Wichtig ist, dass der Filter immer exakt so viele Kanäle haben muss wie die Eingabe.

Beachte: Hier wird klar, warum wir oben gesagt haben, dass die Operation auf 2D-Daten verläuft. Wir haben hier keine räumliche dritte Dimension, es handelt sich lediglich um Kanäle eines 2D-Bildes.

3.2 Mehrere Filter

Oben haben wir gesehen, dass man eine Eingabe mit mehreren Kanälen durch einen 3-dimensionalen Filter verarbeiten kann. Dabei werden die Kanälen quasi "eingedampft".

Jetzt kann es sein, dass wir in einem Schritt mehrere unterschiedliche Filter parallel auf ein Bild anwenden möchten, z.B. zwei Filter: einen für horizontale Kanten und einen für vertikale Kanten.

Wir möchten die Resultate der zwei Filter auch parallel weiterführen. Da bei jedem Filter eine 2-dimensionale Ausgabe erfolgt, haben wir als Endresultat eine 3-dimensionale Matrix, weil wir die beiden Ausgaben einfach "übereinander" legen:

Das obige Beispiel sehen wir uns nochmal in Zahlen an:

Schauen wir uns das als Schema für eine Konvolutionsschicht an (Abb. unten). Hier geben wir die Anzahl der Kanäle der Eingabe an. Die Tatsache, dass die zwei Filter auch 3 Kanäle haben, brauchen wir nicht zu notieren. Ansonsten sehen wir, dass die Anzahl der Filter sich in der Anzahl der Kanäle der Ausgabe wiederfindet.

Beachte: Obwohl wir hier teilweise sehr viele Filter parallel anwenden, bleibt es dabei, dass wir ein 2D-Bild verarbeiten.

Siehe auch: Im Skript der Univ. Stanford zu CNNs finden Sie eine schöne animierte Grafik zur Konvolutionsoperation mit mehreren Kanälen und mehreren Filtern (auf der Seite nach "Convolution Demo" suchen).

3.3 Pooling

Pooling ist im Vergleich zu Convolution eine einfache Operation und wird wie Convolution als eine Verarbeitungsschicht implementiert. Bei einer Pooling-Schicht geht es lediglich darum, die Größe der Eingabe zu reduzieren, um die Anzahl der Parameter zu reduzieren, um die Generalisierung zu erhöhen und größere "Toleranz" zu erwirken. Pooling kann man auch als eine Form von Subsampling bezeichnen.

Auch beim Pooling wird ein Filter als Sliding Window über die Eingabe geschoben. Auf die von den Zellen der Filtermatrix überdeckten Zahlen wird eine einfache Operation ausgeführt, meistens das Maximum, man spricht dann auch von Max Pooling. Alternativ kann auch der Durchschnitt berechnet werden, dann spricht man von Average Pooling oder Mean Pooling.

Auch hier gibt es eine Filtergröße $f$ und einen Stride $s$. Hier zwei Beispiele von Max Pooling mit einem 2x2-Filter ($f=2$) und einer Eingabe mit Dimensionen 4x4. Bei einem Stride von $s=1$ wird die Eingabe auf 3x3 reduziert, bei Stride $s=2$ auf nur 2x2.

Sollte die Eingabe 3 Kanäle haben, wird einfach auf jedem Kanal Pooling angewandt, d.h. die Ausgabe hat wieder 3 Kanäle. Allgemein bleibt also $n_c$ identisch.

Hier eine schematische Darstellung einer Pooling-Schicht:

3.4 Formale Definition der Konvolutionsschicht

Wir haben die Konvolution in der Formel (KV) definiert, aber noch ohne Kanäle und Anzahl der Filter. Schauen wir uns (KV) nochmal an:

$$ \tag{KV} o_{i,j} = \sum_{h=0}^{f-1} \sum_{k=0}^{f-1} I_{i+h, j+k} F_{h, k} $$

Wenn wir uns an FNN erinnern, dann haben wir dort unterschieden zwischen Roheingabe $z$ und Aktivierung $a$. In (KV) haben wir folgende Entsprechungen:

Daher können wir die Variablen wie folgt ersetzen:

$$ z^{(l)}_{i,j} = \sum_{h=0}^{f-1} \sum_{k=0}^{f-1} a^{(l-1)}_{i+h, j+k} \, w^{(l-1)}_{h, k} $$

Wir bezeichnen die Anzahl der Kanäle mit $n_C$ und die Anzahl der Filter $n_F$. Die Filter unterscheiden wir mit einem hochgestellten Index: $W^{<1>}, \ldots, W^{<n_F>}$.

Unsere Formel bekommt einen Parameter $m$ für den Filter $W^{<m>}$. Daraus resultiert der Kanal des Outputs.

$$ z^{(l)}_{i,j,m} = (A^{(l-1)} * W^{(l-1), <m>})_{i,j,m}$$

Jetzt nehmen wir noch die Kanäle hinzu (Summe über $c$) und wir addieren ein Bias-Gewicht $b$ pro Filter, um den Rohinput für Schicht $l$ zu definieren:

$$ \tag{KS 1} z^{(l)}_{i,j,m} = \sum_{c=1}^{n_C} \sum_{h=0}^{f-1} \sum_{k=0}^{f-1} a^{(l-1)}_{i+h, j+k} \, w^{(l-1), <m>}_{h, k} + b^{(l-1), <m>} $$

mit den folgenden Parameterbereichen:

$$ \begin{align*} i &= 1, \ldots, \bar{n}_H \\ j &= 1, \ldots, \bar{n}_W \\ m &= 1, \ldots, n_F \\ \end{align*} $$

Um die Aktivierung in Schicht $l$ zu berechnen, müssen wir noch die Aktivierungsfunktion $g$ anwenden:

$$ \tag{KS 2} a^{(l)}_{i,j,m} = g(z^{(l)}_{i,j,m})$$

Wie schon bei den FNN entspricht die Eingabe $x$ der Aktivierung der ersten Schicht $a^{(1)}$ und die Aktivierung der letzten Schicht $a^{(L)}$ entspricht der Ausgabe $\hat{y}$ des Netzes.

4 Beispiele für CNNs

4.1 CNN mit zwei Konv-Schichten

Hier ein einfaches CNN mit zwei Konvolutionsschichten:

Die Eingabe besteht aus Bildern der Größe 32x32 mit 3 Farbkanälen (RGB).

Die erste Schicht Conv1 hat 10 3x3-Filter, genauer gesagt sind es 3x3x3-Filter. Der Stride ist 1 und es gibt kein Padding. Also wird die Bildgröße reduziert. Die Ausgabe hat die Größe 30x30x10. Die "10" kommt von der Anzahl der Filter. Die Bildgröße können Sie mit folgender Formel ausrechnen:

$$ \bar{n}_W = \left\lfloor \frac{n_W +2p- f}{s} \right\rfloor + 1$$

Die zweite Schicht Conv2 hat 20 5x5-Filter, genauer gesagt sind es 5x5x10-Filter. Der Stride ist 2 und es gibt kein Padding. Hier wird wieder die Größe reduziert auf 13x13 (siehe Formel oben). Durch die 20 Filter bekommen wir 13x13x20.

Die dritte Schicht Flatten linearisiert ledigleich unseren 13x13x20-Tensor zu einem Vektor der Länge 3380.

Die vierte Schicht FC 1 ist die Ausgabeschicht mit 10 Neuronen (für zehn mögliche Kategorien). Diese Schicht ist natürlich komplett verdrahtet mit der vorigen Schicht, also ist die Schicht vom Typ Fully Connected (oder in Keras: Dense).

Parameter

Wir können ausrechnen, wie viele Parameter das Netz hat. Wir rechnen die Anzahl der Filter mal der Filtergröße und addieren die Länge des Biasvektors (= Anzahl der Filter).

$$ \begin{align*} P(\mbox{Conv1}) &= 10 \cdot 3 \cdot 3 \cdot 3 + 10 = 270 + 10 = 280 \\ P(\mbox{Conv2}) &= 20 \cdot 5 \cdot 5 \cdot 10 + 20 = 5000 + 20 = 5020 \\ P(\mbox{FC1}) &= 3380 \cdot 10 + 10 = 33800 + 10 = 33810\\ P &= 280 + 5020 + 33810 = 39110 \end{align*} $$

Das Netz hat also insgesamt 39110 Parameter.

4.2 CNN mit Konv-, Pooling- und FC-Schichten

Wir schauen uns jetzt ein komplexeres CNN an, das ähnlich dem berühmten LeNet-5 ist:

Im Vergleich zum obigen Netz haben wir hier Pooling-Schichten mit jeweils Filtergröße 2x2 und Stride 2. Diese Operation halbiert jeweils die Anzahl der Zeilen und Spalten.

Parameter

Auch hier können wir rechnen. Die Pooling-Schichten und die Flatten-Schicht haben natürlich keine Parameter:

$$ \begin{align*} P(\mbox{Conv1}) &= 6 \cdot 5 \cdot 5 \cdot 3 + 6 = 450 + 6 = 456 \\ P(\mbox{Conv2}) &= 16 \cdot 5 \cdot 5 \cdot 6 + 16 = 2400 + 16 = 2416 \\ P(\mbox{FC1}) &= 400 \cdot 120 + 120 = 48000 + 120 = 48120\\ P(\mbox{FC2}) &= 120 \cdot 84 + 84 = 10080 + 84 = 10164\\ P(\mbox{FC3}) &= 84 \cdot 10 + 10 = 840 + 10 = 850\\ P &= 456 + 2416 + 48120 + 10164 + 850 = 62006 \end{align*} $$

Unser Netz hat also 62006 Parameter und damit nur doppelt so viele wie das deutlich einfachere Netz oben. Das liegt natürlich hauptsächlich an den Pooling-Schichten, die unsere Tensoren deutlich reduzieren, bevor wir zu den "teuren" FC-Schichten kommen.

5 Backpropagation in einer Konv-Schicht

Wir haben gesehen, dass eine Konvolutionsschicht im Grunde eigene Filter "lernt", indem es die Werte der Filter als Gewichte betrachtet, die angepasst werden. Hier versuchen wir, eine Intuition zu bekommen, wie diese Gewichte in den Filtern (und des Bias-Werts) gelernt werden.

Erinnern wir uns zunächst, wie in einem FNN mit FC-Schicht die Gewichte angepasst werden. Die Formel für das Delta eines Gewichts ist wie folgt:

$$ \Delta w_{i,j}^{(l)} = - \frac{\partial J}{\partial w_{i,j}^{(l)}} = - a_j^{(l)} \: \delta_i^{(l+1)} \tag{*}$$

Das Gewicht zeigt von einem Quellneuron $j$ mit Aktivierung $a_j$ auf ein Zielneuron $i$ in der nächsten Schicht. Das Delta ist der Fehler $\delta_i$ dieses Zielneurons $i$. Das $a_j$ ist die Aktivierung des Quellneurons $j$.

Vergleichen wir das mit der Situation in einer Konvolutionsschicht. Wir haben bereits gesehen, dass ein einzelnes Gewicht mehrere Quell- und Zielneuronen verbindet, insofern kann die obige Formel nicht ohne weiteres gelten.

In einer Konvolutionsschicht liegen die Quellneuronen als Matrix vor. Das Ergebnis der Konvolution können wir als Ausgabe betrachten - dies ist wiederum eine Matrix. Wir sehen uns dazu folgendes Beispiel mit einem 4x4-Filter an (kein Padding, Stride 1).

Wenn wir die Konvolutionsoperation verfolgen, sehen wir, dass jedes Gewicht mehrfach zur Anwendung kommt. Wir betrachten exemplarisch Gewicht $w_1$. Dieses Gewicht kommt sechs Mal zum Einsatz, bei den Aktivierungen $a_1, a_2, a_3, a_5, a_6, a_7$. Hier ist das schematisch dargestellt:

Wenn wir das Delta von $w_1$ berechnen wollen, benötigen wir die Ableitung des Fehlers hinsichtlich $w_1$:

$$ \Delta w_1 = - \frac{\partial J}{\partial w_1}$$

Wir nutzen die Kettenregel an, um den Rohinput $z$ einzuführen, der ja $w_1$ als Parameter enthält. Daher dürfen wir schreiben:

$$ - \frac{\partial J}{\partial w_1} = - \frac{\partial J}{\partial z} \frac{\partial z}{\partial w_1}$$

Zu beachten ist, dass $z$ ein Vektor der Länge 6 ist.

Wir haben in unserer Herleitung von Backpropagation den Fehler $\delta$ als $\frac{\partial J}{\partial z}$ definiert. Das $\delta$ ist ein Vektor der gleichen Länge wie $z$, weil es ja die jeweiligen Fehler von $z$ darstellt. Also können wir den Vektor $\delta$ für $z$ einsetzen, gleich mit Komponenten. Die Ableitungen $\frac{\partial}{\partial w_1} z_i$ ergeben sich aus den Summen für den Rohinput (siehe Abb. oben), wo jeweils der Faktor von $w_1$ übrig bleibt:

$$ \begin{align*} - \frac{\partial J}{\partial w_1} &= - \frac{\partial J}{\partial z} \frac{\partial z}{\partial w_1} = - \left( \begin{array}{c} \frac{\partial J}{\partial z_1}\\ \frac{\partial J}{\partial z_2} \\ \frac{\partial J}{\partial z_3} \\ \frac{\partial J}{\partial z_4} \\ \frac{\partial J}{\partial z_5} \\ \frac{\partial J}{\partial z_6} \end{array}\right) \left( \begin{array}{c} \frac{\partial}{\partial w_1} z_1\\ \frac{\partial}{\partial w_1} z_2\\ \frac{\partial}{\partial w_1} z_3\\ \frac{\partial}{\partial w_1} z_4\\ \frac{\partial}{\partial w_1} z_5 \\ \frac{\partial}{\partial w_1} z_6\end{array}\right) = - \left( \begin{array}{c} \delta_1 \\ \delta_2 \\ \delta_3 \\ \delta_4 \\ \delta_5 \\ \delta_6 \end{array}\right) \left( \begin{array}{c} a_1 \\ a_2 \\ a_3 \\ a_5 \\ a_6 \\ a_7 \\ \end{array}\right) \\[4mm] &= - \left( a_1 \delta_1 + a_2 \delta_2 + a_3 \delta_3 + a_5 \delta_4 + a_6 \delta_5 + a_7 \delta_6 \right) \end{align*} $$

Wir sehen, dass die Formel praktisch identisch zu der herkömmlichen Backpropagation-Formel (*) ist, nur dass alle "Verbindungen" aufsummiert werden.

Interessant ist, dass diese Summe, also die Berechnung des $\Delta w_i$, das Ergebnis einer Konvolution ist, die wie folgt formuliert werden kann:

Die obige Konvolution kommt also beim Backpropagation-Algorithmus zum Einsatz, um aus den Fehlerwerten $\delta$ die entsprechenden Gewichtsänderungen zu berechnen.

Damit haben Sie hoffentlich eine Intuition dafür, wie Backpropagation in einer Konvolutionsschicht funktioniert. Wir werden den Algorithmus hier nicht weiter ausführen. Details können Sie aber in dem exzellenten Artikel Backpropagation In Convolutional Neural Networks von Jefkine Kafunah nachlesen.

6 CNNs in Keras

In Keras gibt es zwei Typen von Schichten für CNNs - Conv2D und MaxPooling2D - und bei der Gelegenheit stellen wir auch die Schicht Flatten vor.

Anschließend stellen wir noch die Methode des Early Stopping vor.

6.1 Conv2D

Die Con2D-Schicht ist eine Konvolutionsschicht für ein 2D-Inputbild mit mehreren Kanälen. Der erste Parameter filters gibt die Anzahl der Filter an (z.B. 10), der zweite Parameter kernal_size gibt die Größe $f$ des Filters an, entweder als Skalar - z.B. 5 - oder als Tupel - z.B. (5, 5). Parameter strides gibt den Stride $s$ als Skalar oder als Tupel (in Höhe und Breite) an und padding gibt an, ob man Padding benutzt ("same") oder nicht ("valid").

Es ist optional, eine Aktivierungsfunktion zu verwenden, ebenso ist es optional einen Bias-Term zu verwenden. Beides kann man in den Parametern spezifizieren.

Conv2D(
    filters,
    kernel_size,
    strides=1,
    padding='valid',
    activation='relu',
    use_bias=True
)


Ist diese Schicht die erste Schicht, so kommt der Parameter input_shape hinzu, z.B. (28, 28, 3) für eine RGB-Bild. Die Tatsache, dass die Kanäle an dritter Stelle spezifiziert werden, ergibt sich aus dem standardmäßigen data_format von "channels_last". Man kann dies umstellen auf "channels_first".

Ein Beispiel für ein ConvLayer mit 10 Filtern mit $f=5$, $s=1$ und $p=2$ (ergibt sich aus padding='same'):

model = models.Sequential()
model.add(Conv2D(10, 5, strides=1, padding='same', activation='relu'))

Das gleiche hätte man auch mit Tupeln schreiben können:

model.add(Conv2D(10, (5,5), strides=(1,1), padding='same', activation='relu'))

Siehe: https://keras.io/api/layers/convolution_layers/convolution2d

6.2 MaxPooling2D

Dies ist eine Pooling-Schicht, die das Maximum nimmt. Man kann die Filtergröße $f$ mit pool_size bestimmen und den Stride $s$ mit strides. Beides geht als Skalar oder als Tupel. Hier als Tupel:

MaxPooling2D(
    pool_size=(2, 2), 
    strides=(1, 1)
)

Hier mit Skalaren:

MaxPooling2D(
    pool_size=2, 
    strides=1
)

Siehe: https://keras.io/api/layers/pooling_layers/max_pooling2d

6.3 Flatten

Diese Schicht linearisiert einen multi-dimensionalen Eingabetensor zu einem einfachen Vektor. Zum Beispiel wird eine 10x10x3x20 Eingabe zu einem Vektor der Länge 6000. Entsprechend gibt es keine Parameter, es handelt sich um eine reine Umformungs-Schicht (Reshaping Layer).

Siehe: https://keras.io/api/layers/reshaping_layers/flatten

6.4 Overfitting und Early Stopping

Overfitting bedeutet, dass ein Modell sich zu stark auf den Trainingsdatensatz spezialisiert und daher nicht gut generalisiert. Dies kann man beim Training beobachten, wenn man einen Validierungs-Datensatz verwendet, z.B. mit Hilfe des Parameters validation_split bei der Methode fit.

Häufig sieht man, dass die Performance auf den Validierungsdaten ab einem bestimmten Punkt sinkt. Die folgende Abbildung zeigt die Accuracy auf Trainings- und Validierungsdaten über die Trainingsepochen hinweg.

Wir möchten also das Netzwerk in dem Zustand als Modell wählen, in dem es war, als die Accuracy auf den Validierungsdaten am höchsten war, denn in diesem Zustand generalisiert es wahrscheinlich am besten. Wenn das so ist, muss man das Netz natürlich auch nicht so lange trainieren, sondern kann früher mit dem Training aufhören. Das nennt man auch Early Stopping und ist quasi die einfachste Methode gegen Overfitting.

In Keras funktioniert Early Stopping so, dass man der Trainingsmethode eine Callback-Funktion mitgibt, die das Training quasi überwacht und abbricht, sobald die Performance auf den Validierungsdaten sinkt.

Schritt 1 ist also, die Funktion (ein Objekt) zu defineren:

monitor = EarlyStopping(monitor='val_acc',
                        mode='max',
                        restore_best_weights=True,
                        patience=5)

Parameter monitor gibt an, welchen Wert man beobachten möchte, und mit mode sagt man, ob dieser maximal oder minimal (z.B. für loss) sein soll. Mit patience spezifiziert man die Zahl der Epochen, die man "weitermacht", obwohl der Wert in die falsche Richtung geht. Schließlich kann man mit restore_best_weights angeben, dass die Gewichte des Zeitpunkts genommen werden, wo der beobachtete Wert optimal war.

Schritt 2 ist dann, die Funktion der Methode fit mitzugeben, die ja das Training ausführt. Da man eine Reihe von Callback-Funktionen übergeben kann, spezifiziert man eine Liste:

history = model.fit(x_train, y_train,
                    epochs=20,
                    validation_split=0.1,
                    callbacks=[monitor])

Wie Sie sehen, gibt man dennoch die Zahl der Epochen an. Das ist in diesem Kontext die maximale Zahl der Epochen, die trainiert wird. Beachten Sie auch validation_split, wo wir 10% der Trainingsdaten als Validierungsdaten nehmen und nicht die Testdaten. Das ist bei Early Stopping besonders wichtig, da wir ja nicht auf den Testdaten optimieren dürfen und später die Performance auf den selben Daten messen können.

Siehe:

7 Bespielhaftes CNN in Keras

Wir probieren unser Wissen in Keras aus. Zunächste definieren wir die maximale Anzahl der Epochen:

7.1 Daten (CIFAR-10)

Als Daten nehmen wir CIFAR-10, die wir bereits aus der Übung kennen. Hier haben wir 32x32-Bilder mit 3 Farbkanälen (RGB).

Wir nutzen One-Hot-Encoding:

Wir normalisieren die Daten:

7.2 Modell

Wir erzeugen zwei Konvolutionsschichten mit jeweils nachgelagerten Pooling-Schichten:

  1. Conv-Schicht mit 10 Filtern, $f=5, p=2$
  2. Pooling-Schicht mit $f=2$
  3. Conv-Schicht mit 20 Filtern, $f=3, p=1$
  4. Pooling-Schicht mit $f=2$ und $s=2$

Wo nicht angegeben, ist $s=1$.

7.3 Training

Für das Training definieren wir eine Funktion für das Early Stopping:

Jetzt trainieren wir das Modell:

Das Netz hat das Training nach Epoche 14 abgebrochen.

7.4 Evaluation

Unser Modell erzielt 67% Accuracy auf den Testdaten von CIFAR-10. Wenn Sie die Übungsaufgabe gemacht haben, haben Sie einen Wert von ca. 45% mit einem FNN (mit einer versteckten Schicht mit 1000 Neuronen) erzielt.

8 Literatur

Fukushima, Kunihiko (1980) Neocognitron: A self-organizing neural network model for a mechanism of pattern recognition unaffected by shift in position. In: Biological Cybernetics 36 (4): 193–202.

Fukushima, Kunihiko; Miyake, Sei; Ito, Takayuki (1983) Neocognitron: a neural network model for a mechanism of visual pattern recognition. In: IEEE Transactions on Systems, Man, and Cybernetics SMC-13 (3): 826–834.

Krizhevsky, Alex; Sutskever, Ilya; Hinton, Geoffrey E. (2012) ImageNet classification with deep convolutional neural networks. In: Communications of the ACM 60 (6): 84–90.

LeCun, Y; Boser, B; Denker, J. S.; Henderson, D.; Howard, R. E.; Hubbard, W.; Jackel, L. D. (1989) Backpropagation Applied to Handwritten Zip Code Recognition. In: Neural Computation 1 (4).

LeCun, Yann; Bottou, Leon; Bengio, Yoshua; Haffner, Patrick (1998) Gradient-based learning applied to document recognition. In: Proceedings of the IEEE 86 (11): 2278–2324.