Bab 9: Deep Learning & Jaringan Saraf

9.1 Dasar Jaringan Saraf

Jaringan saraf adalah komposisi fungsi sederhana (neuron) yang diorganisasi dalam lapisan. Setiap neuron menghitung jumlah tertimbang input, menambahkan bias, dan menerapkan fungsi aktivasi.

y = f(Σ wᵢxᵢ + b) di mana f adalah fungsi aktivasi

ReLU

f(x) = max(0, x)

Default untuk hidden layer. Cepat, tidak ada vanishing gradient.

Sigmoid

f(x) = 1/(1+e⁻ˣ)

Output layer untuk klasifikasi biner. Bisa mengalami vanishing.

Tanh

f(x) = (eˣ−e⁻ˣ)/(eˣ+e⁻ˣ)

Berpusat di nol. Bagus untuk RNN. Tetap bisa vanishing.

Softmax

f(xᵢ) = eˣⁱ/Σeˣʲ

Output layer untuk multi-kelas. Menghasilkan probabilitas.

9.2 Backpropagation

Backpropagation adalah algoritma yang menghitung gradien loss terhadap setiap bobot menggunakan aturan rantai, memungkinkan optimasi berbasis gradien.

# Forward pass konseptual
z1 = W1 @ x + b1        # Transformasi linier
a1 = relu(z1)           # Aktivasi
z2 = W2 @ a1 + b2       # Transformasi linier
a2 = softmax(z2)        # Probabilitas output
loss = cross_entropy(a2, y)  # Loss

# Backward pass (aturan rantai)
# ∂L/∂W2 = ∂L/∂a2 · ∂a2/∂z2 · ∂z2/∂W2
# ∂L/∂W1 = ∂L/∂a2 · ∂a2/∂z2 · ∂z2/∂a1 · ∂a1/∂z1 · ∂z1/∂W1

# Perbarui bobot
W1 -= lr * dW1
W2 -= lr * dW2

Masalah utama: Vanishing gradients di jaringan dalam (diselesaikan oleh ReLU, batch norm, residual connections). Exploding gradients (diselesaikan oleh gradient clipping, inisialisasi yang tepat).

9.3 Dasar-Dasar PyTorch

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# Siapkan data
X_tensor = torch.float32(X_train_scaled)
y_tensor = torch.long(y_train.values)
dataset = TensorDataset(X_tensor, y_tensor)
loader = DataLoader(dataset, batch_size=32, shuffle=True)

# Definisikan model
class JaringanSederhana(nn.Module):
    def __init__(self, input_dim, num_classes):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(64, num_classes)
        )
    def forward(self, x):
        return self.net(x)

model = JaringanSederhana(X.shape[1], 10)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

# Loop training
for epoch in range(50):
    model.train()
    for X_batch, y_batch in loader:
        optimizer.zero_grad()
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)
        loss.backward()
        optimizer.step()

9.4 Convolutional Neural Networks

CNN mengeksploitasi struktur spasial dalam data (gambar, time series) melalui receptive field lokal dan pembagian bobot.

class CNN_Sederhana(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 128),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(128, 10)
        )
    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

Rumus ukuran output: O = ⌊(I − K + 2P) / S⌋ + 1 di mana I=input, K=kernel, P=padding, S=stride. Kernel 3×3 dengan padding=1 mempertahankan dimensi spasial.

9.5 RNN, LSTM & Transformer

RNN

Memproses sekuens langkah demi langkah. Menderita vanishing gradient untuk sekuens panjang.

LSTM

Sel berpintu yang mengontrol aliran informasi. Menangani dependensi jarak jauh jauh lebih baik.

Transformer

Mekanisme self-attention. Dapat diparalelkan, scale baik. Kekuatan di balik GPT, BERT, dll.

import torch.nn as nn

# LSTM untuk klasifikasi teks
class LSTM_Teks(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, batch_first=True,
                          num_layers=2, dropout=0.3)
        self.fc = nn.Linear(hidden_dim, num_classes)
    def forward(self, x):
        x = self.embedding(x)
        _, (hidden, _) = self.lstm(x)
        return self.fc(hidden[-1])

9.6 Transfer Learning

Gunakan kembali model yang dilatih sebelumnya pada dataset besar (misalnya ImageNet) dan fine-tune untuk tugas spesifik Anda. Ini cara sebagian besar deep learning dilakukan di dunia nyata.

from torchvision import models

# Muat ResNet-18 yang sudah dilatih
model = models.resnet18(pretrained=True)

# Bekukan semua layer
for param in model.parameters():
    param.requires_grad = False

# Ganti layer final untuk tugas kita
num_features = model.fc.in_features  # 512
model.fc = nn.Linear(num_features, 5)  # 5 kelas

# Hanya latih layer baru
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)

# Setelah beberapa epoch, buka kunci layer terakhir untuk fine-tuning
for param in model.layer4.parameters():
    param.requires_grad = True
optimizer = optim.Adam([
    {'params': model.layer4.parameters(), 'lr': 1e-4},
    {'params': model.fc.parameters(), 'lr': 1e-3}
])

Latihan: Fine-tune ResNet-18 pada dataset gambar kustom (misalnya kucing vs anjing dari Kaggle). Bandingkan: (1) training dari nol, (2) backbone dibekukan + head baru, (3) fine-tuned backbone. Laporkan akurasi dan waktu training.