Lapisan konvolusional untuk gambar

Deep Learning untuk Gambar dengan PyTorch

Michal Oleszak

Machine Learning Engineer

Lapisan konvolusional untuk gambar

Terapkan layer konvolusional pada data gambar
Akses dan tambahkan layer konvolusional
Buat blok konvolusional

Digunakan untuk menyesuaikan model dengan tugas tertentu

Kotak di sekitar kucing

Conv2d: saluran input

Saluran RGB

Gambar grayscale: in_channels=1
Gambar RGB (merah, hijau, biru): in_channels=3
Transparansi dengan kanal 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

filter

Tensor input Kernel Tensor output (peta fitur)

Kernel (berwarna hijau) bergerak dari kiri ke kanan, atas ke bawah pada gambar$^1$

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

Ukuran kernel

perhitungan matriks

Ukuran kernel paling umum: 3x3 (Conv2d) dan 2x2 (MaxPool2d)
Konvolusi adalah perkalian titik antara kernel (hijau) dan area gambar (merah muda)
Jumlah hasil perkalian membentuk peta fitur (biru)

Kernel adalah filter

Menangkap pola pada gambar

filter area

filter garis

Conv2d: saluran output

saluran keluaran Saluran input Filter kernel Saluran output

Jumlah saluran output menentukan berapa banyak filter diterapkan
Tiap saluran output mewakili satu filter berbeda
Lebih banyak saluran output memungkinkan layer belajar fitur lebih kompleks
Jumlah saluran output umum dipilih pangkat 2 (16, 32, 64, 128)
- Memudahkan penggabungan/pemisahan saluran di layer berikutnya

Menambahkan layer konvolusional

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)

Mengakses layer konvolusional

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

Membuat blok konvolusional

Menumpuk layer konvolusional dalam blok dengan 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)

Ayo berlatih!

Deep Learning untuk Gambar dengan PyTorch