Logaritma dan Eksponensial

Pertumbuhan eksponensial melipatgandakan nilainya pada setiap langkah, sedangkan logaritma menghitung mundur banyaknya langkah yang diperlukan untuk mencapai suatu nilai. Topik ini membahas definisi logaritma sebagai invers fungsi eksponensial, tiga aturan hitung logaritma beserta verifikasi numeriknya, serta alasan skala logaritmik mengubah kurva eksponensial menjadi garis lurus. Penerapannya pada kode, yaitu kompleksitas $O(\log n)$ pada pencarian biner dan penggunaan logaritma pada machine learning, dibahas sebelum topik ditutup dengan kesalahan hitung yang sering terjadi. Setiap rumus diverifikasi menggunakan NumPy sehingga kebenarannya dapat diuji ulang oleh pembaca.

Logaritma sebagai invers eksponensial#

Logaritma basis $b$ dari suatu bilangan $c$ adalah pangkat $a$ yang membuat $b^a$ bernilai $c$. Hubungan kedua arah tersebut dinyatakan sebagai berikut.

Tiga basis yang paling sering digunakan adalah 10, 2, dan bilangan $e \approx 2{,}718$. Logaritma basis 10 disebut logaritma biasa, basis 2 mendasari satuan informasi seperti bit, sedangkan basis $e$ disebut logaritma asli (natural logarithm) dan dilambangkan $\ln$. NumPy menyediakan np.log10, np.log2, dan np.log untuk ketiganya, sehingga setiap basis yang umum sudah terwakili oleh satu fungsi.

Sifat invers berarti kedua operasi saling membatalkan. Mengeksponensialkan suatu nilai lalu mengambil logaritmanya dengan basis yang sama mengembalikan nilai semula, demikian pula urutan sebaliknya. Potongan kode berikut menguji hubungan itu pada beberapa nilai.

import numpy as np

print("np.log2(8)        =", np.log2(8.0))
print("np.log10(1000)    =", np.log10(1000.0))
print("np.log(np.e ** 2) =", np.log(np.e ** 2))
print("np.log2(2 ** 40)  =", np.log2(2 ** 40))
print("2 ** np.log2(100) =", 2.0 ** np.log2(100.0))

np.log2(8)        = 3.0
np.log10(1000)    = 3.0
np.log(np.e ** 2) = 2.0
np.log2(2 ** 40)  = 40.0
2 ** np.log2(100) = 99.99999999999997

Empat baris pertama menunjukkan bahwa logaritma mengembalikan pangkatnya dengan tepat, misalnya $\log_2 8 = 3$ karena $2^3 = 8$. Baris terakhir bernilai 99.99999999999997, bukan 100 persis, karena $\log_2 100$ bukan bilangan bulat dan pembulatan pecahan biner menyisakan selisih kecil. Selisih sekecil itu dibaca sebagai nol pada praktik pemrograman, dan perbandingannya menggunakan toleransi sebagaimana np.allclose.

Aturan logaritma#

Logaritma mengubah perkalian menjadi penjumlahan, pembagian menjadi pengurangan, dan perpangkatan menjadi perkalian. Ketiga aturan berikut berlaku untuk setiap basis $b$ yang positif dan tidak sama dengan 1.

Ketiga aturan tersebut merupakan turunan langsung dari aturan eksponen. Apabila $x = b^m$ dan $y = b^n$, hasil kalinya adalah $b^{m+n}$, sehingga logaritma hasil kali menjadi $m + n$. Aturan pangkat muncul dari sifat $(b^m)^k = b^{mk}$. Memahami asal aturan-aturan tersebut membuat ketiganya mudah diingat sekaligus membedakan aturan yang benar dari yang hanya terdengar mirip. Perubahan basis melengkapi ketiganya, yaitu $\log_b x = \frac{\ln x}{\ln b}$, sehingga logaritma basis apa pun dapat dihitung dari logaritma asli.

Ketiga aturan diuji pada $x = 8$ dan $y = 32$ dengan basis 2, yaitu $2^3$ dan $2^5$.

import numpy as np

