2022-10-27

Convolutional Neural Network (CNN)

Apa itu Convolutional Neural Network (CNN)

Convolutional Neural Network (CNN) adalah jenis jaringan syaraf tiruan yang dirancang untuk memproses data berstruktur berbentuk grid, seperti gambar, dengan menggunakan lapisan konvolusi, lapisan penyetimbangan, dan lapisan terhubung penuh. CNN telah banyak digunakan dalam tugas visi komputer, termasuk klasifikasi gambar, deteksi objek, dan segmentasi semantik, antara lain.

Arsitektur CNN

Lapisan Input

Lapisan input adalah titik awal dari CNN di mana data mentah, seperti gambar, dimasukkan ke dalam jaringan. Untuk gambar, input biasanya direpresentasikan sebagai tensor tiga dimensi dengan tinggi, lebar, dan saluran (misalnya, saluran merah, hijau, dan biru untuk gambar berwarna). Peran utama lapisan input adalah untuk memproses pra dan menstandarisasi data masukan untuk memastikan bahwa jaringan dapat belajar dengan efektif.

Lapisan Konvolusi

Lapisan konvolusi adalah komponen inti dari CNN. Ia menerapkan serangkaian filter, yang juga dikenal sebagai kernel, pada data masukan, yang memungkinkan jaringan untuk mempelajari fitur lokal seperti tepi, tekstur, dan bentuk. Filter digeser ke seluruh data masukan, melakukan perkalian elemen dan menjumlahkan hasil untuk menghasilkan feature map. Setiap filter di lapisan konvolusi bertanggung jawab untuk mendeteksi fitur tertentu dalam data masukan.

Feature map

Feature map adalah keluaran dari lapisan konvolusi, yang menangkap keberadaan fitur yang dipelajari dalam data masukan. Mereka dihasilkan dengan menerapkan filter atau kernel pada data masukan menggunakan operasi konvolusi. Saat CNN bergerak melalui beberapa lapisan, feature map menjadi lebih abstrak dan tingkat tinggi, memungkinkan jaringan untuk mengenali pola dan struktur yang kompleks.

A Comprehensive Guide to Convolutional Neural Networks — the ELI5 way

Matriks merah muda adalah feature map.

Filter (Kernel)

Filter, juga dikenal sebagai kernel, adalah matriks kecil yang digunakan di lapisan konvolusi untuk mengekstrak fitur dari data masukan. Setiap filter bertanggung jawab untuk mendeteksi fitur tertentu, seperti tepi, tekstur, atau bentuk. Filter diinisialisasi dengan nilai acak dan dipelajari oleh jaringan selama proses pelatihan. Ukuran filter, yang dikenal sebagai dimensi filter atau ukuran kernel, adalah hiperparameter yang dapat disesuaikan untuk mengontrol granularitas fitur yang dipelajari.

A Comprehensive Guide to Convolutional Neural Networks — the ELI5 way

Matriks kuning adalah filter.

Stride dan Padding

Stride dan padding adalah hiperparameter yang mengontrol operasi konvolusi di lapisan konvolusi. Stride adalah jumlah piksel di mana filter digerakkan di seluruh data masukan selama konvolusi. Stride yang lebih besar menghasilkan feature map yang lebih kecil dan mengurangi kompleksitas komputasi. Padding mengacu pada proses menambahkan piksel tambahan di sekitar data masukan, biasanya dengan nilai nol untuk mempertahankan dimensi spasial feature map setelah operasi konvolusi. Ada dua jenis padding utama: padding 'valid', di mana tidak ada padding yang diterapkan, dan padding 'same', di mana padding ditambahkan untuk memastikan feature map keluaran memiliki dimensi yang sama dengan data masukan. Penyesuaian stride dan padding dapat memiliki dampak signifikan pada kinerja dan efisiensi komputasi dari CNN.

Stride
Convolution Neural Network

Padding
Convolution Neural Network

Fungsi Aktivasi

Fungsi aktivasi digunakan untuk memperkenalkan non-linearitas ke dalam CNN, memungkinkannya untuk mempelajari pola dan representasi yang kompleks. Mereka diterapkan pada keluaran lapisan konvolusi, mengubah feature map. Beberapa fungsi aktivasi populer yang digunakan dalam CNN termasuk Rectified Linear Unit (ReLU), Leaky ReLU, Sigmoid, dan Hyperbolic Tangent (tanh). ReLU adalah fungsi aktivasi yang paling umum digunakan karena efisiensi komputasinya dan kemampuannya untuk mengatasi masalah gradien yang menghilang.

