Mengapa Matematika untuk Pemrogram

Topik ini memetakan titik temu antara matematika dan pekerjaan pemrograman sehari-hari. Empat bidang dibahas satu per satu, yaitu machine learning, grafika, kriptografi, dan analisis algoritma, lengkap dengan contoh kode kecil beserta keluaran aslinya. Setiap contoh dijalankan menggunakan NumPy atau Python murni sehingga dapat diperiksa ulang di lingkungan mana pun. Setelah topik ini selesai, ruang lingkup matematika yang perlu dikuasai sepanjang jalur ini menjadi jelas beserta alasan konkretnya.

Empat bidang yang paling sering bersentuhan dengan matematika#

Matematika di dalam kode jarang muncul sebagai soal hitungan di papan tulis. Bentuknya lebih sering berupa struktur data berdimensi banyak, rumus singkat di tengah fungsi, atau batas kompleksitas yang menentukan apakah program selesai dalam sekejap atau memakan waktu berjam-jam. Gambaran besarnya dapat dilihat pada peta berikut, yang menghubungkan empat bidang teknologi dengan cabang matematika yang paling sering digunakan pada masing-masing bidang.

Keempat bidang dipilih karena kehadirannya paling mudah ditemukan dalam pekerjaan teknologi saat ini. Machine learning berperan dalam sistem rekomendasi dan prediksi, grafika berperan dalam antarmuka dan permainan, kriptografi berperan dalam setiap koneksi aman, sedangkan analisis algoritma menjadi dasar penilaian efisiensi program. Kedalaman matematika yang dituntut pun berbeda, dari trigonometri pada grafika sampai kalkulus multivariabel pada machine learning tingkat lanjut. Kabar baiknya, seluruh cabang tersebut berangkat dari fondasi yang sama, yaitu bilangan, aljabar, dan fungsi, yang dibangun bertahap sepanjang jalur ini.

Machine learning: data sebagai matriks#

Machine learning, yakni teknik membangun program yang menyesuaikan perilakunya berdasarkan data, hampir seluruhnya dinyatakan dalam bahasa matriks dan turunan. Data ditata sebagai matriks berukuran baris kali kolom, model berupa rumus berparameter, dan proses belajar berupa pencarian parameter yang memperkecil ukuran kesalahannya. Bentuk paling sederhananya adalah model linear berikut.

Simbol $w$ menyatakan bobot (weight), simbol $b$ menyatakan bias (bias), sedangkan tanda topi pada $y$ menandai nilai hasil prediksi, bukan nilai yang sebenarnya. Perkalian matriks menjadi cara alami menulis model ini karena jumlah masukan boleh bertambah dari dua menjadi ribuan tanpa mengubah bentuk rumusnya. Proses pelajarannya pun berbasis kalkulus, yaitu turunan yang menunjukkan arah perubahan bobot agar prediksi makin mendekati nilai sebenarnya. Kode berikut menghitung satu prediksi dan menampilkan keluarannya.

import numpy as np

# model linear dengan dua masukan: estimasi konsumsi bahan bakar
w = np.array([0.4, 1.5])   # bobot tiap masukan
b = 2.0                    # bias
x = np.array([3.0, 2.0])   # nilai masukan
prediksi = w @ x + b
print(f"Prediksi: {prediksi:.2f}")

Prediksi: 6.20

Keluaran 6.20 diperoleh dari perhitungan $0.4 \times 3 + 1.5 \times 2 + 2.0 = 6.2$ yang dapat diperiksa ulang dengan tangan. Operator @ pada NumPy mengerjakan perkalian titik (dot product) antara bobot dan masukan, yaitu operasi yang sama dengan menjumlahkan seluruh suku pada rumus di atas. Pada model nyata, perhitungan yang sama dijalankan untuk ribuan baris data sekaligus tanpa mengubah bentuk kodenya.

Grafika: geometri yang bergerak#

Setiap gambar yang bergerak di layar pada dasarnya adalah kumpulan titik yang diputar, digeser, dan diperbesar menggunakan aljabar linear. Rotasi satu titik pada bidang dinyatakan sebagai perkalian matriks berikut. Bentuk yang sama juga digunakan untuk menggeser dan menskalakan, sehingga satu jenis operasi mencakup hampir seluruh gerakan gambar dua dimensi.

