PyTorch adalah salah satu framework deep learning paling populer saat ini — dipakai oleh peneliti maupun tim produksi di perusahaan seperti Meta, Tesla, dan OpenAI. Dibandingkan framework lain yang terasa seperti “kotak hitam”, PyTorch dirancang agar alurnya transparan: kamu bisa memeriksa nilai tensor, melakukan debugging seperti Python biasa, dan memahami persis bagaimana gradien mengalir di balik layar. Di tutorial ini kita akan belajar PyTorch dari nol, mulai dari tensor, diferensiasi otomatis (autograd), hingga melatih neural network yang mampu mengklasifikasikan gambar digit tulisan tangan dengan akurasi di atas 95%.

Apa Itu PyTorch?

PyTorch adalah library open-source untuk komputasi tensor dan deep learning yang dikembangkan oleh Meta AI. Ada dua komponen inti yang perlu kamu pahami: (1) tensor, struktur data mirip array NumPy yang bisa diakselerasi di GPU, dan (2) autograd, mesin diferensiasi otomatis yang menghitung gradien tanpa kamu perlu menurunkan rumus secara manual. Karena alur kerjanya yang mirip Python murni, PyTorch menjadi pilihan utama banyak peneliti machine learning.

Instalasi PyTorch

Sebelum mulai, pastikan Python sudah terpasang di komputermu. Jika belum, ikuti dulu panduan cara install Python. Setelah itu, install PyTorch beserta torchvision (untuk memuat dataset gambar) lewat pip:

bash
pip install torch torchvision

Untuk memastikan instalasi berhasil, jalankan skrip singkat berikut. Jika muncul nomor versi dan status CUDA, berarti semua sudah siap:

python
import torch

print("Versi PyTorch:", torch.__version__)
print("CUDA tersedia:", torch.cuda.is_available())

Jika CUDA tersedia menampilkan True, GPU-mu terdeteksi dan training akan jauh lebih cepat. Jika False, jangan khawatir — seluruh kode di tutorial ini tetap berjalan normal di CPU.

Tensor: Fondasi dari Segalanya

Tensor adalah struktur data inti PyTorch — generalisasi dari skalar, vektor, dan matriks ke dimensi berapa pun. Kabar baiknya, jika kamu sudah terbiasa dengan NumPy, sebagian besar operasi tensor akan terasa sangat familiar. Mari kita coba:

python
import torch

# Membuat tensor dari list Python
x = torch.tensor([[1, 2, 3],
                  [4, 5, 6]])
print("x =", x)
print("Shape:", x.shape)   # torch.Size([2, 3])
print("Dtype:", x.dtype)   # torch.int64

# Tensor acak (banyak dipakai untuk inisialisasi bobot)
r = torch.rand(3, 3)
print("Tensor acak:\n", r)

# Operasi aritmatika element-wise
a = torch.tensor([1.0, 2.0, 3.0])
b = torch.tensor([4.0, 5.0, 6.0])
print("a + b =", a + b)
print("a * b =", a * b)

# Perkalian matriks
m = torch.rand(2, 3)
n = torch.rand(3, 2)
print("m @ n shape:", (m @ n).shape)  # torch.Size([2, 2])

Perhatikan bahwa operator +, *, dan @ (perkalian matriks) bekerja element-wise layaknya NumPy. Satu hal yang perlu diingat: tensor yang akan dipakai untuk training (melibatkan gradien) harus bertipe float, bukan integer.

Autograd: Diferensiasi Otomatis

Inilah kekuatan utama PyTorch. Dengan menyetel requires_grad=True, PyTorch merekam semua operasi ke dalam computation graph. Ketika kita memanggil .backward(), gradien dihitung otomatis:

python
x = torch.tensor(3.0, requires_grad=True)
y = x ** 2 + 3 * x + 1

y.backward()
print("dy/dx pada x=3:", x.grad)  # 2*3 + 3 = 9

Pada contoh di atas, y = x² + 3x + 1 memiliki turunan 2x + 3. Saat x = 3, turunannya adalah 9 — persis seperti yang dihitung PyTorch. Mekanisme inilah yang membuat training deep learning terasa sederhana: kita hanya mendefinisikan forward pass, dan PyTorch menangani semua perhitungan turunan.

Saat melakukan inference (prediksi) saja, bungkus kode dengan torch.no_grad() agar computation graph tidak dibangun. Ini menghemat memori dan mempercepat komputasi.

Membangun Neural Network dengan nn.Module

PyTorch menyediakan torch.nn untuk merakit layer-layer neural network. Setiap model dibuat dengan mewarisi nn.Module dan mendefinisikan metode forward(). Mari bangun jaringan untuk mengklasifikasikan gambar digit 28×28 ke dalam 10 kelas (angka 0–9):

