Kita sudah tahu bahwa model “belajar dari data”, tetapi kata belajar itu sendiri masih kabur. Apa yang persisnya berubah di dalam model saat fit() dijalankan? Jawabannya bisa diringkas dalam satu kalimat: machine learning adalah proses menyetel parameter model agar sebuah angka penilaian kesalahan — loss — menjadi sekecil mungkin. Chapter ini membedah mekanisme tersebut sampai ke angka-angkanya: kita menghitung loss dengan tangan, melihat bagaimana perubahan parameter menggerakkan nilainya, lalu membedakan dua cara menemukan parameter terbaik — rumus tertutup dan pencarian iteratif.

Belajar Berarti Menurunkan Loss #

Mari kita mulai dari masalah yang paling konkret: memasang garis lurus pada data harga rumah. Katakanlah harga rumah di sebuah kompleks naik kira-kira sebanding dengan luasnya. Sebuah model linier sederhana dapat ditulis harga = w * luas, dengan w sebagai parameter yang harus dipelajari. Garis yang berbeda menghasilkan prediksi yang berbeda — dan kita butuh cara objektif untuk menyatakan garis mana yang paling pas.

Di sinilah fungsi loss masuk. Loss mengambil seluruh prediksi model, membandingkannya dengan nilai aktual pada data, lalu meringkas kesalahan tersebut menjadi satu angka: semakin besar angkanya, semakin salah modelnya. Loss yang paling populer untuk masalah regresi adalah mean squared error (MSE) — rata-rata dari kuadrat selisih antara prediksi dan nilai aktual. Dengan loss di tangan, definisi “belajar” menjadi operasional: cari nilai parameter yang membuat MSE sekecil mungkin. Seluruh proses training pada model modern, dari regresi linier sampai jaringan saraf, pada dasarnya adalah minimisasi loss.

Menghitung MSE dengan Tangan #

Teori di atas paling cepat dicerna lewat perhitungan nyata. File loss-mse.py berikut memuat lima data penjualan rumah (luas dan harga), memasang garis harga = 10 * luas, membedah MSE-nya kolom per kolom, lalu mencoba tiga kemiringan berbeda untuk melihat bagaimana loss ikut berubah. Semua hitungan memakai NumPy murni — belum ada pustaka machine learning sama sekali.

python 
# Fungsi loss MSE dihitung dengan tangan, tanpa pustaka machine learning.
# Kita memasang garis lurus harga = w * luas ke lima data rumah,
# lalu menilai seberapa "salah" tiap kandidat kemiringan w.

import numpy as np

# Lima rumah terjual: luas (m^2) dan harga (juta rupiah).
luas = np.array([20.0, 30.0, 40.0, 50.0, 60.0])
harga_aktual = np.array([250.0, 340.0, 470.0, 550.0, 620.0])


def hitung_mse(y_aktual, y_prediksi):
    """MSE = rata-rata kuadrat selisih antara prediksi dan nilai aktual."""
    selisih = y_prediksi - y_aktual
    return np.mean(selisih**2)


# Bagian 1: bedah MSE manual untuk satu kandidat garis, w = 10.
print("Bedah MSE untuk kandidat garis harga = 10.0 * luas:")
print(f"{'luas':>5} {'aktual':>8} {'prediksi':>9} {'selisih':>8} {'kuadrat':>9}")
for l, a in zip(luas, harga_aktual):
    p = 10.0 * l
    selisih = p - a
    print(f"{l:5.0f} {a:8.1f} {p:9.1f} {selisih:8.1f} {selisih**2:9.1f}")
print(f"MSE = rata-rata kolom kuadrat = {hitung_mse(harga_aktual, 10.0 * luas):.1f}")
print()

# Bagian 2: ubah kemiringan, lihat bagaimana loss ikut berubah.
print("Tiga kandidat kemiringan w (intercept tetap nol):")
for w in [9.0, 10.0, 11.0]:
    mse = hitung_mse(harga_aktual, w * luas)
    print(f"  w = {w:4.1f} -> MSE = {mse:8.1f}")
print()

# Bagian 3: rumus tertutup mencari w terbaik langsung, tanpa mencoba-coba.
w_terbaik = np.sum(luas * harga_aktual) / np.sum(luas**2)
mse_terbaik = hitung_mse(harga_aktual, w_terbaik * luas)
print(f"Rumus tertutup: w* = {w_terbaik:.3f} -> MSE = {mse_terbaik:.1f}")

Output yang Dihasilkan:

