Modul Praktikum Artificial Intelligence PyTorch Deep Dive

MODUL PRAKTIKUM
PYTORCH
DEEP DIVE
Tensors · Autograd · Training · GPU · Deployment

Tensors Autograd [Link] DataLoader Checkpoints GPU & AMP Deployment

Teori · Praktikum Kode · Studi Kasus · Latihan Mandiri

Program Studi Ilmu Komputer
Universitas Dian Nuswantoro (UDINUS) Semarang

Program AI Bootcamp UDINUS Hal. 1 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

DAFTAR ISI
TOC \h \o "1-3"

Catatan: klik kanan pada daftar isi lalu pilih "Update Field" di Microsoft Word untuk memuat nomor halaman.

Program AI Bootcamp UDINUS Hal. 2 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

06
MODUL PRAKTIKUM

PYTORCH DEEP DIVE

Menyelami framework PyTorch untuk pengembangan deep learning secara langsung

Program AI Bootcamp UDINUS Hal. 3 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

MODUL 6 PyTorch Deep Dive

Modul ini menyelami PyTorch — framework deep learning paling populer di dunia riset —
secara mendalam dan praktis. Anda akan menguasai tensor dan automatic differentiation
sebagai fondasi, membangun arsitektur jaringan kustom, menyusun training loop dan
checkpoint yang benar, memuat data secara efisien dengan Dataset & DataLoader,
memanfaatkan akselerasi GPU dan gambaran distributed training, menerapkan transfer
learning, hingga deployment & optimasi model. Seluruh materi disertai kode yang dapat
langsung dijalankan.

🎯 Capaian Pembelajaran
Membuat dan memanipulasi tensor PyTorch serta memahami automatic differentiation (autograd).
Membangun arsitektur neural network kustom dengan [Link].
Menyusun training loop lengkap serta menyimpan dan memuat checkpoint model.
Memuat & memproses data dengan Dataset dan DataLoader (termasuk dataset kustom).
Memanfaatkan akselerasi GPU dan memahami konsep distributed training & mixed precision.
Menerapkan transfer learning dan mengekspor model untuk deployment (TorchScript/ONNX).

ℹ️ Prasyarat & Lingkungan

Memahami dasar Python, NumPy, dan konsep deep learning (neural network, gradient descent) dari
Modul 5.
Python ≥ 3.10 dengan torch, torchvision. GPU (CUDA) sangat disarankan namun tidak wajib.
Instalasi: pip install torch torchvision (lihat [Link] untuk versi CUDA yang tepat).

6.1 Tensor: Fondasi PyTorch

▶ 6.1.1 Mengapa PyTorch

PyTorch menyediakan tiga hal utama: tensor (array multidimensi seperti NumPy namun dapat
berjalan di GPU), autograd (diferensiasi otomatis untuk backpropagation), dan pustaka `nn`
berisi lapisan & fungsi siap pakai. Sifatnya yang *Pythonic* dan dynamic computational graph
membuatnya intuitif untuk eksperimen dan debugging.

▶ 6.1.2 Membuat & Memanipulasi Tensor

Buat berkas 01_tensor.py. Tensor adalah unit data dasar; operasinya mirip NumPy.

1 import torch
2
3 # Membuat tensor
4 a = [Link]([[1., 2.], [3., 4.]]) # dari list
5 b = [Link](2, 3) # matriks nol
6 c = [Link](2, 2) # acak normal
7 d = [Link](0, 10, 2) # [0,2,4,6,8]
8
9 print("Bentuk a:", [Link], "| dtype:", [Link])
10
11 # Operasi elemen & matriks
12 print("a + 10:\n", a + 10)
13 print("Perkalian matriks a@a:\n", a @ a)
14 print("Transpose:\n", a.T)
15

Program AI Bootcamp UDINUS Hal. 4 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

16 # Reshape & indexing

17 e = [Link](12).reshape(3, 4)
18 print("Baris pertama:", e[0])
19 print("Kolom terakhir:", e[:, -1])
20 print("Reshape jadi (2,6):\n", [Link](2, 6))

Kode Membuat, mengoperasikan, dan mengubah bentuk tensor

▶ 6.1.3 Jembatan NumPy & Perangkat

Tensor dapat dikonversi dari/ke NumPy dan dipindahkan antar perangkat (CPU/GPU).

1 import torch, numpy as np