Lapisan Penyetimbangan

Lapisan penyetimbangan bertanggung jawab untuk menurunkan dimensi spasial dan kompleksitas komputasi dari feature map yang dihasilkan oleh lapisan konvolusi. Lapisan ini membantu jaringan menjadi lebih invarian terhadap translasi, rotasi, dan skala, meningkatkan kemampuannya untuk mengenali fitur. Ada berbagai jenis operasi penyetimbangan, seperti penyetimbangan maksimum, penyetimbangan rata-rata, dan penyetimbangan rata-rata global. Penyetimbangan maksimum adalah metode yang paling banyak digunakan, yang memilih nilai maksimum dalam wilayah yang ditentukan di feature map.

Pooling layer
Convolutional Neural Network: An Overview

Lapisan Terhubung Penuh (Lapisan Affine)

Setelah beberapa lapisan konvolusi dan penyetimbangan, CNN sering mengandung satu atau lebih lapisan terhubung penuh. Lapisan ini bertanggung jawab untuk mengintegrasikan fitur yang dipelajari dari lapisan sebelumnya dan membuat keputusan tingkat tinggi berdasarkan pola yang diekstraksi. Lapisan terhubung penuh mirip dengan yang ditemukan dalam jaringan syaraf maju tradisional, di mana setiap neuron terhubung ke semua neuron di lapisan sebelumnya dan berikutnya.

Lapisan Output

Lapisan output adalah lapisan terakhir dari CNN dan bertanggung jawab untuk menghasilkan prediksi atau klasifikasi jaringan. Lapisan ini biasanya menggunakan fungsi aktivasi softmax, yang menormalisasi keluaran untuk menghasilkan distribusi probabilitas atas kelas yang mungkin. Untuk tugas regresi, lapisan output dapat menggunakan fungsi aktivasi linier sebagai gantinya. Fungsi rugi, seperti cross-entropy atau mean squared error, kemudian digunakan untuk mengukur perbedaan antara prediksi jaringan dan kebenaran dasar, memandu proses optimisasi selama pelatihan.

Menerapkan CNN menggunakan Python

Dalam bagian ini, saya akan menerapkan CNN sederhana menggunakan kerangka kerja PyTorch dan melatihnya pada dataset CIFAR-10 publik. Dataset CIFAR-10 terdiri dari 60.000 gambar warna 32x32 dalam 10 kelas, dengan 6.000 gambar per kelas. Ada 50.000 gambar pelatihan dan 10.000 gambar pengujian.

Pertama, mari impor pustaka yang diperlukan:

python

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
import torchvision.datasets as datasets

Selanjutnya, tentukan arsitektur CNN:

python

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=1)
        self.relu1 = nn.ReLU()
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1)
        self.relu2 = nn.ReLU()
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(64 * 8 * 8, 128)
        self.relu3 = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = self.pool1(self.relu1(self.conv1(x)))
        x = self.pool2(self.relu2(self.conv2(x)))
        x = x.view(x.size(0), -1)
        x = self.relu3(self.fc1(x))
        x = self.fc2(x)
        return x

model = SimpleCNN()

Sekarang, tentukan fungsi rugi, pengoptimal, dan konfigurasi lainnya:

python

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

Muat dataset CIFAR-10 dan terapkan augmentasi data:

python

transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=100, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2)

Latih model:

python

num_epochs = 10

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0

    for i, data in enumerate(train_loader, 0):
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f"Epoch {epoch + 1}, Loss: {running_loss / (i + 1)}")

Evaluasi kinerja model pada dataset pengujian:

python

model.eval()
correct = 0
total = 0

with torch.no_grad():
    for data in test_loader:
        inputs, labels = data
        inputs, labels = inputs.to(device), labels.to(device)

        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)

        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Accuracy of the model on the 10,000 test images: {100 * correct / total}%")

