Kuliah 1: Fondasi Deep Learning

🎯 Ringkasan Kuliah

Kuliah pertama MIT 6.S191 — Introduction to Deep Learning oleh Alexander Amini membangun fondasi matematika deep learning dari nol. Dimulai dari satu neuron (perceptron), kita naik level ke jaringan multi-layer, backpropagation, gradient descent, hingga teknik regularisasi modern.

🧠 1. Single Neuron (Perceptron)

Neuron adalah unit paling fundamental dalam deep learning. Satu neuron menerima m input, mengalikan setiap input dengan bobot (weight), menjumlahkan semuanya, menambahkan bias, lalu melewatkannya melalui fungsi aktivasi non-linear.

📐 Rumus Matematika

Di mana:

• X = vektor input (m dimensi)
• W = vektor bobot (m dimensi) — ini yang dipelajari oleh model
• b = bias (W₀) — menggeser fungsi ke atas/bawah
• g(·) = fungsi aktivasi non-linear
• ŷ = output prediksi

🐍 Implementasi Python (dari nol)

import numpy as np

class SingleNeuron:
    def __init__(self, n_inputs):
        self.W = np.random.randn(n_inputs)  # bobot
        self.b = np.random.randn()           # bias
    
    def sigmoid(self, z):
        return 1 / (1 + np.exp(-z))
    
    def forward(self, X):
        z = np.dot(X, self.W) + self.b      # dot product + bias
        return self.sigmoid(z)               # aktivasi

# Contoh: neuron dengan 3 input
neuron = SingleNeuron(3)
X = np.array([0.5, -1.2, 0.8])
y_pred = neuron.forward(X)
print(f"Prediksi: {y_pred:.4f}")  # output antara 0-1

📈 2. Fungsi Aktivasi (Activation Functions)

Fungsi aktivasi memperkenalkan non-linearitas ke dalam model. Tanpa non-linearitas, seluruh jaringan akan kolaps menjadi transformasi linear biasa — tidak peduli seberapa dalam.

Jenis-jenis Aktivasi Utama

🏗️ 3. Dari Neuron → Jaringan Neural

Jaringan neural dibangun dengan menumpuk neuron menjadi layer, lalu menumpuk layer menjadi arsitektur dalam.

Arsitektur Forward Pass

Input (X) ──→ [Layer 1: W₁,b₁ + ReLU] ──→ [Layer 2: W₂,b₂ + ReLU] ──→ Output (ŷ)

# Setiap layer melakukan 3 langkah:
# 1. Matrix multiply: X @ W
# 2. Tambah bias: + b
# 3. Aktivasi non-linear: g(z)

🐍 TensorFlow / Keras

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')  # 10 kelas
])

🔥 PyTorch

import torch.nn as nn

model = nn.Sequential(
    nn.Linear(784, 128),
    nn.ReLU(),
    nn.Linear(128, 64),
    nn.ReLU(),
    nn.Linear(64, 10),
    nn.Softmax(dim=1)
)

📉 4. Loss Function — Mengukur Error

Loss adalah selisih antara prediksi (ŷ) dan nilai sebenarnya (y). Semakin kecil loss, semakin baik model.

Dua Jenis Loss Utama

📉 5. Gradient Descent — Belajar dari Error

Training = mencari bobot W yang meminimalkan loss J(W) di seluruh dataset.

Algoritma Gradient Descent

1. Inisialisasi: Bobot W di-acak
2. Forward pass: Hitung prediksi ŷ dan loss J
3. Backward pass (backpropagation): Hitung gradien ∂J/∂W — arah kemiringan loss
4. Update: W ← W − η · ∂J/∂W (melangkah berlawanan arah gradien)
5. Ulangi sampai konvergen

η (eta) = learning rate — seberapa besar langkah yang diambil setiap iterasi.

🧮 Backpropagation = Chain Rule

Backpropagation hanyalah aplikasi aturan rantai (chain rule) dari kalkulus. Gradien dihitung mundur dari output → input:

∂J/∂W₁ = ∂J/∂ŷ  ×  ∂ŷ/∂z₂  ×  ∂z₂/∂a₁  ×  ∂a₁/∂z₁  ×  ∂z₁/∂W₁
         ↑ output   ↑ layer 2   ↑ aktivasi ↑ layer 1   ↑ weight

⚙️ 6. Training Praktis

🎯 Batch Size

• Batch Gradient Descent: Gradien dari seluruh dataset — akurat tapi sangat lambat
• Stochastic GD (SGD): Gradien dari 1 data point — cepat tapi sangat noisy
• Mini-batch GD: Gradien dari B data point (B=32, 64, 128...) — keseimbangan terbaik ✅

📏 Learning Rate

🚀 Optimizer Modern: Adam

Hampir tidak ada yang pakai SGD vanilla di production. Adam (Adaptive Moment Estimation) adalah standar de facto — learning rate adaptif per parameter + momentum:

# TensorFlow
model.compile(optimizer='adam', loss='binary_crossentropy')

# PyTorch
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

🛡️ 7. Regularisasi — Melawan Overfitting

Overfitting: Model terlalu "menghafal" data training — bagus di training, jelek di data baru.
Underfitting: Model terlalu sederhana — bahkan tidak bisa menangkap pola di data training.

🎲 Dropout

Pada setiap iterasi training, random 50% neuron di-hidden-layer dimatikan. Ini memaksa jaringan tidak bergantung pada satu jalur spesifik → generalisasi lebih baik.

# TensorFlow
tf.keras.layers.Dropout(0.5)

# PyTorch  
nn.Dropout(p=0.5)

⏹️ Early Stopping

Pantau loss di validation set (data yang tidak dilihat model saat training). Begitu validation loss mulai naik → hentikan training. Simpan checkpoint terbaik.

🎓 Rangkuman: Pipeline Training Neural Network

📚 Referensi

• 🎥 Video Original — MIT 6.S191 Lecture 1
• 📖 Website Resmi Kursus
• 📝 Slide tersedia di: introtodeeplearning.com/slides
• 🔬 Lab 1: Music Generation dengan TensorFlow/PyTorch

📅 Kuliah berikutnya: Lecture 2 — Sequence Models (RNN, LSTM, Transformers) oleh Ava