Belajar Deep Learning - Transfer Learning & Pretrained Models

#Pendahuluan

Di akhir episode 7 kalian melihat satu baris resnet18(weights=DEFAULT) yang langsung memberi akurasi tinggi. Sekarang kita membedah apa yang sebenarnya terjadi dan bagaimana memanfaatkannya secara benar. Transfer learning adalah keterampilan paling praktis di seluruh deep learning: hampir tidak ada proyek serius di 2026 yang melatih model dari nol, kecuali data sangat khusus atau model benar-benar baru.

Inti transfer learning: fitur yang dipelajari dari satu domain (14 juta gambar ImageNet) sebagian besar berguna untuk domain lain (mobil, produk, x-ray). Tepi dan tekstur dasar bersifat universal. Kita memindahkan "bahasa visual" ini dan tinggal mengajarkan tugas spesifik kita.

#Fine-Tuning vs Feature Extraction

#Feature Extraction (Model Beku)

Bobot pretrained dikunci (freeze) — hanya classifier baru yang dilatih. Backbone berperan sebagai ekstraktor fitur yang sudah jadi:

Freeze backbone

import torchvision.models as models
import torch.nn as nn
 
backbone = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
for param in backbone.parameters():
    param.requires_grad = False
 
backbone.fc = nn.Linear(512, 10)  # hanya ini yang dilatih

Cepat, murah, butuh data sedikit. Cocok saat data kalian kecil dan domainnya tidak terlalu jauh dari ImageNet.

#Fine-Tuning (Semua Dilatih)

Semua bobot tetap bisa diperbarui, tetapi dengan learning rate lebih kecil untuk backbone. Backbone sudah punya fitur bagus; kita hanya menyetelnya sedikit agar sesuai domain:

Fine-tuning semua layer

optimizer = torch.optim.AdamW([
    {"params": backbone.parameters(), "lr": 1e-5},
    {"params": backbone.fc.parameters(), "lr": 1e-4},
])

Dua learning rate ini merefleksikan dua kepercayaan berbeda: backbone hampir selesai (lr kecil), classifier baru dimulai (lr lebih besar).

#Kapan Memakai yang Mana

Aturan jempol: mulai dengan feature extraction sebagai baseline, lalu fine-tune jika validation sudah plateau dan kalian punya data cukup.

#Mengapa Transfer Learning Bekerja

Tiga alasan fundamental:

• Fitur hierarkis universal: layer awal CNN belajar tepi & tekstur yang sama untuk semua foto. Hanya layer akhir yang spesifik tugas.
• Regularisasi implisit: memulai dari fitur yang sudah bagus mencegah model overfit data kecil — bobot tidak mulai dari acak.
• Hemat komputasi: jutaan sample ImageNet sudah "digratiskan" oleh orang lain; kita menumpang hasilnya.

#Kapan Pretrained Tidak Membantu

• Domain sangat jauh: sinyal radar, citra satelit multi-spektral, histologi medis — fitur foto biasa tidak banyak berguna. Cari pretrained domain-spesifik, atau mulai dari nol.
• Input sangat berbeda: gambar besar 512x512 vs pretrained yang dilatih di 224x224 tetap bisa dipakai (resize dulu), tetapi perhatikan penurunan kualitas.
• Tugas bukan visual: di NLP, aturannya sama — pretrained model bahasa (BERT/LLaMA) mengalahkan training dari nol, dibahas di episode 15-16.

#Pipeline Lengkap dengan Hugging Face

Untuk tugas di luar torchvision, Hugging Face menyediakan ribuan pretrained model siap pakai — dari klasifikasi gambar sampai deteksi objek:

Pipeline klasifikasi gambar HF

from transformers import pipeline
 
classifier = pipeline("image-classification", model="google/vit-base-patch16-224")
result = classifier("kucing.jpg")
print(result)

Hugging Face juga menyediakan image processor dan feature extractor yang konsisten dengan cara training model aslinya — menghilangkan banyak bug dimensi yang biasa terjadi saat memakai model external secara manual.

#Praktik: Fine-Tune ResNet di CIFAR-10

Pipeline transfer learning lengkap

import torch
import torch.nn as nn
import torchvision.models as models
 
model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
model.fc = nn.Linear(512, 10)
 
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4, weight_decay=1e-2)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=15)
loss_fn = nn.CrossEntropyLoss()
 
for epoch in range(15):
    model.train()
    for x, y in train_loader:
        optimizer.zero_grad()
        loss = loss_fn(model(x), y)
        loss.backward()
        optimizer.step()
    scheduler.step()

Dengan augmentasi ringan dan 15 epoch, ResNet18 yang di-fine-tune di CIFAR-10 mudah menembus 90-95% — dibanding ~70-75% CNN dari nol. Selisih itu adalah nilai transfer learning.

#Common Pitfalls

• Freeze yang salah: mem-freeze seluruh model termasuk classifier (yang baru) membuat tidak ada yang bisa belajar. Freeze hanya backbone.
• Normalisasi tidak sesuai: gunakan statistik yang sama dengan saat pretrained dilatih.
• Ganti ukuran input: pretrained dilatih di resolusi tertentu (224x224); resize input kalian, jangan mengubah arsitektur agar "menyesuaikan".
• BatchNorm saat freeze: jika layer BatchNorm di-freeze tapi berjalan di mode train, statistiknya berubah tiap batch. Gunakan model.eval() untuk layer frozen, atau fine-tune sebagai gantinya.

#Penutup

Pada episode 8 ini, kalian telah menguasai transfer learning.

Inti yang harus dibawa pulang:

• Feature extraction membekukan backbone; fine-tuning melatihnya dengan lr lebih kecil.
• Data kecil + domain dekat → feature extraction; data besar/domain jauh → fine-tune.
• Pretrained gagal saat domain sangat berbeda — cari model domain-spesifik.
• HF pipeline dan AutoImageProcessor menyederhanakan penggunaan pretrained.
• Normalisasi input harus persis seperti saat pretrained dilatih.

Di episode 9 selanjutnya kita akan membangun data pipeline yang benar — Dataset & DataLoader di PyTorch, batching, shuffling, prefetch, dan augmentasi dengan torchvision transforms serta Albumentations untuk robustness. Sampai jumpa di episode 9!