2
3 # NumPy <-> Tensor (berbagi memori di CPU)
4 arr = [Link]([1.0, 2.0, 3.0])
5 t = torch.from_numpy(arr)
6 kembali = [Link]()
7
8 # Memindahkan tensor ke GPU bila tersedia
9 device = "cuda" if [Link].is_available() else "cpu"
10 t_gpu = [Link](device)
11 print("Tensor berada di:", t_gpu.device)

Kode Konversi NumPy dan pemindahan tensor antar perangkat

💡 Operasi in-place & broadcasting

Operasi berakhiran garis bawah (add_, mul_) memodifikasi tensor di tempat (in-place), menghemat
memori. Broadcasting memungkinkan operasi antar-tensor berbeda bentuk secara otomatis, mirip
NumPy.

6.2 Automatic Differentiation (Autograd)

Autograd adalah mesin yang menghitung gradien secara otomatis. Ketika sebuah tensor
memiliki requires_grad=True, PyTorch merekam semua operasi terhadapnya dalam sebuah
computational graph dinamis, lalu .backward() menghitung gradien melalui graph tersebut.

▶ Langkah — Menghitung Gradien

Buat berkas 02_autograd.py. Contoh menghitung gradien fungsi sederhana.

1 import torch
2
3 # Tensor dengan pelacakan gradien
4 x = [Link](3.0, requires_grad=True)
5 y = [Link](2.0, requires_grad=True)
6
7 # Fungsi: z = x^2 + 3xy + y^2
8 z = x**2 + 3*x*y + y**2
9
10 # Hitung gradien dz/dx dan dz/dy
11 [Link]()
12 print("dz/dx =", [Link]()) # 2x + 3y = 6 + 6 = 12
13 print("dz/dy =", [Link]()) # 3x + 2y = 9 + 4 = 13

Kode Menghitung gradien otomatis dengan backward()

Program AI Bootcamp UDINUS Hal. 5 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

▶ 6.2.1 Mengelola Gradien

● `torch.no_grad()` — menonaktifkan pelacakan gradien saat inferensi/evaluasi untuk
menghemat memori & mempercepat.
● `.zero_grad()` — mengosongkan gradien sebelum iterasi berikutnya (gradien terakumulasi
secara default).
● `.detach()` — melepas tensor dari graph agar tidak dilacak.
1 import torch
2
3 w = [Link](3, requires_grad=True)
4
5 # Inferensi tanpa melacak gradien
6 with torch.no_grad():
7 hasil = w * 2 # tidak masuk computational graph
8
9 # Melepas tensor dari graph
10 w_lepas = [Link]() # salinan tanpa gradien
11 print("requires_grad:", w_lepas.requires_grad) # False

Kode Mengendalikan pelacakan gradien: no_grad dan detach

⚠️ Selalu kosongkan gradien!

PyTorch mengakumulasi gradien secara default. Bila lupa memanggil optimizer.zero_grad() di
tiap iterasi, gradien lama akan bertumpuk dan pelatihan menjadi salah. Ini kesalahan pemula yang paling
sering terjadi.

6.3 Membangun Arsitektur Neural Network Kustom

Semua model PyTorch mewarisi `[Link]`. Anda mendefinisikan lapisan di __init__ dan
alur komputasi maju di forward. Pendekatan ini memberi fleksibilitas penuh untuk arsitektur
apa pun.

▶ 6.3.1 Dua Gaya Definisi

● `[Link]` — merangkai lapisan secara linear; ringkas untuk arsitektur sederhana.
● Subkelas `[Link]` — mendefinisikan forward secara manual; diperlukan untuk aliran
kompleks (skip connection, percabangan, multi-input).

▶ Langkah — Modul Kustom dengan Skip Connection

Buat berkas 03_custom_model.py. Kita bangun blok residual sederhana untuk menunjukkan
fleksibilitas forward kustom.

1 import torch, [Link] as nn, [Link] as F

2
3 class ResidualBlock([Link]):
4 def __init__(self, dim):
5 super().__init__()
6 self.fc1 = [Link](dim, dim)
7 self.fc2 = [Link](dim, dim)
8
9 def forward(self, x):
10 identitas = x # simpan masukan
11 out = [Link](self.fc1(x))

Program AI Bootcamp UDINUS Hal. 6 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

