Convolutional Neural Network

Convolutional Neural Network (CNN) adalah jenis artificial neural network yang menggunakan operasi konvolusi (bukan perkalian matriks umum) pada setidaknya satu layer-nya. CNN dirancang khusus untuk data dengan topologi seperti grid (grid-like topology), seperti gambar.

#Link to this headingWhy CNN?

#Link to this headingAI, Machine Learning, dan Deep Learning

• Artificial Intelligence: program yang dapat merasakan, bernalar, bertindak, dan beradaptasi.
• Machine Learning: algoritma yang performanya meningkat seiring lebih banyak data.
• Deep Learning: subset ML di mana jaringan saraf berlapis banyak belajar dari data dalam jumlah besar.

Deep Learning sekarang berkembang pesat karena tiga faktor: dataset yang lebih besar, hardware yang lebih baik (biaya per GB turun dari $1000 (1995) ke $0.02 (2017)), dan algoritma yang lebih cerdas.

#Link to this headingCurse of Dimensionality

Jumlah konfigurasi yang mungkin terjadi meningkat secara eksponensial seiring bertambahnya jumlah variabel/fitur. Ini menjadi masalah besar saat memproses gambar beresolusi tinggi dengan ANN biasa.

#Link to this headingUniversal Approximator Theorem

Satu hidden layer sudah cukup untuk merepresentasikan fungsi apapun, tetapi tidak efisien untuk mempelajarinya:

• Shallow network mungkin membutuhkan lebar yang eksponensial
• Shallow network lebih mudah overfit

Model yang lebih dalam (deeper) memberikan generalisasi lebih baik dibanding model yang lebih lebar (shallower) dengan jumlah parameter yang sama.

#Link to this headingJenis-Jenis Model Deep Learning

#Link to this headingSejarah CNN

CNN memiliki lima era perkembangan:

1. Asal-usul: terinspirasi dari korteks visual biologis
2. Stagnansi: kesulitan training (vanishing gradient, kurangnya data)
3. Kebangkitan: AlexNet (2012) menang ImageNet Challenge
4. Kebangkitan CNN: inovasi arsitektur pesat (VGG, GoogLeNet, ResNet)
5. Akselerasi pesat: CNN menjadi algoritma deep learning paling luas digunakan

#Link to this headingCNN adalah ANN

CNN tetap merupakan ANN dengan:

• Layer: input, hidden, output
• Forward propagation: menghitung output
• Neuron dengan learnable weights dan bias
• Learning algorithm: backpropagation

Perbedaannya: CNN menggunakan operasi konvolusi (bukan perkalian matriks umum) di beberapa layer-nya, dengan local connectivity dan parameter sharing.

#Link to this headingTantangan ANN untuk Klasifikasi Gambar

ANN tradisional menghadapi dua masalah utama saat digunakan untuk klasifikasi gambar:

1. Jumlah parameter sangat besar: Setiap piksel menjadi input terpisah. Gambar 224×224×3 menghasilkan ~150.000 input, jumlah parameter explodes.
2. Kehilangan fitur spasial: Proses flattening n-dimensi ke 1-dimensi menghilangkan informasi tata letak spasial yang penting.

#Link to this headingMengapa CNN Unggul?

#Link to this heading02: Local Connectivity & Parameter Sharing

#Link to this headingDampak terhadap Akurasi (LeCun, 1989)

Eksperimen LeCun (1989) pada data tulisan tangan menunjukkan dampak signifikan dari kedua teknik ini:

Local connectivity + parameter sharing memberikan akurasi jauh lebih tinggi sekaligus jumlah parameter lebih sedikit.

#Link to this headingLocal/Sparse Connectivity

Pada ANN: setiap output unit berinteraksi dengan semua input unit, setiap pasangan input-output memiliki parameter tersendiri.

Pada CNN: setiap output unit hanya berinteraksi dengan sebagian kecil input unit melalui receptive field. Contoh: $s_3$ dengan kernel lebar 3 hanya bergantung pada $x_2, x_3, x_4$.

#Link to this headingInspirasi Biologis: Receptive Field

Hubel & Wiesel (1959) menemukan bahwa sel-sel pada korteks visual hanya sensitif terhadap area visual tertentu (receptive field), dan semua neuron ini terorganisasi dalam arsitektur kolumnar yang bersama-sama menghasilkan persepsi visual.

Untuk data berbentuk grid (gambar), setiap neuron pada CNN merespons kernel 3×3 piksel di sekitar posisinya, mengikuti prinsip receptive field ini.

