Dua kata — turunan dan integral — sering menjadi penghalang terakhir sebelum seseorang menekuni data science. Kabar baiknya: untuk bekerja sehari-hari, kita tidak perlu menuntaskan seluruh buku kalkulus; kita hanya perlu dua intuisi. Turunan adalah laju perubahan, dan integral adalah akumulasi. Istilah-istilah lain yang terdengar berat — gradien, gradient descent, hingga cara model “belajar” — seluruhnya dibangun di atas dua intuisi tersebut. Pada chapter penutup Section ini kita bangun keduanya dengan contoh angka konkret dan loop Python murni, tanpa satu pun rumus yang perlu dihafal.

Turunan: Laju Perubahan pada Satu Titik #

Kita mulai dari pertanyaan bisnis yang nyata: berapa tambahan biaya yang harus dibayar jika produksi ditambah? Sebuah pabrik minuman kemasan mencatat biaya total produksinya, dan catatan itu memperlihatkan pola yang lazim dijumpai di mana saja — tambahan biayanya makin lama makin besar.

Produksi (ribu kemasan)Biaya total (juta rupiah)Tambahan biaya
24—
39+5
416+7
525+9

Biaya total naik makin cepat karena kapasitas makin terdesak: jam lembur bertambah, pembersihan mesin makin sering. Tambahan biaya ketika produksi bertambah itulah yang oleh ekonom disebut biaya marginal — dan biaya marginal adalah turunan dari biaya total. Turunan sebuah fungsi f di titik x adalah laju perubahan nilai fungsi tepat di titik itu: seberapa cepat f berubah ketika x bergeser sedikit.

Kita bisa mendekati laju itu tanpa rumus apa pun: geser x sejauh kecil h, ukur perubahan nilai fungsi, lalu bagi oleh lebar geserannya.

text 
turunan f di x  ≈  ( f(x + h) - f(x) ) / h

Cara ini disebut beda hingga (finite difference). Kita terapkannya pada biaya produksi yang memenuhi C(q) = q^2 — biaya total dalam juta rupiah untuk memproduksi q ribu kemasan — tepat di titik q = 3, sambil mengecilkan h tahap demi tahap:

python 
def biaya_total(q):
    """Biaya total (juta rupiah) memproduksi q ribu kemasan minuman."""
    return q**2

def turunan_numerik(f, x, h):
    """Beda hingga maju: laju perubahan f di x dengan langkah kecil h."""
    return (f(x + h) - f(x)) / h

q = 3  # produksi saat ini: 3 ribu kemasan

for h in [1, 0.1, 0.01, 0.001]:
    laju = turunan_numerik(biaya_total, q, h)
    print(f"h = {h:<6} -> biaya marginal di q = 3 : {laju:.4f} juta per ribu kemasan")

Output yang Dihasilkan:

text 
h = 1      -> biaya marginal di q = 3 : 7.0000 juta per ribu kemasan
h = 0.1    -> biaya marginal di q = 3 : 6.1000 juta per ribu kemasan
h = 0.01   -> biaya marginal di q = 3 : 6.0100 juta per ribu kemasan
h = 0.001  -> biaya marginal di q = 3 : 6.0010 juta per ribu kemasan

Mari kita telaah baris-baris kode di atas:

  1. Fungsi biaya_total: fungsi kuadrat sederhana q**2. Pada kasus nyata kita menggantinya dengan fungsi biaya sesungguhnya — mekanisme turunannya tidak berubah.
  2. Fungsi turunan_numerik: menghitung selisih f(x + h) - f(x) lalu membaginya dengan h. Satu baris ini adalah seluruh “mesin turunan” kita.
  3. Loop h: mencoba langkah yang makin kecil dan mencetak laju pada tiap langkah.

