Panduan Lengkap Stochastic Gradient Descent (SGD) untuk Machine Learning

Gradient Descent merupakan salah satu konsep fundamental dalam machine learning, khususnya dalam melatih model. Bayangkan Anda sedang berada di puncak gunung yang berkabut tebal dan ingin turun ke lembah terendah. Karena kabut, Anda tidak bisa melihat seluruh area pegunungan sekaligus. Salah satu cara yang bisa Anda lakukan adalah dengan merasakan kemiringan tanah di sekitar Anda, lalu melangkah ke arah yang paling curam menurun. Inilah inti dari Gradient Descent: mencari arah penurunan (gradient) dari fungsi loss (yang mengukur seberapa buruk performa model) dan memperbarui parameter model ke arah tersebut. Proses ini diulangi hingga mencapai titik terendah (minimum), di mana loss model sekecil mungkin. Learning rate menentukan seberapa besar langkah yang diambil dalam setiap iterasi. Learning rate yang terlalu besar bisa membuat Anda “terlewat” lembah, sedangkan yang terlalu kecil membuat prosesnya sangat lambat. Dalam konteks optimasi machine learning, ini berarti model bisa jadi tidak mencapai performa terbaiknya atau membutuhkan waktu yang sangat lama untuk mencapai konvergensi.

Apa itu Gradient Descent?

Gradient Descent adalah algoritma optimasi yang digunakan untuk menemukan nilai minimum dari sebuah fungsi. Dalam konteks machine learning, fungsi yang ingin diminimalkan biasanya adalah fungsi loss (atau cost function), yang mengukur seberapa besar kesalahan prediksi model dibandingkan dengan data sebenarnya. Secara intuitif, Gradient Descent dapat dianalogikan seperti menuruni bukit. Tujuan kita adalah mencari titik terendah di bukit tersebut. Kita mulai dari suatu titik acak, lalu secara iteratif bergerak ke arah yang paling curam menurun hingga mencapai dasar bukit.

Baca juga: Memahami Gradient Descent: Algoritma Inti Pelatihan Model AI

Dalam algoritma ini learning rate sangat berperan penting. Learning rate SGD akan menentukan seberapa besar langkah yang kita ambil dalam setiap iterasi.

Masalah dengan Batch Gradient Descent

Batch Gradient Descent adalah varian Gradient Descent yang menghitung gradient menggunakan seluruh dataset dalam setiap iterasi. Ini memiliki beberapa kelemahan utama:

• Lambat: Untuk dataset yang sangat besar, menghitung gradient dari seluruh dataset membutuhkan waktu yang sangat lama.
• Penggunaan Memori: Menyimpan seluruh dataset dalam memori (terutama jika dataset sangat besar) bisa menjadi masalah.
• Kurang Scalable: Batch Gradient Descent tidak efisien untuk dataset berskala besar.

Pengenalan Stochastic Gradient Descent (SGD)

Stochastic Gradient Descent (SGD) adalah solusi untuk mengatasi masalah yang dihadapi Batch Gradient Descent. SGD, sesuai namanya (stochastic berarti acak), menggunakan satu sampel data yang dipilih secara acak (atau terkadang beberapa sampel, yang disebut “mini-batch”) untuk menghitung gradient dan memperbarui parameter model. Jadi, apa itu SGD? Inti dari stochastic gradient descent (SGD) adalah pendekatan yang lebih efisien dalam hal komputasi.

Alih-alih memproses seluruh dataset, SGD hanya menggunakan satu atau mini-batch gradient descent data. Hal ini membuat setiap iterasi jauh lebih cepat dan membutuhkan lebih sedikit memori.

Memahami Cara Kerja SGD

Cara kerja SGD adalah sebagai berikut:

1. Inisialisasi: Pilih nilai awal untuk parameter model (bobot dan bias).
2. Iterasi: Ulangi langkah-langkah berikut hingga konvergensi (atau hingga kriteria berhenti terpenuhi):
   • Acak: Pilih satu sampel data secara acak dari dataset (atau mini-batch, yang berisi beberapa sampel).
   • Hitung Gradient: Hitung gradient fungsi loss terhadap parameter model, menggunakan sampel (atau mini-batch) yang dipilih.
   • Update Parameter: Perbarui parameter model dengan mengurangi gradient yang telah dikalikan dengan learning rate.