#Link to this headingOperasi Konvolusi: Tanpa Parameter Sharing

Tanpa parameter sharing, setiap posisi dalam feature map memiliki kernel tersendiri. Contoh: input $5 \times 5$, kernel $3 \times 3$:

Contoh perhitungan (kernel di posisi tertentu):

$a = 252 \times 1 + 246 \times 0 + 207 \times (-1) + 242 \times 1 + 236 \times 0 + 144 \times (-1) + \ldots = 44$

Jumlah bobot (tanpa sharing):

$= N_\text{neurons} \times (F \times F \times d_\text{in} + 1)$

Untuk 9 neuron output, filter $3 \times 3 \times 1$: $9 \times (3 \times 3 \times 1 + 1) = 90$ bobot.

#Link to this headingOperasi Konvolusi: Dengan Parameter Sharing

Dengan parameter sharing, satu kernel yang sama digeser ke seluruh posisi spasial input:

Contoh perhitungan (kernel $[1, 0, -1; 1, 0, -1; 1, 0, -1]$):

$284 = 251 \times 1 + 246 \times 0 + 207 \times (-1) + 242 \times 1 + 236 \times 0 + 144 \times (-1) + 244 \times 1 + 228 \times 0 + 102 \times (-1)$

$494 = 228 \times 1 + 102 \times 0 + 43 \times (-1) + 214 \times 1 + 59 \times 0 + 52 \times (-1) + 201 \times 1 + 44 \times 0 + 54 \times (-1)$

Jumlah bobot (dengan sharing):

$= K \times (F \times F \times d_\text{in} + 1)$

Untuk 1 feature map, filter $3 \times 3 \times 1$: $1 \times (3 \times 3 \times 1 + 1) = 10$ bobot.

#Link to this headingParameter Sharing: Formula Lengkap

Di mana $F$ = ukuran filter, $d_\text{in}$ = kedalaman input, $K$ = jumlah filter/kernel.

#Link to this headingEfisiensi Komputasi

Perbandingan deteksi tepi pada gambar $320 \times 280$ dengan kernel $1 \times 2$:

Konvolusi sekitar 60.000× lebih efisien dibanding FFNN untuk task yang sama.

#Link to this headingConvolutional Layer

#Link to this headingTerminologi

Satu convolutional layer (terminologi kompleks) terdiri dari tiga tahap yang bekerja berurutan:

#Link to this headingTahap Konvolusi (Convolution Stage)

Kernel bergerak melintasi input sehingga semua area tercakup. Kernel mengekstrak fitur spasial dari input (tepi, tekstur, pola) dan hasilnya disebut feature map.

Stride dan Padding:

• Stride ($S$): jumlah piksel yang dilompati kernel setiap langkah. Stride lebih besar menghasilkan output lebih kecil.
• Padding ($P$): lapisan nol yang ditambahkan di tepi input. Padding = 1 dengan stride = 1 mempertahankan ukuran spatial output sama dengan input.

Rumus dimensi output:

$V = \left\lfloor \frac{W - F + 2P}{S} \right\rfloor + 1$

Di mana: $W$ = lebar/tinggi input, $F$ = ukuran kernel, $P$ = padding, $S$ = stride.

Contoh 1: Input $3 \times 3 \times 3$, $K=1$ filter $2 \times 2 \times 3$, $S=1$, $P=0$:

$V = \frac{3 - 2 + 0}{1} + 1 = 2 \quad \Rightarrow \text{Output: } 2 \times 2 \times 1$

Contoh 2: Input $3 \times 3 \times 2$, $K=3$ filter $2 \times 2 \times 2$, $S=1$, $P=0$:

$V = \frac{3 - 2 + 0}{1} + 1 = 2 \quad \Rightarrow \text{Output: } 2 \times 2 \times 3$

Contoh 3: Input $32 \times 32 \times 3$, $K=10$ filter $5 \times 5 \times 3$, $S=1$, $P=0$:

$V = \frac{32 - 5 + 0}{1} + 1 = 28 \quad \Rightarrow \text{Output: } 28 \times 28 \times 10$

Konvolusi multi-channel: Setiap kernel memiliki kedalaman sama dengan kedalaman input. Hasil konvolusi tiap channel dijumlahkan (bukan dipisah), lalu ditambah bias sehingga menghasilkan satu feature map per kernel.

Multi-filter: Semakin banyak convolutional layer, semakin kompleks fitur yang diekstrak, layer awal menangkap tepi/warna, sedangkan layer dalam menangkap pola/objek abstrak.

