Convolutionele neurale netwerken

Gevorderde Deep Learning met PyTorch

Michal Oleszak

Machine Learning Engineer

Waarom geen lineaire lagen?

Een zwart vierkant dat een 256x256-grijswaardeafbeelding voorstelt.

Waarom geen lineaire lagen?

Een 256 bij 256-grijswaardeafbeelding bevat ~65k pixelwaarden.

Waarom geen lineaire lagen?

Een lineaire laag met 1000 neuronen verwerkt de ~65k pixelwaarden.

Waarom geen lineaire lagen?

Er zijn ~65 mln verbindingen tussen de afbeelding en de laag.

Waarom geen lineaire lagen?

Met een RGB-kleurafbeelding zijn het ~200 mln verbindingen.

Waarom geen lineaire lagen?

Lineaire lagen:
- Trage training
- Overfitting
- Herkennen geen ruimtelijke patronen
Beter alternatief: convolutionele lagen!

Afbeelding met kat in de hoek en neuronen die dat deel van de afbeelding lezen

Convolutionele laag

Filter van 3 bij 3 schuift over input van 5 bij 5 en produceert een featuremap van 3 bij 3.

Schuif filter(s) met parameters over de input
Voer op elke positie een convolutie uit
Resulterende featuremap:
- Behoudt ruimtelijke patronen uit de input
- Minder parameters dan een lineaire laag
Eén filter = één featuremap
Pas activaties toe op featuremaps
Alle featuremaps samen vormen de output
nn.Conv2d(3, 32, kernel_size=3)

Convolutie

Twee 3 bij 3-matrices worden elementgewijs vermenigvuldigd en daarna worden alle getallen opgeteld.

Bereken het inwendig product van de inputpatch en het filter
- Linksboven: 2 × 1 = 2
Sommeer het resultaat

Zero-padding

Een 4 bij 4-afbeelding omgeven door een rand van pixels met waarde nul.

Voeg een rand van nullen toe aan de input van de convolutionele laag

nn.Conv2d(
  3, 32, kernel_size=3, padding=1
)

Behoudt de ruimtelijke afmetingen van input en output
Zorgt dat randpixels gelijk worden behandeld

Max-pooling

Een 4 bij 4-matrix waarvan elk 2 bij 2-kwadrant een andere kleur heeft wordt na max-pooling een 2 bij 2-matrix.

Schuif een niet-overlappend venster over de input
Neem op elke positie alleen de maximumwaarde
Gebruikt na convolutionele lagen om ruimtelijke afmetingen te verkleinen
nn.MaxPool2d(kernel_size=2)

Convolutioneel neuraal netwerk

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: (convolutie, activatie, pooling), twee keer herhaald en geflattened
classifier: enkele lineaire laag
forward(): stuur inputafbeelding door feature-extractor en classifier