04 — Aljabar Linear (Intuisi)

Estimasi: 6 jam (3-4 jam baca + 2 jam tonton 3Blue1Brown) Tujuan: Paham vektor, matriks, dot product, dan eigenvalue secara visual — bukan untuk hitung manual.

WAJIB SEBELUM BACA: tonton 3Blue1Brown "Essence of Linear Algebra" di YouTube (15 video, 3 jam total). File ini adalah summary + practice, bukan pengganti video.

Pembukaan

Aljabar linear adalah bahasa neural network. Setiap layer di NN adalah multiplikasi matriks. Tanpa intuisi aljabar linear, deep learning terasa magic (dan saat error, kamu tidak tahu kenapa).

Tujuan kita: dapat gambar mental untuk konsep penting. Komputasi biarkan NumPy.

Kenapa Materi Ini Penting?

Sebelum lanjut, mari sambungkan setiap konsep ke aplikasi nyata di AI/ML:

flowchart LR
    V["📐 Vektor"] --> E["🔤 Embedding<br/>(kata → angka)"]
    M["🔢 Matriks"] --> W["⚖️ Weight Layer<br/>di Neural Net"]
    D["🎯 Dot Product"] --> A["👁️ Attention<br/>di Transformer"]
    EV["🧭 Eigenvector"] --> P["📉 PCA<br/>(reduksi dimensi)"]
    MM["✖️ Matrix Mult"] --> F["⚡ Forward Pass<br/>NN"]

Konsep Aljabar Linear	Dipakai di Mana di AI/ML
Vektor	Embedding kata, gambar, audio jadi angka
Dot product	Cosine similarity (RAG, semantic search), attention score
Matrix multiplication	Setiap layer NN, transformer block, output projection
Transpose	Backpropagation, attention (Q × Kᵀ)
Eigenvalue/vector	PCA, spectral methods, stability analisis
Tensor	Format data di PyTorch/TensorFlow

Bottom line: ChatGPT pada dasarnya = tumpukan multiplikasi matriks dengan beberapa fungsi non-linear di antaranya. Paham aljabar linear = paham mesin di balik LLM.

Bagian 1 — Vektor

Definisi 3 Sudut Pandang

1. Vektor sebagai panah (geometri)

Punya arah dan panjang.

Analogi: vektor itu seperti panah dari titik (0,0). Dua hal yang penting: kemana panahnya menunjuk (arah) dan seberapa panjang (magnitude). Dua vektor sama kalau arah dan panjangnya sama, tidak peduli "ditaruh" di mana.

Cara Membaca Diagram:

Node Origin = titik (0, 0) sebagai pangkal panah.
Edge bertuliskan "arah + panjang" = dua atribut yang mendefinisikan vektor.
Node Titik (3, 4) = ujung panah, nilai komponen vektor.

Walkthrough Step-by-Step:

Mulai dari Origin di koordinat (0, 0).
Pilih arah dan panjang — keduanya membentuk panah.
Ujung panah jatuh di (3, 4); list angka [3, 4] adalah representasi numeriknya.

Analogi Sehari-hari: seperti instruksi navigasi "jalan 3 langkah ke timur, 4 langkah ke utara" — yang penting hanya arah dan jaraknya.

Diagram statis Mermaid sebagai fallback:

flowchart LR
    O["🎯 Origin<br/>(0,0)"] -->|"arah + panjang"| V["📍 Titik (3,4)<br/>vektor [3,4]"]

2. Vektor sebagai list angka (komputer)

v = [3, 4]      # 2D
v = [3, 4, 5]   # 3D
v = [3, 4, 5, ..., 768]   # 768D (typical embedding)

3. Vektor sebagai titik di ruang (analogi)

[3, 4] = titik di koordinat (3, 4) di plot 2D.

Insight: dalam ML, kita kerja di ruang dimensi tinggi (768D, 1536D, dll). Tidak bisa visualkan, tapi konsep tetap sama dengan 2D/3D.

Operasi Vektor

Penjumlahan (Element-wise)

[1, 2] + [3, 4] = [4, 6]

Visualisasi: tempel ekor vektor B ke ujung A.

Analogi "perjalanan": kalau A = "jalan 1 km timur, 2 km utara", dan B = "jalan 3 km timur, 4 km utara", maka A+B = "jalan 4 km timur, 6 km utara". Tempel rute satu ke ujung rute lainnya.

