Definisi Limit

Formalisasi turunan melalui limit secara bertahap.

Daftar isi

Topik ini merumuskan turunan secara resmi melalui limit, dibangun selangkah demi selangkah dari kemiringan garis potong yang sudah dikenal. Cara membaca notasi $f'(x)$ dijelaskan, rumus limitnya diturunkan pada fungsi sederhana, lalu seluruh hasilnya diverifikasi secara numerik menggunakan NumPy. Setelah membaca, definisi limit turunan dapat ditulis, dibaca, dan diperiksa kebenarannya dengan kode, termasuk mengapa $h$ yang terlalu kecil justru memperburuk hasil.

Beda kuotien dan limit menuju nol#

Kemiringan garis potong pada topik laju perubahan dihitung dari dua titik yang berjarak $h$ , dan bentuk perhitungan itu diberi nama beda kuotien (difference quotient), yaitu perbandingan selisih keluaran terhadap selisih masukan. Turunan fungsi $f$ di titik $x$ didefinisikan sebagai nilai yang didekati beda kuotien apabila $h$ mendekati nol,

f'(x) = \lim_{h \to 0} \frac{f(x + h) - f(x)}{h}.

Notasi $f'(x)$ dibaca “f aksen x”, sedangkan tanda $\lim_{h \to 0}$ dibaca “limit untuk $h$ menuju nol”. Maknanya adalah nilai yang didekati pecahan itu, bukan nilai pada $h = 0$ , karena pada $h = 0$ pecahan tersebut memang tidak terdefinisi. Pendekatan $h \to 0$ berlaku dari dua arah, yaitu $h$ positif maupun $h$ negatif, dan keduanya harus menuju nilai yang sama agar turunan ada.

Penurunan bertahap pada fungsi kuadrat#

Definisi limit menjadi berguna setelah dilatih secara manual pada satu fungsi. Ambil $f(x) = x^2$ , tuliskan rumus beda kuotien untuk fungsi itu, jabarkan kuadratnya, lalu sederhanakan pecahannya sebelum limitnya dinilai,

\begin{aligned} f'(x) &= \lim_{h \to 0} \frac{(x + h)^2 - x^2}{h} = \lim_{h \to 0} \frac{x^2 + 2xh + h^2 - x^2}{h}\\ &= \lim_{h \to 0} \frac{h(2x + h)}{h} = \lim_{h \to 0} \, (2x + h) = 2x. \end{aligned}

Pembagian dengan $h$ pada langkah ketiga sah karena selama proses pendekatan, $h$ tidak pernah sama dengan nol. Suku $h$ yang tersisa kemudian menghilang pada limit, sehingga diperoleh rumus eksak $f'(x) = 2x$ tanpa menghitung satu limit angka pun. Inilah alasan limit diperlukan, yaitu memungkinkan pembagian oleh besaran yang menuju nol tanpa pernah membagi dengan nol. Hasil rumus eksak ini selanjutnya dibandingkan dengan beda kuotien numerik pada beberapa titik.

python Contoh: membandingkan beda kuotien dengan rumus eksak 2x

import numpy as np

def f(x):
    return x**2

def beda_kuotien(x, h):
    return (f(x + h) - f(x)) / h

h = 0.0001
for x in (0.5, 1.0, 2.0, 3.0):
    numerik = beda_kuotien(x, h)
    eksak = 2.0 * x
    print(f"x = {x:.1f} : beda kuotien = {numerik:.6f}, eksak = {eksak:.6f}")

text Keluaran

x = 0.5 : beda kuotien = 1.000100, eksak = 1.000000
x = 1.0 : beda kuotien = 2.000100, eksak = 2.000000
x = 2.0 : beda kuotien = 4.000100, eksak = 4.000000
x = 3.0 : beda kuotien = 6.000100, eksak = 6.000000

Keempat baris keluaran menunjukkan pola yang sama, yaitu beda kuotien selalu lebih besar $0.0001$ daripada nilai eksak, dan angka itu persis sama dengan $h$ yang dipilih. Kesesuaian ini konsisten dengan hasil penurunan manual, karena beda kuotien $f(x) = x^2$ memang bernilai $2x + h$ . Nilai numerik mendekati nilai eksak dari atas, dan jaraknya dapat dibuat sekecil apa pun dengan memilih $h$ yang lebih kecil.

Batas presisi karena derau float#

Pemilihan $h$ yang semakin kecil ternyata memiliki batas, dan batas itu berasal dari pembulatan floating point (float) pada komputer. Tabel berikut menghitung beda kuotien $f(x) = x^2$ di $x = 1$ untuk $h$ yang menurun beberapa orde besaran, kemudian mengukur jaraknya dari nilai eksak $2$ .

python Contoh: error beda kuotien terhadap ukuran h

import numpy as np

x = 1.0
eksak = 2.0
for h in (1e-1, 1e-3, 1e-6, 1e-9, 1e-12, 1e-15):
    kuotien = ((x + h)**2 - x**2) / h
    error = abs(kuotien - eksak)
    print(f"h = {h:.0e} : kuotien = {kuotien:.12f}, error = {error:.2e}")

