Bagian 4: Membandingkan Hasil

Klaim “transfer learning lebih baik” baru menjadi ilmu ketika disandingkan dengan pembanding yang adil. Bagian penutup ini melatih arsitektur yang sama persis — backbone CNNBackbone plus head Linear(512, 5) — dari bobot acak pada data yang sama, kemudian menjalankan kedua strategi pada dua anggaran epoch (hemat: 10, besar: 40). Hasilnya membentuk tabel yang jujur: transfer learning unggul jauh saat anggaran ketat, sementara pelatihan penuh menyusul saat anggaran longgar.

Pembanding dari Bobot Acak #

Skrip src/dari_nol.py menyalin alur transfer.py dengan satu perbedaan mendasar — tidak ada pembekuan:

torch.manual_seed(SEED)              # init model selalu dari seed sama
backbone = CNNBackbone()
kepala_b = nn.Linear(512, 5)
model = ModelGabung(backbone, kepala_b)   # tidak ada pembekuan
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

Seluruh 7365 parameter dilatih dari nilai acak pada 30 sampel yang sama. Menjalankannya memberi angka pembanding pertama:

python3 src/dari_nol.py

Output yang Dihasilkan:

data tugas B : 30 latih + 200 uji (digit 5-9)
model        : 7365 parameter, semua dilatih dari bobot acak
pelatihan    : Adam lr=0.001, batch 15, 10 epoch
akurasi uji tugas B: 0.680

Dengan anggaran 10 epoch, model dari nol mencapai 0.680 — tertinggal 0.155 dari hasil transfer learning pada Bagian 3 (0.835). Dataset berisi 30 sampel tidak cukup untuk melatih 7365 parameter sekaligus; fitur convolution harus dibentuk dari nol bersamaan dengan head classifier.

Tabel Perbandingan Dua Anggaran #

Skrip src/bandingkan.py mengulang kedua strategi pada dua anggaran epoch lalu menyusun hasilnya:

python3 src/bandingkan.py

Output yang Dihasilkan:

perbandingan pada tugas B: 30 sampel latih, 200 sampel uji
strategi               epoch akurasi uji      param dilatih      param total
transfer (backbone beku)    10       0.835               2565             7365
dari nol                  10       0.680               7365             7365
transfer (backbone beku)    40       0.880               2565             7365
dari nol                  40       0.890               7365             7365

selisih akurasi pada 10 epoch : +0.155
selisih akurasi pada 40 epoch : -0.010
parameter dilatih transfer vs dari nol   : 2565 vs 7365 (2.9x)

Tiga pembacaan layak digarisbawahi:

1. Anggaran 10 epoch: transfer unggul 0.155 (0.835 vs 0.680) sambil melatih 2.9 kali lebih sedikit parameter. Head baru belajar cepat karena fitur masukannya sudah bermakna — inilah skenario khas transfer learning: data langka, anggaran pelatihan ketat.
2. Anggaran 40 epoch: model dari nol menyusul sampai 0.890, sedikit di atas transfer (0.880). Dengan cukup banyak pembaruan, fitur sendiri terbentuk dan keunggulan bobot awal menyempit — kejujuran yang jarang disebut: transfer learning bukan jaminan menang mutlak, melainkan lompatan awal yang besar.
3. Kolom param total sama (7365): perbandingan ini adil karena arsitektur identik; yang berbeda hanya titik awal bobot dan bagian yang dilatih.

Membaca Pola yang Lebih Umum #

Pola pada tabel ini berskala kecil namun mencerminkan temuan industri: model besar seperti ResNet yang dilatih ImageNet menghemat minggu kerja GPU ketika dipakai untuk dataset foto baru, karena fitur bawahannya (tepian, tekstur, bentuk) nyaris universal untuk domain citra natural. Sebaliknya, ketika domain target sangat berbeda dari domain pelatihan — misalnya citra medis dari model foto natural — keunggulannya menyusut dan fine-tuning sebagian (membuka beberapa layer teratas) menjadi pilihan tengah, pokok bahasan lanjutan chapter Transfer Learning untuk Gambar .

Proyek ini menutup materi dengan keterampilan yang paling sering dipakai praktisi modern: memanfaatkan bobot yang sudah terlatih, membekukan bagian yang tidak perlu belajar, dan mengukur nilainya lewat pembanding yang adil. Kemampuan tersebut menjadi bekal untuk proyek lanjutan yang menggabungkan CNN, data nyata, dan keputusan arsitektur Anda sendiri.