Cara Membaca Diagram:

Node Start = titik awal perjalanan di (0, 0).
Edge vektor A = pergerakan pertama menuju (1, 2).
Edge vektor B = lanjut dari titik tengah menuju (4, 6).
Edge putus-putus = vektor hasil A+B langsung dari Start ke End.

Walkthrough Step-by-Step:

Mulai di Start (0, 0), terapkan vektor A → tiba di (1, 2).
Dari (1, 2), terapkan vektor B → tiba di (4, 6).
Vektor hasil A+B = panah lurus dari Start ke End, komponennya ditambahkan elemen-per-elemen.

Analogi Sehari-hari: dua segmen perjalanan yang disambung. Total perpindahan sama saja kalau kamu langsung "potong kompas" dari awal ke akhir.

Diagram statis Mermaid sebagai fallback:

flowchart LR
    S["🚶 Start (0,0)"] -->|"vektor A<br/>[1,2]"| M["📍 (1,2)"]
    M -->|"vektor B<br/>[3,4]"| E["🎯 End (4,6)"]
    S -.->|"A+B = [4,6]"| E

Skalar (Scaling)

2 * [3, 4] = [6, 8]

Visualisasi: panjangkan/perpendek vektor.

Magnitude (Panjang)

|v| = √(x² + y² + z² + ...)

import numpy as np
v = np.array([3, 4])
np.linalg.norm(v)    # 5.0  (dari Pythagoras)

Bagian 2 — Dot Product (Hasil Kali Titik)

WAJIB PAHAM — dot product adalah operasi paling penting di neural network.

Analogi "kecocokan": dot product itu seperti mengukur seberapa sejalan dua vektor. Bayangkan kamu dan teman lagi mendorong gerobak. Kalau kalian dorong ke arah yang sama → gerobak melaju kencang (dot product besar positif). Kalau kalian dorong tegak lurus → gerobak tidak bergerak (dot product = 0). Kalau kalian dorong berlawanan → gerobak malah mundur (dot product negatif).

Cara Membaca Diagram:

Node atas = operasi a · b, bercabang ke 3 kemungkinan tanda.
3 cabang tengah = hasil Positif / Nol / Negatif.
3 node bawah = interpretasi praktis tiap kasus.

Walkthrough Step-by-Step:

Hitung a · b (jumlah perkalian elemen).
Lihat tandanya untuk tahu hubungan arah dua vektor.
Terjemahkan ke makna: vektor mirip, tidak related, atau bertentangan.

Analogi Sehari-hari: dua kekuatan yang dorong objek. Searah = ketolong, tegak lurus = sia-sia, berlawanan = saling membatalkan.

Diagram statis Mermaid sebagai fallback:

flowchart TD
    DP["🎯 Dot Product<br/>a · b"] --> Pos["✅ Positif<br/>(arah serupa)"]
    DP --> Zero["⚪ Nol<br/>(tegak lurus)"]
    DP --> Neg["❌ Negatif<br/>(arah berlawanan)"]
    Pos --> ExP["🤝 Mirip<br/>(cocok)"]
    Zero --> ExZ["🔀 Tidak related"]
    Neg --> ExN["🔁 Bertentangan"]

Formula

a · b = a₁×b₁ + a₂×b₂ + ... + aₙ×bₙ

Hasil: satu angka (scalar).

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

a @ b           # 32 (operator @ untuk dot product)
np.dot(a, b)    # 32

Worked Example — Hitung Dot Product Step-by-Step

Mari kita hitung a · b dimana a = [1, 2, 3] dan b = [4, 5, 6]:

Step 1: Kalikan elemen per elemen
        a₁ × b₁ = 1 × 4 = 4
        a₂ × b₂ = 2 × 5 = 10
        a₃ × b₃ = 3 × 6 = 18

Step 2: Jumlahkan semua
        4 + 10 + 18 = 32

Hasil: a · b = 32

flowchart LR
    A1["1 × 4 = 4"] --> Sum["➕ Sum"]
    A2["2 × 5 = 10"] --> Sum
    A3["3 × 6 = 18"] --> Sum
    Sum --> R["🎯 Hasil: 32"]

Interpretasi Geometri

a · b = |a| × |b| × cos(θ)

dimana θ = sudut antara a dan b.

