Gradient Descent dan Cara Model Belajar Menurunkan Error

Saat model machine learning membuat prediksi yang meleset, kita membutuhkan cara untuk memperbaikinya. Gradient descent menjalankan pekerjaan itu. Ia membaca arah kenaikan error, lalu menggerakkan parameter model ke arah sebaliknya.

Bayangkan kita sedang membuat regresi linear untuk memprediksi harga rumah. Pada awal training, garis prediksinya mungkin terlalu tinggi atau terlalu rendah. Model belum tahu bobot yang tepat. Ia hanya memiliki nilai awal, sekumpulan data, dan ukuran kesalahan yang disebut loss.

Gradient descent menghubungkan ketiganya. Dari nilai loss, algoritma ini menghitung arah perubahan parameter. Setelah itu, bobot diperbarui sedikit demi sedikit sampai prediksi model menjadi lebih dekat dengan data.

Masalah yang Diselesaikan Gradient Descent

Model machine learning dapat memiliki satu parameter, ribuan parameter, bahkan miliaran parameter. Kita tidak mungkin mencoba seluruh kombinasi nilainya satu per satu. Ruang pencariannya terlalu besar.

Karena itu, kita membutuhkan fungsi loss. Fungsi ini mengubah kualitas prediksi menjadi satu angka. Nilai yang besar berarti prediksi masih jauh dari target. Nilai yang kecil menunjukkan model mulai menemukan parameter yang lebih sesuai.

Tugas gradient descent adalah mencari nilai parameter yang membuat loss semakin kecil. Prosesnya dimulai dari titik awal, lalu bergerak melalui beberapa langkah pembaruan.

Membaca Rumus Update tanpa Takut

Aturan dasar gradient descent dapat ditulis seperti berikut.

θ adalah parameter model. Pada regresi linear, parameter ini dapat berupa slope dan intercept. Pada neural network, bentuknya adalah bobot dan bias di setiap layer.

J(θ) adalah fungsi loss. Sementara itu, ∇J(θ) adalah gradient yang menunjukkan seberapa sensitif loss terhadap perubahan parameter. Terakhir, α adalah learning rate atau ukuran langkah.

Tanda minus memiliki peran penting. Gradient menunjuk ke arah kenaikan tercepat. Kita ingin menuju arah penurunan, sehingga langkahnya dibalik.

Misalnya gradient sebuah bobot bernilai positif. Jika bobot dinaikkan, loss cenderung ikut naik. Gradient descent akan mengurangi bobot tersebut. Jika gradient bernilai negatif, update bergerak ke arah sebaliknya.

Apa yang Terjadi dalam Satu Iterasi?

Satu iterasi training dapat kita baca sebagai alur kerja yang pendek.

1. Model menerima input dan menghasilkan prediksi.
2. Prediksi dibandingkan dengan target untuk menghitung loss.
3. Gradient dihitung terhadap setiap parameter.
4. Parameter diperbarui menggunakan learning rate.
5. Model membuat prediksi lagi dengan parameter yang baru.

Perubahan pada satu iterasi biasanya kecil. Namun ketika proses ini dijalankan berkali-kali, garis regresi, decision boundary, atau bobot neural network dapat bergerak menuju solusi yang lebih baik.

Batch, Stochastic, atau Mini-batch?

Ketiga versi gradient descent memakai aturan update yang sama. Perbedaannya terletak pada jumlah data yang dipakai untuk menghitung satu gradient.

Batch Gradient Descent

Batch gradient descent memakai seluruh data training sebelum melakukan satu update. Arah perubahannya cenderung stabil karena setiap langkah mempertimbangkan seluruh dataset. Biayanya adalah waktu dan memory yang lebih besar.

def batch_gradient_descent(X, y, theta, alpha, epochs):
    m = len(y)

    for _ in range(epochs):
        prediction = X @ theta
        error = prediction - y
        gradient = (X.T @ error) / m
        theta = theta - alpha * gradient

    return theta

Stochastic Gradient Descent

Stochastic Gradient Descent atau SGD memperbarui parameter setelah membaca satu sampel. Update menjadi lebih cepat dan ringan. Namun arahnya juga lebih berisik karena satu sampel belum tentu mewakili pola seluruh dataset.

def stochastic_gradient_descent(X, y, theta, alpha, epochs):
    for _ in range(epochs):
        for x_i, y_i in zip(X, y):
            error = x_i @ theta - y_i
            gradient = x_i * error
            theta = theta - alpha * gradient

    return theta

Mini-batch Gradient Descent

Mini-batch mengambil jalan tengah. Data dibagi menjadi kelompok kecil, misalnya 32 atau 64 sampel. Setiap kelompok menghasilkan satu update. Pendekatan ini cukup stabil, efisien dijalankan pada GPU, dan menjadi pilihan umum saat melatih neural network.

def mini_batch_gradient_descent(
    X, y, theta, alpha, epochs, batch_size=32
):
    m = len(y)

    for _ in range(epochs):
        indices = np.random.permutation(m)
        X_shuffled = X[indices]
        y_shuffled = y[indices]

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

            error = X_batch @ theta - y_batch
            gradient = (X_batch.T @ error) / len(y_batch)
            theta = theta - alpha * gradient

    return theta

