Fundamental Machine Learning yang Benar-Benar Kepakai: dari Teori ke Praktik Produksi

Machine learning sering terlihat seperti urusan model: pilih algoritma, tuning hyperparameter, lalu berharap skor naik. Kenyataannya, model hanya satu komponen kecil.

Kalau ingin sistem AI yang betul-betul berguna, fondasinya ada di empat hal:

  1. framing masalah bisnis yang tepat,
  2. data yang representatif,
  3. evaluasi yang jujur,
  4. eksekusi teknis yang rapi dan bisa diulang.

Artikel ini dirancang sebagai panduan fundamental yang tidak berhenti di teori. Kita akan bahas prinsip, lalu langsung sambungkan ke setup teknis yang realistis untuk proyek nyata.

1) Mulai dari problem framing, bukan dari model

Kesalahan paling umum dalam proyek AI adalah pertanyaan awal yang salah.

Contoh:

  • Pertanyaan salah: "Model apa paling bagus buat churn?"
  • Pertanyaan benar: "Keputusan apa yang ingin diambil tim retention, dan seberapa cepat keputusan itu harus tersedia?"

Machine learning seharusnya menjawab keputusan, bukan sekadar menghasilkan angka.

Sebelum menyentuh kode, pastikan empat komponen ini jelas:

  1. Decision target: keputusan apa yang akan dipicu model.
  2. Prediction target: variabel apa yang diprediksi.
  3. Action window: berapa lama waktu dari prediksi ke aksi.
  4. Cost of error: mana yang lebih mahal, false positive atau false negative.

Jika empat hal ini tidak tegas, model dengan akurasi tinggi pun bisa gagal memberi dampak.

2) Mental model inti machine learning

Secara praktis, machine learning adalah proses belajar fungsi:

f(X) -> y

X adalah fitur, y adalah target. Tujuan kita bukan mencari fungsi yang sempurna di data lama, tetapi fungsi yang cukup baik untuk data baru.

Karena itu, konsep paling penting justru:

  • generalization, bukan hafalan,
  • bias-variance tradeoff,
  • signal vs noise.

Intuisi singkat:

  • Underfitting: model terlalu sederhana, gagal menangkap pola.
  • Overfitting: model terlalu hafal data latih, gagal di data baru.
  • Good fit: model menangkap pola yang stabil dan tetap masuk akal saat diuji.

3) Data lebih penting daripada algoritma

Dalam banyak proyek, peningkatan terbesar datang dari data engineering, bukan dari ganti model.

Prinsip data yang wajib dijaga:

  1. Representatif: data latih harus mirip distribusi data saat inferensi.
  2. Bersih: label noise, missing value, dan duplikasi harus ditangani eksplisit.
  3. Bebas leakage: fitur tidak boleh membawa informasi masa depan.
  4. Terukur: kualitas data harus punya indikator, bukan asumsi.

Checklist leakage cepat:

  • Apakah fitur dibuat dari data setelah timestamp prediksi?
  • Apakah ada agregasi global yang diam-diam melihat masa depan?
  • Apakah train/test split dilakukan sebelum feature engineering temporal?

Satu titik leakage bisa membuat model tampak hebat di validasi, lalu runtuh saat dipakai.

4) Setup teknis minimal yang proper

Kalau ingin eksperimen yang bisa diulang dan mudah dikembangkan, gunakan struktur proyek seperti ini:

ml-foundation/
  data/
    raw/
    processed/
  notebooks/
  src/
    train.py
    evaluate.py
    inference.py
    features.py
    config.py
  models/
  reports/
  requirements.txt

Contoh setup Python:

python -m venv .venv
.venv\Scripts\activate
pip install --upgrade pip
pip install numpy pandas scikit-learn matplotlib seaborn joblib fastapi uvicorn
pip freeze > requirements.txt

Prinsip setup:

  • pakai virtual environment,
  • lock dependency,
  • simpan model artifact (.pkl/.joblib) dengan versi,
  • pisahkan script training dan inference.

Ini terlihat sepele, tapi inilah pembeda antara proyek belajar dan proyek yang siap tumbuh.

5) Alur baseline yang seharusnya jadi standar

Mari ambil contoh use case klasifikasi: prediksi pelanggan berisiko churn.

Urutan yang sehat:

  1. Bangun baseline sederhana (misalnya Logistic Regression).
  2. Gunakan split yang benar (train/valid/test).
  3. Evaluasi dengan metrik yang relevan bisnis.
  4. Baru coba model lebih kompleks jika baseline mentok.

Contoh pipeline singkat:

from sklearn.model_selection import train_test_split
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score

num_cols = ["tenure", "monthly_spend", "support_tickets"]
cat_cols = ["plan_type", "region"]

num_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
])

cat_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("ohe", OneHotEncoder(handle_unknown="ignore")),
])

