Belajar Deep Learning - Experiment Tracking & Hyperparameter Tuning

#Pendahuluan

Di episode-episode sebelumnya kalian melatih model dan mencetak loss ke konsol. Di dunia nyata, satu masalah bisa memakan puluhan bahkan ratusan eksperimen: ubah learning rate, tambah layer, ganti augmentasi, dan bandingkan hasilnya. Tanpa pencatatan yang rapi, kalian tenggelam dalam notebook dan tidak tahu perubahan mana yang membuat akurasi naik.

Episode ini mengubah cara kerja kalian dari "coba-coba" menjadi ilmiah: setiap eksperimen tercatat lengkap (parameter, metrik, checkpoint), perbandingan antar eksperimen otomatis, dan pencarian hyperparameter tidak lagi manual. Keterampilan ini yang membedakan prototype notebook dari riset yang bisa dipertanggungjawabkan.

#Experiment Tracking

#TensorBoard: Cepat dan Lokal

TensorBoard datang bersama TensorFlow dan berfungsi juga untuk PyTorch lewat torch.utils.tensorboard. Paling ringan untuk mulai:

Log ke TensorBoard

from torch.utils.tensorboard import SummaryWriter
 
writer = SummaryWriter("runs/fashion-mnist-adamw")
writer.add_scalar("loss/train", loss.item(), step)
writer.add_scalar("acc/val", val_acc, step)
writer.add_histogram("fc1/weights", model.fc1.weight, step)
writer.close()

Lalu jalankan di terminal untuk melihat kurva loss, akurasi, dan distribusi bobot di browser:

tensorboard --logdir runs

Keunggulan: tanpa akun, data lokal, gratis. Kekurangan: tidak ada fitur perbandingan antar eksperimen yang kuat.

#Weights & Biases: Tracking + Kolaborasi

W&B adalah standar industri untuk tracking eksperimen. Satu baris wandb.init dan wandb.log sudah cukup, dan semua eksperimen bisa dibandingkan di dashboard cloud — lengkap dengan tabel hyperparameter, kurva, dan konfigurasi:

Log ke W&B

import wandb
 
wandb.init(project="learn-deep-learning", config={"lr": 1e-3, "epochs": 10})
model = build_model()
wandb.watch(model, log="all")  # pantau gradien & bobot otomatis
 
for epoch in range(config.epochs):
    train_loss, val_acc = train_epoch()
    wandb.log({"loss": train_loss, "acc": val_acc, "epoch": epoch})

W&B juga menyediakan sweeps (pencarian hyperparameter terdistribusi) yang kita bahas sebentar lagi.

#MLflow: Tracking di Lingkungan Enterprise

Jika organisasi tidak boleh mengirim data ke cloud pihak ketiga, MLflow adalah pilihan self-hosted: tracking server, registry model, dan packaging. Untuk deep learning, MLflow melengkapi, bukan menggantikan, TensorBoard/W&B — fokusnya pada siklus hidup model dari experiment sampai deployment.

#Hyperparameter Tuning

#Grid dan Random Search

Grid search mencoba semua kombinasi nilai — mahal. Random search memilih kombinasi acak dan biasanya lebih efisien karena tidak semua dimensi sama pentingnya. Untuk deep learning, keduanya boros karena satu training bisa berjam-jam.

#Optuna: Bayesian Optimization

Optuna memakai TPE (Tree-structured Parzen Estimator) untuk belajar dari hasil sebelumnya: ia memilih nilai yang kemungkinan besar lebih baik, bukan menebak acak. Ini memangkas jumlah eksperimen drastis:

Tuning dengan Optuna

import optuna
 
def objective(trial):
    lr = trial.suggest_float("lr", 1e-4, 1e-2, log=True)
    hidden = trial.suggest_int("hidden", 64, 512, step=64)
    dropout = trial.suggest_float("dropout", 0.0, 0.5)
 
    model = build_mlp(hidden=hidden, dropout=dropout)
    acc = train_and_eval(model, lr=lr)
    return acc   # Optuna memaksimalkan ini
 
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=30)
print(study.best_params)

Tiap trial adalah satu training lengkap. Optuna menjalankan semuanya, mencatat hasil, dan mengarahkan pencarian berikutnya. 30 trial Optuna sering mengalahkan ratusan trial grid search.

#Learning Rate Finder

Sebelum tuning menyeluruh, cari learning rate terbaik dulu. Ide LR finder: jalankan training singkat sambil menaikkan lr secara eksponensial, lalu lihat di mana loss turun paling tajam. torch-lr-finder dan fastai menyediakannya:

Learning rate finder

from torch_lr_finder import LRFinder
 
lr_finder = LRFinder(model, optimizer, loss_fn)
lr_finder.range_test(train_loader, end_lr=10, num_iter=200)
lr_finder.plot()   # pilih lr di lembah loss paling curam

Hasilnya satu nilai lr yang hampir optimal — lalu bisa dituning halus dengan Optuna di sekitar nilai itu.

#Membuat Eksperimen Reproducible

Reproducibility bukan sekadar mematikan randomness:

Seed lengkap

import random, numpy as np, torch
 
def set_seed(seed=42):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)

Catat seluruh konteks eksperimen: versi library, seed, kode model, data split, dan hyperparameter — bukan hanya metrik. wandb.config dan wandb.init menyimpan otomatis banyak hal ini. Eksperimen yang tidak bisa direproduksi adalah eksperimen yang tidak bernilai.

#Common Pitfalls

• Track tanpa config: mencatat metrik tanpa mencatat hyperparameter membuat perbandingan tidak bermakna.
• Terlalu banyak trial murah, baseline buruk: selalu punya baseline sederhana dulu.
• Tuning semua sekaligus: ubah satu variabel per eksperimen untuk memahami dampak masing-masing.
• Melupakan versi library: hasil yang sama belum tentu terulang di versi lain — simpan requirements.txt atau lockfile per eksperimen.

#Penutup

Pada episode 14 ini, kalian telah membuat proses training menjadi ilmiah.

Inti yang harus dibawa pulang:

• TensorBoard untuk offline ringan; W&B untuk kolaborasi tim; MLflow untuk enterprise.
• Random search mengalahkan grid; Optuna (bayesian) mengalahkan keduanya.
• LR finder memberi nilai awal learning rate yang hampir optimal.
• Reproducibility = seed + versi library + config tercatat + data split tetap.

Di episode 15 selanjutnya kita masuk ke NLP modern & LLM — tokenization BPE, embeddings, arsitektur BERT/LLaMA-class, dan fine-tune BERT kecil untuk klasifikasi teks dengan Hugging Face. Sampai jumpa di episode 15!