Learning Rate Menentukan Besar Langkah

Arah yang benar belum cukup. Kita juga perlu menentukan seberapa jauh parameter bergerak pada setiap update. Inilah tugas learning rate.

Jika learning rate terlalu kecil, loss mungkin tetap turun. Namun prosesnya sangat lambat. Kita membutuhkan banyak iterasi hanya untuk menghasilkan perubahan kecil.

Jika learning rate terlalu besar, parameter dapat melewati titik minimum. Loss bergerak naik turun dan training menjadi tidak stabil. Pada kondisi yang lebih buruk, nilainya terus membesar dan model gagal konvergen.

Tidak ada satu learning rate yang selalu tepat untuk semua model. Kita perlu melihat kurva training. Loss yang turun perlahan mungkin membutuhkan langkah lebih besar. Loss yang memantul atau meningkat biasanya meminta learning rate yang lebih kecil.

Pada training modern, learning rate juga dapat berubah seiring waktu. Nilainya dibuat lebih besar pada awal training, lalu diperkecil ketika model mulai mendekati solusi. Strategi ini disebut learning rate schedule.

Mengapa Jalurnya Tidak Selalu Mulus?

Visual berbentuk mangkuk membuat gradient descent terlihat sederhana. Lanskap loss pada model nyata dapat memiliki area datar, lembah sempit, dan banyak arah yang saling berinteraksi.

Plateau

Plateau adalah area ketika permukaan loss hampir datar. Gradient menjadi sangat kecil, sehingga parameter bergerak lambat. Momentum dapat membantu dengan membawa sebagian arah update sebelumnya ke langkah berikutnya.

velocity = 0.9 * velocity - learning_rate * gradient
parameter = parameter + velocity

Skala fitur tidak seimbang

Bayangkan satu fitur berada pada rentang 0 sampai 1, sedangkan fitur lain bernilai ribuan. Gradient akan lebih dipengaruhi fitur berskala besar. Jalur optimasi menjadi zig-zag dan membutuhkan waktu lebih lama.

Standardisasi membantu menempatkan fitur pada skala yang lebih sebanding.

x_standard = (x - x.mean()) / x.std()

Local minimum dan saddle point

Pada model kompleks, kita dapat menemukan minimum lokal. Namun pada ruang berdimensi tinggi, saddle point dan area datar juga sering menjadi masalah. Momentum, inisialisasi parameter, learning rate schedule, dan optimizer seperti Adam membantu training bergerak lebih konsisten.

Menggabungkan Mini-batch, Momentum, dan Schedule

Contoh berikut menyatukan tiga keputusan praktis. Mini-batch menjaga proses tetap efisien. Momentum membantu update melewati area datar. Learning rate diperkecil secara bertahap agar langkah menjadi lebih hati-hati menjelang akhir training.

def train_with_momentum(
    X, y, theta, initial_alpha=0.01,
    beta=0.9, batch_size=32, epochs=100
):
    velocity = np.zeros_like(theta)
    m = len(y)

    for epoch in range(epochs):
        alpha = initial_alpha / (1 + epoch * 0.01)
        indices = np.random.permutation(m)
        X_shuffled = X[indices]
        y_shuffled = y[indices]

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

            error = X_batch @ theta - y_batch
            gradient = (X_batch.T @ error) / len(y_batch)

            velocity = beta * velocity - alpha * gradient
            theta = theta + velocity

    return theta

Kode tersebut bukan resep universal. Nilai learning rate, momentum, dan batch size tetap perlu disesuaikan dengan dataset serta model. Hal yang penting adalah memahami fungsi setiap bagian. Dengan begitu, kita tidak mengubah parameter secara acak ketika training bermasalah.

Kapan Training Perlu Berhenti?

Gradient descent tidak harus berjalan sampai gradient benar-benar nol. Dalam praktik, training dapat dihentikan ketika perubahan loss sudah sangat kecil, jumlah epoch tercapai, atau performa pada validation set tidak lagi membaik.

Validation loss penting karena training loss yang terus turun belum tentu berarti model semakin baik pada data baru. Jika training loss turun tetapi validation loss mulai naik, model dapat mengalami overfitting. Early stopping membantu menghentikan training sebelum kondisi tersebut menjadi lebih buruk.

Yang Perlu Kita Bawa Pulang

Gradient descent bekerja melalui keputusan yang berulang. Model membuat prediksi, menghitung loss, membaca gradient, lalu memperbarui parameter. Satu langkah terlihat kecil. Ribuan langkah dapat mengubah model yang awalnya acak menjadi model yang mampu menangkap pola.

Ketika training tidak berjalan baik, kita sekarang punya urutan pemeriksaan yang jelas. Lihat kurva loss. Periksa learning rate. Pastikan skala fitur masuk akal. Setelah itu, pertimbangkan batch size, momentum, atau optimizer lain. Pendekatan ini lebih berguna daripada sekadar mencoba nilai secara acak.

Sumber

1. Amit Jangir, Gradient Descent Explained: A Beginner-Friendly Visual and Intuitive Approach, Medium, 7 November 2024.
2. Google Machine Learning Crash Course: Gradient Descent.