Belajar Deep Learning - PyTorch Dasar (Tensors & Autograd)

#Pendahuluan

Semua teori di episode 2 sekarang kita wujudkan dalam kode. PyTorch adalah framework deep learning standar riset di 2026, dan pemahaman kalian tentang tensor, autograd, dan nn.Module akan menjadi bahasa sehari-hari untuk sisa series ini — termasuk saat kita menyentuh transformer di episode 12 dan distributed training di episode 13.

Inti yang membedakan PyTorch dari NumPy hanya satu hal: autograd. PyTorch secara otomatis menghitung gradien untuk setiap operasi, sehingga backpropagation yang kita bedah manual di episode 2 menjadi satu baris loss.backward(). Mari kita bedah dari tensor dulu.

#Tensor: NumPy Bertenaga GPU

#Membuat dan Memanipulasi Tensor

Tensor adalah generalisasi NumPy array yang bisa dipindahkan ke GPU dan dilacak gradiennya:

Dasar tensor

import torch
 
x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
y = torch.randn(3, 4)
z = torch.zeros(2, 2)
 
print(x.shape, x.dtype, x.device)
print(x @ x.T)

Hampir semua fungsi NumPy punya padanan di torch — torch.randn, torch.zeros, torch.ones. Operasi element-wise dan matriks bekerja persis seperti ekspektasi kalian.

#Memindahkan ke GPU

Memindahkan komputasi ke GPU cukup dengan memindahkan tensor:

Pindah ke GPU

device = "cuda" if torch.cuda.is_available() else "cpu"
x = torch.randn(1000, 1000, device=device)
print(x.device)

Semua operasi berikutnya pada x berjalan di GPU. Aturan penting: tensor di CPU dan GPU tidak bisa dicampur dalam satu operasi — error "expected all tensors to be on the same device" adalah teman akrab setiap pengguna PyTorch.

#Autograd: Backpropagation Otomatis

#Melacak Gradien

Setiap tensor punya atribut requires_grad. Saat requires_grad=True, PyTorch mencatat seluruh grafik operasi yang membentuk tensor tersebut:

Autograd dasar

x = torch.tensor([2.0], requires_grad=True)
w = torch.tensor([3.0], requires_grad=True)
y = w * x + 1
 
y.backward()
print(x.grad, w.grad)

Karena y = 3*x + 1, maka dy/dx = 3 dan dy/dw = 2. PyTorch mencetak tensor([3.]) dan tensor([2.]) — gradien dihitung otomatis lewat chain rule. Inilah backpropagation yang di episode 2 kita bedah manual, sekarang gratis.

#Update Parameter

Siklus training lengkap dalam PyTorch:

Satu langkah training

optimizer.zero_grad()
loss = model(input, target)
loss.backward()
optimizer.step()

Empat baris ini adalah loop terpenting yang akan kalian ulang ribuan kali: kosongkan gradien lama, hitung loss, hitung gradien baru, lalu update bobot. Lupa memanggil optimizer.zero_grad() membuat gradien dari batch sebelumnya menumpuk dan training jadi kacau — salah satu bug paling umum di PyTorch.

#nn.Module dan Membangun Model

#Layer Siap Pakai

Daripada menulis matriks manual, gunakan modul siap pakai: nn.Linear(in, out) untuk fully-connected layer, nn.ReLU(), nn.Sequential untuk menumpuk layer.

#Model Linear dari Scratch

Implementasi regresi linear — satu nn.Linear, selayaknya y = Wx + b di episode 2:

Model linear

import torch.nn as nn
 
class LinearModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(1, 1)
 
    def forward(self, x):
        return self.fc(x)
 
model = LinearModel()

forward adalah tempat alur data; PyTorch otomatis membuat backward dari grafik autograd. Aturan main: definisikan layer di __init__, susun alurnya di forward.

#MLP dari Scratch

Sekarang naik satu tingkat: MLP (Multi-Layer Perceptron) dengan satu hidden layer dan ReLU — jaringan non-linear pertama kita:

MLP dua layer

class MLP(nn.Module):
    def __init__(self, in_features=784, hidden=128, out=10):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_features, hidden),
            nn.ReLU(),
            nn.Linear(hidden, out),
        )
 
    def forward(self, x):
        return self.net(x)
 
model = MLP()

Model ini menerima input 784 angka (gambar 28x28 yang di-flatten), memproyeksikannya ke 128 unit, melewati ReLU, lalu menghasilkan 10 logits — siap untuk klasifikasi 10 kelas. Bentuk pola inilah yang nanti berkembang menjadi CNN dan transformer.

#Common Pitfalls

• Tipe salah: PyTorch memisahkan torch.float32 dan torch.int64. nn.Linear menolak input int — pastikan data sudah .float().
• Device mismatch: campur CPU dan GPU dalam satu operasi selalu error. Pindahkan model dan data ke satu device.
• Lupa zero_grad: gradien menumpuk antar batch, training jadi tidak stabil.
• Mengevaluasi di mode train: Dropout masih aktif, hasil metrik menyesatkan.

#Penutup

Pada episode 3 ini, kalian telah menerjemahkan teori episode 2 ke PyTorch.

Inti yang harus dibawa pulang:

• Tensor = array NumPy yang bisa dipindah ke GPU dan dilacak gradiennya.
• Autograd menghitung semua gradien otomatis; loss.backward() adalah backpropagation.
• Loop training = zero_grad → forward → loss → backward → step.
• Model dibangun dari nn.Module: layer di __init__, alur di forward.
• MLP dua layer adalah blok dasar semua arsitektur selanjutnya.

Di episode 4 selanjutnya kita akan membandingkan workflow ini dengan Keras 3 & TensorFlow — Sequential & Functional API, layer, dan training loop, plus komparasi langsung kapan memakai PyTorch dan kapan Keras. Sampai jumpa di episode 4!