12 out = self.fc2(out)
13 return [Link](out + identitas) # skip connection
14
15 class MyModel([Link]):
16 def __init__(self, in_dim=64, hidden=128, num_classes=10):
17 super().__init__()
18 [Link] = [Link](in_dim, hidden)
19 self.blok1 = ResidualBlock(hidden)
20 self.blok2 = ResidualBlock(hidden)
21 [Link] = [Link](hidden, num_classes)
22
23 def forward(self, x):
24 x = [Link]([Link](x))
25 x = self.blok1(x)
26 x = self.blok2(x)
27 return [Link](x)
28
29 model = MyModel()
30 dummy = [Link](8, 64)
31 print("Keluaran:", model(dummy).shape) # (8, 10)
32 print("Jumlah parameter:", sum([Link]() for p in [Link]()))

Kode Model kustom dengan blok residual dan skip connection

ℹ️ Melihat & mengelola parameter

[Link]() mengembalikan seluruh bobot yang dapat dilatih;
model.named_parameters() menyertakan namanya. model.state_dict() adalah kamus berisi
semua bobot — dasar untuk menyimpan & memuat model.

6.4 Data Loading & Preprocessing

PyTorch memisahkan `Dataset` (menyediakan satu sampel) dari `DataLoader`
(mengelompokkan menjadi batch, mengacak, dan memuat paralel). Pemisahan ini membuat
pipeline data rapi dan efisien.

▶ 6.4.1 Dataset Kustom

Buat berkas 04_dataset.py. Dataset kustom cukup mengimplementasikan __len__ dan
__getitem__.

1 import torch
2 from [Link] import Dataset, DataLoader
3
4 class DatasetKustom(Dataset):
5 def __init__(self, fitur, label, transform=None):
6 [Link] = fitur
7 [Link] = label
8 [Link] = transform
9
10 def __len__(self):
11 return len([Link]) # jumlah sampel
12
13 def __getitem__(self, idx):
14 x = [Link][idx]
15 y = [Link][idx]

Program AI Bootcamp UDINUS Hal. 7 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

16 if [Link]:
17 x = [Link](x) # augmentasi/normalisasi
18 return x, y
19
20 # Data contoh
21 X = [Link](100, 3, 32, 32) # 100 citra
22 y = [Link](0, 5, (100,)) # 5 kelas
23 ds = DatasetKustom(X, y)
24
25 # DataLoader: batch, shuffle, paralel
26 dl = DataLoader(ds, batch_size=16, shuffle=True, num_workers=2)
27 for batch_x, batch_y in dl:
28 print("Batch:", batch_x.shape, batch_y.shape) # (16,3,32,32) (16,)
29 break

Kode Membuat Dataset kustom dan memuatnya dengan DataLoader

💡 torchvision untuk citra

Untuk data citra, [Link] otomatis membaca folder terstruktur (satu
subfolder per kelas), dan [Link] menyediakan augmentasi (resize, crop, flip,
normalisasi) yang siap dirangkai dengan [Link].

6.5 Training Loop & Model Checkpoint

Berbeda dari framework tingkat tinggi, PyTorch memberi kendali penuh atas training loop —
Anda menulis sendiri langkah forward, hitung loss, backward, dan update. Ini menuntut
pemahaman namun memberi fleksibilitas maksimal.

▶ 6.5.1 Anatomi Training Loop

Setiap iterasi pelatihan mengikuti lima langkah baku:
Zero grad — kosongkan gradien: optimizer.zero_grad().
Forward — hitung prediksi: out = model(x).
Loss — hitung kerugian: loss = criterion(out, y).
Backward — hitung gradien: [Link]().
Step — perbarui bobot: [Link]().

▶ Langkah — Training Loop + Checkpoint

Buat berkas 05_training.py. Kita latih model sambil menyimpan checkpoint terbaik dan
mendukung melanjutkan pelatihan (resume).

1 import torch, [Link] as nn

