Kalkulus untuk Machine Learning

Aljabar linear memberi bentuk model, tetapi kalkulus yang mengajarkan cara model menemukan parameter terbaiknya. Hampir semua algoritme training modern — dari regresi linear hingga jaringan saraf dalam — pada intinya menghitung turunan fungsi loss terhadap setiap parameter, lalu menggeser parameter ke arah yang menurunkan loss. Tiga konsep menjadi kunci: turunan sebagai sensitivitas, vektor gradien sebagai arah perbaikan, dan aturan rantai sebagai mesin penghitung pada model berlapis. Chapter ini membahas ketiganya dengan fungsi satu variabel yang bisa diikuti dengan tangan, tanpa notation yang berat.

Turunan sebagai Sensitivitas #

Turunan f’(x) mengukur seberapa cepat nilai fungsi berubah ketika masukan x digeser sedikit. Secara geometri, turunan adalah kemiringan garis singgung pada satu titik: kemiringan positif berarti fungsi naik, kemiringan negatif berarti fungsi turun. Bagi machine learning, cara baca yang paling berguna adalah sensitivitas — jika sebuah parameter digeser sebesar 0,01, seberapa besar loss function akan berubah? Jawaban perkiraannya adalah turunan dikali besar penggeseran.

Ambil contoh konkret f(x) = x². Turunannya f’(x) = 2x, sehingga di titik x = 3 nilainya 6. Artinya, menggeser x naik sebesar 0,01 diperkirakan menaikkan f sekitar 6 × 0,01 = 0,06. File turunan-numerik.py menguji dugaan tersebut dengan angka nyata, lalu membandingkan turunan numerik terhadap rumus analitik pada beberapa titik.

python

# Turunan sebagai sensitivitas: dihitung numerik, dibandingkan rumus analitik.


def f(x):
    return x ** 2


def turunan_analitik(x):
    return 2 * x


def turunan_numerik(x, h=1e-5):
    # Selisih pusat (central difference): lebih akurat daripada selisih maju.
    return (f(x + h) - f(x - h)) / (2 * h)


# Sensitivitas: perubahan kecil pada x memicu perubahan f sekitar f'(x) * dx
x = 3.0
dx = 0.01
print(f"f({x}) = {f(x):.4f}")
print(f"f({x + dx:.2f}) = {f(x + dx):.4f}")
print(f"perubahan nyata    : {f(x + dx) - f(x):.5f}")
print(f"perkiraan f'(x)*dx : {turunan_analitik(x) * dx:.5f}")
print()

print(f"{'x':>6} {'analitik':>10} {'numerik':>12} {'selisih':>12}")
for x in [-3.0, -1.0, 0.0, 1.5, 2.0, 4.0]:
    a = turunan_analitik(x)
    n = turunan_numerik(x)
    print(f"{x:6.1f} {a:10.2f} {n:12.6f} {abs(a - n):12.2e}")

Output yang Dihasilkan:

text
f(3.0) = 9.0000
f(3.01) = 9.0601
perubahan nyata    : 0.06010
perkiraan f'(x)*dx : 0.06000

     x   analitik      numerik      selisih
  -3.0      -6.00    -6.000000     3.93e-11
  -1.0      -2.00    -2.000000     2.00e-12
   0.0       0.00     0.000000     0.00e+00
   1.5       3.00     3.000000     1.97e-11
   2.0       4.00     4.000000     2.62e-11
   4.0       8.00     8.000000     2.14e-10

Mari kita telaah baris-baris kode yang berperan penting:

Baris 3–4 dan 7–8 (f dan turunan_analitik): fungsi uji f(x) = x² dilengkapi rumus turunan eksaktnya f’(x) = 2x sebagai pembanding.
Baris 11–13 (turunan_numerik): turunan dihampiri dengan selisih pusat — fungsi diukur di x − h dan x + h, lalu kemiringannya dibagi 2h. Selisih pusat lebih akurat daripada selisih maju karena galat pembulatan di kedua sisi saling meniadakan.
Baris 17–22 (blok sensitivitas): perubahan nyata akibat dx = 0,01 adalah 0,06010, sementara perkiraan linear f’(x) · dx memberi 0,06000. Selisih keduanya kecil karena fungsi x² hampir lurus pada jarak sependek 0,01.
Baris 25–29 (tabel perbandingan): pada keenam titik uji, turunan numerik cocok dengan analitik hingga orde 10⁻¹⁰ — sisa selisihnya berasal dari pembulatan floating point, bukan dari rumusnya.

Turunan Parsial dan Vektor Gradien #

Model nyata tidak punya satu parameter saja, melainkan ribuan hingga jutaan. Untuk fungsi banyak variabel, kita menghitung turunan parsial: turunan terhadap satu variabel sementara variabel lain dianggap tetap. Pada f(x, y) = x² + 3y², turunan parsialnya adalah ∂f/∂x = 2x dan ∂f/∂y = 6y. Di titik (2, 1), hasilnya 4 dan 6, lalu kedua nilai dikumpulkan menjadi vektor gradien ∇f = (4, 6).

Vektor gradien punya sifat geometris yang luar biasa berguna: gradien menunjuk arah kenaikan fungsi yang paling tajam, sehingga arah berlawanannya adalah arah penurunan yang paling tajam. Algoritme training memakai sifat ini setiap langkah: hitung gradien loss terhadap seluruh bobot, lalu geser semua bobot sedikit ke arah negatif gradien. Pada model dengan satu juta parameter, gradien adalah vektor berdimensi satu juta — dan NumPy menghitung seluruh isinya dalam satu operasi array.

