Belajar Deep Learning - CNN: Computer Vision (Pengenalan)

#Pendahuluan

Di episode 5 kita mengklasifikasi gambar dengan MLP yang mem-flatten seluruh gambar menjadi vektor. Hasilnya sekitar 90% untuk Fashion-MNIST — lumayan, tapi jelas belum optimal, dan untuk gambar berwarna kompleks MLP akan jeblok. Inilah alasan lahirnya CNN (Convolutional Neural Network): arsitektur yang menghormati struktur spasial gambar.

CNN bukan sekadar "lebih baik untuk gambar". Ia juga menjadi fondasi visual untuk semua model modern — dari detector mobil di jalan sampai vision encoder pada model multimodal di episode 21. Pahami mekanikanya sekarang, dan separuh arsitektur yang kalian temui di industri akan terasa familier.

#Mengapa MLP Gagal di Gambar

Gambar CIFAR-10 berukuran 32x32x3 = 3072 angka. MLP memperlakukan 3072 angka itu sebagai vektor tanpa arti posisi. Dua masalah muncul:

• Jumlah parameter meledak: layer pertama 3072 × 1024 unit saja butuh ~3 juta parameter.
• Invarian hilang: kucing yang digeser 2 piksel menghasilkan input yang sama sekali berbeda — MLP harus menghafal ulang.

CNN menjawab dengan berbagi bobot (weight sharing): satu filter kecil digeser ke seluruh gambar. Lokalitas dan translasi-invariance datang gratis.

#Blok Dasar CNN

#Convolution

Filter (kernel) kecil, misalnya 3x3, digeser melintasi gambar dan menghitung dot product di setiap posisi. Hasilnya peta fitur yang menonjolkan pola tertentu — tepi, sudut, tekstur:

#Stride dan Padding

Stride mengontrol seberapa jauh filter bergeser tiap langkah. Stride 1 menghasilkan peta fitur selebar input; stride 2 mengecilkannya. Padding menambah nol di tepi gambar agar peta fitur tidak menyusut terlalu cepat dan tepi gambar tidak diabaikan.

#Pooling

Max pooling mengambil nilai maksimum di setiap blok kecil (misal 2x2), mengurangi resolusi dan membuat model lebih toleran terhadap pergeseran kecil. Pooling memberi translation invariance dan memangkas parameter.

Blok CNN standar

import torch.nn as nn
 
block = nn.Sequential(
    nn.Conv2d(3, 32, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(32, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
)

Pola klasik: conv → ReLU → pool, diulang dengan jumlah channel meningkat (32 → 64 → 128) dan resolusi menurun. Di ujung, flatten ke classifier fully-connected.

#Arsitektur Ikonik

#ResNet

ResNet (2015) menjawab masalah jaringan yang justru makin buruk saat makin dalam: gradien hilang. Solusinya residual connection — blok mempelajari selisih (residual), bukan peta penuh:

y = x + f(x)   # f = dua lapis conv

Karena output minimal x, gradien selalu punya jalur lurus mundur. Ini memungkinkan jaringan ratusan layer. Ide yang sama mendasari transformer dan hampir semua arsitektur modern.

#EfficientNet dan MobileNet

• EfficientNet menyeimbangkan depth, width, dan resolution dengan scaling compound — akurasi terbaik per FLOP di masanya.
• MobileNet memakai depthwise separable convolution untuk memangkas biaya komputasi — target utama: perangkat mobile dan edge.

#Praktik: Klasifikasi CIFAR-10

CIFAR-10: 60.000 gambar berwarna 32x32 dari 10 kelas (pesawat, mobil, burung, ...). Mari bangun CNN sederhana:

CNN untuk CIFAR-10

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1), nn.ReLU(),
            nn.Conv2d(32, 32, 3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(),
            nn.Conv2d(64, 64, 3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 8 * 8, 128), nn.ReLU(),
            nn.Linear(128, 10),
        )
 
    def forward(self, x):
        return self.classifier(self.features(x))

Alur: 32x32x3 → conv (32 ch) → pool (16x16) → conv (64 ch) → pool (8x8) → flatten → 128 → 10. Karena hanya 64 channel terakhir dan resolusi 8x8, flatten menghasilkan 64×8×8 = 4096 — jauh lebih masuk akal daripada MLP murni.

Latih dengan AdamW, cosine schedule, dan augmentasi dari episode 6. Target yang bisa dicapai CNN kecil ini di CIFAR-10: ~70-75% accuracy (vs ~45-50% MLP murni). Lompatan itu persis kontribusi convolution.

#Transfer Learning Sebagai Jalan Pintas

Melatih CNN dari nol di CIFAR-10 butuh cukup lama. Di dunia nyata, kita hampir selalu memakai pretrained — arsitektur yang sudah dilatih di ImageNet (14 juta gambar). Keluarkan fitur tanpa training, atau fine-tune beberapa layer terakhir:

Feature extractor pretrained

import torchvision.models as models
 
backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
backbone.fc = nn.Linear(512, 10)   # ganti classifier

Cara ini biasanya langsung memberikan akurasi 85-90% di CIFAR-10 tanpa training lama. Detail lengkap strategi ini — kapan fine-tune vs freeze — kita bahas khusus di episode 8.

#Common Pitfalls

• Salah dimensi: Conv2d(3, 32, 3) tanpa padding di gambar kecil cepat kehabisan resolusi. Hitung dimensi sebelum menulis arsitektur.
• Lupa channel terakhir: nn.Linear(512, 10) cocok dengan ResNet18, tapi arsitektur lain beda output channel — cek backbone dulu.
• Klasifikasi pada fitur yang belum di-flatten: fitur CNN adalah tensor 4D (batch, ch, h, w); flatten sebelum masuk nn.Linear.
• Coba CNN pada gambar besar tanpa pooling yang cukup: memory dan waktu training membengkak cepat.

#Penutup

Pada episode 7 ini, kalian telah membangun fondasi computer vision.

Inti yang harus dibawa pulang:

• MLP gagal di gambar karena parameter meledak dan tidak ada translasi-invariance.
• CNN = conv (weight sharing) + ReLU + pool; stride & padding mengontrol resolusi peta fitur.
• ResNet memperkenalkan residual connection; EfficientNet/MobileNet menyeimbangkan akurasi vs biaya.
• CNN kecil di CIFAR-10 mencapai ~70-75%; pretrained jauh lebih unggul.
• Transfer learning hampir selalu lebih baik daripada training dari nol.

Di episode 8 selanjutnya kita akan fokus penuh pada transfer learning & pretrained models — perbedaan fine-tuning vs feature extraction, kapan memakai pretrained, dan pipeline lengkap dengan torchvision dan Hugging Face. Sampai jumpa di episode 8!