Aljabar linear memberi kita cara menyusun model, tetapi model yang tersusun rapi tetap tidak berguna kalau bobotnya salah. Proses training memperbaiki bobot sedikit demi sedikit, dan kalkulus-lah yang memberi tahu arah perbaikan tersebut: turunan mengukur seberapa peka loss terhadap perubahan satu parameter, gradien mengumpulkan kepekaan seluruh parameter menjadi satu vektor, dan aturan rantai merangkai kepekaan antar layer menjadi algoritma backpropagation. Pada chapter ini kita hitung semuanya secara eksplisit dengan NumPy pada model satu parameter, mulai dari turunan paling sederhana sampai satu langkah gradient descent yang benar-benar menurunkan loss.

Turunan sebagai Ukuran Kepekaan #

Turunan f'(x) menjawab satu pertanyaan praktis: jika x digeser sedikit, berapa besar perubahan f(x)? Nilai turunan yang besar berarti keluaran sangat peka terhadap masukan; turunan nol berarti masukan tidak berpengaruh sama sekali. Dalam deep learning, x tersebut adalah bobot model dan f(x) adalah nilai loss. Kepekaan inilah yang menentukan bobot mana perlu diubah besar dan bobot mana cukup digeser kecil.

Ambil contoh fungsi sederhana f(x) = x². Turunan simboliknya f'(x) = 2x diperoleh dari rumus, tetapi ada cara lain yang tidak membutuhkan rumus sama sekali: ukur perubahan fungsi pada dua titik yang berdekatan. Metode kedua disebut beda hingga (finite difference) dan menjadi alat verifikasi favorit karena bekerja pada fungsi apa pun, termasuk loss sebuah neural network.

Aturan Rantai: Fondasi Backpropagation #

Sebuah neural network adalah fungsi bersarang: output layer menjadi masukan loss, dan output layer sebelumnya menjadi masukan layer sesudahnya. Aturan rantai (chain rule) menyatakan bahwa turunan fungsi bersarang adalah hasil kali turunan tiap tahap. Diagram berikut memperlihatkan alurnya pada komposisi tiga tahap, dari bobot W hingga nilai loss:

Garis penuh menggambar forward pass: data mengalir dari kiri ke kanan sampai loss terhitung. Garis putus-putus menggambar backward pass: turunan mengalir dari kanan ke kiri, satu segmen demi satu segmen. Backpropagation hanyalah penerapan aturan rantai ini berulang kali — total kepekaan loss terhadap bobot adalah hasil kali ketiga segmen: dL/dW = dL/da × da/dz × dz/dW. Ketika nanti kita memakai PyTorch, seluruh perhitungan ini diotomatisasi oleh autograd ; memahami aturan rantai membuat kita tetap tahu apa yang sebenarnya dihitung mesin.

Gradien: Turunan untuk Banyak Parameter #

Model nyata punya jutaan parameter, bukan satu. Untuk itu kita kumpulkan turunan loss terhadap setiap parameter menjadi satu vektor bernama gradien. Elemen ke-i dari gradien adalah ∂L/∂wᵢ — kepekaan loss terhadap parameter ke-i saat parameter lain dianggap tetap. Arah gradien menunjuk ke penurunan loss paling curam, sehingga aturan pembaruan gradient descent cukup melawan arah tersebut: w ← w − lr × gradien, dengan lr (learning rate) mengatur seberapa jauh langkahnya.

Beda Hingga dalam Praktik #

Sekarang kita buktikan bahwa beda hingga sejalan dengan turunan simbolik. Berkas turunan_beda_hingga.py membandingkan keduanya pada tiga titik berbeda:

python 
"""Membandingkan turunan simbolik dan beda hingga pada f(x) = x^2."""


def f(x):
    return x**2


def turunan_simbolik(x):
    return 2 * x


def beda_hingga(func, x, h=1e-5):
    return (func(x + h) - func(x - h)) / (2 * h)


for x in (1.0, 3.0, -2.5):
    simbolik = turunan_simbolik(x)
    numerik = beda_hingga(f, x)
    print(f"x = {x:5.1f} | turunan simbolik = {simbolik:7.4f} | "
          f"beda hingga = {numerik:7.4f}")

Output yang Dihasilkan:

text 
x =   1.0 | turunan simbolik =  2.0000 | beda hingga =  2.0000
x =   3.0 | turunan simbolik =  6.0000 | beda hingga =  6.0000
x =  -2.5 | turunan simbolik = -5.0000 | beda hingga = -5.0000

