Pytorch Algoritma Convolutional Neural Networks – CNN

Convolutional Neural Networks, juga dikenal sebagai CNN atau ConvNet, termasuk dalam kategori jaringan saraf tiruan yang digunakan untuk pemrosesan gambar dan visualisasi. Kecerdasan buatan menggunakan pembelajaran mendalam untuk melakukan tugas. Jaringan saraf adalah perangkat keras atau perangkat lunak yang diprogram sebagai neuron di otak manusia. Jaringan saraf tradisional hanya mengambil gambar dengan resolusi yang dikurangi sebagai input. CNN memecahkan masalah itu dengan mengatur neuron mereka sebagai lobus frontal otak manusia. Pre-processing pada CNN sangat sedikit jika dibandingkan dengan algoritma lainnya. Konvolusi, operasi matematika linier, digunakan di CNN. Ini menggunakan konvolusi alih-alih perkalian matriks umum di salah satu lapisannya.

Arsitektur Convolutional Neural Network

Secara umum algoritma CNN sebagai berikut

1. Image input layer
2. Convolutional layer
3. Non-Linearity Layer
4. Rectification Layer
5. Rectified Linear Units (ReLU)
6. Pooling Layer
7. Dropout Layer
8. Fully Connected Layer
9. Output Layer
10. Regression Layer

Tulisan ini bersifat serial, kalian bisa pelajari bab-bab berikut

1. Pytorch Apa itu Operasi Linear, Bobot, dan Bias pada Algoritma CNN
2. Pytorch – Membuat Function Loss
3. Pytorch – loss function Cross-entropy loss
4. Pytorch – loss function Negative log likelihood loss nn.NLLLoss
5. PyTorch – Backward dan Step Optimizer serta membuat MLP

Algoritma Convolutional Neural Network sangat mudah dipahami karena kunci utamanya ada di Conv2d – Secara umum untuk CNN yang simple, saya ambil contoh dari PyTorch https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html

import torch.nn as nn
import torch.nn.functional as F


class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = torch.flatten(x, 1) # flatten all dimensions except batch
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


net = Net()

Sebelum membahas mengenai arsitektur, maka hal yang pertama kali yaitu lapisan masukan gambar/layer input berupa gambar yang telah dinormalisasi dan sudah dikonvert ke Tensor.

import torch
import torchvision
import torchvision.transforms as transforms
import os
from PIL import Image
from matplotlib import pyplot as plt
import numpy as np

#membaca gambar
img = Image.open(os.path.join('D:/matang.png')).convert("RGB")

#normalisasi 
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
     ])

#penerapan transform
img2 = transform(img)
npimg = img2.numpy()

plt.figure()
plt.subplot(1,2,1), plt.imshow(img),plt.title('gambar mentah')
plt.subplot(1,2,2), plt.imshow(np.transpose(npimg, (1, 2, 0))), plt.title('normalisasi')
plt.show()

Hasilnya sebagai berikut untuk normalisasi gambar

Pada gambar diatas mempunyai dimensi sebagai berikut

img2.shape

Out[589]: torch.Size([3, 421, 446])

tentu ukuran tersebut tidak cocok dengan model Net() diatas, karena pada model Net() diatas itu menggunakan ukuran 32×32. Kita resize saja agar pas (kalian bisa koq menggunakan beragam ukuran tapi harus ngerti cara menggunakan function Conv2d agar output dihasilkan nantinya pas)

transform2 = transforms.Compose(
        [
            transforms.ToTensor(),
            transforms.Resize((32, 32)),                     
            transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
        ]
    )


img3 = transform2(img)

Ukuran tensor im3 yaitu sebagai berikut

img3.shape
Out[596]: torch.Size([3, 32, 32])

Kita harus tahu bahwa untuk memasukan arsitektur jaringan CNN, membutuhkan urutan sebagai berikut

1. ukuran batch/jumlah record
2. ukuran channel
3. ukuran width
4. ukuran height

sesuai informasi diatas didapatkan bahwa ukuran channel = 3 serta dimensi width x height = 32×32, untuk itu kita butuh ukuran batch, mengingat gambar diatas hanya 1 maka ukuran batch nya yaitu 1.

img4=img3.unsqueeze(0)

sehingga ukuran img4 menjadi berikut

img4.shape
Out[599]: torch.Size([1, 3, 32, 32])

Sekarang kita panggil CNN dengan perintah

net = Net()

hasil = net(img4)

print(hasil)

print(hasil.shape)

hasil nya yaitu

tensor([[ 0.0649, -0.0778, -0.0776, -0.0888, -0.0484, -0.0473, -0.0386, 0.0595, 0.0527, -0.0103]], grad_fn=<AddmmBackward>)

ada 10 array sesuai dengan output dari

self.fc3 = nn.Linear(84, 10)

yang memang model https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html untuk klasifikasi 10 kelas objek yaitu

classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Kalian bisa melihat dari ukuran gambar 3 channel x 32 width x 32 height akan menghasilkan output 1 baris x 10 kolom dalam bentuk tensor. Untuk mengetahui prediksi, ya diambil dari nilai maksimalnya

_, predicted = torch.max(hasil, 1)

untuk hasil predicted=6 atau kelas no 5

Arsitektur Convolutional Neural Network yang lain

Di bawah ini adalah arsitektur jaringan saraf convolutional:

1. LeNet: LeNet diperkenalkan untuk Optical dan Character Recognition in Documents pada tahun 1998. LeNet kecil dan sempurna untuk dijalankan pada CPU.
2. AlexNet: AlexNet dikembangkan pada tahun 2012. Arsitektur ini mempopulerkan CNN dalam Computer vision.
3. ZF Net: ZF Net dikembangkan pada tahun 2013, yang merupakan versi modifikasi dari AlexNet.
4. GoogLeNet: Arsitektur ini dikembangkan pada tahun 2014.
5. VGG Net: Ini merupakan peningkatan dari ZFNet dan selanjutnya dari AlexNet.
6. ResNet: Arsitektur Jaringan Residual dikembangkan pada tahun 2015.