📑 Daftar Isi — Part 1
- Kenapa PyTorch? — Mengapa framework ini jadi standar industri
- Instalasi — Setup environment dalam 2 menit
- Tensor — Fondasi semua operasi di PyTorch
- Operasi Tensor — Reshape, indexing, math, GPU
- Autograd — Mesin diferensiasi otomatis
- Neural Network Pertama — 50 baris kode, bisa belajar sendiri
- Ringkasan & Preview Part 2
🔥
1. Kenapa PyTorch?
Framework deep learning #1 — dari riset hingga production
PyTorch adalah framework deep learning open-source dari Meta AI (Facebook) yang menjadi standar de facto di dunia riset dan industri. Hampir semua paper AI terbaru (GPT, LLaMA, Stable Diffusion, dll) ditulis menggunakan PyTorch.
Dua fitur utama PyTorch:
🧮 Tensor Computation
Seperti NumPy, tapi bisa jalan di GPU. Operasi matematika pada array multi-dimensi dengan akselerasi hardware.
⚡ Automatic Differentiation
Autograd: menghitung gradient (turunan) secara otomatis. Ini yang membuat neural network bisa "belajar" — tanpa Anda menulis rumus turunan manual.
💡 Analogi Sederhana
Bayangkan Anda membuat resep kue. Tensor = bahan-bahan (tepung, gula, telur — data dalam bentuk angka). Autograd = mekanisme yang otomatis mencatat setiap langkah memasak, sehingga kalau kue-nya kurang enak, Anda bisa tahu persis langkah mana yang perlu diubah dan seberapa banyak. Itulah yang disebut gradient.
📦
2. Instalasi — 2 Menit Setup
pip install torch — done
Terminal — Install PyTorch
# CPU only (paling simpel, cukup untuk belajar)
pip install torch torchvision
# Dengan GPU NVIDIA (CUDA 12.4)
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
# Verifikasi instalasi
python -c "import torch; print(torch.__version__)"
# Output: 2.7.0 (atau versi terbaru)
💡 Tip: Untuk belajar, CPU sudah cukup. GPU (NVIDIA) hanya diperlukan ketika melatih model besar. Gunakan
Google Colab (gratis) jika ingin GPU tanpa beli hardware.
🧮
3. Tensor — Fondasi Semua Operasi
Seperti NumPy array, tapi bisa jalan di GPU dan track gradient
Tensor adalah struktur data fundamental di PyTorch — array multi-dimensi yang bisa menyimpan angka. Jika Anda familiar dengan NumPy, tensor sangat mirip ndarray, tapi dengan dua superpower: bisa jalan di GPU dan bisa di-track oleh Autograd.
01_tensor_basics.py — Membuat Tensor
import torch
# ===========================
# 1. Membuat Tensor dari data
# ===========================
# Dari Python list
x = torch.tensor([1, 2, 3])
print(x) # tensor([1, 2, 3])
print(x.shape) # torch.Size([3])
# Matrix 2x3
m = torch.tensor([[1, 2, 3],
[4, 5, 6]])
print(m.shape) # torch.Size([2, 3])
# ===========================
# 2. Tensor generator functions
# ===========================
zeros = torch.zeros(3, 4) # 3x4 berisi 0
ones = torch.ones(2, 3) # 2x3 berisi 1
rand = torch.rand(2, 3) # 2x3 random [0, 1)
randn = torch.randn(2, 3) # 2x3 random normal
arange = torch.arange(0, 10, 2) # tensor([0, 2, 4, 6, 8])
eye = torch.eye(3) # Identity matrix 3x3
# ===========================
# 3. Data types
# ===========================
f = torch.tensor([1.0, 2.0]) # float32 (default)
i = torch.tensor([1, 2]) # int64 (default)
h = torch.tensor([1.0], dtype=torch.float16) # half precision
print(f.dtype) # torch.float32
# ===========================
# 4. NumPy ↔ Tensor conversion
# ===========================
import numpy as np
np_array = np.array([1, 2, 3])
tensor = torch.from_numpy(np_array) # NumPy → Tensor
back = tensor.numpy() # Tensor → NumPy
🎓 Dimensi Tensor
Scalar (0D): satu angka → torch.tensor(42)
Vector (1D): array → torch.tensor([1, 2, 3])
Matrix (2D): tabel → torch.tensor([[1,2],[3,4]])
3D Tensor: batch of matrices → gambar RGB, teks sequences
4D Tensor: batch of gambar → [batch, channels, height, width]
🔧
4. Operasi Tensor — Math, Reshape, GPU
Semua yang perlu Anda tahu untuk manipulasi data
import torch
a = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
b = torch.tensor([[5.0, 6.0], [7.0, 8.0]])
# ===========================
# 1. Operasi Matematika
# ===========================
c = a + b # Element-wise addition
d = a * b # Element-wise multiplication
e = a @ b # Matrix multiplication (matmul)
f = torch.matmul(a, b) # Sama dengan @
print(a.sum()) # tensor(10.) — jumlah semua element
print(a.mean()) # tensor(2.5) — rata-rata
print(a.max()) # tensor(4.) — nilai maksimum
print(a.argmax()) # tensor(3) — index nilai max
# ===========================
# 2. Reshape & Indexing
# ===========================
x = torch.arange(12) # tensor([0,1,2,...,11])
y = x.reshape(3, 4) # Ubah jadi 3x4
z = x.view(4, 3) # Sama, tapi share memory
print(y[0]) # Baris pertama: tensor([0,1,2,3])
print(y[:, 1]) # Kolom kedua: tensor([1,5,9])
print(y[0:2, 1:3]) # Slice: 2 baris, kolom 1-2
# ===========================
# 3. Pindah ke GPU (jika ada)
# ===========================
if torch.cuda.is_available():
device = torch.device("cuda")
gpu_tensor = a.to(device) # Pindah ke GPU
result = gpu_tensor @ gpu_tensor
back_cpu = result.to("cpu") # Kembali ke CPU
else:
print("GPU tidak tersedia, pakai CPU")
⚡
5. Autograd — Mesin Ajaib di Balik Deep Learning
Otomatis hitung gradient — Anda tidak perlu tulis rumus turunan
Autograd adalah fitur terpenting PyTorch. Ia mencatat semua operasi yang Anda lakukan pada tensor, lalu menghitung gradient (turunan) secara otomatis. Ini yang membuat neural network bisa "belajar" — menyesuaikan parameter agar error semakin kecil.
🎓 Apa Itu Gradient?
Gradient = arah dan seberapa besar Anda harus mengubah parameter untuk mengurangi error. Bayangkan Anda berdiri di bukit berkabut dan ingin turun ke lembah (error terkecil). Gradient memberi tahu: "langkah ke kiri 2 meter, ke depan 1 meter" — ini yang disebut gradient descent.
03_autograd.py — Autograd Step by Step
import torch
# ===========================
# 1. Contoh paling sederhana
# ===========================
# Buat tensor dengan requires_grad=True
# → PyTorch akan TRACK semua operasi pada tensor ini
x = torch.tensor(3.0, requires_grad=True)
# Lakukan operasi: y = x²
y = x ** 2
print(y) # tensor(9., grad_fn=<PowBackward0>)
# ↑ grad_fn = PyTorch mencatat operasi "pangkat"
# Hitung gradient: dy/dx = 2x = 2(3) = 6
y.backward()
print(x.grad) # tensor(6.) ← BENAR! Turunan x² = 2x, di x=3 → 6
# ===========================
# 2. Contoh lebih kompleks
# ===========================
a = torch.tensor(2.0, requires_grad=True)
b = torch.tensor(3.0, requires_grad=True)
# z = a² + 3*b
z = a**2 + 3*b
z.backward()
print(a.grad) # tensor(4.) ← dz/da = 2a = 2(2) = 4
print(b.grad) # tensor(3.) ← dz/db = 3
# ===========================
# 3. Penting: Reset gradient!
# ===========================
# Gradient TERAKUMULASI! Harus di-reset sebelum backward berikutnya
a.grad.zero_() # Reset gradient a ke 0
b.grad.zero_() # Reset gradient b ke 0
# ===========================
# 4. Matikan tracking (untuk inference)
# ===========================
with torch.no_grad():
# Di dalam block ini, tidak ada gradient tracking
# Lebih cepat, hemat memory — pakai saat prediction
result = a * 2
🔄 Bagaimana Autograd Bekerja (DAG)
[x = 3.0] ← Leaf tensor (requires_grad=True)
│
▼
[y = x²] ← Forward pass: hitung y
│ PyTorch CATAT: grad_fn = PowBackward0
▼
y.backward() ← Backward pass: hitung dy/dx
│ Chain rule: dy/dx = 2x = 6
▼
x.grad = 6.0 ← Gradient tersimpan di x.grad
🧠
6. Neural Network Pertama — 50 Baris Kode
Dari data → model → training → prediction
Sekarang kita gabungkan semua yang sudah dipelajari. Kita akan membuat neural network sederhana yang belajar menghitung y = 2x + 1 — hanya dari data, tanpa dikasih tahu rumusnya.
04_first_neural_network.py — Neural Network Pertama Anda!
import torch
import torch.nn as nn
# ===========================
# STEP 1: Siapkan Data
# Target: model belajar y = 2x + 1
# ===========================
X = torch.tensor([[1.0], [2.0], [3.0], [4.0], [5.0]])
y = torch.tensor([[3.0], [5.0], [7.0], [9.0], [11.0]])
# y = 2*X + 1
# ===========================
# STEP 2: Definisikan Model
# ===========================
class SimpleNet(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(1, 1) # 1 input → 1 output
def forward(self, x):
return self.linear(x)
model = SimpleNet()
# ===========================
# STEP 3: Loss Function & Optimizer
# ===========================
loss_fn = nn.MSELoss() # Mean Squared Error
optimizer = torch.optim.SGD( # Stochastic Gradient Descent
model.parameters(), lr=0.01
)
# ===========================
# STEP 4: Training Loop! 🔥
# ===========================
for epoch in range(100):
# Forward pass: hitung prediksi
pred = model(X)
# Hitung loss (seberapa jauh prediksi dari target)
loss = loss_fn(pred, y)
# Backward pass: hitung gradient (Autograd!)
optimizer.zero_grad() # Reset gradient
loss.backward() # Hitung gradient
optimizer.step() # Update parameter
if (epoch + 1) % 20 == 0:
print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
# ===========================
# STEP 5: Cek Hasilnya!
# ===========================
# Lihat parameter yang dipelajari model
w = model.linear.weight.item()
b = model.linear.bias.item()
print(f"\nModel belajar: y = {w:.2f}x + {b:.2f}")
# Output: Model belajar: y = 2.00x + 1.00 ← BENAR!
# Prediksi nilai baru
with torch.no_grad():
test = torch.tensor([[10.0]])
print(f"Prediksi x=10: {model(test).item():.2f}")
# Output: Prediksi x=10: 21.00 ← 2(10)+1 = 21 ✓
🎓 Apa yang Terjadi di Training Loop?
1. Forward Pass: Data masuk ke model → model membuat prediksi.
2. Loss: Hitung error — seberapa jauh prediksi dari jawaban benar.
3. Backward Pass: Autograd hitung gradient — "arah mana untuk mengurangi error?"
4. Update: Optimizer menggeser parameter sedikit ke arah yang benar.
Ulangi 100x → model semakin akurat. Ini seluruh inti deep learning.
🎉 Selamat! Anda baru saja membuat neural network yang bisa belajar sendiri dari data. Model ini menemukan rumus y = 2x + 1 tanpa pernah diberitahu — hanya dari contoh input dan output. Inilah kekuatan machine learning.
📝
7. Ringkasan Part 1
Apa yang sudah kita pelajari
| Konsep | Apa Itu | Kode Kunci |
|---|
| Tensor | Array multi-dimensi — fondasi semua data di PyTorch | torch.tensor([1, 2, 3]) |
| GPU Transfer | Pindahkan tensor ke GPU untuk komputasi cepat | tensor.to("cuda") |
| requires_grad | Aktifkan tracking gradient pada tensor | tensor(3.0, requires_grad=True) |
| backward() | Hitung gradient secara otomatis | loss.backward() |
| nn.Module | Base class untuk membuat neural network | class MyNet(nn.Module) |
| nn.Linear | Fully connected layer (y = Wx + b) | nn.Linear(in, out) |
| Loss Function | Mengukur error prediksi vs target | nn.MSELoss() |
| Optimizer | Update parameter berdasarkan gradient | optim.SGD(params, lr=0.01) |
| Training Loop | Forward → Loss → Backward → Update → Repeat | 4 baris di dalam for loop |
📘
Coming Next: Part 2 — Dataset, DataLoader & Classification
Bagaimana memuat data real (gambar, CSV), membuat DataLoader untuk batch training, dan membangun classifier pertama yang bisa mengenali angka tulisan tangan (MNIST). Stay tuned!
🔥
Tech Review Desk — Seri Belajar PyTorch
Tutorial hands-on. Sumber: pytorch.org docs, PyTorch Foundation, Red Hat Developer, DeepLearning.AI. PyTorch v2.7+ (2026).