Memahami Konsep Optimizer dalam Deep Learning: Teori SGD, Adam, dan RMSprop dengan Implementasi PyTorch

Peran Optimizer dalam Proses Training Model Deep Learning

Setiap model deep learning yang kita latih melalui tiga tahapan utama dalam satu iterasi: forward pass untuk menghitung prediksi, loss computation untuk mengukur error, dan backward pass untuk menghitung gradient. Optimizer berada di tahap akhir setelah backward pass — komponen inilah yang bertanggung jawab memperbarui weight berdasarkan gradient yang telah dihitung. Tanpa optimizer, proses pembaruan weight tidak memiliki arah yang jelas dan model tidak akan pernah belajar menurunkan loss secara sistematis.

Mengapa kita tidak bisa memperbarui weight secara acak? Semua algoritma deep learning bergantung pada gradient descent, yaitu prinsip matematis yang menggunakan arah turunan (derivative) dari loss function terhadap setiap weight. Gradient yang mengalir mundur melalui computational graph — dari layer output hingga ke layer input — membawa informasi tentang kontribusi setiap parameter terhadap error total. Optimizer kemudian menggunakan informasi ini untuk menentukan arah dan besaran pembaruan. Gradient memberi tahu kita ke arah mana loss meningkat, sehingga kita bergerak ke arah sebaliknya. Optimizer mengontrol dua aspek fundamental: seberapa besar langkah yang kita ambil (learning rate) dan bagaimana cara menavigasi loss landscape yang kompleks.

Gambar: Visualisasi loss landscape 3D yang menunjukkan jalur gradient descent dari tiga titik awal berbeda menuju minimum lokal — Sumber: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Gradient_descent.gif)

Tanpa pemilihan optimizer yang tepat, training bisa mengalami stagnasi — loss tidak kunjung menurun, konvergensi berjalan sangat lambat, atau model justru divergen. Oleh karena itu, memahami karakteristik masing-masing optimizer menjadi keterampilan esensial bagi setiap praktisi deep learning. Kita akan membahas tiga optimizer paling populer — SGD, Adam, dan RMSprop — lengkap dengan implementasi PyTorch dan perbandingan kinerja secara langsung.

Stochastic Gradient Descent (SGD): Algoritma Paling Dasar untuk Optimasi Parameter

Stochastic Gradient Descent adalah optimizer paling fundamental yang menjadi dasar dari hampir semua algoritma optimasi modern. Prinsip kerjanya sederhana: menghitung gradient pada setiap mini-batch data, lalu memperbarui weight dengan rumus W = W - lr * grad. Tidak ada perhitungan tambahan, tidak ada memori historis — murni berdasarkan gradient batch saat ini. Ukuran mini-batch menjadi faktor penting di sini: batch yang lebih kecil memberikan estimasi gradient yang lebih noise tetapi lebih cepat diproses, sementara batch yang lebih besar memberikan gradient yang lebih stabil namun membutuhkan lebih banyak memori.

Keunggulan utama SGD terletak pada kesederhanaannya. Secara komputasi, SGD sangat ringan karena hanya perlu menyimpan dan memperbarui satu nilai gradient per parameter. Ini membuatnya cocok untuk dataset berukuran sangat besar di mana efisiensi memori menjadi prioritas. Namun, SGD memiliki keterbatasan kritis: learning rate bersifat tetap dan tidak beradaptasi selama training. Akibatnya, SGD mudah terjebak di saddle point — area di mana gradient mendekati nol namun belum mencapai minimum sejati — dan konvergensinya sering membutuhkan penjadwalan learning rate yang cermat.

Gambar: Ilustrasi metode gradient descent menunjukkan contour lines dan langkah-langkah optimasi dari titik awal menuju minimum — Sumber: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Gradient_descent.svg)

Momentum hadir sebagai solusi untuk mengatasi masalah ini. Dengan menambahkan momentum, optimizer menyimpan arah gradient dari iterasi sebelumnya dan menggunakannya sebagai dorongan tambahan. Ini membantu model melewati saddle point dan mempercepat konvergensi secara signifikan.

import torch
import torch.nn as nn
import torch.optim as optim