#Link to this headingTahap Detector (Detector Stage)

Menerapkan fungsi aktivasi non-linear (biasanya ReLU) pada hasil konvolusi. Tujuan: memperkenalkan non-linearitas karena konvolusi hanyalah operasi linear.

$\text{ReLU}(x) = \max(0, x)$

Di masa lalu digunakan tanh dan sigmoid, tetapi ReLU terbukti bekerja jauh lebih baik pada CNN modern.

#Link to this headingTahap Pooling (Pooling Stage)

Downsampling: mereduksi ukuran spasial feature map. Tujuan:

• Mengurangi jumlah parameter dan koneksi
• Mencegah overfitting
• Membuat representasi lebih robust terhadap pergeseran kecil

Jenis pooling: max pooling (paling umum), average pooling, L2-norm pooling.

Rumus dimensi output:

$V = \left\lfloor \frac{W - F + 2P}{S} \right\rfloor + 1$

Contoh: Max pooling $2 \times 2$, stride=2 pada feature map $4 \times 4$ menghasilkan output $2 \times 2$ (setiap region non-overlap diambil nilai maksimumnya).

#Link to this headingCNN Architecture

#Link to this headingStruktur Umum

Input → [Conv + ReLU + Pooling]× → Flatten → [FC]× → Output

Setelah serangkaian convolutional layer, feature map di-flatten menjadi vektor 1D, kemudian diproses oleh fully connected (FC) layers untuk klasifikasi.

#Link to this headingFlattening

Flattening mengubah feature map multidimensi menjadi vektor 1D agar dapat diproses oleh FC layer.

Contoh: Feature map $4 \times 4 \times 16$ diubah menjadi vektor panjang $4 \times 4 \times 16 = 256$.

#Link to this headingContoh: LeNet-5 (LeCun, 1998)

LeNet-5 adalah arsitektur CNN awal untuk pengenalan digit tulisan tangan (MNIST).

Layer C1: Convolution Stage:

• $K=6$ filter $5 \times 5$, $S=1$, $P=0$
• $V = \frac{32 - 5 + 0}{1} + 1 = 28 \Rightarrow$ feature map $28 \times 28 \times 6$
• Parameter: $6 \times (5 \times 5 + 1) = \mathbf{156}$
• Koneksi: $28 \times 28 \times (5 \times 5 + 1) \times 6 = 122.304$

Layer S2: Pooling Stage:

• Avg pool $2 \times 2$, $S=2$, $P=0$ (non-overlapping)
• $V = \frac{28 - 2 + 0}{2} + 1 = 14 \Rightarrow$ feature map $14 \times 14 \times 6$
• Parameter: $0$ (Keras) / $6 \times 2 = 12$ (metode LeCun, ada learnable scale+bias per channel)
• Koneksi: $14 \times 14 \times (2 \times 2 + 1) \times 6 = 5.880$

Layer C3: Convolution Stage:

• $K=16$ filter $5 \times 5$, $S=1$, $P=0$
• $V = \frac{14 - 5 + 0}{1} + 1 = 10 \Rightarrow$ feature map $10 \times 10 \times 16$
• Parameter (semua feature map): $16 \times (5 \times 5 \times 6 + 1) = \mathbf{2416}$
• Parameter (subset LeCun, setiap filter menerima subset 3–4 dari 6 channel): $5 \times 5 \times (6 \times 3 + 9 \times 4 + 1 \times 6) + 16 = \mathbf{1516}$

Ringkasan LeNet-5:

Implementasi (Keras):

from keras.models import Sequential
from keras import layers
 
model = Sequential()
model.add(layers.Conv2D(filters=6, kernel_size=(5,5), activation='relu', input_shape=(32,32,1)))
model.add(layers.AveragePooling2D(pool_size=(2,2)))
model.add(layers.Conv2D(filters=16, kernel_size=(5,5), activation='relu'))
model.add(layers.AveragePooling2D(pool_size=(2,2)))
model.add(layers.Flatten())
model.add(layers.Dense(units=120, activation='relu'))
model.add(layers.Dense(units=84, activation='relu'))
model.add(layers.Dense(units=10, activation='softmax'))

#Link to this headingArsitektur Umum Lainnya

Perkembangan arsitektur CNN dari 1989 hingga sekarang: LeNet, AlexNet, VGG, GoogLeNet/Inception, ResNet, dan seterusnya.

#Link to this headingVGG16 (Simonyan & Zisserman, 2015)

