Penyegaran turunan

Topik ini menyegarkan konsep turunan (derivative), gradien (gradient), dan aturan rantai (chain rule), yaitu tiga perangkat matematika yang digunakan berulang kali selama pelatihan jaringan saraf. Pembahasan bergerak dari turunan satu variabel, gradien banyak variabel, aturan rantai, hingga alasan pelatihan membutuhkan gradien. Di akhir topik, dua perhitungan analitik sederhana diverifikasi menggunakan autograd untuk menunjukkan bahwa mesin diferensiasi otomatis PyTorch menghasilkan nilai yang sama.

Turunan mengukur kepekaan terhadap perubahan#

Turunan sebuah fungsi menyatakan seberapa cepat nilai fungsi berubah ketika masukannya diubah sedikit. Untuk fungsi $f(x) = x^2$, turunannya terhadap $x$ adalah:

Pada $x = 3$, nilai turunannya adalah 6. Artinya, apabila $x$ dinaikkan sebesar $0{,}1$, nilai $f$ naik sekitar $2 \times 3 \times 0{,}1 = 0{,}6$. Kata “sekitar” penting karena turunan adalah laju perubahan lokal, yaitu perkiraan yang paling tepat untuk perubahan masukan yang sangat kecil. Secara geometris, turunan adalah kemiringan garis singgung kurva pada titik tersebut.

Tanda turunan membawa informasi arah. Apabila turunannya positif, nilai fungsi naik ketika masukan dinaikkan. Apabila turunannya negatif, nilai fungsi justru turun ketika masukan dinaikkan. Titik dengan turunan nol disebut titik stasioner, yaitu titik tempat fungsi berhenti naik maupun turun secara lokal. Ketiga perilaku inilah yang kelak menentukan arah pembaruan parameter pada pelatihan.

Dari turunan ke gradien#

Banyak fungsi penting dalam pembelajaran mesin memiliki lebih dari satu masukan. Untuk fungsi dua variabel seperti $f(x, y)$, turunan parsial (partial derivative) $\frac{\partial f}{\partial x}$ mengukur kepekaan $f$ terhadap $x$ saja, dengan variabel lain dianggap tetap. Kumpulan turunan parsial untuk seluruh variabel disusun menjadi sebuah vektor yang disebut gradien, dilambangkan dengan $\nabla f$:

Untuk $f(x, y) = x^2 + 3y$, gradiennya adalah $(2x, 3)$, sehingga di titik $(2, 5)$ nilainya $(4, 3)$. Gradien menunjuk ke arah kenaikan fungsi yang paling tajam, sedangkan arah berlawanannya, yaitu $-\nabla f$, menunjuk ke arah penurunan yang paling tajam. Panjang vektor gradien menyatakan seberapa tajam kemiringan itu. Sifat arah inilah yang menjadikan gradien petunjuk alami untuk mencari titik minimum sebuah fungsi.

Aturan rantai#

Fungsi yang diminimalkan saat pelatihan jaringan saraf, yaitu fungsi loss (loss function) yang mengukur seberapa jauh prediksi model meleset dari target, adalah fungsi bersusun, yakni keluaran satu fungsi menjadi masukan fungsi berikutnya. Turunan fungsi bersusun dihitung dengan aturan rantai. Untuk $f(x) = (2x + 1)^2$, tuliskan $u = 2x + 1$ sehingga $f = u^2$. Aturan rantai menyatakan:

Dengan $\frac{df}{du} = 2u$ dan $\frac{du}{dx} = 2$, diperoleh $\frac{df}{dx} = 4u$. Pada $x = 1$ berlaku $u = 3$, sehingga $\frac{df}{dx} = 12$. Hasil ini cocok dengan penghitungan langsung terhadap bentuk aslinya.

Aturan tersebut terasa ringan untuk dua layer, tetapi jaringan saraf terdiri atas belasan hingga ratusan layer. Menghitung turunan loss terhadap setiap bobot secara manual berarti mengerjakan ribuan kali perkalian aturan rantai, lengkap dengan risiko salah salin. Perhitungan berantai seperti inilah yang diotomatisasi oleh autograd, sebagaimana diverifikasi pada bagian penutup topik ini.

Mengapa pelatihan membutuhkan gradien#

Pelatihan jaringan saraf pada dasarnya adalah pencarian nilai parameter yang membuat loss serendah mungkin. Karena loss adalah fungsi dari parameter, persoalannya berubah menjadi pencarian titik terendah pada sebuah permukaan yang dimensinya sebanyak jumlah parameter, dan jumlah itu dapat mencapai jutaan.