x, y = 8.0, 32.0
print("np.log2(x * y)          =", np.log2(x * y))
print("np.log2(x) + np.log2(y) =", np.log2(x) + np.log2(y))
print("np.log2(y / x)          =", np.log2(y / x))
print("np.log2(y) - np.log2(x) =", np.log2(y) - np.log2(x))
print("np.log2(x ** 5)         =", np.log2(x ** 5))
print("5 * np.log2(x)          =", 5 * np.log2(x))

np.log2(x * y)          = 8.0
np.log2(x) + np.log2(y) = 8.0
np.log2(y / x)          = 2.0
np.log2(y) - np.log2(x) = 2.0
np.log2(x ** 5)         = 15.0
5 * np.log2(x)          = 15.0

Setiap pasangan baris memberikan nilai yang sama. Hasil kali $8 \times 32 = 256$ memiliki logaritma $3 + 5 = 8$, hasil bagi $32 / 8 = 4$ memiliki logaritma $5 - 3 = 2$, dan pangkat kelima dari 8 memiliki logaritma $5 \times 3 = 15$. Nilai-nilai bulat sengaja dipilih agar setiap hasil dapat dihitung ulang tanpa komputer.

Skala logaritmik pada grafik#

Kurva $2^n$ bertambah dua kali lipat pada setiap langkah, sehingga grafiknya pada sumbu tegak berskala linear hampir tidak terlihat di awal lalu meningkat sangat tajam di ujung. Pada $n = 20$, nilainya sudah melebihi satu juta, sedangkan seluruh detail bagian awal kurva termampatkan pada ruang yang sangat sempit di dekat sumbu mendatar. Skala logaritmik menyelesaikan masalah pembacaan ini dengan menempatkan logaritma nilai pada sumbu tegak, bukan nilainya sendiri.

Gambar berikut membandingkan kedua penyajian untuk $2^n$ dengan $n$ dari 0 sampai 20.

Panel kanan memberi label $10^1$, $10^3$, dan $10^5$ pada sumbu tegaknya, dan kurvanya berubah menjadi garis lurus. Perubahan bentuk ini mengikuti aturan pangkat pada bagian sebelumnya, yaitu $\log_b b^n = n$, sehingga logaritma dari nilai eksponensial hanyalah pangkatnya sendiri. Satu kenaikan tingkat pada sumbu log berarti nilai sebenarnya berlipat sepuluh kali, bukan bertambah sepuluh satuan. Kebiasaan membaca skala semacam ini penting sebelum grafik log pada data nyata ditafsirkan, karena bentuk garis lurus pada skala log justru menandakan pertumbuhan eksponensial.

Pencarian biner dan kompleksitas logaritmik#

Pencarian biner (binary search) menemukan posisi suatu nilai pada daftar terurut dengan membuang separuh sisa daftar pada setiap perbandingan. Banyaknya langkah untuk $n$ data adalah sekitar $\log_2 n$, karena pembagian dua yang diulang sampai tersisa satu data sama dengan menghitung berapa kali $n$ dapat dibagi 2. Notasi $O(\log n)$ pada analisis algoritma menyatakan laju pertumbuhan ini, dan inilah alasan indeks basis data dibangun di atas struktur terurut.

Penghitungan berikut membandingkan banyaknya pembagian dua dengan $\log_2 n$ untuk tiga ukuran data.

import numpy as np

for n in [10, 1000, 1000000]:
    sisa, langkah = n, 0
    while sisa > 1:
        sisa = sisa // 2
        langkah += 1
    print(f"n = {n:>8} : pembagian dua = {langkah:>2}, log2(n) = {np.log2(n):.2f}")

n =       10 : pembagian dua =  3, log2(n) = 3.32
n =     1000 : pembagian dua =  9, log2(n) = 9.97
n =  1000000 : pembagian dua = 19, log2(n) = 19.93

Kolom pembagian dua adalah bilangan bulat terbesar yang tidak melebihi $\log_2 n$, sehingga keduanya naik bersama. Memperbesar data dari 10 menjadi 1.000.000, yaitu seratus ribu kali lipat, hanya menaikkan langkah dari 3 menjadi 19. Pertumbuhan yang lambat inilah makna $O(\log n)$, dan logaritma menjadi ukuran banyaknya langkah pembagian dua yang berulang.