VGG16 menggunakan 13 conv layer berukuran $3 \times 3$ (dengan padding=same untuk mempertahankan dimensi) dan 3 FC layer. Total: 138 juta parameter.

model = Sequential()
model.add(Conv2D(input_shape=(224,224,3), filters=64, kernel_size=(3,3),
                 padding="same", activation="relu"))
model.add(Conv2D(filters=64, kernel_size=(3,3), padding="same", activation="relu"))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu"))
model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu"))
model.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
# ... (dst: 256x3, 512x3, 512x3 conv blocks + 3 FC)

#Link to this headingBackpropagation for CNN

Backpropagation CNN mengikuti prinsip yang sama dengan FFNN, tetapi menyesuaikan untuk operasi konvolusi, ReLU, dan max-pooling.

#Link to this headingGambaran Umum

Forward propagation:

$\text{net\_c} = X * K \qquad H = f_c(\text{net\_c}) \qquad \text{net} = HW \qquad O = f(\text{net}) \qquad E = \frac{1}{2} \sum_k (t_k - o_k)^2$

Update bobot kernel $K$ dan bobot FC $w$:

$K \leftarrow K - \eta \frac{\partial E^d}{\partial K} = K - \eta \left[ \frac{\partial E^d}{\partial \text{net}_j} \cdot \frac{\partial \text{net}_j}{\partial H} \cdot \frac{\partial H}{\partial \text{net\_c}} \cdot \frac{\partial \text{net\_c}}{\partial K} \right]$

$w_{ji} \leftarrow w_{ji} - \eta \frac{\partial E^d}{\partial w_{ji}} = w_{ji} - \eta \left[ \frac{\partial E^d}{\partial o_j} \cdot \frac{\partial o_j}{\partial \text{net}_j} \cdot \frac{\partial \text{net}_j}{\partial w_{ji}} \right]$

#Link to this headingBackpropagation untuk ReLU

Turunan ReLU:

$\frac{\partial \text{ReLU}(x)}{\partial x} = \begin{cases} 1 & \text{jika } x > 0 \\ 0 & \text{jika } x \leq 0 \end{cases}$

Error yang di-backprop melalui ReLU: diteruskan jika input aslinya > 0, dinolkan jika input aslinya ≤ 0.

#Link to this headingBackpropagation untuk Max-Pooling

Max-pooling meneruskan gradient hanya ke posisi yang nilai-nya diambil (nilai maksimum dalam window). Posisi lain mendapat gradient = 0.

$\frac{\partial \text{pool}(x)}{\partial x_i} = \begin{cases} 1 & \text{jika } x_i = \max(\text{window}) \\ 0 & \text{lainnya} \end{cases}$

Ini diimplementasikan dengan argmax mask yang dicatat saat forward pass dan digunakan saat backward pass.

#Link to this headingContoh: Arsitektur CNN Lengkap

Untuk arsitektur: Input $\xrightarrow{\text{conv}}$ ReLU $\xrightarrow{\text{max pool}}$ Flatten $\xrightarrow{W_2}$ ReLU $\xrightarrow{W_3}$ Softmax ke Output

Forward propagation:

$X_1 = X * W_1 + B_1 \quad \Rightarrow \quad \text{ReLU}_1 = \text{ReLU}(X_1)$ $X_2 = \text{MaxPool}(\text{ReLU}_1) \quad \Rightarrow \quad X_3 = X_{2,\text{flat}} \cdot W_2 + B_2 \quad \Rightarrow \quad \text{ReLU}_2 = \text{ReLU}(X_3)$ $X_4 = \text{ReLU}_2 \cdot W_3 + B_3 \quad \Rightarrow \quad \text{Output} = \text{Softmax}(X_4)$

Backward propagation dengan softmax + cross-entropy loss $E = -\log(p_\text{target})$:

$\frac{\partial E^d}{\partial \text{net}_j} = p_j - \mathbf{1}[j = \text{target}]$

Di mana $p_j$ adalah probabilitas output softmax untuk kelas $j$. Gradient ini kemudian di-backprop:

1. Melalui FC layer $W_3$: $\frac{\partial E}{\partial W_3}$
2. Melalui ReLU: masker berdasarkan tanda
3. Melalui FC layer $W_2$: $\frac{\partial E}{\partial W_2}$
4. Melalui flatten: reshape gradient
5. Melalui max-pooling: masker argmax
6. Melalui ReLU konvolusi: masker berdasarkan tanda
7. Ke kernel $W_1$: $\frac{\partial E}{\partial W_1}$