Gradien memberikan petunjuk arah di setiap titik pencarian. Nilai $\frac{\partial L}{\partial w}$ menyatakan kepekaan loss terhadap satu bobot $w$, sehingga bobot dapat diperbarui dengan bergerak ke arah yang menurunkan loss:

Nilai $\eta$ disebut learning rate, yakni ukuran langkah yang ditempuh pada setiap pembaruan. Tanda minus pada rumus itu bukan pilihan gaya, melainkan konsekuensi langsung dari fakta bahwa gradien menunjuk ke arah kenaikan. Prosedur berulang seperti ini disebut penurunan gradien (gradient descent). Tanpa gradien, pencarian parameter harus dilakukan dengan mencoba nilai secara acak, dan cara itu tidak praktis untuk jutaan parameter.

Memverifikasi perhitungan dengan autograd#

Autograd adalah mesin diferensiasi otomatis (automatic differentiation) milik PyTorch. Ia menghitung turunan secara tepat dengan menerapkan aturan rantai pada setiap operasi yang direkam, bukan dengan mengira-ngira angka dari selisih kecil. Program berikut menghitung turunan $f(x) = 3x^2 + 2x$ di titik $x = 1$ dengan dua cara, yaitu rumus analitik $f'(x) = 6x + 2$ dan autograd:

import torch

x = torch.tensor(1.0, requires_grad=True)

# fungsi: f(x) = 3x^2 + 2x, turunan analitiknya f'(x) = 6x + 2
f = 3 * x**2 + 2 * x
turunan_analitik = 6 * x.item() + 2

f.backward()

print("f(1.0)           =", f.item())
print("turunan analitik =", turunan_analitik)
print("gradien autograd =", x.grad.item())

f(1.0)           = 5.0
turunan analitik = 8.0
gradien autograd = 8.0

Argumen requires_grad=True menandai x agar dilacak, sedangkan pemanggilan backward() memicu perhitungan dan mengisi atribut grad. Nilai yang dihasilkan autograd sama persis dengan rumus analitik. Contoh kedua menunjukkan bahwa gradien untuk semua variabel diperoleh sekaligus dalam satu pemanggilan:

import torch

x = torch.tensor(2.0, requires_grad=True)
y = torch.tensor(5.0, requires_grad=True)

f = x**2 + 3 * y        # f(x, y) = x^2 + 3y
f.backward()

print("df/dx =", x.grad.item())
print("df/dy =", y.grad.item())

df/dx = 4.0
df/dy = 3.0

Kedua nilai itu cocok dengan gradien analitik $(2x, 3)$ di titik $(2, 5)$, yaitu $(4, 3)$. Mekanisme di balik requires_grad dan backward() baru disentuh sekilas di sini, sedangkan topik requires_grad dan backward() membahas keduanya secara rinci.

Kesalahan umum#

Kesalahan pertama adalah membaca x.grad sebelum backward() dipanggil. Atribut grad berisi None sampai perhitungan dijalankan, dan pembacaan dini ini tidak memunculkan pesan error, sehingga sering baru ketahuan ketika nilai None ikut dihitung lebih lanjut. Perbaikannya sederhana, yaitu selalu memanggil backward() terlebih dahulu sebelum membaca grad.

Kesalahan kedua adalah lupa menandai tensor dengan requires_grad=True. Akibatnya, backward() melempar RuntimeError dengan pesan “element 0 of tensors does not require grad and does not have a grad_fn” karena tidak ada satu pun tensor dalam graf yang dilacak. Perbaikannya adalah mengaktifkan pelacakan pada tensor yang menjadi variabel pencarian, misalnya bobot model, sebelum operasi dijalankan.

Ringkasan#

• Turunan mengukur kepekaan lokal sebuah fungsi terhadap perubahan masukan, dan tanda turunannya menunjukkan arah naik atau turunnya fungsi.
• Gradien menghimpun seluruh turunan parsial menjadi satu vektor yang menunjuk ke arah kenaikan paling tajam, sedangkan arah negatifnya menunjukkan penurunan paling tajam.
• Pelatihan menurunkan loss dengan memperbarui parameter ke arah negatif gradien, sebesar langkah yang diatur learning rate.
• Autograd menghasilkan nilai turunan yang sama dengan perhitungan analitik, termasuk untuk semua variabel sekaligus dalam satu pemanggilan backward().

Referensi#

• PyTorch documentation — PyTorch — Rujukan API resmi PyTorch, termasuk modul torch.autograd yang mendasari contoh pada topik ini.
• Deep Learning with PyTorch: A 60 Minute Blitz — PyTorch — Seri tutorial resmi yang memperkenalkan autograd sebagai fondasi pelatihan model.