python
import torch.nn as nn

class DigitClassifier(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(28 * 28, 128)   # input -> hidden
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(128, 10)        # hidden -> output (10 digit)

    def forward(self, x):
        x = self.flatten(x)   # (batch, 1, 28, 28) -> (batch, 784)
        x = self.fc1(x)
        x = self.relu(x)
        x = self.fc2(x)
        return x

model = DigitClassifier()
print(model)

Jaringan ini disebut multilayer perceptron (MLP): satu hidden layer berisi 128 neuron dengan aktivasi ReLU, plus output layer 10 neuron. Konsepnya mirip dengan model klasifikasi di tutorial Scikit-learn, tetapi dibangun dari nol sebagai neural network sehingga mampu menangkap pola yang jauh lebih kompleks.

Menyiapkan Dataset dan DataLoader

Kita akan memakai dataset MNIST, kumpulan 60.000 gambar digit tulisan tangan yang menjadi “hello world” dunia deep learning. torchvision memudahkan proses unduh, konversi gambar menjadi tensor, dan normalisasi nilai piksel:

python
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# Ubah gambar jadi tensor, lalu normalisasi (mean 0.1307, std 0.3081)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

train_data = datasets.MNIST(root="data", train=True, download=True, transform=transform)
test_data  = datasets.MNIST(root="data", train=False, download=True, transform=transform)

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader  = DataLoader(test_data, batch_size=64, shuffle=False)

print("Jumlah data latih:", len(train_data))
print("Jumlah data uji:", len(test_data))

DataLoader membagi dataset menjadi batch kecil dan mengacaknya setiap epoch. Normalisasi membantu model belajar lebih cepat karena nilai piksel berada pada rentang yang konsisten.

Melatih Model: Training Loop

Training loop di PyTorch selalu mengikuti pola yang sama: forward pass, hitung loss, reset gradien, backward pass, lalu update bobot. Mari kita terapkan:

python
import torch.optim as optim

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = DigitClassifier().to(device)

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

epochs = 5
for epoch in range(epochs):
    model.train()
    total_loss = 0
    for images, labels in train_loader:
        images, labels = images.to(device), labels.to(device)

        # 1. forward pass
        outputs = model(images)
        # 2. hitung loss
        loss = criterion(outputs, labels)

        # 3. reset gradien
        optimizer.zero_grad()
        # 4. backward pass
        loss.backward()
        # 5. update bobot
        optimizer.step()

        total_loss += loss.item()

    print(f"Epoch {epoch+1}/{epochs} - Loss: {total_loss/len(train_loader):.4f}")

Mengevaluasi Model

Setelah training, uji model terhadap test set yang belum pernah dilihatnya. Perhatikan penggunaan model.eval() dan torch.no_grad() agar tidak ada gradien yang dihitung:

python
model.eval()
correct = 0
total = 0

with torch.no_grad():
    for images, labels in test_loader:
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs, 1)  # ambil kelas dengan skor tertinggi
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Akurasi pada test set: {100 * correct / total:.2f}%")

Dengan 5 epoch saja, model sederhana ini biasanya mencapai akurasi sekitar 97–98%. Coba tambah epoch, ubah learning rate, atau tambah hidden layer untuk melihat perubahan akurasi.

Menyimpan dan Memuat Model

Setelah puas dengan hasilnya, simpan bobot model agar bisa digunakan kembali tanpa melatih ulang:

python
# Menyimpan
torch.save(model.state_dict(), "model_mnist.pth")

# Memuat kembali
model_baru = DigitClassifier()
model_baru.load_state_dict(torch.load("model_mnist.pth"))
model_baru.eval()
print("Model berhasil dimuat!")

Kesimpulan

Selamat! Kamu baru saja membangun neural network dari nol dengan PyTorch — dari memahami tensor, memanfaatkan autograd, hingga melatih model yang mengenali digit tulisan tangan. Pola training loop yang dipelajari berlaku untuk hampir semua masalah deep learning: klasifikasi gambar, pemrosesan teks, hingga model transformer berskala besar. Langkah selanjutnya yang disarankan adalah mencoba arsitektur CNN (convolutional neural network) untuk akurasi lebih tinggi, lalu menerapkan PyTorch pada dataset milikmu sendiri.

Ingin melangkah lebih jauh? Setelah menguasai dasar PyTorch, kamu bisa lanjut membaca roadmap menjadi AI Engineer 2026 untuk merencanakan langkah belajar berikutnya secara sistematis.