🧠 Perceptron & Neural Network

Dari neuron sederhana sampai backpropagation — mesin yang membuat deep learning mungkin.

🎬 Animasi: Neural Network: Forward & Backward

Sinyal mengalir forward (biru) untuk memprediksi, lalu error mengalir backward (merah) untuk memperbaiki bobot. Ulangi ribuan kali.

📌 1. Perceptron: Satu "Neuron"

Perceptron = linear regression + fungsi aktivasi step:

    z = w·x + b
    output = 1 jika z > 0,  selain itu 0

Training (Perceptron Learning Rule):
    jika salah klasifikasi (y·z <= 0):
        w ← w + lr · y · x
        b ← b + lr · y

Fungsi aktivasi (pilih sesuai tugas):
    step    : 0/1                    (perceptron klasik)
    sigmoid : 1/(1+e^-z) → (0,1)     (probabilitas)
    tanh    : → (-1,1)
    ReLU    : max(0, z)              (paling populer di deep net — cepat, anti-vanishing)

BATAS PERCEPTRON: hanya bisa memisahkan data LINEARLY SEPARABLE.
→ XOR tidak bisa dipelajari satu perceptron (buktinya di bawah).

📌 2. Contoh: Perceptron Belajar AND, OR, lalu Gagal di XOR

print("=== PERCEPTRON: AND / OR / XOR ===\n")

def train_perceptron(X, y, epochs=100, lr=1.0, name=""):
    w = [0.0] * len(X[0])
    b = 0.0
    for e in range(epochs):
        mis = 0
        for xi, yi in zip(X, y):
            z = dot(w, xi) + b
            if yi * z <= 0:          # salah tebak
                w = vec_add(w, vec_scale(xi, lr * yi))
                b += lr * yi
                mis += 1
        if mis == 0:
            print("%s: KONVERGEN di epoch %d, w=%s b=%.1f"
                  % (name, e + 1, [round(v, 1) for v in w], b))
            return w, b
    pred = [1 if dot(w, xi) + b > 0 else 0 for xi in X]
    print("%s: TIDAK KONVERGEN → prediksi %s (seharusnya %s)"
          % (name, pred, y))
    return w, b

X = [[0, 0], [0, 1], [1, 0], [1, 1]]

train_perceptron(X, [0, 0, 0, 1], name="AND")
train_perceptron(X, [0, 1, 1, 1], name="OR ")
print()
train_perceptron(X, [0, 1, 1, 0], name="XOR")

print("""
Kenapa XOR gagal?
  XOR hanya benar jika KEDUA input 1. Tidak ada garis lurus
  yang bisa memisahkan {(1,0),(0,1)} dari {(0,0),(1,1)}.
  → Perlu LEBIH DARI SATU LAYER (lihat bawah).""")

Output:

📌 3. Multi-Layer Perceptron & Backpropagation

MLP = banyak neuron dalam beberapa layer:

    input(2) → hidden(3) → output(1)
      x1 ─┬─→ h1 ─┬─→ out
      x2 ─┤─→ h2 ─┤
          └─→ h3 ─┘
    Tiap panah = 1 bobot. Total bobot: 2·3 + 3·1 + bias = 12

FORWARD:  h = σ(W1·x + b1)      out = σ(W2·h + b2)

BACKPROPAGATION = chain rule untuk menghitung
"seberapa besar tiap bobot menyumbang error":
    ∂L/∂W2 = (out - y) · h
    ∂L/∂W1 = ((out - y) · W2 · h·(1-h)) · x
Lalu update semua bobot dengan gradient descent (seperti bab 4).

Teorema Universal Approximation:
    jaringan 1 layer tersembunyi (cukup lebar) bisa mengaproksimasi
    FUNGSI APA PUN — termasuk XOR. Layer lebih = komposisi fitur.

📌 4. Contoh: MLP 2-3-1 Belajar XOR

print("=== MLP 2-3-1 BELAJAR XOR (BACKPROP) ===\n")
random_seed(42)
X = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]]
y = [0.0, 1.0, 1.0, 0.0]

# Inisialisasi bobot
W1 = [[randn() * 0.5 for _ in range(3)] for _ in range(2)]  # 2x3
b1 = [0.0, 0.0, 0.0]
W2 = [randn() * 0.5 for _ in range(3)]
b2 = 0.0
lr = 0.5
n = len(X)
losses = []

def forward(x):
    h = [sigmoid(b1[k] + sum(W1[j][k] * x[j] for j in range(2)))
         for k in range(3)]
    out = sigmoid(b2 + sum(W2[k] * h[k] for k in range(3)))
    return h, out

for epoch in range(3000):
    gW1 = [[0.0] * 3 for _ in range(2)]
    gb1 = [0.0] * 3
    gW2 = [0.0] * 3
    gb2 = 0.0
    for xi, yi in zip(X, y):
        h, out = forward(xi)
        d_out = out - yi
        gb2 += d_out
        for k in range(3):
            gW2[k] += d_out * h[k]
            d_h = d_out * W2[k] * h[k] * (1 - h[k])
            gb1[k] += d_h
            for j in range(2):
                gW1[j][k] += d_h * xi[j]
    for j in range(2):
        for k in range(3):
            W1[j][k] -= lr * gW1[j][k] / n
    for k in range(3):
        b1[k] -= lr * gb1[k] / n
        W2[k] -= lr * gW2[k] / n
    b2 -= lr * gb2 / n
    if epoch % 500 == 0:
        loss = sum((forward(xi)[1] - yi) ** 2 for xi, yi in zip(X, y)) / n
        losses.append(loss)
        print("epoch %4d  MSE = %.4f" % (epoch, loss))

print("\nHasil akhir (XOR):")
for xi, yi in zip(X, y):
    _, out = forward(xi)
    print("  %s → P=%.3f  (seharusnya %d)" % (xi, out, int(yi)))
cost_curve(losses)

Output:

💡 Layer tersembunyi "membuat" fitur baru (h1,h2,h3) yang membuat XOR jadi linearly separable. Inilah inti deep learning: belajar representasi, bukan hanya memetakan input→output.

🧠 Latihan

Ubah aktivasi output dari sigmoid menjadi linear (regresi). Latih di make_regression(). Bandingkan dengan linear regression bab 4.
Tambahkan layer tersembunyi ke-2 (arsitektur 2-3-3-1). Apakah XOR konvergen lebih cepat?
Ganti inisialisasi bobot dengan 0.0 semua. Apakah MLP masih belajar XOR? Kenapa? (Petunjuk: simetri.)
Jelaskan dengan kata-katamu apa yang dilakukan backpropagation, dan kenapa ia "menyalahkan" bobot yang tepat.