Belajar Deep Learning - Optimization & Regularization

#Pendahuluan

Di episode 5 kalian sudah melatih MLP dan membaca kurva training-nya. Sekarang kita memperbaiki kualitas training itu sendiri. Dua pertanyaan yang akan dijawab: bagaimana menavigasi loss landscape dengan cepat dan stabil, serta bagaimana mencegah model menghafal — alias optimization dan regularization.

Kedua topik ini sering diremehkan oleh pemula yang langsung lompat ke arsitektur fancy, padahal di dunia kerja tuning yang benar justru yang paling sering menyelamatkan proyek. Model dengan arsitektur standar yang di-training dengan teknik yang benar hampir selalu mengalahkan arsitektur kompleks yang di-training asal-asalan.

#Optimizer

#SGD dengan Momentum

SGD dasar mudah terombang-ambing di lembah sempit. Momentum meniru bola yang menggelinding: kecepatan dari langkah sebelumnya dipertahankan, sehingga melewati osilasi kecil dan mempercepat konvergensi.

SGD dengan momentum

optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

momentum=0.9 adalah nilai paling umum. SGD+momentum butuh tuning learning rate yang teliti, tetapi sering menghasilkan generalisasi terbaik — pilihan favorit untuk model yang butuh hasil akhir maksimal.

#Adam dan AdamW

Adam menggabungkan momentum dengan per-parameter adaptive learning rate: setiap bobot punya learning rate sendiri yang mengecil saat gradiennya berosilasi. Hasilnya training yang sangat stabil tanpa banyak tuning — default yang tepat untuk hampir semua masalah.

AdamW adalah perbaikan penting: weight decay dihitung terpisah dari gradien, bukan sebagai bagian dari loss. Ini terdengar kecil, tetapi berdampak besar pada transformer dan model besar — AdamW adalah standar training LLM di 2026.

Adam dan AdamW

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-2)

#Learning Rate Scheduling

Learning rate tetap jarang optimal. Di awal training kita butuh lr besar untuk bergerak cepat; mendekati akhir butuh lr kecil agar presisi. Dua scheduler paling populer:

#Cosine Annealing

Learning rate turun mengikuti kurva cosinus dari nilai awal hingga hampir nol. Mulus, mudah dipakai, dan hampir selalu membantu:

Cosine annealing

scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
    optimizer, T_max=50, eta_min=1e-6
)

#Warmup

Di awal training, bobot masih acak sehingga gradien bisa sangat besar. Warmup menaikkan learning rate dari hampir nol ke nilai target dalam beberapa epoch pertama — mencegah training meledak. Ini penting untuk transformer dan model besar:

Linear warmup + cosine

scheduler = torch.optim.lr_scheduler.SequentialLR(
    optimizer,
    schedulers=[
        torch.optim.lr_scheduler.LinearLR(optimizer, start_factor=0.1, total_iters=5),
        torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=45),
    ],
    milestones=[5],
)

#Gradient Clipping

Saat gradien tiba-tiba menjadi sangat besar (ledakan gradien, umum pada RNN dan deep network), update bobot meleset dan loss melonjak. Clipping memotong norma gradien:

Clip gradien

torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

Panggil sebelum optimizer.step(). Jika training kalian sering meledak, gradient clipping adalah pertolongan pertama yang hampir selalu menstabilkan.

#Regularisasi

#Weight Decay

Weight decay menambahkan penalti sebanding kuadrat bobot ke update — mendorong bobot tetap kecil dan sederhana. Bobot besar cenderung overfit; bobot kecil membuat fungsi keputusan lebih halus:

Weight decay via optimizer

optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-2)

Dengan AdamW, weight decay cukup disetel di optimizer. Nilai umum 1e-4 sampai 1e-2 tergantung skala masalah.

#Early Stopping

Teknik paling sederhana dan paling sering diabaikan: berhenti saat validation loss mulai naik. Model yang dilatih terus-menerus pasti akan overfit cepat atau lambat; early stopping menghentikannya tepat di titik terbaik:

Early stopping sederhana

best_val, patience, counter = float("inf"), 5, 0
 
for epoch in range(200):
    train_one_epoch()
    val_loss = evaluate()
 
    if val_loss < best_val:
        best_val = val_loss
        counter = 0
        torch.save(model.state_dict(), "best.pt")
    else:
        counter += 1
        if counter >= patience:
            break

#Data Augmentation

Cara paling kuat untuk menekan overfit pada data gambar: ciptakan variasi yang realistis dari data yang ada. Rotasi kecil, crop, flip, dan perubahan pencahayaan membuat model belajar fitur yang invarian — bukan hafalan piksel. Torchvision sudah menyediakannya:

Augmentasi dasar

from torchvision import transforms
 
train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(10),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,)),
])
 
test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,)),
])

Perhatikan: augmentasi hanya untuk training, bukan untuk validation/test. Test harus mewakili data nyata yang polos. Episode 9 akan membedah pipeline data lebih dalam.

#Common Pitfalls

• Scheduler di-loop yang salah: scheduler harus di-step per epoch (atau per batch sesuai konfigurasi), bukan di dalam loop batch tanpa sengaja.
• Augmentasi di test set: menerapkan augmentasi saat evaluasi membuat metrik kalian tidak mewakili performa nyata.
• Weight decay ganda: memakai weight decay sekaligus di optimizer dan di loss (L2 regulasi manual) menggandakan penalti.
• Early stopping sebelum waktunya: validation loss bisa naik sementara lalu turun lagi. Kasih patience 5-10 epoch sebelum menyerah.

#Penutup

Pada episode 6 ini, kalian telah menguasai optimization dan regularization.

Inti yang harus dibawa pulang:

• SGD+momentum untuk hasil akhir presisi; Adam/AdamW untuk stabilitas default.
• Cosine annealing + warmup hampir selalu memperbaiki training; gradient clipping mencegah ledakan.
• Weight decay, early stopping, dan data augmentation adalah tiga senjata utama melawan overfit.
• Terapkan teknik berurutan dan ukur dampaknya pada validation set.
• Seed dikunci sekali; evaluasi tetap fair.

Di episode 7 selanjutnya kita akan pindah ke CNN untuk computer vision — convolution, pooling, stride/padding, arsitektur ResNet/EfficientNet/MobileNet, praktik klasifikasi CIFAR-10, dan transfer learning dengan pretrained feature extractor. Sampai jumpa di episode 7!