Data rumah, foto digital, dokumen teks, bahkan sinyal suara — semuanya berubah menjadi kumpulan angka begitu masuk ke dunia machine learning. Aljabar linear menyediakan bahasa untuk kumpulan angka tersebut: vektor menyimpan satu baris data, matriks menyimpan seluruh tabel dataset, dan operasi seperti dot product serta perkalian matriks menjadi mesin penghitung di dalam model. Tanpa pemahaman operasi-operasi ini, kode scikit-learn dan jaringan saraf akan terasa seperti kotak tertutup yang tidak bisa dibedah. Pada chapter ini kita membongkar operasi intinya satu per satu dengan data kecil yang bisa dihitung dengan tangan, lalu membandingkannya dengan hasil NumPy.

Vektor: Satu Baris Data #

Mulailah dari satu masalah konkret: memperkirakan harga rumah. Kita meringkas setiap rumah menjadi beberapa angka — luas, jumlah kamar, jarak ke stasiun — sehingga satu rumah menjadi daftar angka terurut, misalnya [70, 3, 1.5]. Daftar angka terurut itulah yang disebut vektor fitur (feature vector). Urutan posisi harus konsisten di seluruh dataset: posisi pertama selalu berarti luas, posisi kedua selalu berarti jumlah kamar; jika urutan tertukar, model membaca kolom yang salah dan hasilnya tidak bermakna.

Dalam NumPy, vektor adalah ndarray satu dimensi dengan bentuk (3,) — satu dimensi, tiga elemen. File vektor-dan-dot-product.py berikut memperkenalkan vektor sekaligus dua operasi yang hidup di atasnya: dot product dan norma L2. Contoh pertama sengaja dibuat cukup kecil untuk dihitung dengan tangan.

python 
# Vektor sebagai baris fitur, dot product sebagai ukuran kemiripan,
# dan norma sebagai panjang vektor.

import numpy as np

np.set_printoptions(precision=2, suppress=True)

# Satu vektor = data satu rumah: [luas (m2), jumlah kamar, jarak ke stasiun (km)]
rumah = np.array([70.0, 3.0, 1.5])
print("Vektor fitur rumah :", rumah)
print("Bentuk (shape)     :", rumah.shape)
print("Jumlah elemen      :", rumah.size)

# Hitungan tangan: u . v dengan u = [2, 1] dan v = [3, 4]
# u . v = 2*3 + 1*4 = 10
u = np.array([2.0, 1.0])
v = np.array([3.0, 4.0])
print("\nHitungan tangan u . v = 2*3 + 1*4 =", 2 * 3 + 1 * 4)
print("NumPy np.dot(u, v)                =", np.dot(u, v))
print("Operator u @ v                    =", u @ v)

# Norma L2: akar dari jumlah kuadrat elemen
# ||v|| = sqrt(3^2 + 4^2) = sqrt(25) = 5
print("\nHitungan tangan ||v|| = sqrt(3^2 + 4^2) =", 5.0)
print("NumPy np.linalg.norm(v)                 =", np.linalg.norm(v))

# Cosine similarity antara dua "dokumen" berisi hitungan kata.
# Kolom fitur: [machine, learning, data, bola]
dok_ml = np.array([3.0, 2.0, 4.0, 0.0])
dok_ml_lagi = np.array([4.0, 3.0, 3.0, 0.0])
dok_bola = np.array([0.0, 1.0, 1.0, 5.0])


def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


print("\nKemiripan dok_ml dan dok_ml_lagi  :", f"{cosine_similarity(dok_ml, dok_ml_lagi):.3f}")
print("Kemiripan dok_ml dan dok_bola     :", f"{cosine_similarity(dok_ml, dok_bola):.3f}")
print("Kemiripan dok_ml_lagi dan dok_bola:", f"{cosine_similarity(dok_ml_lagi, dok_bola):.3f}")

Output yang Dihasilkan:

text 
Vektor fitur rumah : [70.   3.   1.5]
Bentuk (shape)     : (3,)
Jumlah elemen      : 3

Hitungan tangan u . v = 2*3 + 1*4 = 10
NumPy np.dot(u, v)                = 10.0
Operator u @ v                    = 10.0

Hitungan tangan ||v|| = sqrt(3^2 + 4^2) = 5.0
NumPy np.linalg.norm(v)                 = 5.0

Kemiripan dok_ml dan dok_ml_lagi  : 0.955
Kemiripan dok_ml dan dok_bola     : 0.214
Kemiripan dok_ml_lagi dan dok_bola: 0.198

