03 — Deep Learning & Neural Network

Estimasi baca: 75 menit Prasyarat: 01-apa-itu-ai.md, 02-jenis-ml.md Tujuan: Setelah ini kamu paham (1) apa itu neuron buatan, (2) bagaimana neural network "belajar" lewat backpropagation, dan (3) kenapa "dalam" itu hal besar.

Pembukaan

Di file 01 saya kasih analogi 1000 orang awam yang berlapis-lapis. Sekarang kita zoom in ke level yang lebih dalam — sambil tetap menjaga supaya tidak overwhelming.

Janji saya: kamu akan keluar dari file ini paham konsep neural network, tanpa harus jago matematika dulu. Math akan dibahas detail di Fase 3 nanti. Sekarang fokus ke intuisi.

Bagian 1 — Apa Itu Neuron Buatan?

Mulai dari Otak Manusia

Otak manusia punya ~86 miliar neuron. Tiap neuron:

Menerima sinyal listrik dari neuron lain (lewat dendrit)
Menghitung "apakah sinyal ini cukup kuat untuk diteruskan?"
Kalau cukup kuat, dia "menembak" (firing) sinyal ke neuron berikutnya (lewat akson)

Sederhananya: neuron = pengambil keputusan kecil. Dia menerima banyak input, memproses, mengeluarkan satu output.

Neuron Buatan (Perceptron)

Komputer meniru ide ini dengan formula matematika sederhana:

output = activation(w1×x1 + w2×x2 + w3×x3 + ... + bias)

Kelihatan rumit, mari kita pecah dengan analogi.

Analogi: Keputusan Beli Sepatu

Kamu mau beli sepatu. Kamu mempertimbangkan 3 hal:

x1 = harga (semakin murah, semakin condong beli)
x2 = nyaman (semakin nyaman, semakin condong beli)
x3 = keren (semakin keren, semakin condong beli)

Tapi kamu tidak menimbang ketiganya sama. Misalkan:

Nyaman penting buatmu → bobot w2 = 5 (besar)
Keren agak penting → w3 = 3
Harga sedikit penting → w1 = 2

Plus kamu punya "kecenderungan default" untuk beli atau tidak — disebut bias. Misalnya kalau lagi ada uang, bias = +1 (cenderung beli). Kalau lagi bokek, bias = -3.

Skor total: w1×x1 + w2×x2 + w3×x3 + bias

Lalu activation function memutuskan:

Kalau skor > 0 → output = 1 (beli)
Kalau skor ≤ 0 → output = 0 (tidak beli)

Itulah satu neuron buatan. Sebuah pengambil keputusan biner sederhana.

Visualisasi

Cara Membaca Diagram: Input (x1, x2, x3) dari kiri masuk ke node tengah (Σ + bias). Tiap input diberi label weight (w1, w2, w3). Hasil weighted sum masuk ke activation, lalu keluar sebagai output.

Walkthrough Step-by-Step:

Input (x1, x2, x3) masuk dari kiri — ini data mentah.
Tiap input dikalikan weight-nya (w1, w2, w3) — bobot ini ditentukan saat training.
Σ + bias menjumlahkan semuanya: w1·x1 + w2·x2 + w3·x3 + bias.
Activation function (ReLU, Sigmoid, dll) menentukan output akhir — ini yang bikin neuron bisa belajar pola non-linear.
Output keluar di kanan — bisa jadi keputusan biner atau angka.

Analogi Sehari-hari: Seperti rapat tim mengambil keputusan. Input = pendapat tiap anggota. Weight = otoritas tiap orang (bos punya weight besar, anak magang weight kecil). Bias = mood hari itu. Activation = aturan rapat (suara mayoritas, veto, dll). Output = keputusan akhir.

Diagram statis Mermaid sebagai fallback:

flowchart LR
    x1["x1"] -->|w1| S["Σ + bias"]
    x2["x2"] -->|w2| S
    x3["x3"] -->|w3| S
    S --> A["activation"]
    A --> O["output"]

Kunci yang harus kamu paham:

