Jaringan Saraf Konvolusional

Deep Learning Lanjutan dengan PyTorch

Michal Oleszak

Machine Learning Engineer

Mengapa tidak pakai lapisan linear?

Sebuah kotak hitam mewakili gambar grayscale 256x256.

Mengapa tidak pakai lapisan linear?

Gambar grayscale 256 kali 256 berisi sekitar 65 ribu nilai piksel.

Mengapa tidak pakai lapisan linear?

Lapisan linear dengan 1000 neuron memproses 65 ribu nilai piksel.

Mengapa tidak pakai lapisan linear?

Ada 65 juta koneksi antara gambar dan layer.

Mengapa tidak pakai lapisan linear?

Dengan gambar berwarna RGB, ada 200 juta koneksi.

Mengapa tidak pakai lapisan linear?

Lapisan linear:
- Pelatihan lambat
- Overfitting
- Tidak mengenali pola spasial
Alternatif yang lebih baik: lapisan konvolusi!

Gambar dengan kucing di pojok dan neuron hanya membaca bagian gambar itu

Lapisan konvolusi

Filter ukuran 3 kali 3 bergeser di atas input ukuran 5 kali 5 untuk menghasilkan feature map ukuran 3 kali 3.

Geser filter (parameter) di atas input
Di tiap posisi, lakukan konvolusi
Feature map hasil:
- Menjaga pola spasial dari input
- Lebih sedikit parameter dari lapisan linear
Satu filter = satu feature map
Terapkan aktivasi ke feature map
Gabungan semua feature map menjadi output
nn.Conv2d(3, 32, kernel_size=3)

Konvolusi

Dua matriks 3 kali 3 dikalikan elemen-per-elemen, lalu semua nilainya dijumlahkan.

Hitung dot product antara patch input dan filter
- Petak kiri-atas: 2 × 1 = 2
Jumlahkan hasilnya

Zero-padding

Gambar 4 kali 4 dikelilingi bingkai piksel bernilai nol.

Tambah bingkai nol pada input lapisan konvolusi

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

Menjaga dimensi spasial tensor input dan output
Memastikan piksel tepi diperlakukan sama

Max pooling

Matriks 4 kali 4 dengan tiap seperempat 2 kali 2 berwarna berbeda menjadi matriks 2 kali 2 setelah max pooling.

Geser jendela non-overlap di atas input
Di tiap posisi, ambil nilai maksimum saja
Dipakai setelah konvolusi untuk mengecilkan dimensi spasial
nn.MaxPool2d(kernel_size=2)

Jaringan Saraf Konvolusional

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: (konvolusi, aktivasi, pooling), diulang dua kali lalu flatten
classifier: satu lapisan linear
forward(): alirkan gambar input lewat feature extractor dan classifier