Ilustrasi sederhananya, jika Batch Gradient Descent seperti menuruni bukit dengan melihat seluruh peta sekaligus, SGD seperti menuruni bukit hanya dengan melihat area kecil di sekitar kita setiap kali melangkah.

Pemilihan sampel secara acak (randomness) ini membuat SGD lebih “berisik” dibandingkan Batch Gradient Descent, tetapi juga memungkinkannya untuk escape dari local minima (titik-titik rendah yang bukan merupakan titik terendah global).

Rumus Matematika SGD

Rumus untuk update parameter (misalnya, bobot w) dalam SGD adalah:

w = w - η * ∇L(w; xᵢ, yᵢ)

di mana:

• w adalah parameter model (bobot).
• η (eta) adalah learning rate.
• ∇L(w; xᵢ, yᵢ) adalah gradient fungsi loss L terhadap w, dihitung menggunakan sampel data ke-i (dengan fitur xᵢ dan label yᵢ).

Keuntungan dan Kerugian SGD

Keuntungan SGD:

• Lebih Cepat: Karena hanya memproses satu (atau beberapa) sampel dalam setiap iterasi, SGD jauh lebih cepat daripada Batch Gradient Descent, terutama untuk dataset besar.
• Lebih Scalable: Lebih efisien dalam penggunaan memori karena tidak perlu menyimpan seluruh dataset dalam memori.
• Escape Local Minima: Fluktuasi yang dihasilkan oleh randomness dalam pemilihan sampel dapat membantu SGD keluar dari local minima.

Kerugian SGD:

• Fluktuasi Tinggi (Noisy Updates): Karena hanya menggunakan satu sampel, gradient yang dihitung bisa sangat bervariasi, menyebabkan update parameter yang “berisik” dan berfluktuasi. Visualisasi stochastic gradient descent akan menunjukan fluktuasi yang tinggi. Hal ini dapat memperlambat konvergensi. Kekurangan dan kelebihan SGD ini perlu diperhatikan dalam implementasinya.

Varian-Varian SGD

Untuk mengatasi masalah fluktuasi dan mempercepat konvergensi, beberapa varian SGD telah dikembangkan.

SGD dengan Momentum

Momentum menambahkan “kecepatan” pada update parameter. Bayangkan sebuah bola yang menggelinding menuruni bukit. Bola tersebut tidak hanya bergerak berdasarkan kemiringan saat ini, tetapi juga berdasarkan “kecepatan” yang telah dikumpulkannya dari langkah-langkah sebelumnya. SGD momentum membantu mempercepat konvergensi dan mengurangi osilasi.

Rumus matematika SGD dengan Momentum:

v = βv + η * ∇L(w; xᵢ, yᵢ)
w = w - v

di mana:

• v adalah “kecepatan” (velocity).
• β (beta) adalah parameter momentum (biasanya antara 0 dan 1), yang mengontrol seberapa besar pengaruh kecepatan sebelumnya terhadap kecepatan saat ini.

Keuntungan: Konvergensi lebih cepat, mengurangi osilasi.

Kerugian: Membutuhkan tuning parameter tambahan (β).

Adagrad (Adaptive Gradient)

Adagrad menyesuaikan learning rate untuk setiap parameter model secara individual. Parameter yang jarang diupdate akan memiliki learning rate yang lebih besar, sedangkan parameter yang sering diupdate akan memiliki learning rate yang lebih kecil. Adagrad optimizer ini sangat berguna untuk data sparse (di mana banyak fitur yang bernilai nol).

Rumus matematika Adagrad:

G = G + (∇L(w; xᵢ, yᵢ))²
w = w - (η / √(G + ε)) * ∇L(w; xᵢ, yᵢ)

di mana:

• G adalah matriks yang mengakumulasi kuadrat gradient dari waktu ke waktu.
• ε (epsilon) adalah konstanta kecil (misalnya, 1e-8) untuk mencegah pembagian dengan nol.

Keuntungan: Cocok untuk data sparse, tidak perlu tuning learning rate secara manual.