# Model linear sederhana
model = nn.Linear(10, 1)
criterion = nn.MSELoss()

# SGD tanpa momentum
optimizer_sgd = optim.SGD(model.parameters(), lr=0.01)

# SGD dengan momentum
optimizer_momentum = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# Data dummy
x = torch.randn(64, 10)
y = torch.randn(64, 1)

# Training loop
for epoch in range(20):
    optimizer_momentum.zero_grad()
    output = model(x)
    loss = criterion(output, y)
    loss.backward()
    optimizer_momentum.step()
    if epoch % 5 == 0:
        print(f"Epoch {epoch}: Loss = {loss.item():.6f}")

Output:

Epoch 0: Loss = 1.334810
Epoch 5: Loss = 1.035774
Epoch 10: Loss = 0.832881
Epoch 15: Loss = 0.860031

Dari kode di atas, kita bisa melihat bahwa penggunaan optim.SGD dengan parameter momentum=0.9 memungkinkan gradient dari langkah sebelumnya tetap berpengaruh pada arah pembaruan saat ini. Logika di balik ini mirip seperti bola yang menggelinding menuruni bukit — momentum membuatnya terus bergerak meskipun medan sesaat relatif datar.

Gambar: Perbandingan gradient descent tanpa momentum (kiri) yang mudah terperangkap di saddle point, dengan momentum (kanan) yang mampu melewati saddle point dan konvergen lebih cepat — Sumber: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Gradient_descent_with_momentum.svg)

Adam dan RMSprop: Optimizer Adaptif untuk Dataset dan Arsitektur Modern

Salah satu kelemahan signifikan SGD adalah penggunaan learning rate yang seragam untuk semua parameter. Dalam arsitektur deep learning modern, setiap parameter memiliki karakteristik gradient yang berbeda — beberapa membutuhkan langkah kecil karena sering berubah, sementara yang lain membutuhkan langkah lebih besar karena gradientnya jarang muncul. Di sinilah konsep adaptive learning rate menjadi relevan.

RMSprop (Root Mean Square Propagation) mengatasi masalah ini dengan menyimpan moving average dari squared gradient untuk setiap parameter. Dengan informasi ini, RMSprop menormalisasi learning rate secara individual: parameter dengan gradient besar mendapatkan langkah yang lebih kecil, sementara parameter dengan gradient kecil mendapatkan langkah yang lebih besar. Pendekatan ini sangat efektif untuk arsitektur RNN dan LSTM di mana loss landscape sering tidak stabil.

Adam (Adaptive Moment Estimation) menggabungkan keunggulan momentum dan RMSprop dalam satu algoritma. Adam melacak first moment (rata-rata gradient — mirip momentum untuk arah) dan second moment (rata-rata squared gradient — mirip RMSprop untuk skala langkah). Dua hyperparameter utama mengontrol keseimbangan ini: betas=(0.9, 0.999) — beta1 mengontrol seberapa cepat momentum memudar, sedangkan beta2 mengontrol window untuk estimasi squared gradient. Nilai default ini bekerja dengan baik pada sebagian besar kasus, tetapi pada dataset dengan gradient sparse, menurunkan beta1 dapat mempercepat adaptasi. Kombinasi ini menghasilkan optimizer yang stabil dan cepat konvergen pada berbagai arsitektur mulai dari NLP, computer vision, hingga model Transformer.

Dalam praktiknya, Adam menjadi pilihan default untuk prototyping karena konfigurasi default-nya (lr=0.001) bekerja dengan baik pada sebagian besar kasus tanpa perlu tuning ekstensif.

Perbandingan Kinerja SGD, Adam, dan RMSprop pada Model Klasifikasi dengan PyTorch

Untuk memahami perbedaan ketiga optimizer secara konkret, mari kita lakukan eksperimen komparatif menggunakan dataset sintetis dan arsitektur yang identik. Kita akan menggunakan dataset berbentuk spiral dari sklearn.datasets dan melatih fully-connected network dengan dua hidden layer.

import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np