text 
Bedah MSE untuk kandidat garis harga = 10.0 * luas:
 luas   aktual  prediksi  selisih   kuadrat
   20    250.0     200.0    -50.0    2500.0
   30    340.0     300.0    -40.0    1600.0
   40    470.0     400.0    -70.0    4900.0
   50    550.0     500.0    -50.0    2500.0
   60    620.0     600.0    -20.0     400.0
MSE = rata-rata kolom kuadrat = 2380.0

Tiga kandidat kemiringan w (intercept tetap nol):
  w =  9.0 -> MSE =   7660.0
  w = 10.0 -> MSE =   2380.0
  w = 11.0 -> MSE =    700.0

Rumus tertutup: w* = 10.967 -> MSE = 698.0

Bedah kode di atas baris demi baris:

  1. Baris 8–9 (luas, harga_aktual): inilah seluruh dataset kita — lima sampel, satu fitur (luas), satu label (harga). Angkanya ditulis tetap sehingga hasil selalu sama di setiap eksekusi.
  2. Baris 12–15 (def hitung_mse): formula MSE diterjemahkan menjadi tiga langkah — hitung selisih (y_prediksi - y_aktual), kuadratkan (selisih**2), lalu rata-ratakan (np.mean). Ini adalah seluruh isi fungsi loss; tidak ada yang lebih gaib dari itu.
  3. Baris 19–25 (tabel bedah): untuk kandidat w = 10, tiap rumah dicetak lengkap: prediksi 10 * luas, selisih terhadap harga aktual, dan kuadratnya. Rumah 40 m² misalnya diprediksi Rp400 juta padahal terjual Rp470 juta — selisih −70, kuadratnya 4.900. Rata-rata kolom kuadrat (11.900 ÷ 5) menghasilkan MSE 2.380.
  4. Baris 29–32 (loop tiga kandidat): parameter w diganti-ganti — 9,0 → 10,0 → 11,0 — dan MSE-nya dihitung ulang. Perhatikan polanya: 7.660 → 2.380 → 700. Menggeser parameter ke arah yang benar menurunkan loss; itulah inti “belajar”.
  5. Baris 36–38 (rumus tertutup): untuk masalah ini, nilai w terbaik memang bisa dihitung langsung dengan rumus sum(x·y) / sum(x²) hasil turunan MSE yang disetel nol. Hasilnya w* = 10,967 dengan MSE 698,0 — lebih baik daripada ketiga kandidat tadi tanpa perlu mencoba-coba.

Dua Jalan Menemukan Parameter Terbaik #

Contoh di atas memperlihatkan dua strategi minimisasi yang berbeda. Strategi pertama terlihat pada loop kandidat: coba beberapa nilai, ukur loss, simpan yang terbaik — pendekatan iteratif. Strategi kedua terlihat pada rumus tertutup: turunkan MSE secara analitik terhadap w, setel turunannya nol, dan selesaikan persamaannya — pendekatan rumus tertutup (closed-form), yang untuk regresi linier dikenal sebagai persamaan normal.

AspekRumus tertutupIteratif (gradient descent)
Cara kerjaSelesaikan persamaan turunan = 0 langsungMulai dari tebakan, geser parameter sedikit demi sedikit menuruni loss
Kapan tersediaHanya model tertentu (mis. regresi linier tanpa regularisasi rumit)Hampir semua model, termasuk jaringan saraf
Biaya pada data besarPembalikan matriks mahal (kubik terhadap jumlah fitur)Hemat — cukup menghitung gradien
Di scikit-learnLinearRegression (least squares langsung)SGDRegressor, LogisticRegression, jaringan saraf

Gradient descent bekerja seperti mendaki turun di lembah berkabut: dari posisi awal, hitung arah kemiringan tercuram (gradien loss terhadap tiap parameter), langkahkan parameter ke arah turun sejauh learning rate, ulangi sampai loss tidak lagi turun. Seluruh mekanisme turunan inilah alasan kalkulus menjadi prasyarat Course ini — pembahasan lengkapnya ada di Chapter Kalkulus untuk Machine Learning.

Sebelum masuk lebih jauh ke praktik melatih model, kita perlu memastikan satu hal: algoritme belajar dari data apa adanya — dan bentuk datanya menentukan paradigma yang bisa dipakai. Data yang membawa label membuka jalan supervised learning; data tanpa label memaksa kita menempuh jalan lain. Pemetaan dua jalan itu adalah bahasan Chapter Paradigma Supervised dan Unsupervised.

Referensi Resmi #