Input (x) = data yang masuk
Weight (w) = bobot, seberapa penting tiap input
Bias = pergeseran/kecenderungan default
Activation function = fungsi non-linear di akhir (alasannya dibahas di bawah)
Output = keputusan/hasil

Bagian 2 — Activation Function: Kenapa Penting?

Tanpa activation function, neural network cuma rentetan perkalian dan penjumlahan — yang secara matematis sama saja dengan satu persamaan linear besar. Mau berapapun lapisannya, tetap linear.

Activation function memberi sifat "non-linear" — itu yang membuat neural network bisa memodelkan pola kompleks.

Activation Function Populer

1. Sigmoid

Mengubah angka apapun ke range 0-1.

        1
       ─── ───────────
      /
     /
─── ───

Cocok untuk output probabilitas. Tapi ada masalah "vanishing gradient" — dibahas nanti.

2. ReLU (Rectified Linear Unit) — Paling Populer

Sangat sederhana:

Kalau input < 0 → output = 0
Kalau input ≥ 0 → output = input

            /
           /
          /
─────────/

Kenapa populer:

Komputasi sangat cepat
Tidak ada masalah vanishing gradient untuk nilai positif
Modern neural network (termasuk transformer) banyak pakai varian ReLU

3. Softmax

Mengubah vektor angka jadi probabilitas yang totalnya 1. Dipakai di output layer untuk klasifikasi multi-kelas.

Contoh:

Input:  [2.0, 1.0, 0.1]
Output (softmax): [0.66, 0.24, 0.10]   ← probabilitas, total = 1

Insight: Saat ChatGPT memilih kata berikutnya, dia pakai softmax untuk dapat probabilitas atas semua kemungkinan kata di vocabulary (misal 50.000 kata). Lalu sampling dari distribusi itu.

Bagian 3 — Dari Satu Neuron ke Network

Satu neuron cuma bisa keputusan sederhana. Kekuatan muncul saat kita gabung banyak neuron dalam lapisan-lapisan.

Arsitektur Dasar — Multi-Layer Perceptron (MLP)

Diagram statis Mermaid sebagai fallback:

flowchart LR
    subgraph Input
        x1["x1"]
        x2["x2"]
    end
    subgraph Hidden1["Hidden Layer 1"]
        h1a["h1"]
        h2a["h2"]
    end
    subgraph Hidden2["Hidden Layer 2"]
        h1b["h1"]
        h2b["h2"]
    end
    subgraph Output
        y1["y1"]
        y2["y2"]
        y3["y3"]
    end
    x1 --> h1a & h2a
    x2 --> h1a & h2a
    h1a --> h1b & h2b
    h2a --> h1b & h2b
    h1b --> y1 & y2 & y3
    h2b --> y1 & y2 & y3

Setiap lingkaran adalah neuron. Setiap garis adalah weight (bobot koneksi).

Input layer: menerima data mentah
Hidden layer: mengolah, mencari pola. "Hidden" karena kita tidak melihat output mereka langsung.
Output layer: menghasilkan prediksi akhir

Kenapa Multi-Layer?

Analogi: Pengenalan Wajah

Bayangkan model harus mengenali wajah dari foto:

Layer 1 (paling dekat input): mendeteksi piksel terang/gelap
Layer 2: menggabungkan piksel jadi tepi (edges) dan tekstur
Layer 3: menggabungkan tepi jadi bentuk (mata, hidung, mulut)
Layer 4: menggabungkan bentuk jadi wajah utuh
Layer 5 (output): "ini wajah Budi" atau "wajah Andi"

Tiap lapisan punya level abstraksi yang lebih tinggi. Lapisan awal sederhana, lapisan akhir kompleks. Ini meniru cara cortex visual otak manusia bekerja.

Itulah inti deep learning — "deep" = banyak lapisan. Sebelum tahun 2012, neural network biasanya cuma 2-3 lapisan. Sekarang LLM modern bisa puluhan hingga ratusan lapisan.

Bagian 4 — Bagaimana Neural Network "Belajar"?

