Belajar Machine Learning - Experiment Tracking & Reproducibility

#Pendahuluan

Setelah di episode 10 kita melakukan tuning dengan cross-validation dan Optuna, mungkin kalian berpikir pekerjaan sudah selesai. Kenyataannya justru di sinilah masalah dimulai: berapa banyak eksperimen yang sudah kalian jalankan? Mana yang terbaik? Bisa kalian ulangi hasilnya tiga bulan lagi?

Di dunia nyata, ML bukan sekali jalan — ia iterasi puluhan kali dengan parameter, fitur, dan data berbeda. Tanpa experiment tracking, kalian akan tersesat: file model_final_v2_akhir_BENAR.ipynb menumpuk, dan tidak ada yang tahu konfigurasi mana yang menghasilkan skor terbaik. Episode ini mengajarkan cara keluar dari kekacauan itu.

#Mengapa Tracking Itu Wajib

Bayangkan dua minggu lalu kalian mendapat ROC-AUC 0.91. Hari ini skornya turun jadi 0.88, padahal "kodenya sama". Apa yang berubah? Tanpa pencatatan, jawabannya hilang — bisa jadi library ter-update, random state berubah, atau data bergeser.

Track record yang baik mencatat tiga hal untuk setiap eksperimen:

Dengan catatan ini, perbandingan antar eksperimen jadi objektif, dan hasil yang bagus bisa diulang (atau "diproduksi") kapan saja.

#MLflow: Tracking Lokal yang Simpel

MLflow adalah tool tracking paling populer untuk memulai. Konsep intinya:

• Run: satu eksekusi training.
• Experiment: kumpulan run yang sejenis.
• Metrics & params: nilai yang dibandingkan.
• Artifacts: file model, plot, dataset.

Install dan mulai dengan mudah:

pip install mlflow
mlflow ui --port 5000

Lalu log eksperimen kalian langsung dari script:

import mlflow
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
 
mlflow.set_experiment("churn-v1")
 
with mlflow.start_run():
    params = {"n_estimators": 300, "max_depth": 8}
    model = RandomForestClassifier(**params, random_state=42)
 
    score = cross_val_score(model, X_train, y_train,
                            cv=5, scoring="roc_auc").mean()
 
    mlflow.log_params(params)
    mlflow.log_metric("cv_roc_auc", score)
 
    model.fit(X_train, y_train)
    mlflow.sklearn.log_model(model, "model")

Setelah beberapa run, buka http://localhost:5000 — kalian melihat tabel perbandingan semua run, bisa menyortir berdasarkan metric, dan mengunduh model terbaik. Tanpa tabel ini, perbandingan eksperimen hanya mengandalkan ingatan.

#Weights & Biases: Alternatif Kolaboratif

Weights & Biases (W&B) adalah alternatif cloud yang unggul di visualisasi dan kolaborasi tim. Kelebihannya dibanding MLflow lokal:

• UI interaktif untuk membandingkan run lintas tim.
• Integrasi mulus dengan Optuna dan framework modern.
• Logging dataset dan grafik tanpa setup server.

import wandb
 
wandb.init(project="churn", config={"n_estimators": 300})
 
model = RandomForestClassifier(
    n_estimators=wandb.config.n_estimators,
    random_state=42,
)

Perbedaan utamanya: MLflow self-hosted (data di infrastruktur kalian), W&B SaaS (data di cloud pihak ketiga). Pilihan bergantung pada kebutuhan privasi data dan anggaran.

#Reproducibility: Seed dan Hashing

Tracking hanya membantu jika eksperimen bisa diulang. Tiga sumber ketidak-reproducible-an paling umum:

#1. Seed Tidak Lengkap

Set seed di semua lapisan acak — bukan hanya di satu model:

import random
import numpy as np
import xgboost as xgb
 
def set_seed(seed=42):
    random.seed(seed)
    np.random.seed(seed)
 
set_seed(42)
model = xgb.XGBClassifier(random_state=42)

Jika ada satu lapisan acak yang tidak diset (misalnya SMOTE), hasil bisa berbeda di tiap run.

#2. Versi Library yang Berubah

Library yang di-update bisa mengubah hasil training. Catat versinya di setiap run:

import sklearn, xgboost, pandas
 
mlflow.log_params({
    "sklearn_version": sklearn.__version__,
    "xgboost_version": xgboost.__version__,
    "pandas_version": pandas.__version__,
})

#3. Hashing Data untuk Verifikasi

Jika data bisa berubah (seseorang menambah baris), beri hash dataset sebagai sidik jari. Dengan begini kalian tahu persis data apa yang dipakai run itu.

import hashlib
 
def data_hash(df):
    raw = df.to_csv(index=False).encode()
    return hashlib.sha256(raw).hexdigest()[:12]
 
mlflow.log_param("data_hash", data_hash(X_train))

Sidik jari yang sama → data sama. Berbeda → data berubah, dan membandingkan skor jadi tidak valid.

#Config-Based Experiment

Trick agar eksperimen rapi: pisahkan konfigurasi dari kode. Simpan parameter dalam file YAML, bukan diketik keras di script:

experiment:
  name: churn-v1
  data_hash_check: true
 
model:
  name: xgboost
  n_estimators: 300
  max_depth: 8
  learning_rate: 0.05
  random_state: 42
 
training:
  cv_folds: 5
  scoring: roc_auc

import yaml
 
with open("config/experiment.yaml") as f:
    config = yaml.safe_load(f)
 
model_cfg = config["model"]
model = xgb.XGBClassifier(**model_cfg)
 
mlflow.set_experiment(config["experiment"]["name"])
mlflow.log_params(model_cfg)

Kelebihannya: percobaan baru cukup dengan mengubah satu file YAML — dan setiap run otomatis mencatat konfigurasi yang dipakainya. Ini fondasi untuk otomasi pipeline di episode 17.

#Alur Kerja Tracking yang Disarankan

Membiasakan alur ini sejak sekarang akan terbayar besar saat proyek ML kalian berkembang dari notebook tunggal menjadi sistem produksi.

#Common Pitfalls

• Log metric tapi lupa params — tidak bisa membandingkan "kenapa beda".
• Tidak mencatat versi library dan data hash — hasil tak bisa diverifikasi.
• Satu experiment untuk semua hal — pisahkan per topik (baseline, tuning, feature-set).
• Autolog tanpa pengaturan experiment name — run berantakan di default experiment.
• Menyimpan model tanpa artifact — model terbaik tidak bisa di-deploy (episode 18).

#Penutup

Pada episode 11 ini, kalian telah membiasakan diri dengan eksperimen yang tercatat dan reproduksibel.

Inti yang harus dibawa pulang:

• Tracking mencatat konfigurasi, hasil, dan environment setiap eksperimen.
• MLflow ringan untuk memulai; W&B untuk kolaborasi cloud.
• Seed lengkap, versi library, dan data hash adalah kunci reproducibility.
• Config-based experiment (YAML) membuat eksperimen rapi dan otomatis ter-dokumentasi.

Di episode 12 selanjutnya kita akan membahas time series forecasting — trend, seasonality, dan stationarity, rolling features, backtesting, model ARIMA/SARIMA dan Prophet, plus pendekatan ML modern dengan lag features dan LightGBM untuk peramalan penjualan. Sampai jumpa di episode 12!