Hasilnya berjalan menuju 6: turunan sesungguhnya dari q^2 adalah 2q, yang tepat bernilai 6 di q = 3, dan beda hingga mendekatinya seiring h mengecil. Perhatikan pula bahwa dengan langkah penuh h = 1 kita memperoleh 7 — persis tambahan biaya dari 3 ke 4 ribu kemasan pada tabel di awal (16 − 9 = 7). Turunan 6 adalah lajunya tepat di titik 3; tambahan untuk satu tingkat penuh sedikit lebih besar karena laju terus bertambah sepanjang jalannya.

Dari Turunan ke Gradien: Intuisi Cara Model Belajar #

Model machine learning hampir tidak pernah punya satu variabel saja; ia punya banyak bobot sekaligus — ingat vektor w pada chapter Operasi Matriks . Untuk banyak variabel, turunan digeneralisasi menjadi gradien: kumpulan turunan untuk tiap bobot yang bersama-sama menunjuk satu arah — arah perubahan bobot yang membuat error model naik paling cepat.

Melatih model memanfaatkan informasi itu dari arah sebaliknya. Karena yang kita inginkan adalah error yang makin kecil, setiap bobot digeser sedikit melawan arah gradien, error diukur ulang, geseran diulang, begitu seterusnya sampai error berhenti menurun. Prosedur berulang inilah yang bernama gradient descent — gradien karena mengikuti arah perubahan tercepat, descent karena arahnya menurun. Seberapa jauh tiap geseran diatur satu angka kecil bernama learning rate.

Bayangkan menuruni lereng berkabut: puncak dan lembah tidak terlihat, tetapi telapak kaki bisa merasakan kemiringan tanah, jadi kita melangkah ke arah yang paling menurun, merasakan kemiringan lagi, dan mengulanginya hingga berdiri di tanah datar. Analogi ini cukup untuk membayangkan cara model belajar; komputasi sesungguhnya menghitung “kemiringan” dari ribuan data lewat operasi matriks yang sudah kita kuasai, lalu memperbaiki bobot sedikit demi sedikit.

Integral: Menjumlahkan Laju Menjadi Total #

Integral adalah kebalikan arah pertanyaan turunan. Jika turunan bertanya “seberapa cepat sesuatu berubah”, integral bertanya “berapa jumlahnya bila lajunya begini terus”. Kasir Toko Kopi Kita, misalnya, melihat laju penjualan kopi susu terus meningkat sejak pintu dibuka: mulai 10 gelas per jam dan naik stabil 2 gelas setiap jam, sehingga pada jam ke-6 lajunya mencapai 22 gelas per jam.

text 
laju(t) = 10 + 2t gelas per jam, selama 6 jam pertama sejak buka

Berapa total gelas yang terjual dalam 6 jam itu? Kita tidak perlu rumus integral untuk menjawabnya. Potonglah 6 jam menjadi selang-selang sempit, anggap laju pada tiap selang tetap (diambil dari tepi kirinya), hitung gelas pada tiap potongan sebagai laju kali lebar selang, lalu jumlahkan semuanya. Semakin sempit selangnya, semakin dekat hasilnya ke total sebenarnya — cara ini disebut penjumlahan Rieman:

python 
def laju_penjualan(t):
    """Laju penjualan kopi susu (gelas per jam) pada jam ke-t."""
    return 10 + 2 * t

def total_riemann(f, awal, akhir, langkah):
    """Integral numerik: jumlahkan luas sel sempit f(t) x langkah."""
    total = 0.0
    banyak_sel = int((akhir - awal) / langkah)
    for i in range(banyak_sel):
        t = awal + i * langkah
        total += f(t) * langkah
    return total

for langkah in [1, 0.5, 0.25, 0.125]:
    total = total_riemann(laju_penjualan, 0, 6, langkah)
    print(f"langkah = {langkah:<6} -> total penjualan 6 jam : {total:.2f} gelas")

Output yang Dihasilkan:

text 
langkah = 1      -> total penjualan 6 jam : 90.00 gelas
langkah = 0.5    -> total penjualan 6 jam : 93.00 gelas
langkah = 0.25   -> total penjualan 6 jam : 94.50 gelas
langkah = 0.125  -> total penjualan 6 jam : 95.25 gelas