2
3 device = "cuda" if [Link].is_available() else "cpu"
4 model = MyModel().to(device) # dari bagian 6.3
5 criterion = [Link]()
6 optimizer = [Link]([Link](), lr=1e-3)
7
8 def simpan_checkpoint(path, epoch, best_acc):
9 [Link]({
10 "epoch": epoch,
11 "model_state": model.state_dict(),

Program AI Bootcamp UDINUS Hal. 8 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

12 "optim_state": optimizer.state_dict(),
13 "best_acc": best_acc,
14 }, path)
15
16 def muat_checkpoint(path):
17 ckpt = [Link](path, map_location=device)
18 model.load_state_dict(ckpt["model_state"])
19 optimizer.load_state_dict(ckpt["optim_state"])
20 return ckpt["epoch"], ckpt["best_acc"]
21
22 best_acc = 0.0
23 for epoch in range(1, 11):
24 [Link]()
25 for x, y in dl: # dl dari bagian 6.4
26 x, y = [Link]([Link](0), -1).to(device), [Link](device)
27 optimizer.zero_grad() # 1) zero grad
28 out = model(x) # 2) forward
29 loss = criterion(out, y) # 3) loss
30 [Link]() # 4) backward
31 [Link]() # 5) step
32 # (evaluasi akurasi -> acc); di sini contoh saja
33 acc = 0.5 + epoch * 0.03
34 if acc > best_acc:
35 best_acc = acc
36 simpan_checkpoint("[Link]", epoch, best_acc)
37 print(f"Epoch {epoch} | loss {[Link]():.3f} | acc {acc:.2f}")

Kode Training loop lengkap dengan penyimpanan checkpoint terbaik

⚠️ Simpan state_dict, bukan seluruh model

Simpanlah model.state_dict() (hanya bobot), bukan objek model utuh. Ini lebih portabel dan aman
antar-versi. Untuk melanjutkan pelatihan, simpan juga optimizer.state_dict() dan epoch terakhir.

6.6 Akselerasi GPU & Distributed Training

GPU mempercepat pelatihan deep learning berkali-kali lipat berkat komputasi paralel. Di
PyTorch, cukup pindahkan model dan data ke perangkat yang sama.

▶ 6.6.1 Menggunakan GPU

1 import torch
2
3 device = "cuda" if [Link].is_available() else "cpu"
4 print("Perangkat:", device)
5 if device == "cuda":
6 print("Nama GPU:", [Link].get_device_name(0))
7
8 model = MyModel().to(device) # pindahkan model
9 # Di dalam loop: pindahkan data ke perangkat yang sama
10 # x, y = [Link](device), [Link](device) # WAJIB agar tidak error

Kode Mendeteksi dan menggunakan GPU

Program AI Bootcamp UDINUS Hal. 9 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

▶ 6.6.2 Mixed Precision (AMP)

Automatic Mixed Precision menggunakan presisi 16-bit di bagian yang aman, mempercepat
pelatihan dan menghemat memori GPU tanpa kehilangan akurasi berarti.

1 import torch
2
3 scaler = [Link]() # penskala gradien
4
5 for x, y in dl:
6 x, y = [Link](device), [Link](device)
7 optimizer.zero_grad()
8 with [Link](): # jalankan di presisi campuran
9 out = model(x)
10 loss = criterion(out, y)
11 [Link](loss).backward() # skala untuk cegah underflow
12 [Link](optimizer)
13 [Link]()

Kode Mempercepat pelatihan dengan mixed precision (AMP)

▶ 6.6.3 Distributed Training

Pendekatan Cara Kerja Catatan

DataParallel Membagi batch ke beberapa GPU dalam satu Mudah dipakai, kurang efisien.
mesin.
DistributedDataParallel Satu proses per GPU, sinkronisasi gradien. Standar & efisien untuk skala
(DDP) besar.
FSDP Membagi (shard) parameter model antar-GPU. Untuk model sangat besar
(LLM).

Tabel 6.1. Pendekatan distributed training di PyTorch

ℹ️ Kapan perlu multi-GPU?

Mulailah dengan satu GPU + AMP. Beralih ke DDP hanya ketika dataset/model terlalu besar atau
pelatihan terlalu lama pada satu GPU. DDP memberi skala hampir linear terhadap jumlah GPU.

6.7 Transfer Learning dengan Pre-trained Models

Alih-alih melatih dari nol, manfaatkan model pra-terlatih dari [Link] yang
telah belajar dari ImageNet. Bekukan lapisan fitur, ganti kepala klasifikasi, dan latih dengan data
Anda.

1 import torch, [Link] as nn

2 from torchvision import models
3
4 device = "cuda" if [Link].is_available() else "cpu"
5
6 # Muat ResNet50 terlatih
7 model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
8
9 # Bekukan seluruh lapisan fitur (feature extraction)
10 for p in [Link]():
11 p.requires_grad = False