Kerugian: Learning rate dapat menjadi terlalu kecil seiring waktu (karena akumulasi kuadrat gradient), sehingga proses belajar berhenti sebelum mencapai konvergensi. Hal ini bisa menjadi indikasi mengatasi vanishing gradient problem dengan SGD.

RMSprop (Root Mean Square Propagation)

RMSprop memperbaiki masalah learning rate yang menurun drastis pada Adagrad. RMSprop optimizer menggunakan moving average dari kuadrat gradient, bukan akumulasi total.

Rumus matematika RMSprop:

G = βG + (1 - β)(∇L(w; xᵢ, yᵢ))²
w = w - (η / √(G + ε)) * ∇L(w; xᵢ, yᵢ)

di mana β adalah parameter decay rate (biasanya antara 0 dan 1).

Keuntungan: Lebih stabil daripada Adagrad.

Kerugian: Masih membutuhkan tuning parameter (β dan η).

Adam (Adaptive Moment Estimation)

Adam menggabungkan ide dari Momentum dan RMSprop. Adam optimizer ini menghitung moving average dari gradient (seperti Momentum) dan moving average dari kuadrat gradient (seperti RMSprop).

Rumus matematika Adam:

m = β₁m + (1 - β₁)∇L(w; xᵢ, yᵢ)
v = β₂v + (1 - β₂)(∇L(w; xᵢ, yᵢ))²
m_hat = m / (1 - β₁ᵗ)
v_hat = v / (1 - β₂ᵗ)
w = w - (η / √(v_hat + ε)) * m_hat

di mana:

• m adalah moving average dari gradient.
• v adalah moving average dari kuadrat gradient.
• β₁ dan β₂ adalah parameter decay rate (biasanya mendekati 1, misalnya, 0.9 dan 0.999).
• t adalah nomor iterasi.
• m_hat dan v_hat adalah koreksi bias untuk m dan v pada iterasi awal.

Keuntungan: Sering menjadi pilihan default karena performanya yang baik secara umum, menggabungkan keunggulan Momentum dan RMSprop. Jika melihat perbedaan SGD Adam RMSprop, Adam seringkali lebih unggul dalam banyak kasus.

Kerugian: Membutuhkan tuning beberapa parameter (β₁, β₂, η).

Perbandingan Varian SGD

Berikut adalah tabel perbandingan varian SGD:

Kapan Menggunakan Varian Tertentu

• SGD: Cocok untuk baseline awal atau jika Anda memiliki sumber daya komputasi yang terbatas.
• Momentum: Jika SGD mengalami osilasi atau konvergensi yang lambat.
• Adagrad: Jika data Anda sparse.
• RMSprop: Alternatif yang lebih stabil untuk Adagrad.
• Adam: Seringkali menjadi pilihan terbaik secara umum, terutama untuk deep learning. Namun, penting juga mengetahui kapan menggunakan SGD dibandingkan Adam.

Baca juga: Terobosan Terbaru Deep Learning: Algoritma hingga Aplikasi 2025

Pemilihan varian SGD yang tepat sangat bergantung pada karakteristik masalah dan data yang dihadapi. Tidak ada satu varian yang selalu terbaik untuk semua kasus. Experimentasi dan cara tuning learning rate SGD untuk deep learning adalah kunci untuk menemukan konfigurasi yang optimal.

Implementasi SGD dengan Python

Berikut adalah contoh implementasi SGD sederhana dengan Python dan NumPy:

import numpy as np

def sgd(X, y, learning_rate, epochs, batch_size):
  """
  Implementasi SGD sederhana.

  Args:
    X: Fitur (data input).
    y: Label (target).
    learning_rate: Learning rate.
    epochs: Jumlah iterasi.
    batch_size: Ukuran batch.

  Returns:
    w: Bobot yang telah dilatih.
  """
  n_samples, n_features = X.shape
  w = np.zeros(n_features)  # Inisialisasi bobot

  for epoch in range(epochs):
    # Acak indeks untuk mini-batch
    indices = np.random.permutation(n_samples)
    X_shuffled = X[indices]
    y_shuffled = y[indices]

    for i in range(0, n_samples, batch_size):
      X_batch = X_shuffled[i:i+batch_size]
      y_batch = y_shuffled[i:i+batch_size]

      # Hitung gradient
      gradient = np.dot(X_batch.T, (np.dot(X_batch, w) - y_batch)) / batch_size

      # Update bobot
      w = w - learning_rate * gradient
    print(f"epoch ke {epoch}, bobot {w}")
  return w