Mari kita telaah baris-baris kode di atas:

  1. Fungsi laju_penjualan: fungsi linear yang naik stabil — sengaja dipilih sederhana agar jawaban tepatnya bisa diperiksa dengan akal sehat.
  2. Fungsi total_riemann: banyak_sel menghitung banyaknya potongan waktu, dan loop menambahkan f(t) * langkah — laju kali lebar selang — untuk tiap potongan. Polanya persis notasi sigma dari chapter sebelumnya: menjumlahkan hasil kali berpasangan.
  3. Loop langkah: membagi dua lebar potongan waktunya di tiap putaran.

Totalnya merambat naik: 90, 93, 94.5, 95.25. Setiap kali lebar selang dibagi dua, selisihnya terhadap jawaban tepat menyusut setengah — dari 6, menjadi 3, 1.5, lalu 0.75 gelas. Jawaban tepatnya sendiri bisa dihitung dengan akal sehat: laju naik seragam dari 10 ke 22, jadi laju rata-ratanya 16 gelas per jam, dan 6 jam × 16 gelas per jam = 96 gelas. Penjumlahan Rieman mendekati angka itu karena kotak-kotak sempit makin menempel pada garis laju.

Seberapa Jauh Kalkulus yang Kita Perlukan #

Dengan dua contoh di atas, kita sudah memegang hampir seluruh kebutuhan kalkulus untuk bekerja: mengenali kapan sebuah angka adalah laju perubahan dan kapan angka itu adalah hasil akumulasi. Laju konversi iklan, laju pertumbuhan pengguna, laju kenaikan harga — semuanya turunan. Total pendapatan dari laju penjualan dan luas di bawah kurva distribusi — semuanya integral.

Rumus formalnya nyaris tidak pernah kita turunkan sendiri. Saat melatih model dengan scikit-learn, perhitungan gradien dikerjakan otomatis di balik layar; luas di bawah kurva pun tersedia sebagai fungsi library. Loop Python murni seperti di atas, pada data yang besar, biasanya digantikan operasi array NumPy yang berjalan serentak — pembahasan lengkapnya ada di chapter Dasar NumPy . Yang tetap dibutuhkan adalah intuisi: cukup untuk memahami mengapa error model “menurun”, apa arti learning rate, dan kapan sebuah metrik berbicara tentang laju atau tentang total.

Rangkuman #

  • Turunan adalah laju perubahan fungsi pada satu titik; biaya marginal adalah turunan dari biaya total.
  • Beda hingga (f(x+h) - f(x)) / h mendekati turunan saat h mengecil — tetapi jangan terlalu kecil, karena pembulatan desimal justru melencengkan hasilnya.
  • Gradien adalah arah perubahan tercepat pada banyak bobot sekaligus; gradient descent menggeser bobot melawan arah itu, sedikit demi sedikit, sampai error berhenti menurun.
  • Integral adalah akumulasi; penjumlahan Rieman mendekatinya dengan menjumlahkan laju kali lebar selang pada selang yang makin sempit.
  • Untuk kerja sehari-hari, intuisi dua arah ini sudah mencukupi — rumus formalnya ditangani oleh library.

Dengan ini perjalanan kita pada Section Dasar Matematika tuntas: aljabar untuk memanipulasi persamaan, fungsi untuk membaca hubungan antar variabel, notasi sigma untuk penjumlahan berulang, matriks beserta operasinya sebagai mesin hitung data, dan kalkulus untuk memahami cara model belajar dari kesalahan. Fondasi teori kita sudah berdiri. Selanjutnya kita menyiapkan peralatan kerjanya — mulai dari memasang Python, mengelola virtual environment, hingga berkenalan dengan Jupyter — pada Section Persiapan Lingkungan .

Referensi #

  1. Python Docs — More on Lists
  2. NumPy — The Absolute Basics for Beginners