Ini bagian magisnya. Bagaimana komputer menemukan sendiri weight (bobot) yang tepat?

Jawabannya: gradient descent + backpropagation.

Konsep Inti: Coba, Salah, Perbaiki

Analogi: Mencari Lembah Terdalam dengan Mata Tertutup

Bayangkan kamu di gunung berkabut. Kamu tidak bisa lihat apa-apa. Tugasmu turun ke lembah terdalam.

Strategi:

Rasakan kemiringan tanah di sekitarmu (kanan, kiri, depan, belakang)
Ambil langkah ke arah yang paling menurun
Ulangi sampai kamu sampai di tempat yang datar (bottom of valley)

Itulah gradient descent.

Terjemahan ke Neural Network

Gunung berkabut = ruang semua kemungkinan kombinasi weight
Ketinggian = "loss" / kesalahan model
Lembah terdalam = kombinasi weight yang menghasilkan kesalahan paling kecil
Kemiringan = gradient (turunan dari loss terhadap weight)
Langkah = update weight

Loss Function — Mengukur Kesalahan

Loss adalah angka yang menunjukkan seberapa salah prediksi model.

Contoh sederhana:

Prediksi model: 800 juta
Harga sebenarnya: 1000 juta
Selisih: 200 juta
Loss = 200² = 40.000 (squared error)

Kenapa kuadrat? Supaya selalu positif dan menghukum kesalahan besar lebih keras.

Loss function populer:

MSE (Mean Squared Error) — untuk regresi
Cross-entropy — untuk klasifikasi
Binary cross-entropy — untuk klasifikasi 2 kelas

Backpropagation — Mengetahui "Siapa yang Salah"

Setelah tahu seberapa besar kesalahan, pertanyaannya: weight mana yang harus diubah, dan ke arah mana?

Bayangkan kamu kerja tim 5 orang. Project gagal. Untuk perbaiki, kamu harus tahu:

Si A kontribusinya berapa terhadap kegagalan?
Si B kontribusinya berapa?
Dst.

Backpropagation menghitung kontribusi tiap weight terhadap loss. Lalu update weight proporsional dengan kontribusinya.

Caranya: pakai chain rule dari kalkulus untuk "menyebarkan" kesalahan dari output layer ke input layer (mundur — itulah kenapa "backward" propagation).

Tidak perlu paham matematika detailnya sekarang. Yang penting paham konsep: model menghitung error → menyalahkan weight yang berkontribusi → update weight ke arah yang mengurangi error → ulangi ribuan kali sampai loss kecil.

Training Loop — Yang Akan Sering Kamu Lihat

for epoch in range(100):              # ulangi 100 kali
    for batch in dataset:             # ambil sebagian data
        prediction = model(batch)     # forward pass
        loss = loss_fn(prediction, target)  # hitung error
        loss.backward()               # backpropagation
        optimizer.step()              # update weights

Empat baris ini adalah inti dari semua deep learning, dari pengenalan kucing sampai ChatGPT. Beneran. Ditulis ulang dengan variasi minor.

Istilah-istilah yang Akan Kamu Sering Dengar

Epoch — satu putaran lengkap melalui seluruh dataset training
Batch — sub-grup data (misal 32 sample) yang diproses bersama. Tidak praktis proses 1 juta data sekaligus.
Learning rate — seberapa besar langkah update weight. Terlalu besar = lompat-lompat tidak konvergen. Terlalu kecil = lambat sekali.
Optimizer — algoritma update weight. Yang populer: SGD, Adam, AdamW.
Gradient — turunan loss terhadap weight. Mengarah ke "naik". Kita update ke arah negatif gradient (turun).

Bagian 5 — Tipe Neural Network yang Akan Kamu Temui

Tidak perlu hafal semua sekarang, sekedar kenalan.

1. Feedforward Neural Network (FFN / MLP)

Jenis dasar yang baru saja kita bahas. Data mengalir lurus dari input ke output.

Cocok untuk: data tabular (kayak data Excel), klasifikasi sederhana.

