Turunan Parsial

Turunan parsial mengukur kemiringan permukaan fungsi multivariabel sepanjang satu sumbu pada satu waktu, dengan variabel lain ditahan konstan. Topik ini membahas notasi $\partial$, aturan turunan yang tetap berlaku, interpretasi melalui potongan lintang, serta penghitungan hampiran numerik menggunakan NumPy. Setelah topik ini selesai, kemiringan $f(x, y)$ sepanjang sumbu $x$ maupun sumbu $y$ dapat diturunkan secara analitik dan diverifikasi secara numerik. Kedua keterampilan itu menjadi bahan baku gradien, yaitu vektor yang menghimpun keduanya sekaligus.

Definisi: menahan variabel lain konstan#

Turunan parsial (partial derivative) fungsi $f(x, y)$ terhadap $x$ dihitung dengan menurunkan $f$ terhadap $x$ sambil $y$ diperlakukan sebagai konstanta. Hasilnya dinotasikan $\frac{\partial f}{\partial x}$, sedangkan turunan terhadap $y$ dinotasikan $\frac{\partial f}{\partial y}$. Simbol $\partial$ menggantikan huruf $d$ sebagai penanda bahwa fungsinya memiliki lebih dari satu variabel. Secara geometris, $\frac{\partial f}{\partial x}$ pada titik $(a, b)$ adalah kemiringan permukaan sepanjang arah sumbu $x$ di titik itu.

Ambil fungsi $f(x, y) = x^2 + 3xy + y^2$ sebagai contoh. Menurunkan terhadap $x$ membuat suku $y^2$ tetap, suku $3xy$ menyisakan $3y$ karena $y$ konstan, dan suku $x^2$ menyisakan $2x$, sehingga

Pada titik $(2, 1)$, nilai keduanya adalah $\frac{\partial f}{\partial x} = 7$ dan $\frac{\partial f}{\partial y} = 8$. Kedua angka itu menggambarkan dua kemiringan berbeda pada satu titik permukaan yang sama, yaitu kemiringan ke arah $x$ dan kemiringan ke arah $y$. Jumlah turunan parsial suatu fungsi sama dengan banyaknya variabel masukannya.

Potongan lintang permukaan#

Cara termudah melihat makna $\frac{\partial f}{\partial x}$ adalah memotong permukaan dengan bidang vertikal $y = b$. Potongan itu menghasilkan kurva satu variabel $z = f(x, b)$, dan kemiringan kurva pada $x = a$ persis bernilai $\frac{\partial f}{\partial x}$ di titik $(a, b)$. Dengan kata lain, turunan parsial adalah turunan biasa pada sepotong permukaan yang dipotong sejajar satu sumbu. Gambar berikut memperlihatkan $f(x, y) = x^2 + y^2$ yang dipotong pada bidang $y = 1$, sehingga kurva potongannya menjadi $z = x^2 + 1$.

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-2.0, 2.0, 100)
z = x**2 + 1.0  # potongan lintang f(x, y) = x^2 + y^2 pada y = 1

fig, ax = plt.subplots(figsize=(6, 3))
ax.plot(x, z, color="#1a5fb4", label="z = f(x, 1) = x^2 + 1")

# garis singgung di x = 0.5 dengan kemiringan df/dx = 2x = 1
xt = 0.5
zt = xt**2 + 1.0
xg = np.linspace(xt - 1.2, xt + 1.2, 10)
ax.plot(xg, zt + 1.0 * (xg - xt), linestyle="--", color="#c01c28",
        label="garis singgung (kemiringan 1)")
ax.plot([xt], [zt], "o", color="#c01c28", markersize=6)
ax.axhline(0.0, color="#000000", linewidth=0.8)
ax.set_xlabel("x")
ax.set_ylabel("z")
ax.set_title("Potongan lintang permukaan pada y = 1")
ax.legend(loc="upper center")
fig.tight_layout()
fig.savefig("potongan-lintang.svg")

Kurva pada gambar merupakan potongan permukaan pada bidang $y = 1$. Garis singgungnya di $x = 0{,}5$ bermiringan $2 \times 0{,}5 = 1$, dan angka itu sama dengan $\frac{\partial f}{\partial x}$ pada titik $(0{,}5, 1)$. Memotong pada nilai $y$ yang lain menghasilkan kurva berbentuk sama yang hanya bergeser ketinggian, sedangkan kemiringannya tetap $2x$ karena $y$ sudah tidak muncul pada turunan terhadap $x$. Setiap sumbu memiliki kelompok potongan lintangnya sendiri, dan kelompok arah $y$ dibaca dengan $\frac{\partial f}{\partial y}$.

Hampiran numerik dengan selisih terpusat#

Turunan parsial juga dapat dihampiri dari nilai fungsi tanpa rumus turunannya, dengan mengambil dua titik di kiri dan kanan titik yang diuji. Metode selisih terpusat (central difference) menghitung

dengan $h$ berupa jarak kecil, dan rumus yang sama berlaku untuk arah $y$. Hampiran ini menjadi alat verifikasi ketika rumus turunan analitik diragukan, karena cukup menggunakan evaluasi fungsi saja. Berkas berikut membandingkan hasil analitik dengan hasil numerik pada titik $(2, 1)$ untuk beberapa ukuran $h$.

import numpy as np


def f(x, y):
    """Fungsi contoh f(x, y) = x^2 + 3xy + y^2."""
    return x**2 + 3.0 * x * y + y**2