Mari kita telaah baris-baris kode yang berperan penting:

  1. Baris 9–12 (rumah = np.array(...) dan tiga baris print): vektor fitur satu rumah dibuat dari list Python; atribut shape melaporkan (3,) dan atribut size menghitung tiga elemen.
  2. Baris 16–20 (u, v, dan pembandingnya): hitungan tangan 2*3 + 1*4 = 10 disandingkan dengan np.dot(u, v) dan operator @. Ketiganya menghasilkan angka yang sama karena pada vektor satu dimensi operator @ memang menjalankan dot product.
  3. Baris 24–25 (np.linalg.norm): norma L2 vektor [3, 4] bernilai 5 — segitiga siku-siku klasik 3-4-5. Nilai inilah yang dipakai sebagai jarak antar sampel pada algoritme k-nearest neighbors.
  4. Baris 29–31 dan 34–35 (tiga dokumen dan fungsi cosine_similarity): setiap dokumen diubah menjadi vektor hitungan kata, kemudian kemiripan dihitung sebagai dot product yang dibagi panjang kedua vektor.
  5. Baris 38–40 (tiga baris hasil): nilai 0,955 menandakan dua dokumen tentang machine learning hampir searah; nilai 0,214 dan 0,198 menandakan dokumen machine learning dan dokumen sepak bola nyaris tidak berhubungan.

Dot Product, Norma, dan Kemiripan #

Dot product menjumlahkan hasil perkalian elemen pada posisi yang sama. Jika dua vektor memiliki nilai besar di posisi-posisi yang sama, hasilnya besar dan positif — itulah sebabnya dot product bekerja sebagai skor kemiripan. Neuron pada jaringan saraf juga menghitung hal yang persis sama: bobot dikalikan dot product dengan masukan, lalu ditambah bias.

Dot product mentah punya satu kelemahan: nilainya ikut membesar untuk vektor yang panjang. Dokumen dengan 500 kata otomatis punya hitungan kata besar walaupun topiknya berbeda. Cosine similarity memperbaikinya dengan membagi dot product oleh norma kedua vektor, sehingga hasilnya hanya mengukur arah dan selalu berada di rentang −1 sampai 1. Pencarian dokumen dan sistem rekomendasi memakai ukuran ini secara luas.

Norma L2 sendiri punya dua peran besar di machine learning. Pertama, sebagai jarak Euclidean antar dua sampel — jarak minimum antara pasangan fitur yang dinormalkan dengan benar. Kedua, sebagai penalti regularisasi: model Ridge menambahkan kuadrat norma vektor bobot ke loss function agar model memilih bobot kecil dan tidak terlalu menyesuaikan derau pada data latih.

Matriks: Dataset sebagai Tabel Angka #

Satu vektor menyimpan satu sampel. Begitu kita menumpuk ribuan sampel, hasilnya adalah matriks berbentuk (jumlah sampel, jumlah fitur). scikit-learn memakai konvensi ini tanpa kompromi: baris adalah sampel, kolom adalah fitur. Matriks berbentuk (4, 3) berarti empat sampel dengan tiga fitur per sampel.

File kedua menunjukkan wajah aljabar linear yang paling penting bagi machine learning: perkalian matriks X @ w yang menghitung prediksi model linear untuk seluruh dataset dalam satu operasi.

python 
# Matriks sebagai tabel dataset dan perkalian matriks sebagai model linear.

import numpy as np

np.set_printoptions(precision=2, suppress=True)

# Matriks X: 4 baris data x 3 kolom fitur
# Kolom: [luas (m2), jumlah kamar, usia bangunan (tahun)]
X = np.array([
    [70.0, 3.0, 10.0],
    [120.0, 4.0, 2.0],
    [85.0, 3.0, 25.0],
    [150.0, 5.0, 12.0],
])
print("Dataset X:")
print(X)
print("Bentuk X (baris, kolom):", X.shape)
print("Jumlah baris (sampel)  :", X.shape[0])
print("Jumlah kolom (fitur)   :", X.shape[1])

# Bobot model linear harga (juta rupiah), dipelajari saat training.
w = np.array([3.5, 20.0, -0.8])
b = 30.0

# Prediksi rumah pertama, hitungan tangan:
# 70*3.5 + 3*20 + 10*(-0.8) + 30 = 245 + 60 - 8 + 30 = 327
print("\nPrediksi rumah pertama (hitungan tangan) : 327.00")
print("Prediksi rumah pertama (X[0] @ w + b)    :", f"{X[0] @ w + b:.2f}")