preprocess = ColumnTransformer([
    ("num", num_pipe, num_cols),
    ("cat", cat_pipe, cat_cols),
])

model = Pipeline([
    ("prep", preprocess),
    ("clf", LogisticRegression(max_iter=1000, class_weight="balanced")),
])

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

model.fit(X_train, y_train)
proba = model.predict_proba(X_test)[:, 1]
pred = (proba >= 0.35).astype(int)

print("ROC-AUC:", roc_auc_score(y_test, proba))
print(classification_report(y_test, pred))

Catatan penting:

  • threshold 0.5 bukan aturan sakral,
  • threshold harus disetel berdasarkan biaya bisnis dari masing-masing jenis error.

6) Metrik: jangan berhenti di akurasi

Untuk klasifikasi tidak seimbang, akurasi sering menipu.

Misal churn rate hanya 8%, model yang selalu menjawab "tidak churn" bisa dapat akurasi 92%, tapi tidak punya nilai bisnis.

Gunakan metrik sesuai konteks:

  • Precision: relevan jika false positive mahal.
  • Recall: relevan jika false negative mahal.
  • F1-score: kompromi precision-recall.
  • ROC-AUC / PR-AUC: kemampuan ranking model.
  • Calibration: apakah probabilitas model bisa dipercaya.

Praktik yang lebih matang:

  • laporkan metrik per segmen (region, channel, tier user),
  • tampilkan confusion matrix,
  • bandingkan performa antar-window waktu.

7) Validasi yang jujur lebih penting dari skor tinggi

Eksperimen yang rapi minimal harus mencatat:

  • versi dataset,
  • versi fitur,
  • parameter model,
  • random seed,
  • hasil metrik utama.

Tanpa jejak eksperimen, Anda tidak akan tahu kenapa model hari ini lebih bagus dari kemarin.

Untuk data temporal, hindari random split buta. Gunakan split berbasis waktu agar simulasi mendekati realita deployment.

Train: Jan-Sep
Valid: Okt
Test : Nov-Des

Ini sederhana, tapi membuat evaluasi jauh lebih jujur.

8) Dari notebook ke service: langkah minimal menuju produksi

Model dianggap "siap pakai" saat bisa diakses sistem lain secara konsisten. Cara paling ringan: bungkus dengan FastAPI.

Contoh endpoint inferensi:

from fastapi import FastAPI
import joblib
import pandas as pd

app = FastAPI()
model = joblib.load("models/churn_model_v1.joblib")

@app.post("/predict")
def predict(payload: dict):
    df = pd.DataFrame([payload])
    score = float(model.predict_proba(df)[0, 1])
    label = int(score >= 0.35)
    return {"score": score, "label": label}

Run:

uvicorn src.inference:app --host 0.0.0.0 --port 8000

Hal minimal sebelum endpoint dipakai:

  • validasi schema input,
  • fallback jika nilai kategori baru muncul,
  • logging request dan output model,
  • versioning model di response.

9) Monitoring: model bagus hari ini belum tentu bagus bulan depan

Setelah deployment, tantangan utama adalah drift.

Jenis drift yang paling sering:

  • data drift: distribusi fitur berubah,
  • concept drift: hubungan fitur-target berubah,
  • upstream drift: ada perubahan dari sistem sumber data.

Indikator yang layak dipantau:

  1. distribusi fitur penting,
  2. rata-rata skor prediksi,
  3. delayed ground truth dan metrik mingguan,
  4. error rate endpoint,
  5. latency inferensi.

Prinsip praktis: buat alert lebih awal, retraining tidak perlu terlalu sering tetapi harus berbasis sinyal yang jelas.

10) Roadmap belajar 30 hari untuk pondasi yang kuat

Kalau Anda ingin naik level secara terstruktur:

Minggu 1

  • ulang konsep supervised learning, bias-variance, dan metrik,
  • kerjakan 1 dataset kecil end-to-end.

Minggu 2

  • bangun pipeline preprocessing yang rapi,
  • bandingkan minimal 2 baseline model.

Minggu 3

  • latih model dengan validasi temporal,
  • buat analisis error per segmen.

Minggu 4

  • deploy model jadi API,
  • tambah logging, monitoring sederhana, dan dokumentasi keputusan threshold.

Di akhir 30 hari, target utamanya bukan "jadi ahli semua algoritma", tetapi punya satu proyek yang bersih, terukur, dan bisa dijelaskan dari sisi teknik maupun bisnis.

Penutup

Fundamental machine learning yang paling penting bukan formula yang rumit, melainkan disiplin berpikir:

  • mulai dari keputusan bisnis,
  • validasi data dengan jujur,
  • ukur model dengan metrik yang tepat,
  • dan operasikan model sebagai sistem, bukan file notebook.

Kalau fondasi ini kuat, Anda bisa pindah dari sekadar "bisa training model" menjadi "bisa membangun solusi AI yang dipakai orang".