def parsial_x(x, y, h):
    """Hampiran turunan parsial terhadap x dengan selisih terpusat."""
    return (f(x + h, y) - f(x - h, y)) / (2.0 * h)


def parsial_y(x, y, h):
    """Hampiran turunan parsial terhadap y dengan selisih terpusat."""
    return (f(x, y + h) - f(x, y - h)) / (2.0 * h)


x, y = 2.0, 1.0
print(f"analitik : df/dx = {2.0 * x + 3.0 * y:.8f}, df/dy = {3.0 * x + 2.0 * y:.8f}")
for h in (1e-2, 1e-4, 1e-6, 1e-8, 1e-10):
    print(f"h = {h:.0e} : numerik df/dx = {parsial_x(x, y, h):.8f}, df/dy = {parsial_y(x, y, h):.8f}")

analitik : df/dx = 7.00000000, df/dy = 8.00000000
h = 1e-02 : numerik df/dx = 7.00000000, df/dy = 8.00000000
h = 1e-04 : numerik df/dx = 7.00000000, df/dy = 8.00000000
h = 1e-06 : numerik df/dx = 7.00000000, df/dy = 8.00000000
h = 1e-08 : numerik df/dx = 6.99999987, df/dy = 8.00000004
h = 1e-10 : numerik df/dx = 7.00000058, df/dy = 8.00000066

Tiga ukuran $h$ pertama menghasilkan hampiran yang cocok dengan nilai analitik hingga delapan desimal. Pada $h = 10^{-8}$, angka terakhirnya mulai bergeser, dan pada $h = 10^{-10}$ penyimpangannya semakin terlihat. Penyebabnya bukan rumusnya, melainkan pembulatan floating point pada pengurangan dua nilai fungsi yang hampir sama, sehingga selisihnya kehilangan banyak angka penting. Pemilihan $h$ selalu merupakan kompromi antara error pemotongan yang mengecil bersama $h$ dan error pembulatan yang membesar bersama $h$.

Aturan turunan tetap berlaku#

Seluruh aturan diferensiasi satu variabel tetap digunakan pada turunan parsial, karena variabel lain hanya berperan sebagai konstanta. Aturan pangkat, aturan hasil kali, dan aturan rantai bekerja tanpa perubahan. Perbedaannya terletak pada pembukuan, yaitu setiap suku perlu diperiksa untuk mengetahui variabel mana yang sedang diturunkan. Tabel berikut merangkum beberapa contoh yang sering muncul.

Pada $x^2 y$, menurunkan terhadap $x$ memperlakukan $y$ sebagai konstanta, sehingga hasilnya $2xy$, sedangkan menurunkan terhadap $y$ menyisakan $x^2$. Suatu suku dapat bertahan pada satu arah dan menghilang pada arah lain, sebagaimana konstanta $5$ yang hilang pada kedua arah. Membiasakan pembukuan dua kolom seperti ini mencegah suku terlewat ketika rumus fungsinya makin panjang.

Di mana hal ini ditemui dalam kode#

Pelatihan neural network menghitung turunan parsial fungsi loss terhadap setiap bobot, dan proses itu bernama backpropagation. Model dengan satu juta bobot menghasilkan satu juta turunan parsial, dan masing-masing menjawab seberapa besar loss berubah bila satu bobot digeser sedikit. Nilai-nilai itu disusun menjadi satu vektor sebagai masukan langkah pembaruan bobot. Tanpa turunan parsial, arah pembaruan bobot tidak dapat ditentukan secara sistematis.

Hampiran selisih terpusat juga muncul dalam kode sebagai gradient check, yaitu pemeriksaan yang membandingkan gradien hasil backpropagation dengan hampiran numeriknya. Selisih yang besar menandakan ada kesalahan implementasi, sehingga pemeriksaan ini lazim dijalankan pada model kecil sebelum pelatihan berskala penuh. Di luar pelatihan, pengaruh satu fitur terhadap keluaran model linear juga dinyatakan sebagai turunan parsial keluaran terhadap fitur tersebut, sehingga konsep ini digunakan pula saat membaca sensitivitas model.

Ringkasan#

• Turunan parsial $\frac{\partial f}{\partial x}$ menurunkan $f$ terhadap satu variabel dengan variabel lain diperlakukan sebagai konstanta, dan hasilnya adalah kemiringan sepanjang sumbu variabel itu.
• Potongan lintang $z = f(x, b)$ mengubah permukaan menjadi kurva satu variabel, dan kemiringannya pada suatu titik adalah turunan parsial di titik tersebut.
• Hampiran selisih terpusat menghitung turunan parsial dari nilai fungsi saja, dengan ukuran $h$ yang menyeimbangkan error pemotongan dan error pembulatan.
• Seluruh aturan turunan satu variabel tetap berlaku, dan hasilnya menjadi bahan baku backpropagation serta pemeriksaan gradient check.

Referensi#

• Calculus Volume 3 — OpenStax — Definisi turunan parsial, aturan menahan variabel lain konstan, dan contoh penghitungannya.
• Mathematics for Machine Learning — Cambridge University Press — Bab diferensiasi memperkenalkan turunan parsial dan gradien sebagai dasar optimasi model.
• NumPy 2.1 documentation — NumPy project — Operasi aritmetika array yang digunakan pada hampiran selisih terpusat.