Program AI Bootcamp UDINUS Hal. 10 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

12
13 # Ganti kepala klasifikasi untuk jumlah kelas kita
14 n_fitur = [Link].in_features
15 [Link] = [Link](n_fitur, 5) # 5 kelas; lapisan baru dilatih
16 model = [Link](device)
17
18 # Optimasi hanya parameter kepala baru
19 optimizer = [Link]([Link](), lr=1e-3)
20 print("Dilatih:", sum([Link]() for p in [Link]()
21 if p.requires_grad), "parameter")
22
23 # Untuk fine-tuning: buka blok akhir & pakai LR kecil
24 # for p in [Link](): p.requires_grad = True

Kode Transfer learning dengan ResNet50 pra-terlatih

💡 Gunakan transform bawaan bobot

[Link]() memberikan pipeline pra-pemrosesan yang persis sesuai model terlatih
(ukuran, normalisasi). Memakainya mencegah ketidaksesuaian yang menurunkan akurasi.

6.8 Deployment & Optimasi Model

Model yang telah dilatih perlu disiapkan untuk inferensi produksi — cepat, ringan, dan portabel
antar-lingkungan.

▶ 6.8.1 Menyiapkan Model untuk Inferensi

● `[Link]()` — aktifkan mode evaluasi (menonaktifkan dropout & mengunci batch norm).
● `torch.no_grad()` — matikan autograd saat inferensi untuk kecepatan & hemat memori.

▶ 6.8.2 Ekspor: TorchScript & ONNX

Metode Kegunaan

TorchScript Serialisasi model agar jalan tanpa Python (C++/mobile).

ONNX Format standar lintas-framework (ONNX Runtime, TensorRT).
Quantization Mengecilkan model ke int8; lebih cepat & ringan.
Pruning Membuang bobot tak penting untuk efisiensi.

Tabel 6.2. Metode deployment & optimasi model

Buat berkas 06_deploy.py. Contoh ekspor ke TorchScript dan ONNX.

1 import torch
2
3 [Link]() # WAJIB sebelum ekspor
4 contoh = [Link](1, 3, 224, 224).to(device)
5
6 # 1) TorchScript via tracing
7 traced = [Link](model, contoh)
8 [Link]("model_scripted.pt")
9
10 # 2) Ekspor ke ONNX
11 [Link](

Program AI Bootcamp UDINUS Hal. 11 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

12 model, contoh, "[Link]",

13 input_names=["input"], output_names=["output"],
14 dynamic_axes={"input": {0: "batch"}, "output": {0: "batch"}},
15 opset_version=17,
16 )
17 print("Model diekspor ke TorchScript & ONNX.")
18
19 # 3) Inferensi cepat
20 with torch.no_grad():
21 hasil = model(contoh)
22 print("Prediksi:", [Link](1).item())

Kode Ekspor model ke TorchScript & ONNX untuk deployment

6.9 Studi Kasus: Klasifikasi Gambar Kustom End-to-End

Kita satukan seluruh materi menjadi satu pipeline utuh: memuat dataset gambar kustom,
menerapkan transfer learning, melatih di GPU dengan checkpoint, dan menyiapkan model untuk
inferensi.

🎯 Tujuan Studi Kasus

Membangun klasifikasi gambar lengkap — dari folder gambar hingga model terlatih yang siap di-deploy
— menerapkan Dataset, DataLoader, transfer learning, training loop, checkpoint, dan GPU.

1 import torch, [Link] as nn, copy

2 from torchvision import datasets, transforms, models
3 from [Link] import DataLoader
4
5 device = "cuda" if [Link].is_available() else "cpu"
6
7 # 1) Data: folder terstruktur (data/train/<kelas>/*.jpg)
8 tf = [Link]([
9 [Link]((224, 224)),
10 [Link](),
11 [Link](),
12 [Link]([0.485, 0.456, 0.406],
13 [0.229, 0.224, 0.225]),
14 ])
15 train_ds = [Link]("data/train", transform=tf)
16 val_ds = [Link]("data/val", transform=tf)
17 train_dl = DataLoader(train_ds, batch_size=32, shuffle=True, num_workers=4)
18 val_dl = DataLoader(val_ds, batch_size=64, num_workers=4)
19 n_kelas = len(train_ds.classes)
20
21 # 2) Transfer learning: ResNet18
22 model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
23 for p in [Link]():
24 p.requires_grad = False
25 [Link] = [Link]([Link].in_features, n_kelas)
26 model = [Link](device)
27
28 criterion = [Link]()
29 optimizer = [Link]([Link](), lr=1e-3)
30
31 def evaluasi(loader):