Implikasi:

a · b > 0 → vektor menghadap arah serupa
a · b = 0 → vektor tegak lurus (perpendicular)
a · b < 0 → vektor menghadap arah berlawanan

Cosine Similarity (Penting di NLP/Embedding!)

Normalize jadi range [-1, 1]:

cos_sim = (a · b) / (|a| × |b|)

1.0 = identik arah
0.0 = tegak lurus (tidak related)
-1.0 = berlawanan

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

Aplikasi di RAG: mencari dokumen yang embedding-nya paling mirip dengan query → cosine similarity. Inilah cara vector DB bekerja.

flowchart TD
    Q["❓ Query<br/>'kucing imut'"] --> EQ["📐 Embed jadi<br/>vektor 768D"]
    EQ --> CS["🎯 Cosine similarity<br/>vs semua dokumen"]
    CS --> Rank["📊 Ranking by<br/>similarity score"]
    Rank --> Top["🏆 Top-K dokumen<br/>paling mirip"]

Bagian 3 — Matriks

Definisi

Matriks = tabel angka atau list of vektor.

M = [[1, 2, 3],
     [4, 5, 6]]

2 baris, 3 kolom → matriks 2×3.

Analogi "mesin transformasi": matriks itu seperti mesin yang menerima vektor sebagai input, dan mengeluarkan vektor lain sebagai output. Mesin ini bisa memutar, memanjangkan, memendekkan, atau memiringkan vektor. Setiap matriks adalah jenis mesin yang berbeda.

Cara Membaca Diagram:

Node kiri = vektor input mentah [x, y].
Node tengah = matriks M sebagai mesin transformasi.
Node kanan = vektor hasil [x', y'] setelah transformasi.

Walkthrough Step-by-Step:

Vektor masuk ke mesin (matrix multiplication dengan M).
Matriks menerapkan rotasi/scaling/shear sesuai isinya.
Vektor baru keluar — bisa berputar, memanjang, atau berubah arah.

Analogi Sehari-hari: seperti filter foto. Foto sama (input vektor), tapi efeknya beda tergantung filter (matriks) yang dipasang.

Diagram statis Mermaid sebagai fallback:

flowchart LR
    V["📥 Input vektor<br/>[x, y]"] --> M["🔧 Matriks M<br/>(mesin transformasi)"]
    M --> V2["📤 Output vektor<br/>[x', y']"]

M = np.array([[1, 2, 3], [4, 5, 6]])
M.shape    # (2, 3)

Operasi Dasar

M + N        # element-wise add (shape harus sama)
M - N        # element-wise sub
M * N        # element-wise multiply (Hadamard)
2 * M        # scalar multiply
M.T          # transpose

Transpose

Tukar baris dan kolom:

M = [[1, 2, 3]              M.T = [[1, 4]
     [4, 5, 6]]                    [2, 5]
                                   [3, 6]]

Shape (2, 3) → (3, 2).

Bagian 4 — Matrix Multiplication (Inti Deep Learning!)

Inti dari neural network.

Aturan

Matriks A (m×n) bisa kalikan B (n×p) → hasil C (m×p).

Penting: kolom A = baris B.

Cara Hitung

Element C[i][j] = dot product dari baris i A dan kolom j B.

A = [[1, 2]              B = [[5, 6]
     [3, 4]]                  [7, 8]]

A @ B = [[1×5+2×7, 1×6+2×8]
         [3×5+4×7, 3×6+4×8]]

       = [[19, 22]
          [43, 50]]

Worked Example — Matrix-Vector Multiplication Step-by-Step

Anggap kita punya weight matrix W dan input vektor x:

W = [[2, 0]              x = [3]
     [0, 3]]                  [4]

W @ x = [[2×3 + 0×4]    = [6]
         [0×3 + 3×4]]      [12]

flowchart TD
    Start["📥 Input x = [3, 4]"] --> R1["Baris 1 W:<br/>[2, 0] · [3, 4]<br/>= 2×3 + 0×4 = 6"]
    Start --> R2["Baris 2 W:<br/>[0, 3] · [3, 4]<br/>= 0×3 + 3×4 = 12"]
    R1 --> Out["📤 Output = [6, 12]"]
    R2 --> Out

Interpretasi: matriks W "men-scale" sumbu x dengan 2 dan sumbu y dengan 3.