Epoch 1, Loss: 2.1893566000461577
Epoch 2, Loss: 1.9117810306549072
Epoch 3, Loss: 1.7671691884994507
Epoch 4, Loss: 1.662340677499771
Epoch 5, Loss: 1.5774701907634736
Epoch 6, Loss: 1.5232401647567748
Epoch 7, Loss: 1.4739297952651977
Epoch 8, Loss: 1.431945639371872
Epoch 9, Loss: 1.39970556807518
Epoch 10, Loss: 1.3656729533672334
Accuracy of the model on the 10,000 test images: 51.57%

Memvisualisasikan Apa yang Dilihat oleh CNN

Dalam bab ini, saya akan mengeksplorasi cara kerja dalam sebuah CNN dengan memvisualisasikan apa yang dilihat oleh CNN saat gambar input melewati lapisannya. Kita akan menggunakan gambar dari dataset publik dan PyTorch untuk membuat visualisasi yang membantu kita memahami sudut pandang CNN pada kedalaman yang berbeda.

Mari impor pustaka yang diperlukan dan muat dataset CIFAR-10:

python

import torch
import torchvision
import torchvision.transforms as transforms

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

# Load CIFAR-10 dataset
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=10,
                                          shuffle=True, num_workers=2)

Memuat Model CNN yang Sudah Dilatih

Untuk visualisasi kita, kita akan menggunakan model CNN yang sudah dilatih yang disediakan oleh PyTorch. Kita akan menggunakan model VGG16, yang merupakan arsitektur populer dan handal. Muat model VGG16 yang sudah dilatih sebagai berikut:

python

import torchvision.models as models

# Load the pre-trained VGG16 model
vgg16 = models.vgg16(pretrained=True)

Memvisualisasikan Sudut Pandang CNN

Untuk memvisualisasikan apa yang dilihat oleh CNN pada lapisan-lapisannya, kita akan membuat sebuah fungsi yang mengekstrak feature map dari lapisan yang diberikan dan memplotnya sebagai gambar. Kode berikut menunjukkan cara melakukan hal ini menggunakan PyTorch dan matplotlib:

python

import matplotlib.pyplot as plt
import numpy as np

def visualize_layer(model, input_image, layer_index):
    # Define a forward hook to extract the output of the target layer
    def hook(module, input, output):
        global layer_output
        layer_output = output.detach()

    # Register the forward hook
    handle = model.features[layer_index].register_forward_hook(hook)

    # Run the input image through the model
    output = model(input_image.unsqueeze(0))

    # Remove the forward hook
    handle.remove()

    # Plot the feature maps
    num_feature_maps = layer_output.shape[1]
    rows = int(np.sqrt(num_feature_maps))
    cols = int(np.ceil(num_feature_maps / rows))

    fig, axes = plt.subplots(rows, cols, figsize=(cols*2, rows*2))

    for i in range(rows * cols):
        ax = axes[i // cols, i % cols]
        if i < num_feature_maps:
            ax.imshow(layer_output[0, i].numpy(), cmap='gray')
        ax.axis('off')

    plt.show()

Mari pilih sebuah gambar contoh dari dataset CIFAR-10 dan praolah datanya:

sample_image, label = trainset[0]
sample_image = (sample_image * 0.5 + 0.5).permute(1, 2, 0).numpy()

# Plot the original image
plt.imshow(sample_image)
plt.axis('off')
plt.show()

Sekarang, mari visualisasikan feature map pada lapisan-lapisan berbeda dari model VGG16:

python

# Visualize the feature maps at layer 1 (first convolutional layer)
visualize_layer(vgg16, trainset[0][0], layer_index=0)

# Visualize the feature maps at layer 5 (fifth convolutional layer)
visualize_layer(vgg16, trainset[0][0], layer_index=4)

# Visualize the feature maps at layer 15 (fifteenth convolutional layer)
visualize_layer(vgg16, trainset[0][0], layer_index=14)

Convolutional layer 1
Convolutional layer 5
Convolutional layer 15

Visualisasi ini menunjukkan bagaimana CNN "melihat" gambar input pada kedalaman yang berbeda dalam jaringan. Pada lapisan awal, feature map menangkap pola-pola sederhana seperti tepi, sudut, dan tekstur. Saat gambar melewati lapisan-lapisan, feature map menjadi lebih abstrak dan kompleks, merepresentasikan pola-pola tingkat tinggi yang membantu CNN membedakan antara kelas-kelas yang berbeda pada dataset.