2. Convolutional Neural Network (CNN)

Spesialis untuk gambar. Pakai operasi "convolution" yang efisien untuk menangkap pola spasial.

Cocok untuk: pengenalan gambar, deteksi objek, segmentasi medis.

Contoh terkenal: AlexNet (2012), ResNet, VGG.

3. Recurrent Neural Network (RNN) — dan LSTM

Spesialis untuk data berurutan (teks, time series). Punya "memori" — output sebelumnya jadi input berikutnya.

Cocok untuk (dulunya): translation, speech recognition.

Sekarang: banyak digantikan oleh Transformer. Tapi masih dipakai di beberapa kasus.

4. Transformer — Bintang Era LLM

Arsitektur yang mendasari semua LLM modern (GPT, Claude, Gemini, Llama, dll).

Inovasi kunci: attention mechanism — model bisa "melihat" semua kata sekaligus dan menentukan mana yang penting untuk konteks.

Detail dibahas di Fase 6 nanti. Untuk sekarang ingat: Transformer = arsitektur LLM = arsitektur paling penting untuk dipelajari.

5. Diffusion Model — untuk Gambar

Arsitektur di balik DALL-E, Stable Diffusion, Midjourney.

Cara kerja singkat: belajar membersihkan "noise" bertahap dari gambar acak sampai menghasilkan gambar bermakna.

Bagian 6 — Konsep Penting yang Sering Bikin Bingung

Overfitting

Definisi: Model menghafal data training, tapi gagal di data baru.

Analogi: Anak yang menghafal soal latihan UN tanpa paham konsep. Saat dapat soal mirip tapi sedikit beda, dia bingung.

Tanda-tanda overfitting:

Akurasi training sangat tinggi (95%)
Akurasi test (data baru) jauh lebih rendah (60%)
Model "kompleks" tapi data sedikit

Cara mencegah:

Lebih banyak data
Dropout (sengaja matikan sebagian neuron saat training)
Regularization (penalti terhadap weight terlalu besar)
Data augmentation
Early stopping (berhenti training sebelum overfit)

Underfitting

Definisi: Model terlalu sederhana, tidak bisa menangkap pola.

Tanda-tanda:

Akurasi training rendah
Akurasi test juga rendah
Loss tidak turun-turun saat training

Cara mengatasi:

Model lebih kompleks (lebih banyak layer/neuron)
Training lebih lama
Feature engineering lebih baik

Bias-Variance Tradeoff

Cara Membaca Diagram: Tiga zona dari kiri ke kanan: Underfitting (terlalu simpel), Sweet Spot (pas), Overfitting (terlalu kompleks). Di bawah masing-masing zona ada hint cara fix-nya.

Walkthrough Step-by-Step:

Underfitting (kiri) — model terlalu simpel, tidak nangkap pola. Loss training & test sama-sama tinggi.
Sweet Spot (tengah) — kompleksitas pas, generalisasi baik. Tujuan kita.
Overfitting (kanan) — model terlalu kompleks, hafal training. Loss training kecil tapi loss test besar.
Tip kiri: Tambah kompleksitas (lebih banyak layer, training lebih lama).
Tip kanan: Kurangi kompleksitas (regularization, dropout) atau tambah data.

Analogi Sehari-hari: Seperti belajar untuk ujian. Underfit = baca buku 5 menit, gagal total. Sweet spot = baca + latihan soal cukup, paham konsep, lulus. Overfit = hafal mati semua soal latihan, tapi soal ujian sedikit beda → bingung. Yang menang: paham konsep, bukan hafal pola permukaan.

Diagram statis Mermaid sebagai fallback:

flowchart LR
    A["Underfitting<br/>(high bias)"] ---|sweet spot| B["Overfitting<br/>(high variance)"]

Tujuan ML adalah cari sweet spot. Terlalu sederhana = bias tinggi. Terlalu kompleks = variance tinggi.

Train / Validation / Test Split

Data dibagi 3:

