Computer vision

Bild Klassifikation

Katze? (0/1)

Object detection

https://commons.wikimedia.org/wiki/File:Detected-with-YOLO--Schreibtisch-mit-Objekten.jpg

Style transfer

Wie können wir große Bilder verarbeiten?

• 64x64x3 bedeutet 12,288 Eingangsfeatures
• 1000x1000x3 bedeutet 3,000,000 Eingangsfeatures
  • Mit 1000 Neuronen im ersten Layer, kommt $W^{[1]}$ auf 3 Milliarden Einträge

Edge detection

https://commons.wikimedia.org/wiki/File:%C3%84%C3%A4retuvastuse_n%C3%A4ide.png

Convolutionoperation

In TensorFlow: tf.nn.conf2d und tf.keras.layers.Conv2D

Vertikale edge detection?

Gespiegeltes Bild

Horizontale edge detection

Alternative edge detection filter

Idee: Wir lernen den Filter, als ihn von Hand zu bauen

Die Convolution $X * W$ kann auf Inputs beliebiger Größe angewendet werden. Die Anzahl Parameter in $W$ bleibt dabei immer gleich.

Unser Output ist kleiner als der Input:

Input Padding

Padding $p=1$

Andere Padding Strategie: Replication

Wieviel Padding?

• "valid": Kein Padding
  $n \times n \quad * \quad f \times f \quad \to \quad n-f+1 \times n-f+1$
• "same": So viel Padding, dass der Output gleich groß, wie der Input ist.
  $p = \frac{f-1}{2}$

https://commons.wikimedia.org/wiki/File:2D_Convolution_Animation.gif

Strided convolutions

stride $s = 2$

• Input: $n_H \times n_W$
• Filter: $f \times f$
• Padding: $p$
• Stride: $s$

Output: $(\lfloor \frac{n_H + 2p - f}{s} \rfloor + 1) \times (\lfloor \frac{n_W + 2p - f}{s} \rfloor + 1)$

Wir können nun auf Graustufenbildern Convolutions verwenden.

Wie sieht es mit RGB Bildern aus?

Z.B. statt $1024 \times 1024$ haben wir nun $1024 \times 1024 \times 3$.

Find vertical edges in red channel

Finde vertikale Kanten in allen Kanälen.

Statt einem können wir auch mehrere Output Kanäle produzieren:

Dimensionen:

• Input: $n_H \times n_W \times n_c$
• Filter: $f \times f \times n_c$
• Anzahl Filter: $n_c'$

Output: $(n_H - f + 1) \times (n_W -f + 1) \times n_c'$

Wir haben nun fast alles für einen Layer Convolutional Neural Network (CNN) zusammen.

Was brauchen wir noch?

• Ein Bias $b$
• Eine Nicht-Linearität

Wenn ein layer $10$ Filter der Größe $3 \times 3 \times 3$ hat, wieviele Parameter hat dann der Layer?

Wir konstruieren nun ein CNN:

Abschluss (Layer 4):

• Reshape zu Vektor mit 1960 Einträgen.
• Fully connected layer mit Sigmoid oder Softmax als Aktivierungsfunktion.

Max pooling

• $f = 2$
• $s = 2$

Wenn wir mehrere Kanäle haben, dann wir Pooling auf jeden Kanal separat angewandt.

Durch Pooling kann die Größe radikal reduziert werden.

Average pooling

Adaptive Pooling

Idee: Wähle Stride und Filter Größe so, dass wir immer eine festgelegte Output Größe erreichen.

\[ s^{[l]} = \lfloor \frac{n^{[l-1]}}{n^{[l]}} \rfloor \\[3mm] f^{[l]} = n^{[l-1]} - (n^{[l]} - 1) s^{[l]} \]

Mit einem adaptive Pooling Layer können wir Input Bilder beliebiger Größe verwenden.

Layer Typen für Convolutional Neural Networks

• Convolution
• Pooling
• Fully connected

Beispiel (ähnlich zum LeNet-5)