Mari kita telaah kode di atas baris per baris:

  1. Baris 4-5 (def f(x)): mendefinisikan fungsi contoh f(x) = x² yang turunannya sudah kita ketahui, sehingga hasilnya bisa dibandingkan langsung.
  2. Baris 8-9 (turunan_simbolik): turunan hasil rumus, 2x, dijadikan pembanding kebenaran.
  3. Baris 12-13 (beda_hingga): mengukur kemiringan fungsi lewat dua titik x−h dan x+h, lalu membagi selisih nilai dengan lebar interval 2h. Bentuk dua sisi seperti ini lebih akurat daripada hanya memakai x dan x+h.
  4. Baris 16-20 (perulangan for): menguji tiga titik sekaligus. Keempat angka desimal pada kedua kolom cocok persis di semua titik, termasuk titik negatif.

Satu Langkah Gradient Descent Manual #

Verifikasi paling meyakinkan adalah menjalankan gradient descent sungguhan pada model kecil. Berkas gradien_loss.py memakai model prediksi = w × x dengan loss MSE, lalu menghitung gradien secara analitik dan numerik, dan menutup dengan satu langkah pembaruan bobot:

python 
"""Gradien loss MSE dan satu langkah gradient descent dihitung manual."""

import numpy as np

x = np.array([1.0, 2.0, 3.0, 4.0])
y = np.array([2.1, 3.9, 6.2, 8.1])     # pola kira-kira y = 2x

w = 0.5                                # bobot awal (tebakan sengaja salah)


def loss(w):
    prediksi = w * x
    return np.mean((prediksi - y)**2)


def gradien_analitik(w):
    return 2 * np.mean((w * x - y) * x)


def gradien_numerik(w, h=1e-5):
    return (loss(w + h) - loss(w - h)) / (2 * h)


print("w awal           :", w)
print("loss awal        :", round(loss(w), 4))
print("gradien analitik :", round(gradien_analitik(w), 4))
print("gradien numerik  :", round(gradien_numerik(w), 4))

lr = 0.1                               # learning rate
w_baru = w - lr * gradien_analitik(w)
print("w setelah update :", round(w_baru, 4))
print("loss setelahnya  :", round(loss(w_baru), 4))

Output yang Dihasilkan:

text 
w awal           : 0.5
loss awal        : 17.5675
gradien analitik : -22.95
gradien numerik  : -22.95
w setelah update : 2.795
loss setelahnya  : 4.3999

Mari kita telaah kode di atas baris per baris:

  1. Baris 5-8 (x, y, w): empat pasang data dengan pola mendekati y = 2x, dan bobot awal 0.5 yang sengaja dipilih jauh dari nilai ideal agar efek pembelajaran terlihat jelas.
  2. Baris 11-13 (loss): mean squared error — selisih prediksi dan target dikuadratkan lalu dirata-rata. Nilai awalnya 17.5675.
  3. Baris 16-17 (gradien_analitik): turunan loss terhadap w hasil penurunan rumus: 2 × mean((w·x − y) × x). Hasilnya -22.95 — tanda negatif berarti menaikkan w akan menurunkan loss.
  4. Baris 20-21 (gradien_numerik): gradien yang sama dihitung tanpa rumus, murni dari selisih nilai loss. Hasilnya identik sampai empat desimal, membuktikan rumus pada poin 3 benar.
  5. Baris 29-30 (lr, w_baru): satu langkah gradient descent w ← w − lr × gradien. Nilai lr = 0.1 menggeser bobot dari 0.5 ke 2.795.
  6. Baris 31-32 (cetak loss baru): loss turun dari 17.5675 menjadi 4.3999 hanya dalam satu langkah — bukti langsung bahwa arah gradien memang arah perbaikan.

Ulangi langkah yang sama beberapa kali dan w akan terus merapat ke 2, nilai yang paling cocok dengan data. Gradient descent pada neural network sesungguhnya melakukan hal yang persis sama, hanya dengan jutaan parameter sekaligus.

Dengan turunan, gradien, aturan rantai, dan gradient descent, kita sudah memegang mekanisme belajar sebuah model. Namun mengukur seberapa baik model setelah dilatih, serta menafsirkan keluarannya sebagai probabilitas, membutuhkan pilar matematika ketiga: probabilitas dan statistika, yang menjadi bahan chapter berikutnya.