Gradien

Gradien menghimpun seluruh turunan parsial suatu fungsi menjadi satu vektor yang menunjuk arah kenaikan paling curam. Topik ini membahas notasi $\nabla f$, hubungannya dengan garis kontur, besar dan arahnya, serta pengujian numerik terhadap klaim arah tersebut menggunakan NumPy. Setelah topik ini selesai, arah naik dan turun paling curam pada permukaan $f(x, y)$ dapat ditentukan hanya dari gradiennya. Sifat itu menjadikan gradien bagian inti dari machine learning, mulai dari backpropagation hingga algoritma gradient descent.

Gradien sebagai vektor turunan parsial#

Gradien (gradient) fungsi $f(x, y)$ adalah vektor yang berisi seluruh turunan parsialnya. Lambangnya adalah $\nabla f$, dibaca “nabla f”, dan untuk fungsi dua variabel isinya dua entri. Bentuk lengkapnya sebagaimana berikut.

Untuk $f(x, y) = x^2 + y^2$, turunan parsialnya adalah $2x$ dan $2y$, sehingga $\nabla f = (2x, 2y)$ dan di titik $(1, 2)$ diperoleh $\nabla f = (2, 4)$. Berbeda dengan turunan parsial yang menyatakan satu kemiringan pada satu arah sumbu, gradien memuat kemiringan setiap arah sumbu sekaligus dalam satu objek. Pada kode, gradien disimpan sebagai array NumPy dengan satu entri per variabel, dan urutan entrinya tetap konsisten sepanjang program.

Arah kenaikan paling curam#

Gradien di titik tertentu menunjuk arah kenaikan paling curam (steepest ascent) pada permukaan, dan negatifnya menunjuk arah penurunan paling curam. Besar gradien menyatakan laju kenaikan pada arah itu, sedangkan gradien pada titik datar bernilai nol karena semua arah sama landainya. Sifat geometris yang sering digunakan adalah sifat tegak lurusnya, yaitu $\nabla f$ selalu tegak lurus garis kontur yang melalui titik tersebut. Panah-panah pada gambar berikut memperlihatkan perilaku itu untuk $f(x, y) = x^2 + y^2$.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-3.5, 3.5, 200)
y = np.linspace(-3.5, 3.5, 200)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2

fig, ax = plt.subplots(figsize=(5, 4))
c = ax.contour(X, Y, Z, levels=[1, 4, 9, 16], colors="#77767b", linewidths=0.8)
ax.clabel(c, fmt="%.0f", fontsize=8)

# panah gradien (2x, 2y) pada beberapa titik, dipendekkan 5x agar terbaca
pts = np.array([
    [1.5, 0.0], [0.0, 1.5], [-1.5, 0.0], [0.0, -1.5],
    [1.0, 1.0], [-1.0, 1.0], [-1.0, -1.0], [1.0, -1.0],
])
U = 2.0 * pts[:, 0] * 0.2
V = 2.0 * pts[:, 1] * 0.2
ax.quiver(pts[:, 0], pts[:, 1], U, V, angles="xy", scale_units="xy",
          scale=1, color="#1a5fb4", width=0.008)

# panah tebal pada titik (1, 2) dengan gradien (2, 4)
ax.quiver([1.0], [2.0], [2.0 * 0.2 * 1.0], [2.0 * 0.2 * 2.0], angles="xy",
          scale_units="xy", scale=1, color="#c01c28", width=0.012)
ax.plot([1.0], [2.0], "o", color="#c01c28", markersize=5)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.set_title("Gradien tegak lurus garis kontur")
ax.set_aspect("equal")
fig.tight_layout()
fig.savefig("gradien-kontur.svg")

Setiap panah pada gambar tegak lurus lingkaran kontur yang melaluinya dan menjauhi pusat, karena nilai fungsi bertambah seiring jarak dari titik asal. Panah pada titik yang lebih jauh dari pusat lebih panjang, sejalan dengan $\nabla f = (2x, 2y)$ yang besarnya bertambah seiring jarak. Membalik arah setiap panah menghasilkan vektor negatif gradien yang menunjuk ke pusat, yaitu arah menuju nilai terendah. Algoritma gradient descent bekerja dengan mengikuti arah negatif gradien tersebut berulang kali.

Menguji arah gradien secara numerik#

Klaim arah paling curam dapat diuji langsung dengan mengevaluasi kenaikan fungsi sepanjang banyak arah dari satu titik. Caranya, hitung gradien analitik pada titik uji, lalu bandingkan dengan kenaikan $f$ setelah melangkah sedikit ke setiap arah satuan. Arah yang menghasilkan kenaikan terbesar seharusnya sejajar dengan gradien, sedangkan arah penurunan terbesar seharusnya sejajar dengan negatif gradien. Berkas berikut menjalankan uji tersebut pada titik $(1, 2)$ dengan arah yang dicoba setiap 10 derajat.

import numpy as np


def f(x, y):
    """Fungsi mangkuk f(x, y) = x^2 + y^2."""
    return x**2 + y**2


# titik uji dan gradien analitiknya
p = np.array([1.0, 2.0])
grad = np.array([2.0 * p[0], 2.0 * p[1]])
sudut_grad = np.rad2deg(np.arctan2(grad[1], grad[0]))
print(f"titik uji : ({p[0]}, {p[1]})")
print(f"gradien   : {grad} dengan arah {sudut_grad:.0f} derajat")