Häufige Muster:

• Schrumpfende Größe mit Tiefe.
• Wachsende Anzahl Kanäle.
• Anzahl Aktivierungen sinkt.
• Convolutions gefolgt von Pooling Layern.
• Fully Connected Layer am Ende.

Parameter sharing

Ein Feature Detektor der auf einem Teil des Bildes funktioniert, sollte auch auf einem anderen Teil nützlich sein.

Translation Invariance

Convolutions produzieren ähnlichen Output, wenn wir das Bild verschieben.

Sparsity / Lokaltiät

Jeder Output wird nur von Inputs aus einer kleinen Region beeinflusst.

Wie finden wir eine gute CNN Architektur?

Kopiere von anderen Modellen die auf ähnlichen Daten funktionieren.

LeNet-5 (1998)

Klassifiziere einzelne Ziffern.

• Input: $32 \times 32 \times 3$
• 6 Convolutions ($f=5, s=1$, tanh) : $28 \times 28 \times 6$
• Avg. pooling ($f=2, s=2$) : $14 \times 14 \times 6$
• 16 Convolutions ($f=5, s=1$, tanh) : $10 \times 10 \times 16$
• Avg. pooling ($f=2, s=2$) : $5 \times 5 \times 16$
• Flatten : $400$
• 120 Fully conn. (tanh): $120$
• 84 Fully conn. (tanh): $84$
• 10 Fully conn. (rbf): $10$

Ungefähr 60k Paramter

AlexNet (2012)

Bilderkennung

• Input: $227 \times 227 \times 3$
• 96 Convolutions ($f=11, s=4$, ReLU) : $55 \times 55 \times 96$
• Max Pooling ($f=3, s=2$) : $27 \times 27 \times 96$
• 256 Convolutions ($f=5, p=2$, ReLU) : $27 \times 27 \times 256$
• Max Pooling ($f=3, s=2$) : $13 \times 13 \times 256$
• 384 Convolutions ($f=3, p=1$, ReLU) : $13 \times 13 \times 384$
• 384 Convolutions ($f=3, p=1$, ReLU) : $13 \times 13 \times 384$
• 256 Convolutions ($f=3, p=1$, ReLU) : $13 \times 13 \times 256$
• Max Pooling ($f=3, s=2$) : $6 \times 6 \times 256$
• Flatten : $9216$
• 4096 Fully conn. (ReLU) : $4096$
• 4096 Fully conn. (ReLU) : $4096$
• 1000 Fully conn. (SoftMax) : $1000$

Ungefähr 60 mio. Parameter

VGG - 16 (2015)

Bilderkennung

CONV: $f=3, p=1$; POOL: $f=2, s=2$

• Input: $224 \times 224 \times 3$
• 2x CONV 64 : $224 \times 224 \times 64$
• POOL : $112 \times 112 \times 64$
• 2x CONV 128 : $112 \times 112 \times 128$
• POOL : $56 \times 56 \times 128$
• 3x CONV 256 : $56 \times 56 \times 256$
• POOL : $28 \times 28 \times 256$
• 3x CONV 512 : $14 \times 14 \times 512$
• POOL : $14 \times 14 \times 512$
• 3x CONV 512 : $14 \times 14 \times 512$
• POOL : $7 \times 7 \times 512$
• 2 x FC $4096$
• Softmax $1000$

Ungefähr 138 Mio. Parameter

Mit sehr tiefen Architekturen wird das Vanishing / Exploding Gradients Problem immer größer.

Idee: Füge dem Netzwerk Abkürzungen hinzu
(residual networks)

Residual block: \[ a^{[l+2]} = g(z^{[l+2]} {\color{red} + a^{[l]}}) \]

Bei sehr tiefen neuronalen Netzwerken wird das Training schnell sehr fragil.

Mit ResNets können wir die Tiefe weiter erhöhen.

Intuition, warum das funktioniert:

