Belajar Data Scientist - Deep Learning Dasar (PyTorch)

#Pendahuluan

Setelah di episode 12 kita menata eksperimen, pada episode ini kita membuka dunia baru: deep learning dengan PyTorch. Deep learning adalah kekuatan di balik NLP modern (episode 14), image recognition, dan sebagian besar AI product 2026. Memahami fondasinya bukan berarti meninggalkan scikit-learn — melainkan menambah kemampuan untuk masalah yang terlalu kompleks bagi model klasik.

Mengapa belajar training loop dari nol, bukan langsung pakai high-level API? Karena deep learning bukanlah sihir: ia adalah optimasi matematis yang berulang. Memahami forward pass, loss, backward pass, dan optimizer membuat kalian bisa mendiagnosis mengapa model tidak belajar — skill yang membedakan orang yang sekadar menjalankan kode dari orang yang benar-benar paham.

#Neural Network dalam Satu Gambaran

Neural network (MLP) adalah tumpukan lapisan neuron:

Setiap panah punya bobot w; setiap neuron menghitung jumlah berbobot dari inputnya, melewati fungsi aktivasi, dan meneruskan hasilnya. Tumpukan beberapa lapisan dengan aktivasi non-linier inilah yang memberi kemampuan mempelajari pola kompleks — melebihi model linier.

#Blok Penyusun PyTorch

pip install torch

Tiga konsep inti:

import torch
import torch.nn as nn
 
# 1. Tensor = array multi-dimensi dengan GPU support
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]], requires_grad=True)
 
# 2. autograd = hitung gradien otomatis
y = (x ** 2).sum()
y.backward()
print("gradien:", x.grad)   # 2*x
 
# 3. nn.Module = blok model dengan parameter terstruktur
model = nn.Linear(4, 1)
print("bobot:", model.weight.shape)

requires_grad dan .backward() adalah jantung training: PyTorch mencatat seluruh komputasi, lalu menghitung gradien loss terhadap setiap bobot secara otomatis — ini yang dulu dihitung manual, sekarang satu baris.

#Praktik: Model Sederhana dari Nol

Kita latih MLP kecil untuk klasifikasi churn — dataset yang sama dari episode sebelumnya:

import torch
import torch.nn as nn
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
 
df = pd.read_csv("telco_churn.csv")
X = df.drop(columns=["churn"]).values.astype(np.float32)
y = df["churn"].values.astype(np.float32)
 
scaler = StandardScaler().fit(X)
X = scaler.transform(X)
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
 
X_t = torch.tensor(X_train, dtype=torch.float32)
y_t = torch.tensor(y_train, dtype=torch.float32).reshape(-1, 1)
 
model = nn.Sequential(
    nn.Linear(X.shape[1], 16),
    nn.ReLU(),
    nn.Linear(16, 1),
)
loss_fn = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
 
for epoch in range(200):
    pred = model(X_t)
    loss = loss_fn(pred, y_t)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    if epoch % 50 == 0:
        print(f"epoch {epoch:3d} | loss {loss.item():.4f}")

Empat langkah dalam loop: forward (hitung prediksi), hitung loss, backward (hitung gradien), optimizer step (update bobot). Pola ini identik untuk semua model deep learning — yang berubah hanya arsitektur dan dataset.

#Evaluasi di Test Set

import torch
import numpy as np
from sklearn.metrics import roc_auc_score
 
with torch.no_grad():
    proba = torch.sigmoid(model(torch.tensor(X_test, dtype=torch.float32)))
    proba = proba.numpy().ravel()
 
print("AUC test:", round(roc_auc_score(y_test, proba), 3))

torch.no_grad() mematikan autograd saat evaluasi — menghemat memori dan mempercepat. Bandingkan AUC ini dengan model scikit-learn di episode 11: kalian akan melihat deep learning tidak otomatis lebih baik untuk data tabular kecil — justru itulah pelajarannya, pilih alat sesuai masalah.

#GPU: Kapan dan Bagaimana

GPU mempercepat training karena bisa memproses ribuan operasi matriks paralel. PyTorch memakainya dengan satu pemindahan:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device:", device)
 
model = model.to(device)
X_t = X_t.to(device)
y_t = y_t.to(device)

Perubahan kode: model dan tensor dipindahkan ke device yang sama. Aturan praktisnya:

#Kesalahan Umum

#Penutup

Inti yang harus dibawa pulang:

• Neural network = tumpukan lapisan berbobot + aktivasi non-linier.
• Training loop PyTorch: forward → loss → backward → optimizer.step, diulang per epoch.
• autograd menghitung gradien otomatis — tidak ada kalkulus manual.
• GPU mempercepat lewat paralelisasi; untuk tabular kecil, CPU sudah cukup.
• Deep learning tidak otomatis lebih baik — pilih sesuai data & masalah.

Di episode 14 selanjutnya kita akan membahas NLP & Transformers — preprocessing teks, embeddings, dan arsitektur Transformer dengan Hugging Face — untuk menganalisis data teks. Sampai jumpa di episode 14!