Program AI Bootcamp UDINUS Hal. 12 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

32 [Link](); benar = total = 0

33 with torch.no_grad():
34 for x, y in loader:
35 x, y = [Link](device), [Link](device)
36 benar += (model(x).argmax(1) == y).sum().item()
37 total += [Link](0)
38 return 100 * benar / total
39
40 # 3) Latih dengan checkpoint terbaik
41 best_acc, best_state = 0, None
42 for epoch in range(1, 11):
43 [Link]()
44 for x, y in train_dl:
45 x, y = [Link](device), [Link](device)
46 optimizer.zero_grad()
47 loss = criterion(model(x), y)
48 [Link](); [Link]()
49 acc = evaluasi(val_dl)
50 print(f"Epoch {epoch} | val_acc {acc:.2f}%")
51 if acc > best_acc:
52 best_acc, best_state = acc, [Link](model.state_dict())
53
54 # 4) Simpan model terbaik untuk deployment
55 [Link](best_state, "klasifikasi_terbaik.pth")
56 print(f"Akurasi terbaik: {best_acc:.2f}% -> model tersimpan.")

Kode Pipeline klasifikasi gambar end-to-end dengan PyTorch

💡 Pengembangan lanjutan
Tambahkan mixed precision (AMP) untuk pelatihan lebih cepat, fine-tune blok akhir untuk akurasi lebih
tinggi, ekspor model ke ONNX, dan bungkus inferensi dengan Streamlit/FastAPI agar dapat diakses
sebagai layanan.

6.10 Latihan Mandiri

1. Buat dua tensor 3×3, lakukan perkalian matriks, transpose, dan hitung rata-rata tiap kolom.
Verifikasi hasilnya dengan NumPy.
2. Definisikan fungsi f(x) = x³ + 2x² − 5x, hitung turunannya di x=2 menggunakan autograd,
dan bandingkan dengan turunan analitik.
3. Bangun model kustom dengan minimal satu skip connection, tampilkan jumlah
parameternya, dan uji forward pass dengan tensor dummy.
4. Buat Dataset kustom yang membaca pasangan (fitur, label) dari array, tambahkan transform
normalisasi, dan muat dengan DataLoader batch 8.
5. Tulis training loop lengkap yang menyimpan checkpoint terbaik DAN mendukung resume
dari checkpoint. Uji dengan menghentikan lalu melanjutkan.
6. Terapkan transfer learning dengan ResNet18 pada dataset ImageFolder kecil, lalu ekspor
model terlatih ke format ONNX.

🧪 Proyek Mini (Nilai Tambah)

Bangun klasifikasi gambar end-to-end untuk dataset pilihan Anda (mis. jenis daun, produk, atau kondisi):
siapkan folder data, terapkan transfer learning + AMP, latih dengan checkpoint, laporkan akurasi &
confusion matrix, ekspor model, dan buat antarmuka Streamlit untuk prediksi gambar baru.

Program AI Bootcamp UDINUS Hal. 13 dari

Modul Praktikum Artificial Intelligence PyTorch Deep Dive

6.11 Rangkuman

📌 Rangkuman Modul 6
Tensor adalah unit data PyTorch (seperti NumPy, dapat di GPU); mendukung reshape, indexing, dan
broadcasting.
Autograd menghitung gradien otomatis via computational graph; selalu zero_grad() tiap iterasi.
Arsitektur kustom dibangun dengan [Link] (__init__ + forward), memberi fleksibilitas penuh.
Dataset & DataLoader memisahkan penyediaan sampel dari batching, shuffling, dan pemuatan paralel.
Training loop mengikuti 5 langkah; checkpoint menyimpan state_dict model & optimizer untuk
resume.
GPU (.to(device)), AMP, dan DDP mempercepat & menskalakan pelatihan.
Transfer learning memanfaatkan model terlatih; deployment memakai eval(), TorchScript/ONNX,
dan optimasi (quantization).

Program AI Bootcamp UDINUS Hal. 14 dari