A @ B            # operator @
np.matmul(A, B)  # equivalent
A.dot(B)         # also equivalent

Interpretasi Geometri

Matrix × Vector = transformasi vektor.

Setiap matriks adalah transformasi linear:

Rotasi
Scaling
Shear
Projeksi

Insight ML: weight matrix di neural network = transformasi yang model pelajari. Saat training, model "menemukan" transformasi yang map input ke output.

Aplikasi di Neural Network

Linear layer di NN:

output = W @ input + b

dimana:

W = weight matrix (yang dilatih)
input = vektor input
b = bias vektor
output = vektor hasil

Itulah satu layer. Dilakukan berulang dengan activation function di antara → deep neural network.

flowchart LR
    X["📥 Input x"] --> L1["W₁ @ x + b₁"]
    L1 --> A1["⚡ Activation"]
    A1 --> L2["W₂ @ ... + b₂"]
    L2 --> A2["⚡ Activation"]
    A2 --> L3["W₃ @ ... + b₃"]
    L3 --> Y["📤 Output"]

import torch
import torch.nn as nn

# 1 linear layer: input 768D → output 256D
layer = nn.Linear(in_features=768, out_features=256)

# Saat layer(x) dipanggil, di dalamnya:
# output = W @ x + b

Bagian 5 — Identity & Inverse Matrix

Identity Matrix (I)

Matriks "1" dunia matriks. Diagonal 1, lainnya 0.

I = [[1, 0, 0]
     [0, 1, 0]
     [0, 0, 1]]

Property: M @ I = M (kalau ukuran cocok).

I = np.eye(3)

Inverse Matrix (M⁻¹)

Matriks yang kalau dikali matriks asal = identity.

M @ M⁻¹ = I

Tidak semua matriks punya inverse (yang punya disebut invertible / non-singular).

M_inv = np.linalg.inv(M)

Konteks ML: inverse matrix dipakai di linear regression (analytical solution: w = (X.T @ X)⁻¹ @ X.T @ y). Tapi untuk dataset besar, gradient descent lebih praktis.

Bagian 6 — Eigenvalue & Eigenvector (Konseptual)

Eigenvector = vektor yang arahnya tidak berubah saat di-transformasi matriks (cuma scaling).

M @ v = λ × v

dimana λ (lambda) = eigenvalue, v = eigenvector.

Intuisi

Bayangkan matriks adalah transformasi. Kebanyakan vektor akan berubah arah setelah ditransformasi. Tapi ada vektor istimewa yang arahnya sama, cuma dipanjangkan/perpendek.

Analogi "sumbu komidi putar": bayangkan komidi putar berputar. Kebanyakan titik bergerak melingkar (berubah arah). Tapi sumbu di tengah tidak bergerak — itulah eigenvector dari rotasi tersebut. Untuk transformasi linear lainnya, eigenvector adalah "arah istimewa" yang tetap sejajar setelah ditransformasi.

Cara Membaca Diagram:

Baris atas: vektor biasa berubah arah setelah dilewatkan matriks M.
Baris bawah: eigenvector tetap sejajar, hanya panjangnya berubah (×λ).
Bandingkan dua hasil untuk memahami sifat "istimewa" eigenvector.

Walkthrough Step-by-Step:

Pilih vektor biasa, misalnya [1, 0]. Kalikan dengan M → arahnya berubah.
Pilih eigenvector v dari M. Kalikan dengan M → hasilnya λv (arah sama).
Skala λ disebut eigenvalue; tanda positif/negatif menentukan arah scaling.

Analogi Sehari-hari: kalau kamu memutar piring keramik, banyak titik bergerak melingkar. Tapi titik di pusat piring tetap di tempat — itulah "arah eigen" dari rotasi tersebut.

Diagram statis Mermaid sebagai fallback:

flowchart LR
    V1["📐 Vektor biasa<br/>[1, 0]"] --> T1["🔧 Matriks M"]
    T1 --> V1Out["📐 Vektor baru<br/>arah berubah"]
    V2["⭐ Eigenvector<br/>v"] --> T2["🔧 Matriks M"]
    T2 --> V2Out["⭐ Hasil λv<br/>arah SAMA<br/>cuma di-scale λ"]

Aplikasi

