Straturi convoluționale pentru imagini

Deep Learning pentru imagini cu PyTorch

Michal Oleszak

Machine Learning Engineer

Straturi convoluționale pentru imagini

Aplicarea straturilor convoluționale pe date de tip imagine
Accesarea și adăugarea straturilor convoluționale
Crearea blocurilor convoluționale

Utilizate pentru adaptarea modelelor la o sarcină specifică

Dreptunghi în jurul unei pisici

Conv2d: canale de intrare

Canale RGB

Imagine în tonuri de gri: in_channels=1
Imagine RGB (roșu, verde, albastru): in_channels=3
Transparența include canalul alfa: 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

filtre

Tensor de intrare Kernel Tensor de ieșire (hartă de trăsături)

Kernel-ul (colorat în verde) se deplasează de la stânga la dreapta, de sus în jos pe imagine$^1$

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

Dimensiunile kernel-ului

calcul matriceal

Cele mai comune dimensiuni de kernel: 3x3 (Conv2d) și 2x2 (MaxPool2d)
Convoluția este un produs scalar între kernel (verde) și regiunea imaginii (roz)
Suma produsului scalar generează o hartă de trăsături (albastru)

Kernel-ul este un filtru

Captează tipare din imagini

filtru de zonă

filtru de linie

Conv2d: canale de ieșire

Canal de intrare Filtre kernel Canale de ieșire

Numărul de canale de ieșire determină câte filtre sunt aplicate
Fiecare canal de ieșire corespunde unui filtru distinct
Mai multe canale de ieșire permit stratului să învețe trăsături mai complexe
Numărul de canale de ieșire se alege de obicei ca putere a lui 2 (16, 32, 64, 128)
- Simplifică combinarea și împărțirea canalelor în straturile ulterioare

Adăugarea straturilor convoluționale

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)

Accesarea straturilor convoluționale

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

Crearea blocurilor convoluționale

Stivuirea straturilor convoluționale într-un bloc cu 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)

Să exersăm!

Deep Learning pentru imagini cu PyTorch