Training set (60-80%) — untuk train model
Validation set (10-20%) — untuk tune hyperparameter (learning rate, ukuran model, dll)
Test set (10-20%) — untuk evaluasi final, TIDAK PERNAH dilihat saat training

Aturan emas: jangan train pakai test set. Itu seperti murid melihat soal ujian sebelum ujian.

Bagian 7 — Mengapa Deep Learning Sukses Sekarang?

Neural network sudah ada sejak 1950-an. Kenapa baru booming 2012?

1. Data

Internet menghasilkan data tak terbatas. Deep learning butuh banyak data. ImageNet (1.2 juta gambar berlabel, 2009) memicu revolusi.

2. Komputasi (GPU)

NVIDIA GPU yang awalnya untuk game, ternyata sangat cocok untuk hitung neural network (banyak perkalian matriks paralel). Tanpa GPU, training GPT-4 butuh ribuan tahun.

3. Algoritma

Backpropagation — sudah ada lama, tapi efisien
ReLU — activation function yang fix masalah vanishing gradient
Dropout, Batch Norm — teknik anti-overfitting
Attention (2017) — terobosan untuk Transformer

4. Software

TensorFlow (2015), PyTorch (2017) — bikin deep learning accessible
Hugging Face — bikin pretrained model accessible

Bagian 8 — Cara Pakai Deep Learning di Praktik

Saat kamu mau pakai DL untuk masalahmu:

Pendekatan 1: Train dari Nol

Bikin arsitektur sendiri
Latih dengan data sendiri
Butuh: data banyak, GPU, waktu, ahli

Kapan dipakai: masalah sangat unik, tidak ada model yang cocok.

Pendekatan 2: Transfer Learning (Lebih Umum)

Ambil model pretrained (sudah dilatih oleh orang lain di data besar)
Lakukan fine-tuning dengan data spesifikmu (yang lebih kecil)

Analogi: Kamu sudah lulus kuliah umum (pretrained), lalu ambil kursus spesialisasi (fine-tuning) untuk domain spesifik.

Kapan dipakai: mayoritas kasus. Lebih cepat, butuh data lebih sedikit, hasil seringkali lebih baik.

Pendekatan 3: Pakai API LLM (Tanpa Train Sama Sekali)

Pakai ChatGPT, Claude, Gemini lewat API
Gunakan prompt engineering untuk dapat hasil yang diinginkan
Tidak ada training sama sekali

Kapan dipakai: masalah natural language, tidak butuh customization mendalam.

Untuk Bootcamp Dicoding: Kamu akan belajar ketiganya. Pendekatan 1 di "Fundamental Deep Learning". Pendekatan 2 dan 3 di "Fundamental Generative AI" dan capstone.

Kesalahpahaman Umum

❌ "Deep learning butuh PhD matematika" → Salah. Untuk menggunakan dan fine-tune model, matematika SMA/dasar kuliah cukup. PhD math hanya untuk meneliti arsitektur baru.

❌ "Neural network meniru otak persis" → Mirip dalam konsep, tapi sangat berbeda dalam detail. Otak manusia punya mekanisme yang masih belum sepenuhnya dipahami.

❌ "Lebih banyak layer = lebih baik" → Tidak selalu. Ada sweet spot. Network terlalu dalam tanpa teknik yang tepat (residual connection, dll) bisa gagal training.

❌ "Deep learning bisa selesaikan semua masalah" → DL bagus untuk pola dari data besar. Untuk masalah dengan logika kuat (misal puzzle catur), simbolik AI atau RL bisa lebih baik.

Cek Pemahaman

Pastikan kamu bisa menjawab tanpa lihat catatan:

Apa 5 komponen satu neuron buatan?
Kenapa activation function penting?
Sebut 3 activation function dan kapan dipakainya
Apa beda forward pass dan backward pass?
Apa itu gradient descent? Pakai analogi gunung
Apa itu overfitting? Bagaimana mendeteksinya?
Sebut 5 jenis arsitektur neural network
Apa itu transfer learning? Kapan dipakai?

Challenge Fase 1.3