PCA (Principal Component Analysis) — dimensionality reduction. Eigenvector dengan eigenvalue terbesar = arah variansi terbesar di data.
Spektral clustering
Stability analysis

Tidak perlu paham detail sekarang. Paham bahwa PCA pakai eigenvalue/vector sudah cukup untuk Fase 4-5.

Bagian 7 — Tensor (Generalisasi Matriks)

Dimensi	Nama	Contoh
0	Scalar	5
1	Vector	[1, 2, 3]
2	Matrix	[[1, 2], [3, 4]]
3	Tensor 3D	gambar grayscale dengan batch
4	Tensor 4D	batch gambar berwarna

Tensor = generalisasi ke dimensi lebih tinggi.

Tensor di Deep Learning

Image grayscale: [height, width] — 2D tensor
Image RGB: [height, width, 3] — 3D tensor
Batch of images: [batch, height, width, channels] — 4D tensor
Text batch (after embedding): [batch, seq_len, embed_dim] — 3D tensor

import torch

# Bikin tensor
t = torch.tensor([[1, 2], [3, 4]])
t.shape    # torch.Size([2, 2])

# Operasi sama dengan NumPy
t + t
t @ t
t.T

PyTorch tensor = NumPy array + GPU support + autograd.

Bagian 8 — Broadcasting (Penting di NumPy/PyTorch)

Cara NumPy/PyTorch handle operasi antar shape berbeda.

Aturan Broadcasting

Align shape dari kanan
Dimensi cocok kalau sama, atau salah satunya 1
Jika beda, error

Contoh

A = np.array([[1, 2, 3], [4, 5, 6]])    # shape (2, 3)
b = np.array([10, 20, 30])               # shape (3,)

A + b
# [[11, 22, 33],
#  [14, 25, 36]]
# b di-"broadcast" ke setiap baris A

M = np.array([[1, 2], [3, 4]])    # shape (2, 2)
v = np.array([[5], [6]])           # shape (2, 1)

M * v
# [[ 5, 10],
#  [18, 24]]
# v di-broadcast ke setiap kolom M

Kapan Berguna?

Add bias ke setiap row matrix
Normalize per kolom (subtract mean per kolom)
Element-wise op antar tensor shape mirip

Bagian 9 — Hands-On dengan NumPy

import numpy as np

# Bikin
v = np.array([1, 2, 3])
M = np.array([[1, 2], [3, 4]])

# Random
np.random.seed(42)
random_v = np.random.randn(3)        # 3 angka random normal
random_M = np.random.randn(2, 3)     # 2x3 matrix

# Special
np.zeros((3, 3))
np.ones((2, 4))
np.eye(3)                             # identity

# Shape & dtype
M.shape          # (2, 2)
M.dtype          # int64
M.ndim           # 2

# Indexing & slicing
M[0]             # row 0: [1, 2]
M[:, 0]          # col 0: [1, 3]
M[0:2, 0:2]      # submatrix
M[M > 2]         # boolean indexing: [3, 4]

# Matrix ops
M @ M            # matmul
M * M            # element-wise (Hadamard)
M.T              # transpose
np.linalg.inv(M) # inverse
np.linalg.norm(v) # magnitude
v @ v            # dot product

# Aggregations
M.sum()          # sum semua
M.sum(axis=0)    # sum per kolom: [4, 6]
M.sum(axis=1)    # sum per baris: [3, 7]
M.mean()
M.std()
M.max(), M.argmax()

# Reshape
v.reshape(3, 1)  # column vector
M.reshape(4)     # flatten
M.flatten()      # same

Cek Pemahaman

Bisa visualisasi vektor sebagai panah dan list angka?
Tahu cara hitung dot product?
Paham makna geometri dot product (angle)?
Tahu cosine similarity dan aplikasinya?
Bisa multiply 2 matriks?
Tahu kenapa matrix mult = inti neural network?
Bisa pakai NumPy untuk operasi dasar?

Hubungan dengan AI/ML

Setelah paham konsep, mari lihat di mana persisnya materi ini muncul di sistem AI nyata:

flowchart TD
    Input["💬 Input text<br/>'Hello world'"] --> Tok["🔤 Tokenizer"]
    Tok --> Emb["📐 Embedding<br/>(VEKTOR per token)"]
    Emb --> Att["👁️ Attention<br/>Q · Kᵀ (DOT PRODUCT)"]
    Att --> FF["⚖️ Feed Forward<br/>W @ x + b (MATRIX MULT)"]
    FF --> Out["📤 Output logits<br/>(VEKTOR ukuran vocab)"]
    Out --> Soft["🎲 Softmax → token"]

