🕸️ CNN & RNN (Konsep)

Dua arsitektur deep learning untuk data berstruktur: gambar (CNN) dan urutan (RNN).

🎬 Animasi: CNN: Filter Menggeser Gambar

Filter 3×3 digeser pixel per pixel. Tepi vertikal menghasilkan respons besar yang muncul di feature map.

📌 1. CNN: Convolution untuk Gambar

Jaringan neural biasa "melihat" gambar sebagai deretan angka panjang — kehilangan informasi spasial. CNN memakai convolution: filter kecil (3×3, 5×5) yang di-geser di seluruh gambar.

Convolution = filter × patch, digeser pixel per pixel:

    filter 3×3          gambar 5×5
    ┌───┬───┬───┐
    │-1 │ 0 │ 1 │        hasil = Σ filter·patch
    ├───┼───┼───┤          di tiap posisi geser
    │-1 │ 0 │ 1 │
    ├───┼───┼───┤
    │-1 │ 0 │ 1 │
    └───┴───┴───┘

    Filter ini mendeteksi "tegaran vertikal" → output besar di tepi.

Komponen CNN:
• Conv layer   : banyak filter → banyak "peta fitur" (tegaran, sudut, tekstur)
• Pooling      : downscale (max/average) → tahan geser, lebih kecil
• Stack        : layer awal = fitur sederhana, layer akhir = konsep kompleks
                 (tegaran → mata → wajah → kucing)
• Fully connected : klasifikasi akhir

Keunggulan: weight sharing (1 filter dipakai di semua posisi) →
    jauh lebih efisien, dan invariant terhadap posisi objek.

📌 2. Contoh: Convolution 2D — Deteksi Tepi

print("=== CONVOLUTION 2D: DETEKSI TEPI ===\n")

# "Gambar" 10x10: kotak putih di atas latar gelap
img = [[1 if 2 <= i <= 7 and 2 <= j <= 7 else 0
        for j in range(10)] for i in range(10)]

print("Gambar asli (kotak):")
for row in img:
    print("  " + "".join("█" if v else "·" for v in row))

# Filter 3x3: deteksi tegaran VERTIKAL (Sobel-x)
kernel = [[-1, 0, 1],
          [-1, 0, 1],
          [-1, 0, 1]]

def conv2d(img, k):
    n = len(img); m = len(k)
    out = []
    for i in range(n - m + 1):
        row = []
        for j in range(n - m + 1):
            s = 0
            for a in range(m):
                for b in range(m):
                    s += img[i + a][j + b] * k[a][b]
            row.append(s)
        out.append(row)
    return out

res = conv2d(img, kernel)
print("\nHasil convolution (respons filter):")
for row in res:
    print("  " + "".join("█" if v > 0.5 else ("░" if v < -0.5 else "·")
                         for v in row))

print("""
Interpretasi:
• Tepi KANAN kotak  → respons POSITIF (█)
• Tepi KIRI kotak   → respons NEGATIF (░)
• Area dalam/luar   → 0 (·)
→ Filter "melihat" di mana tepian vertikal berada!

CNN asli: puluhan filter × puluhan layer, bobotnya DIPELAJI (bukan
didesain manual seperti di sini).""")

Output:

📌 3. RNN: Jaringan untuk Urutan

RNN (Recurrent Neural Network) memproses data SEKUENSIAL:
    kata per kata, frame per frame, tick per tick.

Kunci: HIDDEN STATE (h) — "memori" yang di-update tiap langkah:
    h_t = tanh(Wxh·x_t + Whh·h_{t-1} + bh)
    y_t = Wht·h_t + bt

        x1  x2  x3  x4
        ↓   ↓   ↓   ↓
       [h]→[h]→[h]→[h]→ y
        ↑__________|
        (Whh: memori dibawa ke langkah berikutnya)

Aplikasi: machine translation, text generation, speech recognition,
    prediksi deret waktu (harga saham, cuaca).

Catatan era modern: LSTM/GRU (memori lebih panjang) dan TRANSFORMER
    (attention) kini mendominasi — tapi intinya sama: memproses urutan
    dengan state yang mengalir.

📌 4. Contoh: RNN (Elman) Prediksi Sinyal Sinus

Tugas: diberi 5 nilai sinus terakhir, prediksi nilai berikutnya. Hidden state harus "mengingat" posisi fase gelombang.

print("=== RNN (ELMAN): PREDIKSI SINUS ===\n")
random_seed(42)
seq = [math.sin(i * 0.5) for i in range(40)]
Xr, yr = [], []
for i in range(8, len(seq)):
    Xr.append(seq[i - 8:i])     # 8 nilai terakhir
    yr.append(seq[i])           # nilai berikutnya

# Elman RNN, 1 hidden unit
Wxh = [0.5]; Whh = [0.5]; bh = 0.0
Wht = [0.5]; bt = 0.0
lr = 0.05
losses = []

def run_rnn(xseq):
    h = 0.0
    hs = []
    for t in range(len(xseq)):
        h = math.tanh(Wxh[0] * xseq[t] + Whh[0] * h + bh)
        hs.append(h)
    return hs

for epoch in range(4000):
    gWxh = gWhh = gbh = gWht = gbt = 0.0
    for xseq, y in zip(Xr, yr):
        hs = run_rnn(xseq)
        out = Wht[0] * hs[-1] + bt
        d_out = 2.0 * (out - y)
        gWht += d_out * hs[-1]
        gbt += d_out
        # Backprop Through Time (BPTT)
        dh = d_out * Wht[0] * (1 - hs[-1] ** 2)
        for t in range(len(hs) - 1, -1, -1):
            gWxh += dh * xseq[t]
            if t > 0:
                gWhh += dh * hs[t - 1]
            gbh += dh
            if t > 0:
                dh = dh * Whh[0] * (1 - hs[t - 1] ** 2)
    m = len(Xr)
    Wxh[0] -= lr * gWxh / m
    Whh[0] -= lr * gWhh / m
    bh    -= lr * gbh / m
    Wht[0] -= lr * gWht / m
    bt    -= lr * gbt / m
    if epoch % 800 == 0:
        tot = sum((Wht[0] * run_rnn(x)[-1] + bt - y) ** 2
                  for x, y in zip(Xr, yr))
        losses.append(tot / m)
        print("epoch %4d  MSE = %.4f" % (epoch, tot / m))

# Prediksi nilai berikutnya (setelah index 39)
h_final = run_rnn(seq[32:40])[-1]
pred_next = Wht[0] * h_final + bt
print("\nSebenarnya sin(40·0.5) = %.3f" % math.sin(40 * 0.5))
print("Prediksi RNN           = %.3f" % pred_next)
cost_curve(losses)

Output:

💡 RNN di atas hanya 1 hidden unit — "memori" sangat terbatas. RNN asli punya puluhan unit, dan LSTM/GRU menambah "gerbang" agar informasi bisa bertahan puluhan langkah tanpa luntur.

🧠 Latihan

Buat filter 3×3 untuk deteksi tepi horizontal di conv2d. Terapkan ke gambar kotak.
Tambahkan pooling 2×2 max setelah convolution: ambil nilai max tiap blok 2×2. Berapa ukuran output akhirnya?
Di RNN, ubah tugas menjadi prediksi pola 1,2,3,4,5,1,2,3,... (mod 5). Apakah RNN bisa belajar?
Jelaskan kenapa CNN lebih efisien dari fully-connected untuk gambar 1000×1000. (Petunjuk: berapa bobot masing-masing?)