Notasi $\theta$ menyatakan sudut putar, sedangkan $x'$ dan $y'$ menyatakan posisi titik setelah diputar. Hasilnya dapat ditebak lebih dulu, yaitu titik pada sumbu horizontal positif berpindah ke sumbu vertikal positif. Kode berikut memutar titik $(2, 0)$ sejauh 90 derajat mengelilingi titik asal.

import numpy as np

# memutar titik (2, 0) sejauh 90 derajat mengelilingi titik asal
sudut = np.deg2rad(90)
rotasi = np.array([
    [np.cos(sudut), -np.sin(sudut)],
    [np.sin(sudut),  np.cos(sudut)],
])
titik = np.array([2.0, 0.0])
hasil = rotasi @ titik
print(f"Hasil rotasi: {hasil}")
print(f"Dibulatkan enam angka desimal: {np.round(hasil, 6)}")

Hasil rotasi: [1.2246468e-16 2.0000000e+00]
Dibulatkan enam angka desimal: [0. 2.]

Hasil yang diharapkan adalah titik $(0, 2)$, dan keluaran memang menunjukkannya setelah pembulatan. Angka $1.2246468 \times 10^{-16}$ pada komponen pertama bukan bug, melainkan sisa ketidaksempurnaan representasi pecahan biner yang nilainya praktis sama dengan nol. Pola pembacaan semacam ini akan terus ditemui pada kode numerik, sehingga kemampuan menafsirkan keluaran menjadi keterampilan yang sama pentingnya dengan kemampuan menghitung.

Kriptografi: aritmetika yang menjaga rahasia#

Kriptografi modern berdiri di atas aritmetika modular, yaitu aritmetika yang hasilnya dibungkus kembali ke dalam rentang $0$ sampai $p-1$, sebagaimana jarum jam kembali ke angka 1 setelah melewati 12. Satu-satunya operasi yang dibutuhkan untuk contoh berikut adalah eksponensiasi modular, yaitu perpangkatan yang hasilnya dibungkus dengan modulus $p$. Pertukaran kunci Diffie-Hellman (Diffie-Hellman key exchange) memanfaatkan operasi tersebut agar dua pihak dapat menyepakati kunci rahasia melalui saluran yang mungkin disadap.

Nilai $p$ dan $g$ disepakati terbuka, sedangkan $a$ dan $b$ adalah kunci rahasia masing-masing pihak yang tidak pernah dikirim. Angka pada contoh berikut sengaja kecil agar setiap langkahnya dapat diperiksa ulang dengan tangan. Kode berikut menjalankan skema tersebut.

# pertukaran kunci Diffie-Hellman pada bilangan kecil
p = 23   # bilangan prima (contoh klasik untuk pembelajaran)
g = 5    # generator
a = 6    # kunci rahasia pihak pertama
b = 15   # kunci rahasia pihak kedua

A = pow(g, a, p)   # kunci publik pihak pertama
B = pow(g, b, p)   # kunci publik pihak kedua
rahasia_1 = pow(B, a, p)
rahasia_2 = pow(A, b, p)

print(f"A = {A}, B = {B}")
print(f"Kunci bersama: {rahasia_1} == {rahasia_2}")

A = 8, B = 19
Kunci bersama: 2 == 2

Kedua pihak menghitung kunci bersama dari data yang berbeda, yaitu $B^a \bmod p$ dan $A^b \bmod p$, dan keduanya bertemu pada nilai 2. Pengamat yang hanya melihat $A = 8$ dan $B = 19$ tidak dapat memperoleh 2 dengan mudah, karena membalik eksponen modular tergolong sulit secara komputasi. Pada sistem nyata, bilangan yang digunakan mencapai ratusan digit, tetapi operasi aritmetikanya persis sama dengan contoh kecil ini.

Analisis algoritma: menghitung sebelum mengode#