Challenge 1 — Hitung Neuron Manual (Sangat Sedang)

Diberikan satu neuron dengan:

Input: x1=2, x2=3, x3=1
Weight: w1=0.5, w2=-1, w3=2
Bias: 0.5
Activation: ReLU

Hitung outputnya. Tulis langkah-langkahnya.

Tujuan: rasain "matematika" satu neuron. Beneran cuma kalkulator. Jawaban: di akhir file.

Challenge 2 — Mainkan Neural Network di Browser (Mudah, Wajib!)

Buka playground.tensorflow.org. Ini visualizer interactive untuk neural network.

Coba dataset "Circle" (default)
Tambah/kurangi layer dan neuron
Ubah learning rate
Lihat efeknya
Coba dataset "Spiral" — yang lebih sulit. Berapa layer minimum yang dibutuhkan?

Posting screenshot pencapaianmu (loss terendah dengan arsitektur sederhana) di jurnal.

Tujuan: rasain bagaimana neural network "belajar" secara visual. Tidak ada cara lebih intuitif dari ini.

Challenge 3 — Tonton & Catat (Wajib)

Tonton Karpathy "But what is a Neural Network?" by 3Blue1Brown (Episode 1, ~19 menit). YouTube.

Setelah nonton:

Tulis 5 hal yang baru kamu pahami setelah video itu
Tulis 2 hal yang masih bingung
Posting di jurnal

Tujuan: konsolidasi visual + multi-perspective. Penjelasan visual 3B1B berbeda dengan tulisan saya — kombinasi keduanya = pemahaman dalam.

Challenge 4 — Konsep ke Aplikasi (Sedang)

Pilih 1 produk yang kamu pakai sehari-hari yang menurutmu pakai deep learning. Tulis di jurnal:

Produk apa
Fitur DL-nya yang mana
Tebakan: jenis arsitektur (CNN/RNN/Transformer/dll)? Alasan?
Tebakan: cara dilatihnya?

Contoh kalau bingung: TikTok feed, Spotify Discover, kamera HP, Translate.

Tujuan: latih melihat dunia dengan "kacamata ML practitioner".

Challenge 5 — Skenario Overfitting (Sedang-Sulit)

Kamu bikin model yang akurat 99% di data training, tapi cuma 65% di data test. Tulis 3 hipotesis kenapa, dan 3 cara mengatasi.

Tujuan: latih troubleshooting mindset.

Jawaban Challenge 1

Step 1: Hitung weighted sum
  z = w1×x1 + w2×x2 + w3×x3 + bias
  z = (0.5)(2) + (-1)(3) + (2)(1) + 0.5
  z = 1 - 3 + 2 + 0.5
  z = 0.5

Step 2: Apply ReLU
  ReLU(0.5) = 0.5  (karena 0.5 > 0)

Output: 0.5

Simpel kan? Itu satu neuron. ChatGPT punya ratusan miliar neuron seperti ini, dengan ratusan miliar weight. Tapi prinsip dasarnya persis sama.

Resource Tambahan (Sangat Disarankan)

WAJIB: 3Blue1Brown "Neural Networks" playlist (4 video, 1 jam total). Visualisasi terbaik di internet.
Karpathy "Neural Networks: Zero to Hero" Episode 1 "micrograd" (2.5 jam) — kalau kamu mau benar-benar paham, tonton ini di Fase 6.
Tensorflow Playground — playground.tensorflow.org
Distill.pub — artikel visual tentang DL. Cari "Activation Atlas" atau "Feature Visualization".

Quote untuk Direnungkan

"Deep learning is just glorified curve fitting. But what curves can you fit when you have a billion parameters?" — Yann LeCun (Chief AI Scientist Meta, salah satu bapak DL)

Ini intinya. Neural network = mesin penyesuaian kurva super besar. Sederhana di permukaan, powerful pada skala.

Selanjutnya: 04-generative-ai.md — masuk ke GenAI: bagaimana model bisa menciptakan teks, gambar, musik. Dan apa yang membuat LLM begitu istimewa.