# Contoh penggunaan
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8]])
y = np.array([3, 6, 9, 12])
learning_rate = 0.01
epochs = 50
batch_size = 2 # contoh mini-batch gradient descent

w_trained = sgd(X, y, learning_rate, epochs, batch_size)
print("Bobot terlatih:", w_trained)

Penjelasan kode di atas adalah implementasi SGD python sederhana menggunakan NumPy. Kode tersebut mengimplementasikan mini-batch SGD. Fungsi sgd menerima data input (X), label (y), learning rate, jumlah iterasi (epochs), dan ukuran batch (batch_size). Bobot diinisialisasi dengan nol. Dalam setiap iterasi, data diacak, dan mini-batch dipilih. Gradient dihitung menggunakan mini-batch tersebut, dan bobot diperbarui.

Implementasi Varian SGD dengan TensorFlow

Berikut adalah contoh implementasi Adam dengan TensorFlow:

import tensorflow as tf

# Contoh data
X = tf.constant([[1, 2], [2, 4], [3, 6], [4, 8]], dtype=tf.float32)
y = tf.constant([3, 6, 9, 12], dtype=tf.float32)

# Inisialisasi bobot dan bias
w = tf.Variable([0.0, 0.0], dtype=tf.float32)
b = tf.Variable(0.0, dtype=tf.float32)

# Definisikan model linear
def linear_model(x):
  return tf.tensordot(x, w, axes=1) + b

# Definisikan fungsi loss (mean squared error)
def loss_fn(y_true, y_pred):
  return tf.reduce_mean(tf.square(y_true - y_pred))

# Buat optimizer Adam
optimizer = tf.keras.optimizers.Adam(learning_rate=0.1)

# Training loop
epochs = 50
for epoch in range(epochs):
  with tf.GradientTape() as tape:
    y_pred = linear_model(X)
    loss = loss_fn(y, y_pred)

  # Hitung gradient
  gradients = tape.gradient(loss, [w, b])

  # Update parameter
  optimizer.apply_gradients(zip(gradients, [w, b]))

  print(f"Epoch {epoch+1}, Loss: {loss.numpy()}, w: {w.numpy()}, b: {b.numpy()}")

print("Bobot terlatih (w):", w.numpy())
print("Bias terlatih (b):", b.numpy())
#Contoh Penggunaan SGD dalam klasifikasi gambar dengan tensorflow

Ini merupakan contoh kode implementasi Adam optimizer dengan TensorFlow. Kode tersebut mendefinisikan model linear sederhana, fungsi loss (mean squared error), dan optimizer Adam. Dalam training loop, gradient dihitung menggunakan tf.GradientTape, dan optimizer Adam memperbarui parameter model.

Baca juga: Panduan Lengkap Framework & Library Machine Learning Deep Learning

Kesimpulan

Stochastic Gradient Descent (SGD) dan varian-variannya adalah algoritma optimasi yang sangat penting dalam machine learning, terutama untuk melatih model pada dataset besar. SGD menawarkan efisiensi komputasi dan kemampuan untuk escape dari local minima dibandingkan dengan Batch Gradient Descent. Varian-varian seperti Momentum, Adagrad, RMSprop, dan Adam memperbaiki kinerja SGD dengan mengatasi masalah fluktuasi dan learning rate.

Masa Depan SGD

SGD dan varian-variannya akan terus menjadi algoritma optimasi yang penting dalam machine learning dan deep learning. Pengembangan dan penelitian terus berlanjut untuk meningkatkan efisiensi, stabilitas, dan kemampuan adaptasi SGD.

Dengan memanfaatkan kekuatan AI, Kirim.ai hadir sebagai solusi digital yang komprehensif untuk bisnis Anda. Platform SaaS berbasis AI kami menyediakan berbagai alat canggih untuk mengoptimalkan berbagai aspek bisnis, termasuk pengembangan platform, pemasaran digital, dan kreasi konten visual. Pelajari lebih lanjut tentang bagaimana Kirim.ai dapat membantu Anda mencapai tujuan bisnis.