Faltningslager för bilder

Djupinlärning för bilder med PyTorch

Michal Oleszak

Machine Learning Engineer

Faltningslager för bilder

Tillämpa faltningslager på bilddata
Åtkomst till och tillägg av faltningslager
Skapa faltningsblock

Används för att anpassa modeller till en specifik uppgift

Ruta runt en katt

Conv2d: indatakanaler

RGB-kanaler

Gråskalebild: in_channels=1
RGB-bild (röd, grön, blå): in_channels=3
Transparens inkluderar alfakanal: 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

filter

Indatatensor Kernel Utdatatensor (särdragskarta)

Kerneln (markerad i grönt) rör sig från vänster till höger, uppifrån och ned i bilden$^1$

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

Kernelstorlekar

matriskalkylering

Vanligaste kernelstorlekarna: 3x3 (Conv2d) och 2x2 (MaxPool2d)
Faltning är en skalärprodukt av kerneln (grön) och bildregionen (rosa)
Summan av skalärprodukten skapar en särdragskarta (blå)

Kerneln som filter

Identifierar mönster i bilder

ytfilter

linjefilter

Conv2d: utdatakanaler

Indatakanal Kernelfilter Utdatakanaler

Antalet utdatakanaler avgör hur många filter som tillämpas
Varje utdatakanal motsvarar ett eget filter
Fler utdatakanaler gör att lagret kan lära sig mer komplexa särdrag
Antal utdatakanaler väljs vanligen som tvåpotenser (16, 32, 64, 128)
- Det förenklar sammanslagning och uppdelning av kanaler i efterföljande lager

Lägga till faltningslager

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)

Åtkomst till faltningslager

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))

Skapa faltningsblock

Stapla faltningslager i ett block med 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)

Nu kör vi en övning!

Djupinlärning för bilder med PyTorch