Convolutional lagen voor afbeeldingen

Deep Learning voor afbeeldingen met PyTorch

Michal Oleszak

Machine Learning Engineer

Convolutional lagen voor afbeeldingen

Pas convolutielagen toe op beelddata
Benader en voeg convolutielagen toe
Maak convolutieblokken

Gebruikt om modellen aan te passen aan een specifieke taak

Kader om een kat

Conv2d: inputkanalen

RGB-kanalen

Grijswaarde-afbeelding: in_channels=1
RGB-afbeelding (rood, groen, blauw): in_channels=3
Transparantie met alphakanaal: in_channels=4

from torchvision.transforms import functional
image = PIL.Image.open("dog.png")
num_channels = functional.get_image_num_channels(image)
print("Number of channels: ", num_channels)

Number of channels: 3

Conv2d: kernel

filters

Inputtensor Kernel Outputtensor (feature map)

Kernel (groen) schuift van links naar rechts, van boven naar beneden$^1$

¹ Thevenot, Axel. 2020. A visual and mathematical explanation of the 2D convolution layer.

Kernelgroottes

matrixberekening

Meest gebruikte kernelgroottes: 3x3 (Conv2d) en 2x2 (MaxPool2d)
Convolutie is een dotproduct van de kernel (groen) en het beeldgebied (roze)
De som van het dotproduct vormt een feature map (blauw)

Kernel is een filter

Leg patronen in afbeeldingen vast

gebiedsfilter

lijnfilter

Conv2d: uitvoarkanalen

Inputkanaal Kernelfilters Uitvoarkanalen

Het aantal uitvoarkanalen bepaalt hoeveel filters worden toegepast
Elk uitvoarkanaal komt overeen met één filter
Meer uitvoarkanalen laten de laag complexere features leren
Aantallen zijn vaak machten van 2 (16, 32, 64, 128)
- Dat vereenvoudigt samenvoegen en splitsen van kanalen in volgende lagen

Convolutielagen toevoegen

import torch
import torch.nn as nn

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, padding=1)

conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1)

model = Net()

model.add_module('conv2', conv2)

Convolutielagen benaderen

print(model)

Net(
  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)

model.conv2

Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))

Convolutieblokken maken

Convolutielagen stapelen in een blok met nn.Sequential()

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

        self.conv_block = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )

     def forward(self, x):
         x = self.conv_block(x)

Laten we oefenen!

Deep Learning voor afbeeldingen met PyTorch