Komponen LLM	Aljabar Linear yang Dipakai
Tokenizer + Embedding	Setiap token jadi vektor 768D/1536D/4096D
Self-attention	Q × Kᵀ (dot product), Q/K/V semua hasil matrix mult
Feed-forward layer	W₁ @ x + b₁, lalu W₂ @ ... + b₂
Output projection	Matrix mult ke vocab size, lalu softmax
RAG retrieval	Cosine similarity antar embedding
Fine-tuning (LoRA)	Approximate weight update sebagai 2 matriks kecil A @ B

Insight kunci: kalau kamu pernah dengar "GPT punya 175 miliar parameter", itu sebagian besar adalah angka di matriks weight. Training = mencari angka-angka itu.

Common Mistakes & FAQ

"Vektor itu sama dengan list di Python?"

Hampir. Secara teknis di NumPy, np.array([1, 2, 3]) adalah vektor. Tapi [1, 2, 3] Python list bukan vektor sampai dijadikan array — operasi vektor tidak akan jalan di Python list biasa ([1,2] + [3,4] di Python = [1,2,3,4] concat, bukan element-wise add).

"Kapan pakai `*` vs `@`?"

* di NumPy/PyTorch = element-wise (Hadamard product). Shape harus sama atau broadcastable.
@ = matrix multiplication (dot product). Aturan dimensi: kolom kiri = baris kanan.

A * B    # element-wise
A @ B    # matrix mult

Pemula sering tertukar dan dapat output yang shape-nya bener tapi nilainya salah.

"Kenapa shape error muncul terus?"

99% bug di pemula deep learning = shape mismatch. Biasakan print tensor.shape sebelum dan sesudah setiap operasi.

print(f"Before: {x.shape}")
x = layer(x)
print(f"After: {x.shape}")

"Dot product vs cross product, beda?"

Dot product = scalar (1 angka). Mengukur keserupaan arah.
Cross product = vektor (di 3D). Tegak lurus terhadap kedua input. Tidak dipakai di ML standar.

"Vektor baris vs vektor kolom — penting?"

Secara matematika murni, ya. Di NumPy 1D array tidak punya konsep "baris" atau "kolom" sampai kamu reshape. Tapi di rumus matematika ML (mis. Wx), W biasanya kalikan vektor kolom dari kanan. Hati-hati saat menerjemahkan rumus paper ke kode.

"Tensor vs ndarray vs Matrix?"

Scalar = 0D (angka tunggal)
Vector = 1D
Matrix = 2D
Tensor = umum untuk semua dimensi (terutama 3D+)

Di PyTorch, semua disebut "tensor" walau cuma 1 angka.

Challenge 3.4

Challenge 1 — Tonton 3Blue1Brown (WAJIB)

Essence of Linear Algebra Episode 1-9 (~2 jam total). Catat di jurnal:

3 insight baru per episode
Pertanyaan yang masih bingung

Episode 1-9 cukup untuk fondasi. Sisanya bisa nanti.

Challenge 2 — Vector Operations Manual

Tanpa NumPy, hitung manual (boleh kalkulator):

Magnitude [3, 4, 12]
Dot product [1, 2, 3] dan [4, -5, 6]
Cosine similarity [1, 0, 0] dan [0, 1, 0]
2 × [1, 2, 3] + 3 × [4, 5, 6]

Cek dengan NumPy.

Challenge 3 — Matrix Multiplication

Hitung manual (paper):

A = [[1, 2]      B = [[5, 6, 7]
     [3, 4]]          [8, 9, 10]]

A @ B = ?

Cek dengan NumPy.

Challenge 4 — NumPy Practice

Pakai NumPy:

Bikin matrix 5×5 random
Hitung mean per kolom
Bikin matrix dimana setiap row = mean kolom
Subtract mean dari original (centering data)
Hitung covariance matrix ((M.T @ M) / n)

Challenge 5 — Cosine Similarity di NLP

Bikin function cosine_sim(a, b). Test dengan:

Kata-kata "dummy embedding" (random, tapi konsisten):

