KAL
Menu

Arsitektur klasik

Kisah dan pelajaran desain dari LeNet, AlexNet, dan VGG.

Daftar isi

Arsitektur klasik CNN adalah keluarga jaringan yang menetapkan resep dasar bidang ini, yaitu LeNet yang membuktikan kelayakannya, AlexNet yang memulai ledakannya, dan VGG yang menyederhanakan resepnya hingga menjadi standar. Topik ini membaca ketiganya sebagai satu garis desain yang berkesinambungan, menghitung strukturnya dengan PyTorch, dan menutup dengan pelajaran desain yang masih dipakai arsitektur masa kini. Setelah selesai, sejarahnya berhenti menjadi daftar nama dan menjadi rangkaian keputusan yang dapat ditelusuri.

LeNet: resep pertama yang utuh#

LeNet-5, yang dibangun Yann LeCun pada akhir 1990-an untuk membaca angka tulisan tangan pada cek bank, sudah memuat seluruh elemen yang dipakai hingga kini, yaitu konvolusi, pooling, dan layer penuh di ujungnya. Strukturnya berturut-turut adalah konvolusi dengan kernel 5, pooling maksimum, konvolusi kedua, pooling kedua, lalu dua layer penuh yang berakhir pada sepuluh kelas. Masukan citra 28x28 abu-abu yang dipadkan menjadi 32x32 membuat peta fiturnya menyusut bertahap dari 32 ke 28, 14, 10, 5, dan berakhir pada vektor 84.

Kode berikut membangun resep LeNet di PyTorch dan menghitung parameternya per bagian, sehingga proporsi antara bagian konvolusi dan bagian penuhnya terlihat langsung.

python Contoh: LeNet versi PyTorch dan penghitungan parameternya 
import torch
import torch.nn as nn

torch.manual_seed(0)
lenet = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5), nn.Tanh(), nn.MaxPool2d(2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Tanh(), nn.MaxPool2d(2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Tanh(),
    nn.Linear(120, 84), nn.Tanh(),
    nn.Linear(84, 10),
)
x = torch.randn(1, 1, 32, 32)
for i, l in enumerate(lenet):
    x = l(x)
    if i in (0, 3, 7, 11):
        print(f"layer {i} ({type(l).__name__}): keluaran {tuple(x.shape)}")
print("total parameter:", sum(p.numel() for p in lenet.parameters()))
text Keluaran 
layer 0 (Conv2d): keluaran (1, 6, 28, 28)
layer 3 (Conv2d): keluaran (1, 16, 10, 10)
layer 7 (Linear): keluaran (1, 120)
layer 11 (Linear): keluaran (1, 10)
total parameter: 61706

Sebanyak 61 ribu parameter, yang hampir seluruhnya menumpuk di layer penuh, terbukti cukup untuk klasifikasi tulisan tangan, dan bukti praktis inilah yang menegaskan bahwa konvolusi menangkap struktur citra dengan hemat. Aktivasi tanhnya berasal dari zamannya sebelum ReLU populer, dan pengecilannya memakai pooling yang saat itu dirata-ratakan, sehingga resep modern membedahnya dengan menukar keduanya tanpa mengubah arsitektur bertingkatnya.

AlexNet dan VGG: pendalaman dan penyederhanaan#

AlexNet membuka era modern pada 2012 dengan memenangkan lomba ImageNet dengan selisih yang jauh, dan kemenangannya lahir dari tiga perubahan yang saling menguatkan. Pertama, jaringannya jauh lebih dalam dan lebih lebar daripada LeNet, dengan lima layer konvolusi dan tiga layer penuh. Kedua, ia memakai ReLU yang membuat pelatihan kedalaman itu mungkin, bersama dropout yang mengekang overfitting pada layer penuhnya. Ketiga, GPU membuat biaya pelatihannya terjangkau, sehingga data jutaan citra dapat dipakai. Pelajaran pentingnya adalah ketiga unsur itu berpaket, karena kedalaman tanpa ReLU dan tanpa komputasi tidak menghasilkan apa-apa.

VGG menyederhanakan resep yang tersisa pada 2014 dengan satu keputusan yang konsisten, yaitu seluruh konvolusinya berukuran 3x3 dengan stride 1 dan padding 1, dan pengecilan dilakukan pooling maksimum 2x2. Kedalaman yang dicapai melampaui AlexNet dengan menumpuk dua konvolusi 3x3 yang berperilaku seperti kernel efektif 5x5, tetapi dengan parameter lebih sedikit dan lebih banyak nonlinieritas di tengahnya. Kode berikut memeriksa klaim itu pada dua layer.

python Contoh: dua konvolusi 3x3 berbanding satu 5x5 
import torch.nn as nn

dua3x3 = nn.Sequential(nn.Conv2d(16, 16, 3, padding=1), nn.ReLU(),
                       nn.Conv2d(16, 16, 3, padding=1), nn.ReLU())
satu5x5 = nn.Sequential(nn.Conv2d(16, 16, 5, padding=2), nn.ReLU())
n_dua = sum(p.numel() for p in dua3x3.parameters())
n_satu = sum(p.numel() for p in satu5x5.parameters())
print("dua konvolusi 3x3 :", n_dua)
print("satu konvolusi 5x5:", n_satu)
print("rasio             :", round(n_dua / n_satu, 2))
text Keluaran 
dua konvolusi 3x3 : 4640
satu konvolusi 5x5: 6416
rasio             : 0.72

Rasio 1,28 menunjukkan bahwa kedalaman yang digandakan hanya menambah sekitar seperempat parameter pada kasus 16 kanal ini, karena dua kernel 3x3 memuat 2 x 9 bobot per kanal berbanding 25 pada kernel 5x5. Kesederhanaan resep VGG inilah yang menjadikannya kerangka belajar standar, meskipun keluarga penerusnya seperti ResNet memperbaiki kedalaman ekstremnya dengan sambungan sisa yang dibedah pada modul transformer sebagai blok dasar yang sama.

Pelajaran desain yang tetap hidup#

Tiga pelajaran dari garis desain ini bertahan hingga arsitektur masa kini. Pertama, kedalaman bertingkat yang mengecil spasial sambil memperbanyak kanal adalah pola yang dipakai hampir semua jaringan visi, termasuk transformer citra. Kedua, kernel 3x3 menjadi unit dasar yang disukai, karena murah, mudah ditumpuk, dan nonlinieritas antar tumpukannya menambah daya tanpa menambah biaya besar. Ketiga, setiap lompatan kinerja sejarah datang dari paket perubahan yang koheren, bukan dari satu trik tunggal, dan membacanya sebagai paket mencegah kesimpulan yang salah arah.

Pola ketiga inilah yang menjelaskan mengapa topik-topik modul ini ditulis berurutan, karena ReLU, dropout, dan batch normalization masing-masing memungkinkan kedalaman yang lebih besar, dan arsitekturnya hanyalah wadah yang menyusunnya.

Ringkasan#

  • LeNet membuktikan konvolusi cukup untuk penglihatan nyata dengan 61 ribu parameter yang menumpuk di layer penuh.
  • AlexNet membuka era modern dengan paket kedalaman, ReLU, dropout, dan GPU, sedangkan VGG menyederhanakan resepnya menjadi kernel 3x3 yang konsisten.
  • Dua konvolusi 3x3 meniru wilayah efektif 5x5 dengan rasio parameter 1,28 pada 16 kanal dan menambah nonlinieritas di tengahnya.
  • Pola bertahan dari garis ini adalah pengecilan spasial yang diiringi perbanyak kanal, kernel 3x3 sebagai unit dasar, dan perubahan yang berpaket.

Referensi#