Analisis algoritma menaksir banyaknya langkah sebuah program berdasarkan ukuran masukannya, sebelum program dijalankan sekali pun. Notasi $O(n)$ menyatakan langkah yang tumbuh sebanding dengan banyaknya data, sedangkan $O(\log n)$ menyatakan langkah yang tumbuh jauh lebih lambat melalui fungsi logaritma. Perbedaannya terasa nyata pada pencarian data terurut, yaitu memeriksa elemen satu per satu dibandingkan membagi dua ruang pencarian pada setiap langkah. Batas langkah pencarian biner (binary search) dirumuskan sebagai berikut.

Kode berikut membandingkan batas kedua strategi pada satu juta data terurut.

import numpy as np

# banyak langkah maksimum dua strategi pencarian pada satu juta data terurut
n = 1_000_000
linier = n
biner = int(np.ceil(np.log2(n)))
print(f"Pencarian linier : sampai {linier} langkah")
print(f"Pencarian biner  : sampai {biner} langkah")

Pencarian linier : sampai 1000000 langkah
Pencarian biner  : sampai 20 langkah

Angka pada keluaran menjelaskan mengapa logaritma begitu penting bagi pemrogram. Menambah data dari seribu menjadi satu juta baris menambah batas pencarian linier seribu kali lipat, tetapi batas pencarian biner hanya naik dari 10 menjadi 20 langkah. Perhitungan semacam ini memungkinkan keputusan desain diambil terlebih dahulu, sebelum kode ditulis dan diukur. Inilah alasan struktur data yang menjaga urutan, seperti pohon pencarian biner, menjadi pilihan baku pada indeks basis data.

Di mana hal ini ditemui dalam kode#

Keempat bidang di atas meninggalkan jejak yang dapat dikenali pada kode nyata, dan jejaknya bukan sekadar teori. Jejak itu sering berupa satu operator, satu rumus pendek, atau satu angka kompleksitas pada dokumentasi. Melalui jalur ini, setiap rumus yang ditemui akan segera diverifikasi menggunakan NumPy sehingga notasi dan kode saling menguatkan. Contoh konkret yang paling umum adalah sebagai berikut:

• Library machine learning mengalirkan data sebagai array NumPy dan menghitung prediksi melalui operator @, persis seperti pada contoh model linear.
• Mesin grafika dan kerangka kerja antarmuka memutar serta menskalakan gambar menggunakan matriks rotasi dan penskalaan sebelum satu piksel pun digambar.
• Setiap koneksi HTTPS menegosiasikan kunci rahasia melalui eksponensiasi modular, versi berskala penuh dari contoh Diffie-Hellman di atas.
• Dokumentasi struktur data mencantumkan kompleksitas seperti $O(\log n)$ untuk membantu pemilih algoritma, notasi yang sama dengan contoh pencarian biner.
• Keluaran berbentuk notasi ilmiah seperti 1.2246468e-16 muncul pada kode grafika maupun machine learning setiap kali pecahan biner terlibat, sehingga kepekaan membacanya terus terpakai.

Ringkasan#

• Machine learning menyatakan data sebagai matriks dan proses belajarnya sebagai pencarian parameter yang menggunakan turunan.
• Grafika menyatakan gerakan gambar sebagai perkalian matriks, sedangkan kriptografi berdiri di atas aritmetika modular dan eksponensiasi.
• Analisis algoritma menaksir langkah eksekusi menggunakan logaritma dan notasi $O$ besar sebelum kode ditulis.
• Keluaran numerik perlu dibaca dengan pemahaman pecahan biner, dan setiap rumus dapat diverifikasi ulang menggunakan NumPy.

Referensi#

• Mathematics for Machine Learning — Cambridge University Press — Buku terbuka yang menyusun aljabar linear, kalkulus, dan probabilitas langsung menuju kebutuhan machine learning.
• MIT OpenCourseWare — Massachusetts Institute of Technology — Materi kuliah terbuka yang memuat pengantar algoritma beserta analisis waktu eksekusinya.
• NumPy 2.1 documentation — NumPy project — Dokumentasi operator @, np.cos, dan np.log2 yang digunakan pada contoh topik ini.