text Keluaran

h = 1e-01 : kuotien = 2.100000000000, error = 1.00e-01
h = 1e-03 : kuotien = 2.001000000000, error = 1.00e-03
h = 1e-06 : kuotien = 2.000000999924, error = 1.00e-06
h = 1e-09 : kuotien = 2.000000165481, error = 1.65e-07
h = 1e-12 : kuotien = 2.000177801165, error = 1.78e-04
h = 1e-15 : kuotien = 2.220446049250, error = 2.20e-01

Error menurun mengikuti $h$ sampai sekitar $10^{-9}$ , lalu justru membesar tajam setelahnya. Penyebabnya adalah pengurangan dua bilangan yang hampir sama, yaitu $f(x + h)$ dan $f(x)$ , yang membuang hampir semua angka penting (cancellation) sebelum hasilnya dibagi dengan $h$ yang sangat kecil. Error pembulatan itu tumbuh sebanding dengan $1/h$ , sehingga error total berbentuk lengkung V dengan titik optimalnya di sekitar $10^{-8}$ untuk presisi ganda.

Grafik berikut memetakan error tersebut terhadap $h$ pada skala logaritmik, sehingga lengkung V-nya terlihat utuh.

python gambar_error.py

import numpy as np
import matplotlib.pyplot as plt

x = 1.0
eksak = 2.0
h = np.logspace(-16, -1, 300)
kuotien = ((x + h)**2 - x**2) / h
error = np.abs(kuotien - eksak)

fig, ax = plt.subplots(figsize=(6, 3.2))
ax.loglog(h, error, color="#1a5fb4")
ax.set_xlabel("ukuran h")
ax.set_ylabel("error beda kuotien")
ax.set_title("Error menurun mengikuti h, lalu naik karena derau float")
ax.grid(True, which="both", linestyle=":", linewidth=0.6)
fig.savefig("beda-kuotien.svg")

Error beda kuotien terhadap ukuran h pada skala logaritmik

Cabang kiri grafik berbentuk garis lurus karena error pendekatan sebanding dengan $h$ , sedangkan cabang kanan menanjak karena error pembulatan dibagi dengan $h$ yang sangat kecil. Titik terendahnya adalah kompromi terbaik yang dapat dicapai satu beda kuotien pada presisi ganda. Cara menurunkan batas error tersebut adalah mengubah rumusnya, misalnya beda kuotien simetris $\frac{f(x+h) - f(x-h)}{2h}$ yang errornya sebanding dengan $h^2$ .

Di mana hal ini ditemui dalam kode#

Pemeriksaan gradien (gradient checking) pada machine learning menggunakan definisi pada topik ini secara persis. Implementasi backpropagation menghitung gradien dengan aturan analitik, lalu hasilnya dibandingkan dengan beda kuotien pada beberapa titik acak sebagai alat uji kebenaran, dan ketidakcocokan keduanya menandai bug pada rantai perhitungan. Nilai $h$ yang digunakan biasanya berkisar dari $10^{-6}$ sampai $10^{-7}$ , mengikuti kompromi yang dipetakan grafik di atas.

Fungsi np.gradient pada NumPy juga menerapkan beda kuotien simetris pada titik-titik dalam array, sehingga deret pengukuran dapat diturunkan dalam satu pemanggilan. Pada pemeriksaan gradien, kesesuaian kedua metode dinilai melalui error relatif, yaitu selisih kedua nilai dibagi besar nilainya, dengan ambang lazim di sekitar $10^{-7}$ untuk presisi ganda. Pemahaman tentang batas error tersebut menjelaskan mengapa hasil np.gradient pada data yang berderau perlu dihaluskan dahulu, karena beda kuotien memperbesar derau sebanding dengan kecilnya jarak antara sampel. Dengan demikian, definisi limit bukan sekadar formalitas, melainkan spesifikasi yang dieksekusi setiap kali turunan numerik dihitung.

Ringkasan#

Turunan $f'(x)$ didefinisikan sebagai $\lim_{h \to 0} \frac{f(x+h) - f(x)}{h}$ , yaitu nilai yang didekati beda kuotien ketika $h$ menuju nol tanpa pernah bernilai nol.
Pada $f(x) = x^2$ , penurunan bertahap menghasilkan $f'(x) = 2x$ , dan beda kuotien numeriknya menunjukkan pola $2x + h$ yang sesuai.
Error turunan numerik menurun sebanding dengan $h$ , tetapi derau float menaikkannya kembali sebanding dengan $1/h$ , sehingga nilai $h$ terbaik berada di sekitar $10^{-8}$ untuk presisi ganda.

Referensi#

Calculus Volume 1, 3.2 The Derivative as a Function — OpenStax — Turunan sebagai fungsi yang lahir dari definisi limit dan titik-titik yang tidak terdiferensiasi.
numpy.gradient — NumPy — Dokumentasi turunan numerik array menggunakan beda kuotien simetris.
Mathematics for Machine Learning — Deisenroth, Faisal, dan Ong — Buku terbuka yang membahas turunan dan gradien sebagai fondasi machine learning.