Belajar Deep Learning - MLP: Klasifikasi & Regression

#Pendahuluan

Di episode 3 dan 4 kita membangun model minimal: MLP dua layer di PyTorch dan Keras. Sekarang saatnya memakai semuanya untuk menyelesaikan dua masalah nyata: klasifikasi gambar pakaian (Fashion-MNIST) dan regresi pada data tabular. Dua pola ini mencakup mayoritas masalah yang dihadapi ML Engineer di dunia nyata.

Perbedaan kunci episode ini: kita tidak hanya menulis kode, tetapi juga belajar mendesign arsitektur — berapa layer, berapa unit, aktivasi apa, regularisasi apa — serta membaca kurva training untuk memperbaiki model. Inilah keterampilan yang membedakan orang yang sekadar menjalankan notebook dari orang yang bisa diandalkan untuk menyelesaikan masalah.

#Klasifikasi Fashion-MNIST

Fashion-MNIST berisi 60.000 gambar 28x28 (hitam-putih) dari 10 jenis pakaian. Ini pengganti MNIST yang lebih menantang dan lebih jujur mengukur kualitas model.

#Memuat Data

Muat Fashion-MNIST

from torchvision import datasets, transforms
 
transform = transforms.ToTensor()
train = datasets.FashionMNIST(root="./data", train=True, download=True, transform=transform)
test = datasets.FashionMNIST(root="./data", train=False, download=True, transform=transform)
 
print(len(train), train.classes)

#Arsitektur Dasar

Input 28x28 di-flatten menjadi 784. Design yang umum: hidden layer mengecil secara bertahap — 128 → 64 → 10 logits. Banyaknya unit adalah trade-off: terlalu sedikit underfit, terlalu banyak overfit:

MLP untuk Fashion-MNIST

import torch.nn as nn
 
class MLP(nn.Module):
    def __init__(self, hidden=[128, 64]):
        super().__init__()
        layers = [nn.Flatten(), nn.Linear(784, hidden[0]), nn.ReLU()]
        for h in hidden[1:]:
            layers += [nn.Linear(hidden[hidden.index(h) - 1], h), nn.ReLU()]
        layers.append(nn.Linear(hidden[-1], 10))
        self.net = nn.Sequential(*layers)
 
    def forward(self, x):
        return self.net(x)

#Training Loop

Gabungkan DataLoader (dibahas dalam di episode 9) dan siklus dari episode 3:

Loop training

from torch.utils.data import DataLoader
 
loader = DataLoader(train, batch_size=64, shuffle=True)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
 
for epoch in range(10):
    for x, y in loader:
        optimizer.zero_grad()
        loss = loss_fn(model(x), y)
        loss.backward()
        optimizer.step()
    print(f"epoch {epoch}: loss {loss.item():.4f}")

Model harus mencapai akurasi sekitar 90% di test set — jauh di atas tebakan acak 10%. Ini baseline yang akan kalian lompati jauh saat pakai CNN di episode 7.

#Tabular Regression

Masalah kedua: data tabular seperti prediksi harga rumah. Model regresi memakai output tunggal tanpa aktivasi dan loss MSE.

MLP regresi

import torch.nn.functional as F
 
class RegNet(nn.Module):
    def __init__(self, in_features):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU(),
            nn.Linear(32, 1),
        )
 
    def forward(self, x):
        return self.net(x)
 
model = RegNet(in_features=13)  # 13 fitur
loss_fn = nn.MSELoss()

Perhatikan perbedaan fundamental vs klasifikasi:

Satu jebakan besar regresi: normalisasi fitur. Fitur dengan rentang sangat berbeda (usia 0-100 vs luas rumah 0-10000) membuat training lambat dan tidak stabil. Selalu standardisasi dulu:

Standardisasi fitur

from sklearn.preprocessing import StandardScaler
 
scaler = StandardScaler()
X = scaler.fit_transform(X)  # rata-rata 0, std 1

#Dropout dan Regularisasi

MLP mudah overfit karena mempelajari pola noise. Dropout mematikan unit secara acak selama training, memaksa jaringan tidak bergantung pada satu neuron:

MLP dengan Dropout

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(256, 128),
    nn.ReLU(),
    nn.Dropout(0.2),
    nn.Linear(128, 10),
)

Dropout(0.2) mematikan 20% unit setiap batch. Aturan praktis: dropout 0.1-0.5; semakin besar hidden layer, semakin besar dropout yang aman. Episode 6 akan membahas regularisasi lain (weight decay, early stopping, augmentasi).

#Evaluasi dan Tuning

#Membaca Kurva Training

Dua pola paling sering terjadi:

• Training loss tinggi, validation tinggi → underfit. Tambah kapasitas (lebih banyak unit/layer) atau naikkan learning rate.
• Training loss turun, validation naik → overfit. Tambah dropout/weight decay, atau kurangi kapasitas.

Selalu pantau kurva ini, bukan hanya angka final. Grafik loss adalah dashboard kesehatan model.

#Metrik yang Jujur

Untuk klasifikasi multikelas: accuracy, lalu per kelas f1-score dan confusion matrix. Untuk regresi: RMSE (dalam satuan target) dan R². Laporan klasifikasi:

Laporan klasifikasi

from sklearn.metrics import classification_report
 
print(classification_report(y_true, y_pred, target_names=train.classes))

#Common Pitfalls

• Flatten lupa: nn.Linear menerima vektor 1D; gambar 28x28 harus di-flatten dulu menjadi 784.
• Normalisasi input: piksel 0-255 vs 0-1 menghasilkan training yang sangat berbeda. transforms.ToTensor() membagi 255 — jangan dobel-dobel.
• Loss naik karena lr: jika loss meledak di epoch pertama, learning rate terlalu besar — turunkan ke 1e-3/1e-4.
• Mengevaluasi model yang sama berulang: jika kalian tweak hyperparameter menggunakan hasil test set, test set itu sudah bocor. Sisihkan validation set untuk tuning.

#Penutup

Pada episode 5 ini, kalian telah menyelesaikan dua masalah MLP end-to-end.

Inti yang harus dibawa pulang:

• Klasifikasi: output logits per kelas, CrossEntropyLoss, metrik accuracy/f1.
• Regresi: output satu angka, MSELoss, metrik RMSE/R², dan wajib standardisasi fitur.
• Arsitektur adalah trade-off kapasitas vs overfit; Dropout adalah alat pertama untuk menekan overfit.
• Baca kurva training untuk membedakan underfit dan overfit.
• Sisihkan validation set; test set hanya untuk penilaian final.

Di episode 6 selanjutnya kita akan mendalami optimization & regularization — SGD momentum, Adam/AdamW, learning rate scheduling (cosine, warmup), gradient clipping, weight decay, early stopping, dan data augmentation. Sampai jumpa di episode 6!