\[ a^{[l+2]} = g(z^{[l+2]} + a^{[l]}) \\[3mm] = g(W^{[l+2]} a^{[l+1]} + b^{[l+2]} + a^{[l]}) \]

Setze $W^{[l+2]} = 0, b^{[l+2]} = 0$: \[ a^{[l+2]} = g(a^{[l]}) \] was für ReLU bedeutet: $a^{[l+2]} = a^{[l]}$

Es ist für den Residual Block einfach das Ergebnis nicht zu verschlimmbessern.

Wenn wir Skip Connections verwenden, dann müssen die Dimensionen von $a^{[l]}$ und $a^{[l+2]}$ gleich sein.

Brauchen Convolutions mit der "same" Paddding Strategy.

Was ist eine gute Filtergröße?

Idee: Verwende Filter mit verschiedenen Größen im gleichen Layer.

Inception Network

Alle Teile müssen die "same" Padding Strategie und Stride 1 haben, so dass Output Dimensionen zusammen passen.

Anzahl an Multiplikationen um $32$ Filter der Größe $5 \times 5$ mit "same" Padding auf einen Input mit Größe $28 \times 28 \times 192$:

• Ein einzelner Output braucht $5 \cdot 5 \cdot 192 = 4800$ Multiplikationen
• Wir haben $28 \cdot 28 \cdot 32 = 25088$ Outputs
• Das sind $4800 \cdot 25088 = 120422400$ Multiplikationen.

Bottleneck Layer

Multiplikationen:

• $1 \cdot 1 \cdot 192 \cdot 28 \cdot 28 \cdot 16 = 2408448$
• $5 \cdot 5 \cdot 16 \cdot 28 \cdot 28 \cdot 32 = 10035200$

Gesamt: $12443648$

Inception module

Inception network

https://knowyourmeme.com/photos/531557-we-need-to-go-deeper

MobileNets (2017)

Ziel: Effizientere Berechnung für Inference.

Depthwise Separable Convolution

Idee: Wende jeden Filter auf jeden Kanal unabhängig an und merge diese anschließend mit einem 1x1 Filter.

\[ n_W \times n_H \times n_c \\[3mm] \xrightarrow{\text{depthw. conv.}} n_W' \times n_H' \times n_c \\[3mm] \xrightarrow{n_c' \text{ conv. } 1\times 1} n_W' \times n_H' \times n_c' \]

Einfluss auf Rechenaufwand

Reduziert um Faktor \[ \frac{1}{n_c'} + \frac{1}{f^2} \]

Original MobileNet v1: 13 Layers Depthwise Separable Convolution + POOL + FC + SoftMax

MobileNet v2 (2019)

"Bottleneck Block"

EfficientNet (2020)

Wie wählen wir ein Model für ein bestimmtes Budget an Rechenressourcen?

Das Rad nicht neu erfinden!

Von vielen Modellen gibt es Open Source Implementierungen.

• TensorFlow Hub
• PyTorch pre-trained models
• GitHub

Viele Computer Vision Modelle brauchen sehr viele Daten und sind teuer zu trainieren.

Idee: Wiederverwenden von schon trainierten Modellen und ihren Gewichten für eine neue Aufgabe.

Transfer Learning

Passe Modell für neue Aufgabe an:

Verwende einen neuen Softmax Layer am Ende und halte den Rest konstant.

Wir verwandeln die ersten $L-1$ Layer in eine Funktion $f(x) = a^{[L-1]}$.

Dann trainieren wir eine logistische Regression auf $a^{[L-1]}$: \[ \hat y = g(W^{[L]} x + b^{[L]}) \]

Wenn wir mehr Daten haben, können wir auch mehr Layer neu trainieren.

Gemischte Strategie:

• Ersetze den Softmax Layer, friere Rest ein und trainiere.
• Unfreeze ein paar Layer vom Ende an und trainiere mit kleinerer Lernrate.

Ein vortrainiertes Modell als Startpunkt zu verwenden ist fast immer besser, als ein Modell komplett neu zu trainieren.