Convolutional Neural Networks

Deep Learning mit PyTorch für Fortgeschrittene

Michal Oleszak

Machine Learning Engineer

Warum keine linearen Schichten?

Ein schwarzes Quadrat als 256x256-Graustufenbild.

Deep Learning mit PyTorch für Fortgeschrittene

Warum keine linearen Schichten?

Ein 256x256-Graustufenbild besteht aus ca. 65k Pixelwerten.

Deep Learning mit PyTorch für Fortgeschrittene

Warum keine linearen Schichten?

Eine lineare Schicht mit 1000 Neuronen verarbeitet die ~65k Pixelwerte.

Deep Learning mit PyTorch für Fortgeschrittene

Warum keine linearen Schichten?

Es gibt 65 Mio. Verbindungen zwischen Bild und Schicht.

Deep Learning mit PyTorch für Fortgeschrittene

Warum keine linearen Schichten?

Bei einem RGB-Bild sind es 200 Mio. Verbindungen.

Deep Learning mit PyTorch für Fortgeschrittene

Warum keine linearen Schichten?

  • Lineare Schichten:
    • Langsames Training
    • Overfitting
    • Erkennen keine räumlichen Muster
  • Bessere Alternative: Convolution-Schichten!

Bild mit Katze in der Ecke und Neuronen, die nur diesen Bildteil lesen

Deep Learning mit PyTorch für Fortgeschrittene

Convolution-Schicht

Ein 3x3-Filter gleitet über ein 5x5-Input und erzeugt eine 3x3-Feature-Map.

  • Filterparameter über das Input schieben
  • An jeder Position: Convolution berechnen
  • Ergebnis: Feature-Map
    • Erhält räumliche Muster des Inputs
    • Weniger Parameter als lineare Schicht
  • Ein Filter = eine Feature-Map
  • Aktivierungen auf Feature-Maps anwenden
  • Alle Feature-Maps kombiniert ergeben das Output
  • nn.Conv2d(3, 32, kernel_size=3)
Deep Learning mit PyTorch für Fortgeschrittene

Convolution

Zwei 3x3-Matrizen werden elementweise multipliziert und die Werte danach summiert.

  1. Skalarprodukt aus Input-Patch und Filter berechnen
    • Links oben: 2 × 1 = 2
  2. Ergebnis aufsummieren
Deep Learning mit PyTorch für Fortgeschrittene

Zero-Padding

Ein 4x4-Bild ist von einem Rahmen aus Nullen umgeben.

  • Dem Input der Convolution-Schicht einen Rahmen aus Nullen hinzufügen
nn.Conv2d(
  3, 32, kernel_size=3, padding=1
)
  • Erhält die räumlichen Dimensionen von Input und Output
  • Behandelt Randpixel gleich wie andere
Deep Learning mit PyTorch für Fortgeschrittene

Max-Pooling

Eine 4x4-Matrix, deren vier 2x2-Quadranten farbig markiert sind, wird per Max-Pooling zu 2x2.

  • Nicht überlappendes Fenster über das Input schieben
  • An jeder Position nur den Maximalwert behalten
  • Nach Convolution-Schichten zur Reduktion der räumlichen Dimensionen
  • nn.MaxPool2d(kernel_size=2)
Deep Learning mit PyTorch für Fortgeschrittene

Convolutional Neural Network

class Net(nn.Module):
    def __init__(self, num_classes):
        super().__init__()

        self.feature_extractor = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ELU(),
            nn.MaxPool2d(kernel_size=2),
            nn.Flatten(),
        )

        self.classifier = nn.Linear(64*16*16, num_classes)


    def forward(self, x):  
        x = self.feature_extractor(x)
        x = self.classifier(x)
        return x
  • feature_extractor: (Convolution, Aktivierung, Pooling), zweimal, dann Flatten
  • classifier: eine lineare Schicht
  • forward(): Eingabebild durch Feature-Extractor und Klassifizierer schicken
Deep Learning mit PyTorch für Fortgeschrittene

Output-Größe des Feature-Extractors

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schaubild: Eingaben der Form 3x64x64 gehen durch Conv-, Pooling-, Conv- und Pooling-Schicht.

Deep Learning mit PyTorch für Fortgeschrittene

Output-Größe des Feature-Extractors

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schaubild: Eingaben der Form 3x64x64 gehen durch Conv-, Pooling-, Conv- und Pooling-Schicht.

Deep Learning mit PyTorch für Fortgeschrittene

Output-Größe des Feature-Extractors

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schaubild: Eingaben der Form 3x64x64 gehen durch Conv-, Pooling-, Conv- und Pooling-Schicht.

Deep Learning mit PyTorch für Fortgeschrittene

Output-Größe des Feature-Extractors

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schaubild: Eingaben der Form 3x64x64 gehen durch Conv-, Pooling-, Conv- und Pooling-Schicht.

Deep Learning mit PyTorch für Fortgeschrittene

Output-Größe des Feature-Extractors

self.feature_extractor = nn.Sequential(
  nn.Conv2d(3, 32, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Conv2d(32, 64, kernel_size=3, padding=1),
  nn.ELU(),
  nn.MaxPool2d(kernel_size=2),
  nn.Flatten(),
)
self.classifier = nn.Linear(64*16*16, num_classes)
`

Schaubild: Eingaben der Form 3x64x64 gehen durch Conv-, Pooling-, Conv- und Pooling-Schicht.

Deep Learning mit PyTorch für Fortgeschrittene

Lass uns üben!

Deep Learning mit PyTorch für Fortgeschrittene

Preparing Video For Download...