# kenaikan f setelah melangkah 0.01 ke setiap arah satuan (setiap 10 derajat)
langkah = 0.01
sudut = np.arange(0.0, 360.0, 10.0)
arah = np.column_stack([np.cos(np.deg2rad(sudut)), np.sin(np.deg2rad(sudut))])
kenaikan = f(p[0] + langkah * arah[:, 0], p[1] + langkah * arah[:, 1]) - f(p[0], p[1])
i_maks = int(np.argmax(kenaikan))
i_min = int(np.argmin(kenaikan))
print(f"kenaikan terbesar  : arah {sudut[i_maks]:.0f} derajat, kenaikan {kenaikan[i_maks]:.6f}")
print(f"penurunan terbesar : arah {sudut[i_min]:.0f} derajat, kenaikan {kenaikan[i_min]:.6f}")

titik uji : (1.0, 2.0)
gradien   : [2. 4.] dengan arah 63 derajat
kenaikan terbesar  : arah 60 derajat, kenaikan 0.044741
penurunan terbesar : arah 240 derajat, kenaikan -0.044541

Gradien analitik di titik uji adalah $(2, 4)$ dengan arah sekitar 63 derajat dari sumbu $x$. Di antara arah yang diuji, kenaikan terbesar terjadi pada 60 derajat, yaitu arah sampel yang paling dekat dengan gradien, dan penurunan terbesar pada 240 derajat yang persis berlawanan. Selisih tiga derajat muncul karena arah hanya dicoba setiap 10 derajat, sehingga pemenangnya adalah arah sampel terdekat dengan gradien. Semakin rapat arah diuji, semakin dekat pemenangnya dengan arah gradien.

Hubungan itu dirumuskan oleh turunan berarah (directional derivative), yaitu laju kenaikan per satuan jarak sepanjang arah satuan $u$, yang sama dengan proyeksi gradien pada $u$,

dengan $\theta$ menyatakan sudut antara $u$ dan $\nabla f$. Nilai tersebut maksimum ketika $u$ sejajar dengan gradien karena kosinusnya mencapai 1, dan bernilai nol ketika keduanya saling tegak lurus. Rumus ini sekaligus menjelaskan hasil uji numerik di atas, karena arah 60 derajat adalah yang kosinusnya paling besar di antara arah sampel.

Besar gradien dan laju kenaikan#

Besar gradien dihitung dengan norma vektor, yaitu akar kuadrat jumlah kuadrat komponennya. Pada titik $(1, 2)$, besar gradiennya adalah $\lVert \nabla f \rVert = \sqrt{2^2 + 4^2} = \sqrt{20} \approx 4{,}47$, dan angka itu adalah laju kenaikan paling curam di titik tersebut. Arah lain memberi laju lebih kecil sebesar $\lVert \nabla f \rVert \cos\theta$, sehingga laju pada arah melintang 90 derajat bernilai nol. Konsisten dengan itu, arah melintang selalu sejajar dengan garis kontur, dan bergerak sepanjang kontur memang tidak mengubah nilai fungsi. Dekat titik datar, gradien mendekati vektor nol, dan kondisi $\nabla f = \mathbf{0}$ inilah yang dicari ketika berhenti di titik terendah.

Di mana hal ini ditemui dalam kode#

Gradien fungsi loss terhadap seluruh bobot adalah nilai yang dihitung pada setiap langkah pelatihan neural network. Backpropagation menghasilkan vektor gradien itu secara efisien, dan setiap entrinya menyatakan kontribusi satu bobot terhadap loss. Arah kenaikan paling curam pada permukaan loss tidak berguna untuk pelatihan, sedangkan arah penurunannya yang diikuti, sehingga pembaruan bobot selalu berupa pengurangan kelipatan gradien. Rumus pembaruan inilah inti dari algoritma gradient descent.

Sifat tegak lurus kontur juga digunakan ketika membaca peta loss dua bobot, karena lintasan pelatihan pada kasus paling sederhana menyilang garis kontur secara tegak lurus. Pemilihan arah berbasis proyeksi gradien juga mendasari varian gradient descent dengan momentum, yaitu campuran arah langkah saat ini dan langkah sebelumnya. Gradien bahkan muncul di luar pelatihan, misalnya pada penjelasan model, karena sensitivitas keluaran terhadap setiap masukan dinyatakan sebagai komponen gradien.

Ringkasan#

• Gradien $\nabla f$ menghimpun turunan parsial menjadi satu vektor, dan setiap komponennya adalah kemiringan pada satu arah sumbu.
• Gradien menunjuk arah kenaikan paling curam, selalu tegak lurus garis kontur, dan negatifnya menunjuk arah penurunan paling curam.
• Besar gradien adalah laju kenaikan pada arah tercuram, dihitung sebagai norma vektor komponen-komponennya, dan laju arah lainnya adalah proyeksinya.
• Vektor gradien fungsi loss menjadi inti backpropagation, dan uji numerik dengan banyak arah satuan memastikan pemenang kenaikan terbesar sejajar dengan gradien.

Referensi#

• Calculus Volume 3 — OpenStax — Turunan berarah dan gradien beserta alasan gradien menunjuk arah kenaikan paling curam.
• Mathematics for Machine Learning — Cambridge University Press — Bab diferensiasi dan optimasi menghubungkan gradien dengan pelatihan berbasis turunan.
• NumPy 2.1 documentation — NumPy project — Operasi array, fungsi trigonometri, dan pengurutan indeks yang digunakan pada uji arah numerik.