np.random.seed(42)
embeddings = {
    "kucing": np.random.randn(10),
    "anjing": np.random.randn(10),
    "meja": np.random.randn(10),
    "kursi": np.random.randn(10),
}

Hitung cosine similarity semua pasang. Lihat siapa paling mirip dengan siapa.

Challenge 6 — Implementasi Linear Layer

import numpy as np

class LinearLayer:
    def __init__(self, in_features, out_features):
        self.W = np.random.randn(out_features, in_features) * 0.01
        self.b = np.zeros(out_features)
    
    def forward(self, x):
        # output = W @ x + b
        return self.W @ x + self.b

layer = LinearLayer(in_features=4, out_features=3)
x = np.array([1, 2, 3, 4])
output = layer.forward(x)
print(output.shape)    # (3,)

Test dengan beberapa input. Pahami: ini persis seperti nn.Linear di PyTorch.

Challenge 7 — Visualisasi 2D

Pakai matplotlib:

Plot beberapa vektor 2D sebagai arrow
Plot transformasi matriks (sebelum dan sesudah)
Lihat efek scaling, rotation, shear

import numpy as np
import matplotlib.pyplot as plt

# Vector original
v = np.array([1, 2])

# Transformation matrix
M = np.array([[2, 0], [0, 1]])    # scaling x by 2

# Transform
v_transformed = M @ v

# Plot
fig, ax = plt.subplots()
ax.quiver(0, 0, v[0], v[1], scale=1, scale_units='xy', angles='xy', color='blue', label='original')
ax.quiver(0, 0, v_transformed[0], v_transformed[1], scale=1, scale_units='xy', angles='xy', color='red', label='transformed')
ax.set_xlim(-1, 5)
ax.set_ylim(-1, 5)
ax.legend()
ax.grid()
plt.show()

Challenge 8 — Refleksi

Tulis di jurnal: "Setelah belajar aljabar linear, apa yang sebelumnya magic tentang neural network sekarang masuk akal?"

300-500 kata.

Selanjutnya: 05-calculus-intuition.md — kalkulus secukupnya untuk paham gradient descent.

Aljabar Linear (Intuisi)

04 — Aljabar Linear (Intuisi)

Pembukaan

Kenapa Materi Ini Penting?

Bagian 1 — Vektor

Definisi 3 Sudut Pandang

Operasi Vektor

Penjumlahan (Element-wise)

Skalar (Scaling)

Magnitude (Panjang)

Bagian 2 — Dot Product (Hasil Kali Titik)

Formula

Worked Example — Hitung Dot Product Step-by-Step

Interpretasi Geometri

Cosine Similarity (Penting di NLP/Embedding!)

Bagian 3 — Matriks

Definisi

Operasi Dasar

Transpose

Bagian 4 — Matrix Multiplication (Inti Deep Learning!)

Aturan

Cara Hitung

Worked Example — Matrix-Vector Multiplication Step-by-Step

Interpretasi Geometri

Aplikasi di Neural Network

Bagian 5 — Identity & Inverse Matrix

Identity Matrix (I)

Inverse Matrix (M⁻¹)

Bagian 6 — Eigenvalue & Eigenvector (Konseptual)

Intuisi

Aplikasi

Bagian 7 — Tensor (Generalisasi Matriks)

Tensor di Deep Learning

Bagian 8 — Broadcasting (Penting di NumPy/PyTorch)

Aturan Broadcasting

Contoh

Kapan Berguna?

Bagian 9 — Hands-On dengan NumPy

Cek Pemahaman

Hubungan dengan AI/ML

Common Mistakes & FAQ

"Vektor itu sama dengan list di Python?"

"Kapan pakai * vs @?"

"Kenapa shape error muncul terus?"

"Dot product vs cross product, beda?"

"Vektor baris vs vektor kolom — penting?"

"Tensor vs ndarray vs Matrix?"

Challenge 3.4

Challenge 1 — Tonton 3Blue1Brown (WAJIB)

Challenge 2 — Vector Operations Manual

Challenge 3 — Matrix Multiplication

Challenge 4 — NumPy Practice

Challenge 5 — Cosine Similarity di NLP

Challenge 6 — Implementasi Linear Layer

Challenge 7 — Visualisasi 2D

Challenge 8 — Refleksi

"Kapan pakai `*` vs `@`?"