# Prediksi seluruh baris sekaligus: (4, 3) @ (3,) -> (4,)
prediksi = X @ w + b
print("\nPrediksi 4 rumah (juta rupiah):")
print(prediksi)

# Dua model sekaligus: W berbentuk (3 fitur, 2 model), lalu X @ W -> (4, 2)
W = np.array([
    [3.5, 2.0],
    [20.0, 15.0],
    [-0.8, -0.5],
])
dua_model = X @ W
print(f"\nX @ W berbentuk {dua_model.shape}: 4 baris data, 2 model")
print(dua_model)

Output yang Dihasilkan:

text 
Dataset X:
[[ 70.   3.  10.]
 [120.   4.   2.]
 [ 85.   3.  25.]
 [150.   5.  12.]]
Bentuk X (baris, kolom): (4, 3)
Jumlah baris (sampel)  : 4
Jumlah kolom (fitur)   : 3

Prediksi rumah pertama (hitungan tangan) : 327.00
Prediksi rumah pertama (X[0] @ w + b)    : 327.00

Prediksi 4 rumah (juta rupiah):
[327.  528.4 367.5 645.4]

X @ W berbentuk (4, 2): 4 baris data, 2 model
[[297.  180. ]
 [498.4 299. ]
 [337.5 202.5]
 [615.4 369. ]]

Bedah kode di atas baris demi baris:

  1. Baris 9–14 (X = np.array(...)): empat baris data rumah ditumpuk menjadi matriks (4, 3). Baris pertama [70, 3, 10] adalah satu sampel; kolom pertama memuat fitur luas untuk seluruh sampel.
  2. Baris 22–23 (w dan b): vektor bobot menyimpan kontribusi tiap fitur terhadap harga, sedangkan b adalah bias — harga dasar sebelum fitur mana pun dihitung. Pada model sungguhan, nilai-nilai ini dipelajari algoritme training, bukan diketik manual seperti di sini.
  3. Baris 27–28: prediksi rumah pertama dihitung dua cara — hitungan tangan dan X[0] @ w + b — dan keduanya menghasilkan 327,00 juta rupiah. Satu baris data cukup dikalikan dot product dengan bobot.
  4. Baris 31–33 (prediksi = X @ w + b): NumPy mengalikan keempat baris sekaligus. Bentuk (4, 3) @ (3,) menghasilkan (4,) — satu prediksi per sampel tanpa loop eksplisit.
  5. Baris 36–43 (W dan dua_model): matriks bobot W berbentuk (3, 2) memuat dua model sekaligus. Hasil X @ W berbentuk (4, 2): setiap baris berisi prediksi kedua model untuk sampel tersebut. Komputasi berbentuk inilah yang dipakai setiap layer jaringan saraf.

Perkalian Matriks sebagai Model Linear #

Model regresi linear ditulis sebagai ŷ = b + w₁x₁ + w₂x₂ + w₃x₃, atau ringkasnya ŷ = b + w·x. Untuk satu batch berisi m sampel, seluruh prediksi dihitung sekaligus sebagai ŷ = Xw + b. Aturan bentuknya wajib dihafal: jumlah kolom di ruas kiri harus sama dengan jumlah baris di ruas kanan, sehingga (m, n) @ (n, k) menghasilkan (m, k). Jaringan saraf modern pada dasarnya adalah rangkaian operasi X @ W yang disambung fungsi aktivasi — miliaran perkalian matriks kecil setiap kali model melakukan satu prediksi.

OperasiRumusan ringkasPeran di machine learning
Dot productJumlah hasil kali elemen seposisiSkor kemiripan, keluaran satu neuron
Norma L2Akar jumlah kuadrat elemenJarak antar sampel, penalti Ridge
Cosine similarityDot product dibagi panjang kedua vektorPencarian dokumen, sistem rekomendasi
Perkalian matriksBaris kali kolom, berlapisPrediksi satu batch, layer jaringan saraf

Aljabar linear memberi kita bentuk model, tetapi satu pertanyaan penting masih terbuka: dari mana nilai w dan b terbaik itu datang? Jawabannya ada di kalkulus — turunan memberi tahu arah setiap parameter harus digeser supaya galat prediksi mengecil. Kita akan mengurai mekanisme tersebut pada Chapter Kalkulus untuk Machine Learning.

Referensi Resmi #