Aturan Rantai: Fondasi Backpropagation #

Model yang menarik selalu berlapis: keluaran satu tahap menjadi masukan tahap berikutnya. Fungsi semacam itu disebut fungsi komposit, h(x) = f(g(x)), dan turunannya dihitung dengan aturan rantai: h’(x) = f’(g(x)) · g’(x). Contoh kecil: dengan g(x) = x² dan f(u) = 3u + 1, kompositnya h(x) = 3x² + 1, dan aturan rantai memberi h’(x) = 3 · 2x = 6x — persis sama dengan turunan langsung dari 3x² + 1.

Jaringan saraf adalah rangkaian komposit yang panjang: masukan melewati layer demi layer fungsi aktivasi dan perkalian matriks hingga menghasilkan loss. Backpropagation pada dasarnya adalah aturan rantai yang dijalankan sistematis dari loss mundur ke setiap bobot di setiap layer. Tanpa aturan rantai, menghitung gradien jaringan yang dalam menjadi tidak praktis; dengan aturan rantai, komputasinya tersusun dari perkalian kecil yang berulang dan efisien.

Gradient Descent: Melangkah Melawan Gradien #

Sekarang kita rakit seluruh konsep menjadi satu algoritme. Bayangkan sebuah bola di lereng lembah yang berkabut: bola tidak melihat dasar lembah, tetapi bisa merasakan kemiringan di posisinya dan menggelinding ke arah paling menurun. Gradient descent meniru perilaku tersebut dengan aturan update x ← x − lr · f’(x): ukur kemiringan, langkahkan x sebesar lr ke arah berlawanan gradien, ulangi. Angka lr disebut learning rate dan menjadi salah satu hyperparameter paling berpengaruh di seluruh machine learning.

File gradient-descent-sederhana.py menjalankan aturan tersebut pada f(x) = x² + 3x yang minimum analitiknya ada di x = −1,5.

python

# Gradient descent paling sederhana: cari minimum f(x) = x^2 + 3x
# dengan melangkah berlawanan arah gradien.


def f(x):
    return x ** 2 + 3 * x


def grad_f(x):
    return 2 * x + 3


x = 5.0       # titik awal
lr = 0.1      # learning rate: panjang langkah tiap iterasi

print(f"{'iter':>4} {'x':>9} {'f(x)':>9} {'grad':>9}")
print(f"{0:4d} {x:9.4f} {f(x):9.4f} {grad_f(x):9.4f}")
for i in range(1, 11):
    g = grad_f(x)
    x = x - lr * g   # inti gradient descent: melangkah melawan gradien
    print(f"{i:4d} {x:9.4f} {f(x):9.4f} {grad_f(x):9.4f}")

print("\nMinimum analitik : x = -1.5000, f(x) = -2.2500")
print(f"Hasil iterasi ke-10 : x = {x:.4f}, f(x) = {f(x):.4f}")

Output yang Dihasilkan:

text
iter         x      f(x)      grad
  5.0000   40.0000   13.0000
  3.7000   24.7900   10.4000
  2.6600   15.0556    8.3200
  1.8280    8.8256    6.6560
  1.1624    4.8384    5.3248
  0.6299    2.2866    4.2598
  0.2039    0.6534    3.4079
 -0.1369   -0.3918    2.7263
 -0.4095   -1.0608    2.1810
 -0.6276   -1.4889    1.7448
 -0.8021   -1.7629    1.3959

Minimum analitik : x = -1.5000, f(x) = -2.2500
Hasil iterasi ke-10 : x = -0.8021, f(x) = -1.7629

Bedah kode di atas baris demi baris:

Baris 5–6 dan 9–10 (f dan grad_f): fungsi tujuan beserta turunannya. Pada model nyata, f adalah loss function dan grad_f dihitung backpropagation, bukan ditulis tangan.
Baris 13–14 (x dan lr): titik awal x = 5,0 berada jauh di kanan minimum; learning rate 0,1 dipilih cukup kecil agar langkah stabil.
Baris 16–17: tabel dicetak mulai iterasi ke-0 agar perjalanan x, nilai f(x), dan gradien terpantau bersama.
Baris 18–21 (loop utama): baris x = x - lr * g adalah jantung algoritme. Perhatikan pola pada keluaran: gradien mengecil (13,00 → 1,40) selaras x yang mendekati −1,5, dan f(x) turun monoton dari 40,00 ke −1,7629.
Baris 23–24: setelah 10 iterasi x = −0,8021 — belum tepat di −1,5, tetapi arah dan jalurnya benar; iterasi tambahan akan terus mendekat.

Konsep kalkulus	Padanan di machine learning
Turunan f’(x)	Sensitivitas loss terhadap satu parameter
Turunan parsial	Sensitivitas loss terhadap tiap bobot secara terpisah
Vektor gradien	Arah penurunan loss tercepat di ruang parameter
Aturan rantai	Backpropagation pada model berlapis
Titik minimum	Kumpulan bobot dengan loss terkecil

Kalkulus menjawab bagaimana parameter diperbaiki, tetapi sebelum melatih model kita perlu membaca data itu sendiri: di mana pusatnya, seberapa lebar sebarannya, dan bagaimana hubungan antar kolomnya. Pertanyaan-pertanyaan itu dijawab statistika deskriptif — materi Chapter Statistika Dasar untuk Machine Learning.

Referensi Resmi #

Stochastic Gradient Descent — scikit-learn User Guide — implementasi resmi gradient descent pada scikit-learn.
Linear Models — scikit-learn User Guide — keluarga model linear yang dilatih dengan mekanisme turunan.