Di mana hal ini ditemui dalam kode#

Machine learning menggunakan logaritma pada perhitungan yang tidak selalu tampak dari rumus modelnya. Peluang sebuah kumpulan data adalah hasil kali peluang tiap datanya, dan hasil kali ratusan bilangan yang sangat kecil itu cepat menuju underflow, yaitu keadaan bilangan terlalu kecil untuk disimpan sehingga dibulatkan menjadi nol. Mengalihkan perhitungan ke logaritma mengubah hasil kali menjadi penjumlahan, dan hasil penjumlahannya tetap terwakili dengan baik. Potongan kode berikut memperlihatkan perbedaannya pada dua peluang yang sangat kecil.

import numpy as np

p = np.array([1e-300, 1e-300])
print("hasil kali langsung :", p[0] * p[1])
print("jumlah logaritma    :", np.log(p[0]) + np.log(p[1]))

hasil kali langsung : 0.0
jumlah logaritma    : -1381.5510557964274

Hasil kali langsung dibulatkan menjadi 0.0 karena $10^{-600}$ berada di luar jangkauan bilangan pecahan, sedangkan jumlah logaritmanya bernilai $-1381{,}55$ dan masih menyimpan informasi tentang besarnya peluang tersebut. Teknik ini digunakan pada pelatihan model probabilistik melalui log-likelihood, yaitu jumlah logaritma peluang seluruh data. Skala log juga digunakan untuk membaca grafik nilai loss yang membentang banyak tingkat besaran, misalnya melalui set_yscale("log") pada matplotlib sebagaimana panel kanan gambar di atas. Kurva loss yang tampak datar pada skala linear tetap terbaca penurunannya sampai akhir pelatihan pada skala log.

Kesalahan umum#

• Mengubah logaritma penjumlahan menjadi penjumlahan logaritma. Nilai $\log_2(8 + 8) = 4$, sedangkan $\log_2 8 + \log_2 8 = 6$, sehingga aturan itu tidak berlaku untuk penjumlahan. Perbaikannya adalah menggunakan aturan logaritma hanya untuk perkalian, pembagian, dan perpangkatan.
• Mengalikan dua logaritma seolah-olah hasilnya merupakan logaritma hasil kalinya. Nilai $\log_2 8 \times \log_2 8 = 9$, sedangkan $\log_2(8 \times 8) = 6$. Perbaikannya adalah memeriksa letak tanda kurungnya sebelum menerapkan aturan mana pun.
• Mengabaikan basis ketika membandingkan hasil. Nilai $\log_2 1024 = 10$, sedangkan $\log_{10} 1024 \approx 3{,}01$. Perbaikannya adalah memilih fungsi NumPy sesuai basisnya, yaitu np.log2 untuk basis 2 dan np.log10 untuk basis 10.

Ringkasan#

• Logaritma $\log_b c = a$ adalah invers eksponensial, yaitu pangkat $a$ yang membuat $b^a$ bernilai $c$.
• Aturan logaritma mengubah perkalian menjadi penjumlahan, pembagian menjadi pengurangan, dan pangkat menjadi perkalian koefisien.
• Skala logaritmik mengubah kurva eksponensial menjadi garis lurus karena $\log_b b^n = n$.
• Kompleksitas $O(\log n)$ pada pencarian biner dan penggantian hasil kali peluang dengan jumlah logaritma menjaga perhitungan tetap ringan pada data berukuran besar.

Referensi#

• Dokumentasi NumPy 2.1 — NumPy — Rujukan fungsi np.log, np.log2, dan np.log10 yang digunakan untuk verifikasi numerik pada topik ini.
• Mathematics for Machine Learning — Cambridge University Press — Buku terbuka yang membahas fungsi eksponensial dan logaritma sebagai dasar model probabilistik.
• Latihan logaritma — Khan Academy — Materi dan latihan definisi logaritma serta aturan hitungnya secara bertahap.