# Dataset sintetis
X, y = make_classification(n_samples=2000, n_features=20, n_classes=3,
                           n_informative=15, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

X_train_t = torch.FloatTensor(X_train)
y_train_t = torch.LongTensor(y_train)
X_test_t = torch.FloatTensor(X_test)
y_test_t = torch.LongTensor(y_test)

# Arsitektur model — identik untuk ketiga optimizer
class Classifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(20, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 3)
        )

    def forward(self, x):
        return self.net(x)

criterion = nn.CrossEntropyLoss()
optimizers = {
    "SGD": optim.SGD,
    "Adam": optim.Adam,
    "RMSprop": optim.RMSprop
}
results = {}

for name, opt_class in optimizers.items():
    model = Classifier()
    optimizer = opt_class(model.parameters(), lr=0.001)
    losses = []

    for epoch in range(100):
        optimizer.zero_grad()
        output = model(X_train_t)
        loss = criterion(output, y_train_t)
        loss.backward()
        optimizer.step()
        losses.append(loss.item())

    results[name] = losses
    print(f"{name} — Final Loss: {losses[-1]:.4f}")

# Plot perbandingan loss curve
plt.figure(figsize=(10, 6))
for name, losses in results.items():
    plt.plot(losses, label=name)
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.legend()
plt.title("Perbandingan Loss Curve: SGD vs Adam vs RMSprop")
plt.show()

Output:

SGD — Final Loss: 1.0755
Adam — Final Loss: 0.3102
RMSprop — Final Loss: 0.1595

Kode di atas mendefinisikan satu arsitektur Classifier dengan dua hidden layer (64 dan 32 neuron) serta aktivasi ReLU. Tiga percobaan dijalankan secara independen — masing-masing menggunakan optimizer yang berbeda tetapi dengan model dan data yang persis identik. Pola yang biasanya terlihat adalah Adam mencapai loss rendah dalam beberapa epoch pertama, RMSprop mengikuti dengan stabilitas yang baik, sedangkan SGD konvergen lebih lambat namun sering mencapai generalisasi yang lebih baik pada akhir training.

Dari output di atas, RMSprop mencapai final loss terendah (0.1595), diikuti Adam (0.3102), sementara SGD tertinggal di 1.0755. Perbedaan ini wajar karena optimizer adaptif menyesuaikan langkah pembaruan per parameter sehingga konvergensi lebih cepat. Namun perlu dicatat bahwa loss rendah pada training set belum menjamin performa yang sama pada data baru — SGD yang konvergen lebih lambat sering menemukan minimum yang lebih datar yang generalisasinya lebih baik pada data uji.

Panduan Memilih Optimizer Berdasarkan Karakteristik Dataset dan Arsitektur Model

Pemilihan optimizer yang tepat bergantung pada konteks proyek. SGD dengan momentum menjadi pilihan utama untuk dataset sangat besar dan model CNN konvensional, terutama jika generalisasi menjadi prioritas. Banyak praktik industri menggunakan Adam untuk eksperimen awal, kemudian beralih ke SGD dengan learning rate scheduler untuk fine-tuning. Beberapa scheduler yang umum digunakan antara lain StepLR, CosineAnnealingLR, dan ReduceLROnPlateau.

Adam adalah standar de facto untuk NLP, Transformer, dan model dengan sparse gradient. Kemampuan adaptifnya menangani variasi skala gradient dengan baik tanpa memerlukan tuning learning rate yang rumit. Untuk model RNN, LSTM, atau reinforcement learning di mana loss landscape sangat tidak stabil, RMSprop sering memberikan hasil terbaik karena mekanisme normalisasi gradientnya.

Satu pola umum yang banyak digunakan di industri: gunakan Adam untuk eksperimen cepat dan prototyping, lalu lakukan fine-tuning dengan SGD + momentum + learning rate scheduler untuk mencapai performa puncak. Pendekatan ini menggabungkan kecepatan eksplorasi Adam dengan stabilitas generalisasi SGD.

Memilih optimizer adalah keputusan arsitektural yang sama pentingnya dengan memilih jumlah layer atau fungsi aktivasi. Di bootcamp Deep Learning Rumah Coding, kita membahas secara mendalam strategi pemilihan optimizer, arsitektur model, dan teknik training yang digunakan di industri. Setiap sesi dirancang untuk memberikan pemahaman teoritis sekaligus praktik langsung yang aplikatif.