zenaisy

About zenaisy

http://zens.my.id

Posts by :

27 May 2026

Pipeline ML & Praktik Terbaik

zenaisy Tak Berkategori 0

ML Pipelines & Best Practices | Full-Stack AI Engineer

🤖

Full-Stack AI Engineer

BAB 10

Bab 10 · ML Pipelines & Best Practices

Membangun ML Pipeline yang Handal

Pelajari cara membangun pipeline ML yang terstruktur, mencegah data leakage, memastikan reproducibility, dan menghindari kesalahan umum dalam proyek Machine Learning.

Sub Topik

~45

Menit Belajar

Contoh Kode

Kuis Interaktif

🔧 Membangun ML Pipeline

🏗️

Apa Itu ML Pipeline?

Konsep dasar dan manfaatnya

ML Pipeline adalah serangkaian langkah yang terautomatisasi dan terstruktur untuk memproses data hingga menghasilkan model machine learning. Bayangkan pipeline seperti jalur produksi di pabrik — setiap bahan baku (data mentah) melewati serangkaian proses yang terurut sampai menjadi produk jadi (model terlatih).

Tanpa pipeline, proyek ML rentan terhadap kesalahan manual, sulit direproduksi, dan tidak bisa di-deploy dengan mudah. Dengan pipeline, seluruh proses bisa dijalankan ulang hanya dengan satu perintah.

💡 Prinsip Utama

Pipeline yang baik bersifat: modular (setiap langkah bisa diganti), reproducible (hasil konsisten), dan automatable (bisa dijalankan otomatis).

🔄

Anatomi ML Pipeline

Tahapan standar yang harus ada

Berikut adalah alur umum sebuah ML Pipeline lengkap:

📥
Data Ingestion

→

🧹
Preprocessing

→

⚙️
Feature Eng.

→

📊
Train/Test Split

→

🤖
Training

→

📈
Evaluation

→

🚀
Deployment

Setiap kotak di atas adalah sebuah step (tahap) dalam pipeline. Dengan Scikit-learn, setiap step direpresentasikan sebagai objek yang mengimplementasikan metode fit() dan transform().

🐍

Implementasi Pipeline dengan Scikit-learn

Menggunakan sklearn.pipeline.Pipeline

Scikit-learn menyediakan class Pipeline yang memungkinkan kita menggabungkan beberapa langkah preprocessing dan modeling menjadi satu objek tunggal.

Python

# Import library yang dibutuhkan
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import RandomForestClassifier
import pandas as pd

# Definisikan kolom numerik dan kategoris
numeric_features = ['umur', 'pendapatan', 'lama_bekerja']
categorical_features = ['kota', 'pendidikan']

# Pipeline untuk data numerik
numeric_pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),   # isi nilai kosong
    ('scaler', StandardScaler())                      # normalisasi
])

# Pipeline untuk data kategoris
categorical_pipeline = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')), # isi nilai kosong
    ('encoder', OneHotEncoder(handle_unknown='ignore'))    # encode
])

# Gabungkan dengan ColumnTransformer
preprocessor = ColumnTransformer(transformers=[
    ('num', numeric_pipeline, numeric_features),
    ('cat', categorical_pipeline, categorical_features)
])

# Pipeline LENGKAP: preprocessing + model
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# Latih sekaligus (fit) dan prediksi (transform)
full_pipeline.fit(X_train, y_train)
y_pred = full_pipeline.predict(X_test)
accuracy = full_pipeline.score(X_test, y_test)
print(f"Akurasi: {accuracy:.2f}")

✅ Keuntungan Pendekatan Ini

Ketika kita memanggil full_pipeline.fit(X_train, y_train), seluruh langkah preprocessing dan training dijalankan secara otomatis dan berurutan. Saat inferensi, predict() juga otomatis menerapkan preprocessing yang sama.

🔀

Custom Transformer

Membuat step pipeline sendiri

Kadang kita membutuhkan transformasi khusus yang tidak tersedia di Scikit-learn. Kita bisa membuat transformer custom dengan mewarisi BaseEstimator dan TransformerMixin.

Python

from sklearn.base import BaseEstimator, TransformerMixin
import numpy as np

class LogTransformer(BaseEstimator, TransformerMixin):
    """Custom transformer untuk log transformation."""
    
    def __init__(self, add_one=True):
        self.add_one = add_one  # tambah 1 agar log(0) tidak error
    
    def fit(self, X, y=None):
        return self  # tidak perlu belajar apapun
    
    def transform(self, X):
        if self.add_one:
            return np.log1p(X)  # log(1 + x)
        return np.log(X)

# Gunakan dalam pipeline
pipeline_log = Pipeline([
    ('log_transform', LogTransformer(add_one=True)),
    ('scaler', StandardScaler()),
    ('model', RandomForestClassifier())
])

💾

Menyimpan & Memuat Pipeline

Serialisasi untuk deployment

Menggunakan Joblib (Direkomendasikan)

Python

import joblib

# Simpan pipeline
joblib.dump(full_pipeline, 'model_pipeline.pkl')

# Muat kembali
loaded_pipeline = joblib.load('model_pipeline.pkl')

# Langsung prediksi data baru
prediksi = loaded_pipeline.predict(data_baru)

Menggunakan Pickle

Python

import pickle

# Simpan pipeline
with open('pipeline.pkl', 'wb') as f:
    pickle.dump(full_pipeline, f)

# Muat kembali
with open('pipeline.pkl', 'rb') as f:
    loaded = pickle.load(f)

⚠️ Perhatian

Gunakan joblib untuk array NumPy besar karena lebih efisien dari pickle.

🧠 Kuis: Manakah urutan yang BENAR dalam sebuah ML Pipeline?

A. Training → Preprocessing → Evaluation → Deployment

B. Data Ingestion → Preprocessing → Feature Engineering → Training → Evaluation → Deployment

C. Evaluation → Preprocessing → Training → Deployment

D. Deployment → Training → Preprocessing → Evaluation

🚫 Mencegah Data Leakage

⚠️

Apa Itu Data Leakage?

Ancaman terbesar akurasi palsu dalam ML

Data Leakage terjadi ketika informasi dari luar training set “bocor” masuk ke proses pelatihan model, sehingga model terlihat sangat akurat di tahap evaluasi — tetapi gagal total di produksi. Ini adalah salah satu jebakan paling berbahaya dan paling umum dalam ML.

Analogi sederhananya: bayangkan kamu ujian dan sudah tahu kunci jawaban sebelumnya. Nilaimu akan sempurna, tapi kamu belum tentu benar-benar paham materi tersebut.

🚨 Tanda Bahaya Data Leakage

Jika akurasi model pada test set terlalu tinggi (misal 99%+ pada dataset dunia nyata), kemungkinan besar ada data leakage. Model yang baik jarang mencapai angka sempurna.

🔍

Jenis-Jenis Data Leakage

Kenali bentuk-bentuknya agar bisa dihindari

Jenis	Deskripsi	Status
Target Leakage	Fitur yang hanya tersedia SETELAH target diketahui ikut digunakan sebagai input. Contoh: menggunakan “tanggal pelunasan pinjaman” untuk memprediksi apakah seseorang akan gagal bayar.	Berbahaya
Train-Test Contamination	Transformasi (seperti scaling atau imputation) di-fit menggunakan seluruh data (termasuk test set), bukan hanya training set.	Umum
Temporal Leakage	Untuk data time-series, menggunakan data masa depan untuk memprediksi masa lalu. Misalnya split acak pada data historis harga saham.	Berbahaya
Duplicate Leakage	Baris data yang sama muncul di training dan test set sekaligus karena ada duplikasi data yang tidak dibersihkan.	Tersembunyi

💉

Contoh Train-Test Contamination

Kesalahan paling sering yang dilakukan pemula

❌ SALAH — Ada Leakage!

Python

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# ❌ SALAH: scaler di-fit SEBELUM split!
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)  # pakai seluruh data!

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

# Model "melihat" statistik test set saat fitting scaler
# → Hasil evaluasi TIDAK VALID

✅ BENAR — Tidak Ada Leakage

Python

# ✅ BENAR: split DULU, baru fit scaler
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

scaler = StandardScaler()
# fit HANYA pada training data
X_train_scaled = scaler.fit_transform(X_train)
# transform test menggunakan statistik training
X_test_scaled = scaler.transform(X_test)

# Scaler hanya "belajar" dari training data ✓

💡 Solusi Terbaik: Gunakan Pipeline!

Dengan sklearn.pipeline.Pipeline, Scikit-learn otomatis memastikan bahwa setiap transformer hanya di-fit pada training data saja saat menggunakan cross_validate() atau GridSearchCV().

📅

Mencegah Temporal Leakage

Untuk data time-series dan urutan waktu

Data time-series memiliki urutan temporal yang harus dihormati. Jangan pernah menggunakan split acak untuk data ini!

Python

from sklearn.model_selection import TimeSeriesSplit
import pandas as pd

# Data harga saham (harus terurut berdasarkan waktu)
df = df.sort_values('tanggal')  # pastikan terurut!

# ❌ JANGAN pakai ini untuk time-series:
# X_train, X_test = train_test_split(X, test_size=0.2)  # shuffle = leakage!

# ✅ Gunakan TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)

for fold, (train_idx, test_idx) in enumerate(tscv.split(X)):
    X_train, X_test = X[train_idx], X[test_idx]
    y_train, y_test = y[train_idx], y[test_idx]
    
    # Train hanya pakai data HISTORIS
    # Test selalu ada SETELAH training period
    print(f"Fold {fold+1}: Train[{train_idx[0]}:{train_idx[-1]}] → Test[{test_idx[0]}:{test_idx[-1]}]")

🛡️

Checklist Pencegahan Data Leakage

Selalu periksa sebelum melaporkan hasil

Split data SEBELUM melakukan apapun pada data
Semua transformasi (scaler, imputer, encoder) di-fit hanya pada training set
Tidak ada fitur yang “tahu” nilai target di masa depan
Untuk time-series: gunakan TimeSeriesSplit atau split kronologis
Hapus duplikat sebelum melakukan split
Gunakan Pipeline Scikit-learn untuk cross-validation
Verifikasi: jika akurasi terlalu tinggi, investigasi kemungkinan leakage

🧠 Kuis: Manakah yang MENYEBABKAN data leakage?

A. Fit scaler hanya pada X_train, lalu transform X_test

B. Menggunakan sklearn Pipeline untuk cross-validation

C. Fit StandardScaler pada seluruh X sebelum train-test split

D. Menggunakan TimeSeriesSplit untuk data berurutan waktu

🔁 Reproducibility dalam ML

🎯

Mengapa Reproducibility Itu Penting?

Fondasi ilmu pengetahuan dan rekayasa ML yang baik

Reproducibility berarti kemampuan untuk menjalankan ulang eksperimen ML dan mendapatkan hasil yang identik. Ini krusial karena tanpa reproducibility, kamu tidak tahu apakah peningkatan performa model disebabkan oleh perubahan kode/data, atau hanya keberuntungan acak.

Bayangkan membangun sebuah model yang akurasinya 92%, tapi ketika dijalankan ulang keesokan harinya oleh rekan kerja, hasilnya 85%. Tidak ada yang bisa dipercaya dari model seperti itu.

🔬 Untuk Riset

Hasil penelitian harus bisa diverifikasi dan direplikasi oleh peneliti lain.

🏭 Untuk Produksi

Tim yang berbeda harus bisa rebuild model dengan hasil yang sama.

🐛 Untuk Debugging

Kesalahan harus bisa direproduksi untuk bisa diperbaiki.

🎲

Mengontrol Randomness dengan Random Seed

Sumber utama ketidakpastian dalam ML

Machine Learning menggunakan banyak operasi acak: inisialisasi bobot neural network, shuffling data, random split, dll. Dengan menetapkan random seed, kita memaksa “keacakan” ini menjadi konsisten.

Python

import numpy as np
import random
import os

def set_all_seeds(seed=42):
    """Set semua random seed untuk reproducibility penuh."""
    
    # Python built-in random
    random.seed(seed)
    
    # NumPy
    np.random.seed(seed)
    
    # Hash seed untuk Python (mencegah non-determinisme pada dict)
    os.environ['PYTHONHASHSEED'] = str(seed)
    
    # TensorFlow / Keras (jika digunakan)
    try:
        import tensorflow as tf
        tf.random.set_seed(seed)
    except ImportError:
        pass
    
    # PyTorch (jika digunakan)
    try:
        import torch
        torch.manual_seed(seed)
        torch.cuda.manual_seed_all(seed)
        torch.backends.cudnn.deterministic = True
    except ImportError:
        pass
    
    print(f"✅ Semua random seed di-set ke: {seed}")

# Panggil di awal setiap notebook/script
set_all_seeds(42)

# Selalu gunakan random_state di Scikit-learn
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42  # ← WAJIB!
)

📦

Manajemen Dependensi & Environment

Versi library yang berbeda = hasil yang berbeda

Versi berbeda dari library (NumPy, Scikit-learn, XGBoost) bisa menghasilkan angka yang berbeda meskipun kodenya sama. Selalu dokumentasikan environment kamu!

requirements.txt (Minimal)

Shell

# Buat requirements.txt
pip freeze > requirements.txt

# Install di environment baru
pip install -r requirements.txt

requirements.txt

numpy==1.26.4
pandas==2.2.1
scikit-learn==1.4.2
xgboost==2.0.3
matplotlib==3.8.3
joblib==1.3.2

Conda Environment (Lebih Kuat)

Shell

# Export environment lengkap
conda env export > environment.yml

# Buat environment dari file
conda env create -f environment.yml

environment.yml

name: ml-project
channels:
  - defaults
  - conda-forge
dependencies:
  - python=3.11.5
  - numpy=1.26.4
  - pandas=2.2.1
  - scikit-learn=1.4.2
  - pip:
    - xgboost==2.0.3

📋

Eksperimen Tracking dengan MLflow

Catat semua eksperimen secara sistematis

MLflow adalah tools open-source untuk mencatat parameter, metrik, dan artefak dari setiap eksperimen ML. Dengan MLflow, kamu bisa membandingkan ratusan eksperimen dan selalu tahu konfigurasi mana yang menghasilkan model terbaik.

Python

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score

# Mulai eksperimen
mlflow.set_experiment("klasifikasi-churn-pelanggan")

with mlflow.start_run(run_name="random-forest-v1"):
    # Parameter yang digunakan
    params = {
        "n_estimators": 100,
        "max_depth": 5,
        "random_state": 42
    }
    mlflow.log_params(params)
    
    # Latih model
    model = RandomForestClassifier(**params)
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    
    # Catat metrik
    mlflow.log_metric("accuracy", accuracy_score(y_test, y_pred))
    mlflow.log_metric("f1_score", f1_score(y_test, y_pred))
    
    # Simpan model sebagai artefak
    mlflow.sklearn.log_model(model, "model")
    
    print("Eksperimen berhasil dicatat di MLflow!")

# Jalankan UI: mlflow ui → buka http://localhost:5000

✅ Alternatif Tools Lainnya

Selain MLflow, kamu bisa menggunakan: Weights & Biases (W&B) untuk tim besar, Neptune.ai untuk kolaborasi, atau DVC (Data Version Control) untuk versioning data dan model.

📁

Struktur Proyek ML yang Reproducible

Folder structure standar industri

Struktur Folder

ml-project/
├── data/
│   ├── raw/              # Data mentah — JANGAN diubah!
│   ├── processed/        # Data setelah preprocessing
│   └── external/         # Data dari sumber eksternal
├── notebooks/
│   ├── 01_eda.ipynb      # Eksplorasi data
│   ├── 02_features.ipynb # Feature engineering
│   └── 03_modeling.ipynb # Training & evaluasi
├── src/
│   ├── data/             # Script preprocessing
│   ├── features/         # Script feature engineering
│   ├── models/           # Script training
│   └── utils/            # Helper functions
├── models/               # Model tersimpan (.pkl, .joblib)
├── reports/              # Grafik & laporan
├── requirements.txt      # Dependensi Python
├── config.yaml           # Konfigurasi hyperparameter
└── README.md             # Dokumentasi proyek

🧠 Kuis: Apa yang PALING EFEKTIF untuk memastikan reproducibility eksperimen ML?

A. Mencatat nilai akurasi akhir model di notebook

B. Kombinasi: set random seed, pin versi library, dan gunakan experiment tracking (MLflow)

C. Menyimpan model dengan joblib.dump()

D. Menggunakan Jupyter Notebook untuk semua eksperimen

⚠️ Kesalahan Umum dalam ML yang Harus Dihindari

🎯

Mengapa Kesalahan Ini Penting Diketahui?

Belajar dari pengalaman praktisi ML senior

Bahkan data scientist berpengalaman pun masih bisa terjebak pada kesalahan-kesalahan klasik ini. Mengenali dan menghindari kesalahan ini sejak dini akan menghemat berjam-jam debugging dan mencegah model buruk masuk ke produksi.

❌

Kesalahan #1: Langsung ke Modeling Tanpa EDA

Terburu-buru adalah musuh ML

Banyak pemula langsung menjalankan algoritma ML tanpa memahami data terlebih dahulu. Hasilnya: model yang dibangun di atas fondasi yang salah.

❌ Yang Salah

Langsung fit model ke data mentah
Tidak cek distribusi fitur
Tidak cek class imbalance
Tidak cek outlier ekstrem

✅ Yang Benar

Lakukan EDA menyeluruh terlebih dahulu
Visualisasikan distribusi semua fitur
Cek & tangani class imbalance
Identifikasi dan tangani outlier

❌

Kesalahan #2: Menggunakan Akurasi Saja pada Data Imbalanced

Metrik yang salah = keputusan yang salah

Jika dataset kamu memiliki 95% kelas negatif dan 5% kelas positif, model yang selalu memprediksi negatif akan mendapat akurasi 95% — padahal model tersebut sama sekali tidak berguna!

Python

from sklearn.metrics import classification_report, confusion_matrix
from sklearn.metrics import roc_auc_score, average_precision_score

# ❌ JANGAN hanya gunakan akurasi untuk imbalanced data
accuracy = (y_pred == y_test).mean()  # bisa menipu!

# ✅ Gunakan metrik yang tepat
print(classification_report(y_test, y_pred))
# Output: precision, recall, f1-score per kelas

# ROC-AUC: bagus untuk imbalanced
roc_auc = roc_auc_score(y_test, y_prob)

# PR-AUC: lebih baik dari ROC-AUC untuk sangat imbalanced
pr_auc = average_precision_score(y_test, y_prob)

# Tangani imbalance dengan class_weight
from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(class_weight='balanced', random_state=42)

# Atau gunakan SMOTE untuk oversampling
from imblearn.over_sampling import SMOTE
X_resampled, y_resampled = SMOTE(random_state=42).fit_resample(X_train, y_train)

❌

Kesalahan #3: Tidak Menggunakan Cross-Validation

Single split bisa sangat misleading

Mengevaluasi model dengan satu kali train-test split sangat rentan terhadap keberuntungan. Mungkin saja data yang masuk ke test set kebetulan “mudah” atau “sulit” diprediksi.

Python

from sklearn.model_selection import cross_val_score, StratifiedKFold
import numpy as np

# ❌ Jangan hanya evaluasi sekali
model.fit(X_train, y_train)
score = model.score(X_test, y_test)  # hasil mungkin tidak representatif

# ✅ Gunakan Stratified K-Fold Cross Validation
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

scores = cross_val_score(
    pipeline,      # gunakan pipeline, bukan model saja!
    X, y,
    cv=cv,
    scoring='f1',
    n_jobs=-1      # paralel processing
)

print(f"F1 Scores per fold: {scores.round(3)}")
print(f"Mean F1: {scores.mean():.3f} ± {scores.std():.3f}")
# Output: F1 Scores per fold: [0.84 0.86 0.83 0.87 0.85]
# Output: Mean F1: 0.850 ± 0.014

❌

Kesalahan #4: Overfitting & Tidak Memeriksa Generalisasi

Model hafal data, bukan belajar pola

Model yang terlalu kompleks akan “hafal” training data tetapi gagal pada data baru. Selalu bandingkan performa training vs validation/test.

Python

# Deteksi overfitting: bandingkan train vs test score
train_score = model.score(X_train, y_train)
test_score  = model.score(X_test, y_test)
gap = train_score - test_score

print(f"Train Accuracy: {train_score:.3f}")
print(f"Test  Accuracy: {test_score:.3f}")
print(f"Gap           : {gap:.3f}")

# Diagnosa:
if gap > 0.1:
    print("⚠️  Kemungkinan OVERFITTING — kurangi kompleksitas model")
elif test_score < 0.7:
    print("⚠️  Kemungkinan UNDERFITTING — tingkatkan kompleksitas model")
else:
    print("✅ Model generalisasi dengan baik!")

# Solusi overfitting:
# - Regularization (L1/L2)
# - Kurangi max_depth pada tree
# - Tambah data training
# - Feature selection
# - Dropout (untuk neural network)

❌

Kesalahan #5: Lupa Baseline Model

Selalu bandingkan dengan model sederhana

Banyak orang langsung membangun model kompleks tanpa baseline. Bagaimana kamu tahu model Random Forest-mu bagus jika tidak dibandingkan dengan model sederhana?

Python

from sklearn.dummy import DummyClassifier

# ✅ SELALU buat baseline dulu!
# Baseline 1: Prediksi selalu kelas mayoritas
dummy_majority = DummyClassifier(strategy='most_frequent')
dummy_majority.fit(X_train, y_train)
baseline_score = dummy_majority.score(X_test, y_test)
print(f"Baseline (majority): {baseline_score:.3f}")

# Baseline 2: Model paling sederhana (Logistic Regression)
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(random_state=42)
lr.fit(X_train, y_train)
lr_score = lr.score(X_test, y_test)
print(f"Logistic Regression: {lr_score:.3f}")

# Model kompleks kamu
rf_score = rf_model.score(X_test, y_test)
print(f"Random Forest      : {rf_score:.3f}")

# Jika RF tidak jauh lebih baik dari LR → mungkin tidak perlu kompleksitas ekstra

📋

Ringkasan: 10 Kesalahan ML yang Harus Dihindari

Simpan sebagai referensi cepat

#	Kesalahan	Dampak	Solusi
1	Langsung modeling tanpa EDA	Tinggi	Selalu eksplorasi data dulu
2	Hanya pakai akurasi untuk imbalanced	Tinggi	Gunakan F1, ROC-AUC, PR-AUC
3	Tidak pakai cross-validation	Sedang	StratifiedKFold dengan Pipeline
4	Tidak cek overfitting	Tinggi	Bandingkan train vs test score
5	Tidak membuat baseline model	Sedang	Mulai dari DummyClassifier/LR
6	Data leakage saat preprocessing	Kritis	Gunakan Pipeline + split dulu
7	Tidak set random seed	Sedang	Set semua seed di awal script
8	Tidak dokumentasikan eksperimen	Sedang	Gunakan MLflow/W&B
9	Tidak versioning data & model	Sedang	Gunakan DVC + Git
10	Langsung deploy tanpa monitoring	Tinggi	Selalu monitor data drift

🧠 Kuis Final: Sebuah model klasifikasi kamu memiliki akurasi 97% pada dataset dengan rasio kelas 97:3. Apa yang paling mungkin terjadi?

A. Model kamu luar biasa dan siap deploy!

B. Model kemungkinan memprediksi semua sebagai kelas mayoritas (dummy classifier)

C. Ada data leakage yang perlu diselidiki

D. Model mengalami overfitting parah

🎓

Ringkasan Bab: ML Pipelines & Best Practices

Poin-poin kunci yang harus kamu ingat

✅ Yang Harus Selalu Dilakukan

Gunakan sklearn Pipeline untuk semua proyek ML
Split data SEBELUM preprocessing apapun
Set random seed di awal setiap script
Dokumentasikan versi library di requirements.txt
Gunakan cross-validation untuk evaluasi yang valid
Selalu buat baseline model sebagai pembanding
Track eksperimen dengan MLflow atau tools sejenis

🚫 Yang Harus Selalu Dihindari

Jangan fit transformer pada data test
Jangan gunakan split acak untuk time-series
Jangan hanya rely pada akurasi untuk imbalanced data
Jangan langsung ke model kompleks tanpa EDA
Jangan deploy tanpa memonitor performa di produksi
Jangan abaikan data leakage meski akurasi bagus

7 May 2026

Rekayasa Fitur & Optimasi Model

zenaisy Tak Berkategori 0

Feature Engineering & Model Optimization – Full-Stack AI Engineer

Bab 10 · Sub-bab 1

Feature Scaling & Normalization

Penskalaan fitur adalah langkah penting sebelum melatih banyak model. Beberapa algoritma (KNN, SVM, K-Means, neural networks) sangat sensitif terhadap skala fitur — tanpa scaling, fitur dengan range besar akan mendominasi.

Standardization Min-Max Scaling Robust Scaling When to Use

Perbedaan Utama: StandardScaler vs MinMaxScaler vs RobustScaler

StandardScaler (Z-score)

Mentransformasikan fitur sehingga memiliki mean = 0 dan std = 1. Cocok bila fitur mengikuti distribusi mendekati Gaussian. Formula: z = (x − μ) / σ.

MinMaxScaler

Memetakan nilai ke rentang [0, 1] (atau rentang custom). Baik untuk algoritma yang mengasumsikan rentang tertentu (misal jaringan syaraf dengan activation tertentu).

RobustScaler

Skala berdasarkan median dan IQR (interquartile range). Lebih tahan terhadap outlier dibanding Standard/MinMax.

Power Transform & Log

Transformasi non-linear (Box-Cox, Yeo-Johnson) berguna untuk membuat distribusi lebih Gaussian; log sering dipakai untuk mengurangi skewness fitur moneter.

Ilustrasi Interaktif — Dampak Scaling

Contoh: Fitur area (0–5000) vs fitur score (0–1)

Panel tengah (Min-Max) menampilkan hasil penskalaan yang ideal untuk K-Means; panel kanan (Z-score) memperlihatkan normalisasi standar; panel kiri menampilkan raw data tanpa scaling.

Praktik Terbaik

1
Selalu fit scaler pada training set saja. Lalu gunakan transform pada test/validation. Jangan pernah fit scaler pada seluruh data (data leakage).
2
Pilih scaler sesuai model: KNN/SVM/K-Means → StandardScaler/MinMax; Tree-based → tidak perlu scaling biasanya; Outlier-heavy → RobustScaler.
3
Simpan scaler (joblib.dump) bersama model agar pipeline produksi mereplikasi preprocessing yang sama.

Kode: Penerapan Scaling di Pipeline

scaling_pipeline.py

from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
from sklearn.pipeline import Pipeline

# Contoh: Pipeline sederhana untuk model-sensitive-to-scale
pipeline = Pipeline([
  ('scaler', StandardScaler()),
  ('model', LogisticRegression(random_state=42))
])

# Fit hanya pada training set:
# pipeline.fit(X_train, y_train)
# predictions = pipeline.predict(X_test)

💡

Catatan Penggunaan: Tree-based models seperti Random Forest atau Decision Tree tidak membutuhkan scaling — tetapi jika kamu menyertakan model yang butuh scaling dalam Stacking, lebih aman untuk menskalakan fitur sebagai bagian dari pipeline.

🧠 Uji Pemahaman

Pilihan mana yang paling tepat untuk data yang mengandung banyak outlier?

A. StandardScaler

C. Tidak perlu scaling

D. OneHotEncoder

Bab 10 · Sub-bab 2

Encoding Categorical Variables

Variabel kategorikal (seperti gender, negara, atau tipe produk) perlu diubah menjadi bentuk numerik agar model ML bisa memprosesnya. Ada banyak teknik encoding — pilihan tergantung pada jumlah kategori (cardinality), urutan (ordinalitas), dan model yang digunakan.

One-Hot Ordinal Target Encoding High-Cardinality

1) One-Hot Encoding

Membuat kolom biner untuk setiap kategori. Sangat intuitif dan bekerja baik untuk kategori yang sedikit (< 10–20). Namun dapat menyebabkan "dimensionality explosion" jika kategori sangat banyak.

onehot_example.py

from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline

cat_cols = ['gender', 'contract_type']
preprocessor = ColumnTransformer([
  ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False), cat_cols)
], remainder='passthrough')

pipeline = Pipeline([
  ('pre', preprocessor),
  ('clf', RandomForestClassifier(random_state=42))
])

Kapan Pakai

•
Gunakan jika cardinality rendah (misal < 20) dan model tidak sensitif terhadap banyak fitur baru.
•
Gunakan handle_unknown=’ignore’ agar data baru pada saat inference tidak menyebabkan error.

2) Ordinal Encoding

Mengubah kategori menjadi bilangan bulat berdasarkan urutan yang logis (misal: low < medium < high). Hati-hati: angka ini memperkenalkan bias ordinal ke model; hanya pakai jika ada makna urutan.

ordinal_example.py

from sklearn.preprocessing import OrdinalEncoder

ord_map = [['low', 'medium', 'high']]
enc = OrdinalEncoder(categories=ord_map)
X['size_ord'] = enc.fit_transform(X[['size']])

3) Target / Mean Encoding (with CV)

Mengganti kategori dengan rata-rata target pada kategori tersebut (misal probabilitas rata-rata label=1). Berisiko data leakage jika langsung menggunakan seluruh train set — gunakan teknik K-Fold target encoding untuk menghindari kebocoran.

target_encoding_cv.py (sketch)

import numpy as np
import pandas as pd
from sklearn.model_selection import KFold

def target_encode_cv(train_series, target, n_splits=5):
    kf = KFold(n_splits=n_splits, shuffle=True, random_state=42)
    oof = pd.Series(np.nan, index=train_series.index)
    for tr_idx, val_idx in kf.split(train_series):
        tr_s = train_series.iloc[tr_idx]
        tr_t = target.iloc[tr_idx]
        means = tr_t.groupby(tr_s).mean()
        oof.iloc[val_idx] = train_series.iloc[val_idx].map(means)
    # Fill unseen categories with global mean
    oof.fillna(target.mean(), inplace=True)
    return oof

# usage: X['cat_te'] = target_encode_cv(X['category'], y_train)

Kapan Pakai

1
Cardinality tinggi (puluhan ribu kategori): target encoding mengurangi dimensi secara efektif.
2
Penting: Gunakan K-Fold atau smoothing untuk menghindari overfitting / leakage.

4) Binary / Hashing Encoding

Metode binary mengubah kategori menjadi representasi biner (bit) — lebih compact dari one-hot. Hashing trick memetakan kategori ke sejumlah kolom fixed tanpa menyimpan dictionary kategori, berguna untuk data streaming atau cardinality sangat besar.

hashing_example.py

from sklearn.feature_extraction.text import HashingVectorizer

hv = HashingVectorizer(n_features=32, alternate_sign=False)
X_h = hv.transform(X['category_text'].astype('str'))

5) Count / Frequency Encoding

Gantikan kategori dengan frekuensi atau count kemunculannya. Sederhana dan seringkali kuat—misal fitur “rare” bisa jadi sinyal penting.

# Count encoding
counts = X['category'].value_counts()
X['category_cnt'] = X['category'].map(counts)

6) Practical Tips & Pitfalls

✅ Simpan mapping encoder

Simpan dictionary mapping (mis. category→mean) atau encoder object (joblib) bersama model untuk inference konsisten.

⚠️ Tangani kategori baru (unseen)

One-Hot: gunakan handle_unknown=’ignore’. Target encoding: isi dengan global mean atau smoothing.

Pipeline Best Practice

Selalu jadikan encoding bagian dari Pipeline atau ColumnTransformer. Dengan demikian cross-validation dan production inference akan mereplikasi preprocessing yang sama tanpa data leakage.

🧠 Uji Pemahaman

Jika sebuah fitur kategorikal memiliki 10.000 kategori unik, strategi encoding manakah yang lebih tepat?

A. One-Hot Encoding

B. Target Encoding / Hashing / Binary

C. Ordinal Encoding

D. Drop feature

Bab 10 · Sub-bab 3

Feature Selection Techniques

Memilih fitur yang tepat membantu model lebih cepat, lebih sederhana, dan seringkali lebih akurat. Ada tiga keluarga teknik: Filter, Wrapper, dan Embedded.

Filter Wrapper Embedded

Filter Methods — Cepat & Model-Agnostic

Filter mengevaluasi fitur berdasarkan statistik independen dari model, seperti korelasi, chi-squared, ANOVA, atau mutual information. Cocok untuk pra-seleksi awal.

filter_selection.py

from sklearn.feature_selection import SelectKBest, f_classif, mutual_info_classif

# ANOVA F-test untuk fitur numerik
selector = SelectKBest(score_func=f_classif, k=10)
X_new = selector.fit_transform(X_train, y_train)

# Mutual information untuk fitur baik numerik maupun kategorikal
selector2 = SelectKBest(score_func=mutual_info_classif, k=15)
X_new2 = selector2.fit_transform(X_train, y_train)

Wrapper Methods — Lebih Akurat tapi Mahal

Wrapper menggunakan model sebagai “black box” untuk mengevaluasi subset fitur (mis: RFE, forward selection). Metode ini cenderung memberikan subset fitur yang lebih baik namun memerlukan banyak training model.

wrapper_rfe.py

from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

est = LogisticRegression(max_iter=1000)
rfe = RFE(estimator=est, n_features_to_select=10)
rfe.fit(X_train, y_train)
selected_features = X_train.columns[rfe.get_support()]
print(selected_features)

Embedded Methods — Seleksi Saat Training

Embedded methods menggabungkan pemilihan fitur dalam proses training model. Contoh populer: Lasso (L1) regularization, decision tree feature importance, dan feature importance dari ensembles (Random Forest, XGBoost).

embedded_lasso.py

from sklearn.linear_model import LogisticRegression

# L1 regularization untuk pemilihan fitur (koef menjadi 0)
clf = LogisticRegression(penalty='l1', solver='saga', max_iter=2000)
clf.fit(X_train, y_train)
coef = pd.Series(clf.coef_[0], index=X_train.columns)
selected = coef[coef.abs() > 1e-4].index

Praktik: Gabungkan Teknik

Strategi yang umum: gunakan metode filter cepat untuk memangkas fitur (misal dari 1000 → 200), lalu pakai RFE atau embedded (Lasso / Tree importance) untuk memilih subset akhir.

Evaluasi Fitur Secara Praktis

Permutation Importance

Nilai seberapa besar performa model turun ketika fitur diacak. Lebih andal daripada MDI karena dihitung pada test set.

Stability Selection

Jalankan seleksi berulang pada bootstrap sample; pilih fitur yang sering muncul. Mengurangi variabilitas pilihan fitur.

permutation_importance.py

from sklearn.inspection import permutation_importance

results = permutation_importance(rf, X_test, y_test, n_repeats=30, random_state=42)
perm_sorted_idx = results.importances_mean.argsort()[-10:]
for i in perm_sorted_idx:
    print(X_test.columns[i], results.importances_mean[i].round(4))

🧠 Uji Pemahaman

Mana pernyataan yang benar tentang Embedded methods?

A. Tidak memerlukan training model

C. Melakukan pemilihan fitur selama training model (contoh: Lasso)

D. Hanya berlaku untuk tree-based models

Bab 10 · Sub-bab 4

Cross-Validation Explained

Cross-validation (CV) adalah teknik untuk menilai generalisasi model dan mengurangi risiko overfitting pada hyperparameter tuning. CV membagi data menjadi beberapa fold, melatih model pada sebagian dan menguji pada sisanya secara bergantian.

K-Fold Stratified TimeSeriesSplit Nested CV

Jenis Cross-Validation yang Biasa Dipakai

K-Fold CV

Data dibagi menjadi K bagian (fold). Setiap fold bergantian menjadi validation set, sisanya menjadi training. Hasilnya adalah rata-rata skor across folds.

Stratified K-Fold

Versi K-Fold yang menjaga proporsi kelas di setiap fold — penting untuk dataset imbalanced pada klasifikasi.

TimeSeriesSplit

Untuk data berurutan (time series). Tidak boleh mengacak data temporal — train pada masa lalu, validasi pada masa depan.

Nested Cross-Validation

Metode terbaik untuk memilih model dan mengukur generalisasi sekaligus: ada CV luar untuk evaluasi dan CV dalam untuk tuning hyperparameter (Grid/Random).

Visualisasi CV (Ilustrasi K-Fold)

Diagram menunjukkan bagaimana setiap fold bergantian menjadi validation set, dan mean CV score dihitung.

Kode: Contoh Stratified K-Fold CV

cv_example.py

from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.ensemble import RandomForestClassifier

clf = RandomForestClassifier(random_state=42)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(clf, X, y, cv=skf, scoring='f1')
print(f"F1 CV: {scores.mean():.4f} ± {scores.std():.4f}")

Nested CV untuk Model Selection

Gunakan nested CV saat melakukan hyperparameter tuning untuk menghindari bias optimistik pada evaluasi. CV luar memberikan estimasi performa final, CV dalam melakukan pencarian hyperparameter.

nested_cv.py

from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier

param_grid = {'n_estimators':[50,100],'max_depth':[5,10]}
clf = RandomForestClassifier(random_state=42)
inner_cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)
outer_cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)

grid = GridSearchCV(clf, param_grid, cv=inner_cv, scoring='f1')
nested_scores = cross_val_score(grid, X, y, cv=outer_cv, scoring='f1')
print(f"Nested CV F1: {nested_scores.mean():.4f} ± {nested_scores.std():.4f}")

⚠️

Perhatian: Jangan menggunakan CV jika data memiliki dependence waktu tanpa memakai TimeSeriesSplit — mengacak data bisa menyebabkan kebocoran informasi masa depan ke masa lalu.

🧠 Uji Pemahaman

Mengapa nested CV diperlukan saat melakukan hyperparameter tuning?

A. Karena lebih cepat

B. Untuk menghindari bias optimistik pada estimasi performa ketika hyperparameter dipilih

C. Untuk menambah data training

D. Karena GridSearch butuh nested CV

Bab 10 · Sub-bab 5

Hyperparameter Tuning (Grid & Random Search)

Hyperparameter tuning adalah proses mencari konfigurasi parameter terbaik untuk model. Dua teknik klasik: Grid Search (eksplorasi lengkap pada grid) dan Random Search (sampling acak dari distribusi). Untuk performa lebih baik dan resource efisien, ada juga Bayesian optimization (Optuna, Hyperopt).

GridSearch RandomizedSearch Optuna Early Stopping

Grid Search vs Random Search

Grid Search

Mencoba semua kombinasi dalam grid parameter. Bisa memberikan hasil optimal jika grid kecil, tetapi sangat mahal secara komputasi jika banyak parameter atau nilai.

Randomized Search

Sampling acak dari distribusi parameter selama N iterasi. Lebih efisien untuk ruang parameter besar — sering menemukan konfigurasi baik dengan jauh lebih sedikit evaluasi.

Ilustrasi: Grid vs Random

Grid: semua kombinasi dievaluasi. Random: titik acak dievaluasi — cepat dan seringkali cukup.

Kode: GridSearchCV (Contoh)

gridsearch_example.py

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

param_grid = {
  'n_estimators': [50, 100, 200],
  'max_depth'   : [None, 10, 20],
  'min_samples_leaf': [1, 2, 5]
}

clf = RandomForestClassifier(random_state=42)
grid = GridSearchCV(clf, param_grid, cv=5, scoring='f1', n_jobs=-1, verbose=2)
grid.fit(X_train, y_train)

print(f"Best params: {grid.best_params_}")
print(f"Best CV score: {grid.best_score_:.4f}")

Kode: RandomizedSearchCV (Contoh)

random_search_example.py

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint

param_dist = {
  'n_estimators': randint(50, 500),
  'max_depth'   : [None]+list(range(5,31,5)),
  'min_samples_leaf': randint(1, 6)
}

clf = RandomForestClassifier(random_state=42)
rand_search = RandomizedSearchCV(clf, param_distributions=param_dist, n_iter=40, cv=5, scoring='f1', n_jobs=-1, random_state=42)
rand_search.fit(X_train, y_train)

print(f"Best params: {rand_search.best_params_}")
print(f"Best CV score: {rand_search.best_score_:.4f}")

Praktik: Early Stopping & Resource Tips

Early Stopping

Untuk model boosting (XGBoost, LightGBM), gunakan early stopping pada validation set saat tuning untuk menghindari overfitting dan mengurangi waktu training.

Resource Tips

• Gunakan n_jobs untuk paralelisasi
• Untuk ruang besar, gunakan RandomizedSearch dulu untuk menemukan wilayah menjanjikan, lalu GridSearch sempit di wilayah itu
• Batasi n_iter agar waktu tidak meledak

Alternatif: Bayesian Optimization

Optuna dan Hyperopt mencari hyperparameter secara pintar menggunakan model probabilistik (Bayesian). Lebih efisien dibanding Random Search terutama pada ruang berdimensi tinggi.

optuna_sketch.py

# pip install optuna
import optuna

def objective(trial):
    n_estimators = trial.suggest_int('n_estimators', 50, 500)
    max_depth = trial.suggest_int('max_depth', 3, 30)
    clf = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, random_state=42)
    score = cross_val_score(clf, X_train, y_train, cv=3, scoring='f1').mean()
    return score

study = optuna.create_study(direction='maximize')
study.optimize(objective, n_trials=50)
print(study.best_params)

🧠 Uji Pemahaman

Strategi mana yang paling efisien ketika ada 6 hyperparameter dengan range luas?

A. Grid Search penuh

B. Randomized Search atau Bayesian Optimization

C. Manual trial-and-error

D. Tidak perlu tuning

Pipeline ML & Praktik Terbaik

6 May 2026

Pembelajaran Tak Terawasi

zenaisy Tak Berkategori 0

Unsupervised Learning – Full-Stack AI Engineer

Bab 9 · Sub-bab 1

What Is Unsupervised Learning?

Berbeda dari Supervised Learning yang belajar dari label, Unsupervised Learning menemukan pola tersembunyi dalam data secara mandiri — tanpa panduan jawaban yang benar. Ini seperti membiarkan model menjelajahi data sendiri dan menemukan strukturnya.

Tanpa Label Pattern Discovery Clustering Dimensionality Reduction

Supervised vs Unsupervised Learning

Perbedaan mendasar keduanya terletak pada ada tidaknya label (y). Di Supervised Learning, kita punya pasangan (X, y). Di Unsupervised Learning, kita hanya punya X — dan tugas model adalah menemukan struktur di dalamnya sendiri.

Dua Tugas Utama Unsupervised Learning

🔵 Clustering

Mengelompokkan data yang mirip ke dalam satu kelompok (cluster) tanpa tahu nama kelompoknya terlebih dahulu. Algoritma mencari sendiri batas antar kelompok berdasarkan jarak atau kemiripan.

K-Means DBSCAN Hierarchical

📉 Dimensionality Reduction

Menyederhanakan data berdimensi tinggi menjadi representasi yang lebih kecil, sambil mempertahankan informasi paling penting. Berguna untuk visualisasi dan mempercepat model ML.

PCA t-SNE UMAP

Kapan Menggunakan Unsupervised Learning?

1

Data Tidak Punya Label Dalam banyak skenario nyata, melabeli data membutuhkan waktu dan biaya yang sangat besar. Unsupervised Learning memungkinkan kita mengekstrak nilai dari data yang belum dilabeli.
2

Eksplorasi Awal — Memahami Struktur Data Sebelum membangun model prediktif, clustering dan PCA membantu kita memahami apakah ada kelompok alami dalam data, outlier tersembunyi, atau fitur yang redundan.
3

Generasi Fitur Baru (Feature Engineering) Hasil clustering bisa dijadikan fitur baru untuk model supervised. Hasil PCA bisa menggantikan ratusan fitur asli dengan sedikit komponen yang merangkum informasi terpenting.
4

Deteksi Anomali Data yang tidak cocok di cluster manapun bisa dianggap sebagai anomali — berguna untuk fraud detection, network intrusion, atau quality control manufaktur.

💡

Tantangan Evaluasi Unsupervised Learning Karena tidak ada label “benar”, mengevaluasi model unsupervised lebih sulit. Kita tidak bisa menghitung akurasi seperti di supervised. Sebaliknya, kita menggunakan metrik seperti Inertia, Silhouette Score, Davies-Bouldin Index, atau evaluasi kualitatif dari domain expert.

Aspek	Supervised Learning	Unsupervised Learning
Data yang Dibutuhkan	X dan y (berlabel)	Hanya X (tanpa label)
Tujuan	Prediksi nilai/kelas	Temukan struktur/pola
Evaluasi	Akurasi, F1, RMSE, dll.	Silhouette, Inertia, visualisasi
Contoh Tugas	Klasifikasi spam, prediksi harga	Segmentasi pelanggan, kompresi data
Kesulitan Utama	Butuh data berlabel (mahal)	Validasi hasil lebih sulit

🌍

Contoh Nyata di Industri Netflix menggunakan clustering untuk mengelompokkan tontonan pengguna → rekomendasi. Google News mengelompokkan artikel serupa secara otomatis. Bank menggunakan clustering untuk mendeteksi pola transaksi mencurigakan. Semua ini dilakukan tanpa label — murni Unsupervised Learning!

🧠 Uji Pemahaman

Seorang Data Scientist memiliki 1 juta data transaksi e-commerce tanpa label apapun dan ingin mengelompokkan pelanggan berdasarkan perilaku belanja. Pendekatan mana yang paling tepat?

A. Logistic Regression karena datanya besar

B. Unsupervised Clustering karena tidak ada label

C. Random Forest karena lebih akurat

D. Linear Regression untuk memprediksi nilai transaksi

Bab 9 · Sub-bab 2

K-Means Clustering Explained

K-Means adalah algoritma clustering paling populer di dunia. Idenya sederhana namun powerful: temukan K titik pusat (centroid) yang mewakili K kelompok, lalu iterasi hingga setiap titik data menetap di kelompok paling tepat.

Centroid-Based Iterative Euclidean Distance Partitional

Algoritma K-Means — 4 Langkah Sederhana

K-Means bekerja melalui proses iteratif yang terus berulang hingga centroid tidak lagi bergerak (konvergen). Setiap iterasi terdiri dari dua langkah utama: Assignment dan Update.

1

Inisialisasi — Tempatkan K Centroid Secara Acak Pilih K titik secara acak sebagai centroid awal. Kualitas inisialisasi sangat mempengaruhi hasil akhir. Metode K-Means++ (default sklearn) menggunakan strategi cerdas agar centroid awal tersebar merata.
2

Assignment — Tetapkan Setiap Titik ke Centroid Terdekat Hitung jarak Euclidean dari setiap titik data ke semua centroid. Setiap titik bergabung dengan cluster yang centroid-nya paling dekat.
3

Update — Geser Centroid ke Rata-Rata Cluster Hitung ulang posisi setiap centroid sebagai rata-rata koordinat semua titik dalam cluster-nya. Centroid bergerak mendekati “pusat berat” kelompoknya.
4

Ulangi Langkah 2–3 Hingga Konvergen Proses berlanjut sampai tidak ada titik yang berpindah cluster (centroid tidak bergerak lagi). Biasanya hanya butuh 10–50 iterasi.

Assign: cluster(xᵢ) = argmin_k ‖xᵢ − μₖ‖²

Update: μₖ = (1/|Cₖ|) Σ xᵢ — rata-rata semua titik dalam cluster k

Tujuan: minimasi total Within-Cluster Sum of Squares (WCSS / Inertia)

🎮 Simulator K-Means Interaktif

Klik Step untuk melihat satu iterasi K-Means secara live, atau Run All untuk langsung animasi hingga konvergen. Ubah nilai K untuk melihat perbedaan hasil clustering.

Pilih jumlah cluster K:

Klik “Step” untuk menjalankan satu iterasi K-Means.

● Titik data ● Centroid (berlabel C1, C2…)

Implementasi K-Means dengan Scikit-learn

kmeans_basic.py – Training & Visualisasi

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs

# ── Generate dataset sintetis ──
X, y_true = make_blobs(
    n_samples=300,
    centers=4,
    cluster_std=0.8,
    random_state=42
)

# ── PENTING: Selalu scale sebelum K-Means ──
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# ── Inisialisasi & Training K-Means ──
kmeans = KMeans(
    n_clusters=4,       # Jumlah cluster yang diinginkan
    init='k-means++',   # Inisialisasi cerdas (hindari local minima)
    n_init=10,          # Ulangi 10x dengan inisialisasi berbeda
    max_iter=300,       # Maksimum iterasi per run
    random_state=42
)
kmeans.fit(X_scaled)

# ── Hasil ──
labels    = kmeans.labels_           # Cluster untuk setiap titik
centers   = kmeans.cluster_centers_  # Posisi centroid akhir
inertia   = kmeans.inertia_          # WCSS (semakin kecil = semakin rapat)
n_iter    = kmeans.n_iter_           # Jumlah iterasi hingga konvergen

print(f"Inertia    : {inertia:.2f}")
print(f"Konvergen  : {n_iter} iterasi")
print(f"Distribusi cluster: {np.bincount(labels)}")

# ── Visualisasi hasil clustering ──
colors = ['#00c9ff', '#00e5a0', '#ff6b9d', '#ffd166']
plt.figure(figsize=(8, 6))
for i in range(4):
    mask = labels == i
    plt.scatter(X_scaled[mask, 0], X_scaled[mask, 1],
                c=colors[i], alpha=0.7, s=40, label=f'Cluster {i+1}')
plt.scatter(centers[:, 0], centers[:, 1],
            c='white', s=200, marker='*', zorder=5,
            edgecolors='black', linewidths=1.5, label='Centroid')
plt.title('K-Means Clustering Result (K=4)')
plt.legend(); plt.show()

kmeans_predict.py – Prediksi Cluster Data Baru

# Setelah model terlatih, prediksi cluster data baru
new_data = np.array([[1.5, -0.8], [-2.1, 3.2], [0.3, 0.1]])
new_scaled = scaler.transform(new_data)
predicted  = kmeans.predict(new_scaled)
print(f"Cluster prediksi: {predicted}")

# Tambahkan label cluster ke DataFrame asli
df = pd.DataFrame(X_scaled, columns=['feature_1', 'feature_2'])
df['cluster'] = labels
print(df.groupby('cluster').mean())  # Profil rata-rata tiap cluster

⚠️

3 Kelemahan K-Means yang Wajib Diketahui 1) Harus menentukan K terlebih dahulu — tidak selalu jelas berapa cluster yang “benar”. 2) Sensitif terhadap outlier — satu outlier bisa menarik centroid jauh dari pusat cluster aslinya. 3) Hanya bisa membuat cluster berbentuk bulat (convex) — tidak bagus untuk cluster berbentuk bulan sabit atau spiral.

🧠 Uji Pemahaman

Apa yang terjadi pada langkah “Update” di setiap iterasi K-Means?

A. Setiap titik diacak ulang ke cluster yang berbeda

B. Nilai K ditambah satu secara otomatis

C. Posisi centroid diperbarui ke rata-rata semua titik dalam cluster-nya

D. Titik yang jauh dari semua centroid dihapus dari dataset

Bab 9 · Sub-bab 3

Choosing the Right Number of Clusters

Menentukan nilai K yang tepat adalah tantangan terbesar dalam K-Means. Tidak ada jawaban mutlak — namun ada beberapa metode sistematis yang membantu kita membuat keputusan yang lebih terinformasi.

Elbow Method Silhouette Score Davies-Bouldin Domain Knowledge

Metode 1 — Elbow Method (Metode Siku)

Plot nilai Inertia (WCSS) untuk setiap K dari 1 hingga N. Inertia selalu turun seiring bertambahnya K. Carilah titik “siku” — di mana penurunan inertia mulai melambat drastis. Titik itu adalah K yang optimal.

💡 Titik kuning menunjukkan “elbow” — di K=4, penambahan cluster berikutnya tidak banyak mengurangi inertia

elbow_method.py – Plot Inertia vs K

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

inertias = []
K_range  = range(1, 12)

for k in K_range:
    km = KMeans(n_clusters=k, init='k-means++',
                n_init=10, random_state=42)
    km.fit(X_scaled)
    inertias.append(km.inertia_)

plt.figure(figsize=(9, 5))
plt.plot(K_range, inertias, 'o-', color='#00c9ff', lw=2, ms=7)
plt.xlabel('Jumlah Cluster K')
plt.ylabel('Inertia (WCSS)')
plt.title('Elbow Method — Mencari K Optimal')
plt.axvline(x=4, color='#ffd166', ls='--', label='Elbow K=4')
plt.legend()
plt.show()

Metode 2 — Silhouette Score

Silhouette Score mengukur seberapa baik setiap titik cocok di cluster-nya sendiri dibanding cluster lain. Nilainya antara −1 hingga +1. Semakin mendekati +1, semakin baik pemisahan cluster. Pilih K dengan Silhouette Score tertinggi.

s(i) = (b(i) − a(i)) / max(a(i), b(i))

a(i) = rata-rata jarak titik i ke semua titik di cluster-nya sendiri (cohesion)
b(i) = rata-rata jarak titik i ke semua titik di cluster terdekat lainnya (separation)

🎛️ Simulator: Silhouette Score vs K

Nilai K2 – 8

K = 3 → Silhouette Score = 0.55 (Baik ✅)

Kualitas Pemisahan Cluster:

−1 (Buruk)0 (Tidak Jelas)+1 (Sempurna)

silhouette_analysis.py – Silhouette + Davies-Bouldin

from sklearn.metrics import silhouette_score, davies_bouldin_score
import matplotlib.pyplot as plt

sil_scores = []
db_scores  = []
K_range    = range(2, 10)

for k in K_range:
    km     = KMeans(n_clusters=k, n_init=10, random_state=42)
    labels = km.fit_predict(X_scaled)
    sil_scores.append(silhouette_score(X_scaled, labels))
    db_scores.append(davies_bouldin_score(X_scaled, labels))

fig, axes = plt.subplots(1, 2, figsize=(12, 4))

# Silhouette Score (lebih tinggi = lebih baik)
axes[0].plot(K_range, sil_scores, 'o-', color='#00e5a0', lw=2)
axes[0].set_title('Silhouette Score (↑ lebih baik)')
axes[0].set_xlabel('K')

# Davies-Bouldin Index (lebih rendah = lebih baik)
axes[1].plot(K_range, db_scores, 'o-', color='#ff6b9d', lw=2)
axes[1].set_title('Davies-Bouldin Index (↓ lebih baik)')
axes[1].set_xlabel('K')

# Best K = tertinggi di Silhouette dan terendah di Davies-Bouldin
best_k_sil = list(K_range)[sil_scores.index(max(sil_scores))]
best_k_db  = list(K_range)[db_scores.index(min(db_scores))]
print(f"K terbaik (Silhouette)     : {best_k_sil}")
print(f"K terbaik (Davies-Bouldin) : {best_k_db}")
plt.tight_layout(); plt.show()

Panduan Memilih K — Kombinasi Metode

Metode	Yang Dicari	Kelebihan	Kekurangan
Elbow Method	Titik “siku” pada kurva inertia	Mudah dipahami secara visual	Titik siku kadang tidak jelas
Silhouette Score	Nilai tertinggi (mendekati +1)	Kuantitatif, lebih objektif	Lambat untuk dataset besar
Davies-Bouldin Index	Nilai terendah (mendekati 0)	Tidak perlu jarak ke centroid	Sensitif pada cluster tak beraturan
Domain Knowledge	Kebutuhan bisnis	Paling relevan untuk keputusan nyata	Subjektif, butuh expert

✅

Rekomendasi Praktis: Kombinasikan 3 Metode Gunakan Elbow Method untuk mendapatkan rentang K kandidat (misal K=3–5), lalu validasi dengan Silhouette Score untuk memilih yang terbaik secara kuantitatif, dan terakhir tanyakan kepada domain expert apakah jumlah segmen tersebut masuk akal secara bisnis.

🧠 Uji Pemahaman

Silhouette Score sebuah model clustering adalah 0.82. Apa artinya ini?

A. 82% data berhasil diklasifikasi dengan benar

B. Cluster terbentuk dengan sangat baik — titik-titik jauh lebih dekat ke cluster sendiri daripada cluster lain

C. Model membutuhkan 82 iterasi untuk konvergen

D. Inertia model bernilai 0.82

Bab 9 · Sub-bab 4

Dimensionality Reduction with PCA

Principal Component Analysis (PCA) adalah teknik paling fundamental untuk mereduksi dimensi data. Dari 100 fitur menjadi 2 fitur — sambil mempertahankan sebanyak mungkin informasi. Ini kunci untuk visualisasi dan mempercepat model ML.

PCA Variance Explained Eigenvectors Visualisasi

Mengapa Kita Perlu Reduksi Dimensi?

Semakin banyak fitur, semakin kompleks data. Di atas 10–20 fitur, banyak hal aneh terjadi — ini disebut “Curse of Dimensionality”: data menjadi sangat jarang, jarak antar titik kehilangan makna, dan model semakin lambat serta rentan overfit.

👁️ Visualisasi

Manusia hanya bisa melihat 2–3 dimensi. PCA memungkinkan kita memplot data 100-dimensi ke scatter plot 2D yang bisa dibaca.

⚡ Percepat Model

Kurangi 500 fitur menjadi 20 komponen → training 25x lebih cepat. Sangat berguna sebelum melatih model yang mahal secara komputasi.

🔇 Noise Reduction

Komponen dengan variance kecil seringkali hanya berisi noise. Menghapusnya justru meningkatkan generalisasi model.

Intuisi PCA — Menemukan Arah Variance Terbesar

PCA mencari sumbu baru (Principal Components) yang menangkap variance terbesar dalam data. PC1 adalah arah dengan variance terbesar, PC2 tegak lurus terhadap PC1 dengan variance terbesar berikutnya, dan seterusnya.

Kiri: Data asli 2D dengan 3 kelas. Kanan: Setelah PCA 1D — cluster tetap terpisah meski dimensi berkurang!

Implementasi PCA dengan Scikit-learn

pca_basics.py – Reduksi Dimensi & Explained Variance

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_breast_cancer
import matplotlib.pyplot as plt
import numpy as np

# ── Load data ──
data = load_breast_cancer()
X, y = data.data, data.target  # 30 fitur!

# ── WAJIB: Scale sebelum PCA ──
scaler   = StandardScaler()
X_scaled = scaler.fit_transform(X)

# ── Step 1: Analisis berapa PC yang dibutuhkan ──
pca_full = PCA()           # Tanpa n_components = gunakan semua
pca_full.fit(X_scaled)

cumvar = np.cumsum(pca_full.explained_variance_ratio_)
plt.figure(figsize=(9, 4))
plt.plot(range(1, len(cumvar)+1), cumvar * 100, 'o-', color='#00c9ff', lw=2)
plt.axhline(y=95, color='#ffd166', ls='--', label='95% Variance')
plt.xlabel('Jumlah PC')
plt.ylabel('Cumulative Explained Variance (%)')
plt.title('Scree Plot — Berapa PC yang Cukup?')
plt.legend(); plt.show()

# Berapa PC yang menjelaskan 95% variance?
n_95 = np.argmax(cumvar >= 0.95) + 1
print(f"PC untuk 95% variance: {n_95} dari {X.shape[1]} fitur")

# ── Step 2: Terapkan PCA dengan n_components optimal ──
pca = PCA(n_components=n_95)
X_pca = pca.fit_transform(X_scaled)
print(f"Shape sebelum PCA : {X_scaled.shape}")
print(f"Shape setelah PCA : {X_pca.shape}")

pca_visualization.py – Visualisasi 2D dengan PCA

# ── Visualisasi 2D menggunakan PC1 dan PC2 ──
pca_2d   = PCA(n_components=2)
X_2d     = pca_2d.fit_transform(X_scaled)

var_pc1  = pca_2d.explained_variance_ratio_[0] * 100
var_pc2  = pca_2d.explained_variance_ratio_[1] * 100

plt.figure(figsize=(8, 6))
for label, name, color in [(0,'Malignant','#ff6b9d'),(1,'Benign','#00e5a0')]:
    mask = y == label
    plt.scatter(X_2d[mask,0], X_2d[mask,1],
                c=color, alpha=0.7, s=40, label=name)

plt.xlabel(f'PC1 ({var_pc1:.1f}% variance)')
plt.ylabel(f'PC2 ({var_pc2:.1f}% variance)')
plt.title(f'Breast Cancer Dataset — PCA 2D\n(Total: {var_pc1+var_pc2:.1f}% variance explained)')
plt.legend(); plt.show()

# ── PCA sebagai preprocessing untuk model ML ──
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('pca',    PCA(n_components=0.95)),  # Otomatis pilih PC untuk 95% variance
    ('model',  RandomForestClassifier(random_state=42))
])
scores = cross_val_score(pipe, X, y, cv=5, scoring='accuracy')
print(f"CV Accuracy dengan PCA: {scores.mean():.4f} ± {scores.std():.4f}")

🔬

PCA vs t-SNE vs UMAP — Kapan Pakai Yang Mana? PCA — cepat, deterministic, cocok untuk preprocessing sebelum ML. t-SNE — terbaik untuk visualisasi cluster, tapi lambat dan hasilnya non-deterministik. UMAP — lebih cepat dari t-SNE, mempertahankan struktur global lebih baik, cocok untuk dataset besar.

Teknik	Kecepatan	Cocok untuk ML	Interpretabilitas	Use Case Utama
PCA	⚡ Sangat Cepat	✅ Ya	Sedang (loading matrix)	Preprocessing, denoising, visualisasi
t-SNE	🐢 Lambat	❌ Tidak	Rendah	Visualisasi cluster 2D/3D
UMAP	🐇 Cukup Cepat	⚠️ Terbatas	Rendah	Visualisasi + eksplorasi data besar
Autoencoder	🐢 Lambat (DL)	✅ Ya	Rendah	Non-linear dimensionality reduction

🧠 Uji Pemahaman

Seorang Data Scientist menggunakan PCA dengan n_components=0.95. Apa artinya parameter ini?

A. PCA hanya akan menggunakan 95% dari data training

B. Persis 95 komponen akan dipilih

C. PCA otomatis memilih jumlah PC minimum yang menjelaskan setidaknya 95% total variance

D. Hanya fitur dengan korelasi ≥ 0.95 yang disertakan

Bab 9 · Sub-bab 5

Use Cases of Clustering in Industry

Unsupervised Learning bukan sekadar teori akademis — ia bekerja keras di balik produk-produk digital yang kamu gunakan setiap hari. Mari kita telusuri implementasi nyata di berbagai industri beserta kode yang bisa langsung diaplikasikan.

Customer Segmentation Anomaly Detection Recommendation NLP Computer Vision

5 Use Case Utama di Industri

🏪 1. Customer Segmentation — Retail & E-Commerce

Problem: Toko online memiliki jutaan pelanggan. Strategi marketing satu-untuk-semua tidak efektif dan boros. Solution: K-Means clustering pada data RFM (Recency, Frequency, Monetary) untuk membagi pelanggan ke segmen bermakna.

Champions
RFM tinggi semua

Loyal Customers
Frekuensi tinggi

At Risk
Dulu aktif, kini jarang

Lost
Tidak pernah kembali

rfm_segmentation.py – Segmentasi Pelanggan dengan RFM

import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from datetime import datetime

# ── Hitung RFM dari data transaksi ──
today = datetime.now()

rfm = df.groupby('customer_id').agg({
    'order_date'   : lambda x: (today - x.max()).days,  # Recency
    'order_id'     : 'count',                            # Frequency
    'total_amount' : 'sum'                               # Monetary
}).rename(columns={
    'order_date'  : 'Recency',
    'order_id'    : 'Frequency',
    'total_amount': 'Monetary'
})

# ── Scaling ──
scaler  = StandardScaler()
rfm_sc  = scaler.fit_transform(rfm)

# ── K-Means Clustering ──
kmeans  = KMeans(n_clusters=4, n_init=10, random_state=42)
rfm['Segment'] = kmeans.fit_predict(rfm_sc)

# ── Beri nama segmen berdasarkan profil RFM ──
segment_profile = rfm.groupby('Segment').mean().round(1)
print(segment_profile)

# Contoh output mapping nama segmen
segment_map = {0:'Champions', 1:'Loyal', 2:'At Risk', 3:'Lost'}
rfm['Segment_Name'] = rfm['Segment'].map(segment_map)
print(rfm['Segment_Name'].value_counts())

🚨 2. Anomaly Detection — Perbankan & Cybersecurity

Problem: Transaksi fraudulent sangat jarang (<0.1%) sehingga tidak ada label yang cukup. Solution: Data normal akan membentuk cluster padat. Transaksi yang tidak cocok di cluster manapun (jarak jauh dari semua centroid) adalah anomali potensial.

anomaly_detection.py – Deteksi Anomali dengan Clustering & Isolation Forest

from sklearn.ensemble import IsolationForest
from sklearn.cluster import KMeans
import numpy as np

# ── Metode 1: Jarak dari Centroid ──
kmeans = KMeans(n_clusters=5, n_init=10, random_state=42)
kmeans.fit(X_scaled)

# Hitung jarak setiap titik ke centroid cluster-nya
distances = np.min(kmeans.transform(X_scaled), axis=1)

# Threshold: titik dengan jarak di atas persentil 95 = anomali
threshold = np.percentile(distances, 95)
anomalies_kmeans = X_scaled[distances > threshold]
print(f"Anomali terdeteksi (K-Means): {len(anomalies_kmeans)}")

# ── Metode 2: Isolation Forest (lebih powerful) ──
iso_forest = IsolationForest(
    contamination=0.05,   # Perkiraan % anomali dalam data
    random_state=42,
    n_estimators=100
)
predictions = iso_forest.fit_predict(X_scaled)
# -1 = anomali, 1 = normal
anomalies_if = X_scaled[predictions == -1]
print(f"Anomali terdeteksi (Isolation Forest): {len(anomalies_if)}")

🎬 3. Recommendation System — Streaming & Media

Problem: Netflix, Spotify, YouTube perlu merekomendasikan konten yang relevan dari jutaan pilihan. Solution: Collaborative Filtering menggunakan matrix factorization (mirip PCA) + clustering pengguna berdasarkan preferensi tontonan/dengaran.

📝 4. Topic Modeling — NLP & Media Sosial

Problem: Perusahaan menerima ribuan review/tweet setiap hari. Tidak mungkin dibaca manual. Solution: Representasikan teks sebagai vektor (TF-IDF/Embeddings), lalu cluster dokumen serupa untuk menemukan topik tersembunyi secara otomatis.

text_clustering.py – Clustering Dokumen Teks

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
import pandas as pd

# Dataset: daftar review/artikel
documents = [
    "Laptop ini sangat cepat dan ringan",
    "Baterai tahan lama, cocok untuk kerja",
    "Harga mahal tapi worth it untuk profesional",
    "Film action terbaik tahun ini",
    "Cerita yang menarik dan visual memukau",
    "Akting pemain sangat natural dan mengharukan",
]

# ── Step 1: Representasi teks menjadi vektor TF-IDF ──
vectorizer = TfidfVectorizer(max_features=500)
X_text     = vectorizer.fit_transform(documents)

# ── Step 2: Reduksi dimensi dengan PCA sebelum clustering ──
pca    = PCA(n_components=50)
X_pca  = pca.fit_transform(X_text.toarray())

# ── Step 3: K-Means clustering ──
kmeans = KMeans(n_clusters=2, n_init=10, random_state=42)
labels = kmeans.fit_predict(X_pca)

# ── Step 4: Lihat hasil per cluster ──
df_result = pd.DataFrame({'text': documents, 'cluster': labels})
for i in df_result['cluster'].unique():
    print(f"\n=== Cluster {i} ===")
    print(df_result[df_result['cluster']==i]['text'].tolist())

# Top keywords per cluster
order_centroids = kmeans.cluster_centers_.argsort()[:, ::-1]
terms = vectorizer.get_feature_names_out()
for i in range(2):
    top_words = [terms[ind] for ind in order_centroids[i, :5]]
    print(f"Topik Cluster {i}: {', '.join(top_words)}")

Ringkasan Use Cases per Industri

Industri	Problem	Teknik Utama	Output
🛒 Retail/E-Commerce	Segmentasi pelanggan	K-Means pada RFM	Persona pelanggan untuk marketing
🏦 Perbankan	Deteksi fraud	Isolation Forest, DBSCAN	Alert transaksi mencurigakan
🎬 Streaming	Rekomendasi konten	Matrix Factorization, Clustering	Daftar konten yang dipersonalisasi
🏥 Healthcare	Pengelompokan pasien	Hierarchical Clustering	Subtype penyakit, personalized medicine
📰 Media/NLP	Topic discovery	LDA, K-Means + TF-IDF	Kategori topik otomatis
🏭 Manufaktur	Quality control	DBSCAN, Autoencoder	Deteksi produk cacat
🌐 Cybersecurity	Network intrusion	K-Means, Isolation Forest	Alert aktivitas mencurigakan

🚀

Tips Profesional: Unsupervised → Supervised Pipeline Salah satu pattern paling powerful di industri: gunakan Unsupervised Learning terlebih dahulu untuk membuat label, lalu latih Supervised model pada label tersebut. Contoh: clustering pelanggan → label manual oleh bisnis → train classifier untuk label pelanggan baru secara otomatis di real-time!

Checklist Praktis Sebelum Deploy Clustering

✓
Selalu StandardScaler sebelum K-MeansK-Means sangat sensitif terhadap skala. Fitur dengan range besar (0–10000) akan mendominasi fitur dengan range kecil (0–1).
✓
Validasi dengan minimal 2 metrik + domain expertJangan hanya bergantung pada Elbow Method. Konfirmasi dengan Silhouette Score dan tanyakan kepada stakeholder bisnis apakah segmen yang terbentuk masuk akal.
✓
Beri nama dan interpretasi tiap clusterCluster angka (0, 1, 2) tidak berguna untuk bisnis. Analisis profil rata-rata tiap cluster dan beri nama deskriptif agar bisa dikomunikasikan ke non-teknis.
✓
Pantau cluster drift secara berkalaPerilaku pelanggan berubah seiring waktu. Jalankan ulang clustering setiap bulan/kuartal dan bandingkan apakah ada pergeseran signifikan pada distribusi cluster.
✓
Pertimbangkan DBSCAN untuk data tidak beraturanJika data memiliki cluster berbentuk tidak beraturan atau banyak outlier, DBSCAN lebih baik dari K-Means karena tidak butuh K dan bisa mendeteksi noise secara otomatis.

🎉 Selamat! Bab Unsupervised Learning Selesai!

Kamu telah menjelajahi dunia Unsupervised Learning secara menyeluruh — dari memahami konsep dasar, menguasai K-Means dengan simulator interaktif, memilih K yang tepat dengan Elbow & Silhouette, mereduksi dimensi dengan PCA, hingga mengaplikasikannya di 7 industri berbeda. Bab berikutnya akan membahas Neural Networks & Deep Learning — lompatan terbesar menuju AI modern!

✅ Konsep Unsupervised Learning

✅ K-Means + Simulator

✅ Elbow & Silhouette

✅ PCA & Reduksi Dimensi

✅ 7 Industry Use Cases

Rekayasa Fitur & Optimasi Model

6 May 2026

Pembelajaran Ensemble

zenaisy Tak Berkategori 0

Ensemble Learning – Full-Stack AI Engineer

Bab 8 · Sub-bab 1

Why Single Models Fail

Sebelum memahami kekuatan Ensemble, kita perlu memahami kelemahan mendasar model tunggal — dan mengapa menggabungkan banyak model lemah bisa menghasilkan prediksi yang jauh lebih kuat.

Overfitting Bias-Variance Wisdom of Crowds Ensemble Theory

Masalah Utama Model Tunggal

Model Machine Learning tunggal selalu berhadapan dengan dua musuh utama: Bias dan Variance. Mengurangi satu masalah biasanya memperburuk yang lain — inilah yang disebut Bias-Variance Tradeoff.

📉 High Bias (Underfitting)

Model terlalu sederhana. Tidak mampu menangkap pola dalam data. Contoh: Decision Tree dengan max_depth=1. Performa buruk di training dan test data.

📈 High Variance (Overfitting)

Model terlalu kompleks. “Hafal” data training tapi gagal pada data baru. Contoh: Decision Tree tanpa batasan kedalaman. Performa sempurna di training, jelek di test.

Tiga Sumber Kegagalan Model Tunggal

1

Bias Tinggi — Model Terlalu Simplistis Model seperti Linear Regression berasumsi hubungan data bersifat linear. Jika data nyata lebih kompleks, model ini akan selalu salah, tidak peduli seberapa banyak data yang diberikan.
2

Variance Tinggi — Model Terlalu Sensitif Terhadap Data Decision Tree yang dalam bisa “hafal” semua noise di data training. Sedikit perubahan pada data input akan menghasilkan prediksi yang sangat berbeda.
3

Keterbatasan Satu Perspektif Satu model hanya melihat pola dari satu “sudut pandang” algoritma. Realita dunia nyata sering memiliki pola yang kompleks yang sulit ditangkap oleh satu jenis model.

Solusi: Wisdom of the Crowd — Ide Dasar Ensemble

Bayangkan kamu meminta 1.000 orang menebak berat sebuah sapi. Rata-rata tebakan mereka hampir selalu lebih akurat daripada tebakan satu ahli saja. Inilah prinsip “Wisdom of Crowds” yang menjadi landasan Ensemble Learning.

🌟

Teorema Condorcet’s Jury (1785) Jika setiap individu memiliki probabilitas >50% untuk benar, maka mayoritas kelompok akan lebih sering benar dibanding individu. Dan semakin banyak individu, semakin mendekati 100% kebenaran kelompok!

✅ Strategi Ensemble: Bagging

Latih banyak model pada subset data berbeda (bootstrap sampling), lalu gabungkan hasil voting/averaging. Mengurangi Variance. Contoh: Random Forest.

🚀 Strategi Ensemble: Boosting

Latih model secara berurutan — setiap model baru fokus memperbaiki kesalahan model sebelumnya. Mengurangi Bias. Contoh: XGBoost, LightGBM.

🔀 Strategi Ensemble: Stacking

Gabungkan prediksi dari beberapa model yang berbeda jenis (meta-learning) menggunakan model tingkat kedua. Paling fleksibel, tapi juga paling kompleks.

Metode	Cara Kerja	Masalah yang Diselesaikan	Contoh Algoritma
Bagging	Parallel — model independent	High Variance (Overfitting)	Random Forest
Boosting	Sequential — model saling melengkapi	High Bias (Underfitting)	AdaBoost, XGBoost, LightGBM
Stacking	Meta-learning dari output model lain	Bias dan Variance	StackingClassifier
Voting	Ambil mayoritas/rata-rata prediksi	Variance & ketidakpastian	VotingClassifier

💡

Kenapa Ensemble Bekerja? Kunci keberhasilan ensemble adalah diversity — setiap model harus membuat kesalahan yang berbeda-beda. Jika semua model membuat kesalahan yang sama, menggabungkannya tidak akan membantu. Diversity bisa dicapai dengan: data berbeda (bagging), fitur berbeda (random subspace), atau algoritma berbeda (stacking).

🧠 Uji Pemahaman

Teknik Ensemble mana yang melatih model secara berurutan, di mana setiap model baru fokus pada kesalahan model sebelumnya?

A. Bagging

B. Boosting

C. Stacking

D. Voting

Bab 8 · Sub-bab 2

Random Forests Explained

Random Forest adalah raja algoritma Bagging — ia membangun ratusan Decision Tree pada data yang berbeda-beda, lalu menggabungkan suara mereka. Hasilnya? Model yang stabil, akurat, dan tahan banting terhadap overfitting.

Bagging Bootstrap Sampling Feature Randomness Voting

Cara Kerja Random Forest

Random Forest menggabungkan dua sumber keacakan: Bootstrap Sampling (data acak) dan Random Feature Selection (fitur acak). Kombinasi ini menghasilkan pohon-pohon yang beragam sehingga error mereka saling mengkompensasi.

Dua Keacakan yang Membuat Random Forest Kuat

🎲 1. Bootstrap Sampling (Bagging)

Setiap pohon dilatih pada sampel dengan pengembalian (with replacement) dari data asli. Rata-rata ~63.2% data unik per pohon, sisanya terulang. Data yang tidak terpakai disebut Out-of-Bag (OOB) dan digunakan untuk validasi gratis!

🎯 2. Random Feature Selection

Di setiap node split, hanya √(jumlah fitur) yang dipilih secara acak untuk dipertimbangkan. Ini memastikan setiap pohon berbeda — tidak semua pohon akan memilih fitur yang sama di root node.

🌲

Out-of-Bag (OOB) Score — Validasi Gratis! Karena setiap pohon hanya melihat ~63% data, sisa 37%-nya bisa digunakan sebagai test set untuk pohon tersebut. OOB Score adalah rata-rata akurasi dari semua pohon pada data OOB masing-masing — estimasi yang sangat baik tanpa perlu cross-validation terpisah!

Pengaruh Jumlah Pohon — Simulator Interaktif

🎛️ Coba: Berapa Jumlah Pohon yang Ideal?

Jumlah Pohon (n_estimators)1 – 300

10 pohon → Estimasi Akurasi ~79.0% | Stabilitas: Cukup stabil

Estimasi Akurasi

💡 Performa meningkat pesat di awal, lalu melandai setelah ~100 pohon. Menambah pohon tidak akan membuat model overfit, tapi akan memperlambat training!

Implementasi Random Forest di Python

random_forest.py – Training & Evaluasi

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score, classification_report
import numpy as np

# ── Inisialisasi Random Forest ──
rf = RandomForestClassifier(
    n_estimators=100,       # Jumlah pohon
    max_depth=None,          # Biarkan pohon tumbuh penuh (ensemble urus overfitting)
    max_features='sqrt',     # √n_features di tiap split
    min_samples_leaf=1,     # Min sampel di leaf
    oob_score=True,          # Aktifkan OOB Score
    n_jobs=-1,               # Gunakan semua CPU core
    random_state=42
)

# ── Training ──
rf.fit(X_train, y_train)

# ── Evaluasi ──
y_pred = rf.predict(X_test)
print(f"Test Accuracy : {accuracy_score(y_test, y_pred):.4f}")
print(f"OOB Score     : {rf.oob_score_:.4f}")  # Estimasi akurasi tanpa test set!

# ── Cross-Validation untuk validasi lebih robust ──
cv_scores = cross_val_score(rf, X_train, y_train, cv=5, scoring='accuracy')
print(f"CV Accuracy   : {cv_scores.mean():.4f} ± {cv_scores.std():.4f}")

print("\nClassification Report:")
print(classification_report(y_test, y_pred))

rf_hyperparameter_tuning.py – GridSearchCV

from sklearn.model_selection import GridSearchCV

# Grid parameter yang akan dicoba
param_grid = {
    'n_estimators'    : [50, 100, 200],
    'max_depth'       : [None, 10, 20],
    'max_features'    : ['sqrt', 'log2'],
    'min_samples_leaf': [1, 2, 5],
}

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42, oob_score=True),
    param_grid,
    cv=5,
    scoring='f1',
    n_jobs=-1,
    verbose=1
)
grid_search.fit(X_train, y_train)

print(f"Parameter Terbaik: {grid_search.best_params_}")
print(f"F1-Score Terbaik : {grid_search.best_score_:.4f}")

best_rf = grid_search.best_estimator_

Kelebihan vs Kekurangan Random Forest

✅ Kelebihan

• Sangat tahan terhadap overfitting
• Bisa menangani data dengan banyak fitur
• Memberikan feature importance secara gratis
• OOB score sebagai validasi bawaan
• Hampir tidak perlu feature scaling

❌ Kekurangan

• Model “black box” — sulit diinterpretasi
• Lambat untuk prediksi real-time (ratusan pohon)
• Membutuhkan lebih banyak memori dan waktu training
• Kurang baik untuk data time series

🧠 Uji Pemahaman

Apa yang dimaksud dengan “Out-of-Bag (OOB) Score” pada Random Forest?

A. Skor akurasi model di training set

B. Jumlah pohon yang tidak digunakan

C. Estimasi akurasi menggunakan data yang tidak dipakai saat melatih tiap pohon

D. Skor validasi dari cross-validation 5-fold

Bab 8 · Sub-bab 3

Gradient Boosting Intuition

Gradient Boosting adalah teknik paling powerful dalam dunia ML kompetitif. Berbeda dengan Random Forest yang paralel, Boosting membangun model secara berurutan — setiap model baru adalah “dokter” yang mengobati kesalahan model sebelumnya.

Boosting Sequential Learning XGBoost LightGBM

Intuisi: Belajar dari Kesalahan

Bayangkan seorang siswa yang mengerjakan soal ujian. Setelah tiap percobaan, ia hanya fokus belajar soal-soal yang salah. Inilah inti dari Boosting — setiap model selanjutnya memberikan bobot lebih besar pada data yang sebelumnya salah diprediksi.

Perbedaan Mendasar: Bagging vs Boosting

🌳 Bagging (Random Forest)

Paralel: semua pohon dilatih secara bersamaan & independent. Mengurangi Variance. Setiap pohon bertanya: “Apa prediksi terbaikku untuk data ini?” Hasil digabung dengan voting.

🚀 Boosting (GBM)

Sequential: model dilatih satu per satu. Setiap model mempelajari residual (kesalahan) model sebelumnya. Mengurangi Bias. Lebih kuat tapi lebih mudah overfit.

Learning Rate — Pengontrol Kecepatan Belajar

Learning rate (η) mengontrol seberapa besar kontribusi setiap pohon baru. Nilai kecil = belajar lambat tapi stabil. Nilai besar = belajar cepat tapi bisa melewati solusi optimal.

🎛️ Simulator: Dampak Learning Rate

Learning Rate (η)0.001 – 1.0

Learning Rate = 0.1 → Ideal — keseimbangan kecepatan & akurasi

💡 Aturan praktis: Learning Rate kecil + Banyak Pohon hampir selalu lebih baik dari Learning Rate besar + Sedikit Pohon. Gunakan 0.01–0.1 untuk hasil terbaik.

Tiga Varian Gradient Boosting Populer

📦 GradientBoostingClassifier

Implementasi bawaan Scikit-learn. Mudah digunakan tapi paling lambat. Cocok untuk dataset kecil-medium.

sklearn

⚡ XGBoost

Extreme Gradient Boosting. Sangat cepat dengan regularisasi L1/L2 bawaan. Pemenang banyak kompetisi Kaggle.

xgboost

💡 LightGBM

Light Gradient Boosting Machine. Tercepat untuk dataset besar. Menggunakan histogram-based learning yang sangat efisien.

lightgbm

Implementasi XGBoost & LightGBM

xgboost_model.py – Training dengan XGBoost

# Install: pip install xgboost
import xgboost as xgb
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score

# ── Inisialisasi XGBoost ──
xgb_model = xgb.XGBClassifier(
    n_estimators=300,       # Jumlah boosting rounds
    learning_rate=0.05,    # Step size (η) — kecil lebih baik
    max_depth=6,            # Kedalaman tiap pohon
    subsample=0.8,          # Fraction data per pohon (seperti bagging)
    colsample_bytree=0.8,  # Fraction fitur per pohon
    reg_alpha=0.1,          # Regularisasi L1
    reg_lambda=1.0,         # Regularisasi L2
    use_label_encoder=False,
    eval_metric='logloss',
    random_state=42,
    n_jobs=-1
)

# ── Training dengan Early Stopping ──
xgb_model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    early_stopping_rounds=20,  # Berhenti jika 20 round tidak improve
    verbose=50
)

# ── Evaluasi ──
y_pred  = xgb_model.predict(X_test)
y_proba = xgb_model.predict_proba(X_test)[:, 1]
print(f"XGBoost Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(f"XGBoost F1-Score: {f1_score(y_test, y_pred):.4f}")
print(f"XGBoost ROC-AUC : {roc_auc_score(y_test, y_proba):.4f}")

lightgbm_model.py – Training dengan LightGBM

# Install: pip install lightgbm
import lightgbm as lgb

# ── Inisialisasi LightGBM ──
lgb_model = lgb.LGBMClassifier(
    n_estimators=300,
    learning_rate=0.05,
    max_depth=-1,             # -1 = tidak dibatasi (LightGBM atur sendiri)
    num_leaves=31,           # Parameter utama LightGBM
    subsample=0.8,
    colsample_bytree=0.8,
    reg_alpha=0.1,
    reg_lambda=0.1,
    min_child_samples=20,
    random_state=42,
    n_jobs=-1,
    verbose=-1               # Suppress output
)

lgb_model.fit(
    X_train, y_train,
    eval_set=[(X_test, y_test)],
    callbacks=[lgb.early_stopping(20), lgb.log_evaluation(50)]
)

y_pred_lgb = lgb_model.predict(X_test)
print(f"LightGBM Accuracy: {accuracy_score(y_test, y_pred_lgb):.4f}")
print(f"LightGBM F1-Score: {f1_score(y_test, y_pred_lgb):.4f}")

Perbandingan Algoritma Boosting

Aspek	GBM (sklearn)	XGBoost	LightGBM
Kecepatan Training	🐢 Lambat	🐇 Cepat	🚀 Tercepat
Penggunaan Memory	Tinggi	Sedang	Paling Rendah
Akurasi	Baik	Sangat Baik	Sangat Baik
Regularisasi	Dasar	L1 + L2	L1 + L2
Dataset Besar	❌ Tidak ideal	✅ Baik	✅ Sangat Baik
Kemudahan Tuning	Mudah	Sedang	Sedang

⚠️

Boosting Lebih Mudah Overfit daripada Bagging! Berbeda dengan Random Forest, Gradient Boosting perlu hati-hati terhadap overfitting. Selalu gunakan early stopping, validasi set terpisah, dan regularisasi. Jangan pernah train Boosting tanpa monitoring validation loss!

🧠 Uji Pemahaman

Apa fungsi dari Early Stopping pada Gradient Boosting?

A. Menghentikan training saat akurasi mencapai 100%

B. Menghentikan training saat performa validasi tidak membaik selama N iterasi berturut-turut

C. Membatasi jumlah fitur yang digunakan

D. Mengurangi learning rate secara otomatis

Bab 8 · Sub-bab 4

Feature Importance & Interpretability

Model Ensemble yang powerful sering dianggap “black box”. Di sub-bab ini kita akan membuka kotak hitam itu — memahami fitur mana yang paling berpengaruh dan bagaimana model membuat keputusannya.

Feature Importance SHAP Values Permutation Interpretability

Mengapa Interpretabilitas Penting?

Di dunia kerja, seorang Data Scientist tidak hanya perlu model yang akurat — ia juga perlu menjelaskan mengapa model membuat keputusan tertentu kepada stakeholder bisnis, tim hukum, atau regulator. Inilah mengapa interpretabilitas adalah skill yang wajib dimiliki.

🔍 Debugging Model

Menemukan fitur yang tidak seharusnya berpengaruh besar (data leakage, proxy variable).

💼 Business Insight

Memberikan insight actionable: “Apa yang harus dilakukan bisnis untuk mengurangi churn?”

⚖️ Fairness & Compliance

Memastikan model tidak diskriminatif berdasarkan ras, gender, atau atribut sensitif lainnya.

Metode 1 — Built-in Feature Importance (Gini/MDI)

Random Forest dan Gradient Boosting secara otomatis menghitung Mean Decrease in Impurity (MDI) — seberapa banyak setiap fitur mengurangi Gini Impurity di semua pohon. Metode ini cepat tapi bisa bias terhadap fitur dengan kardinalitas tinggi.

feature_importance_builtin.py

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

# ── Feature Importance dari Random Forest ──
feature_imp = pd.Series(
    rf.feature_importances_,
    index=feature_names
).sort_values(ascending=False)

# Ambil Top 15 fitur
top_features = feature_imp.head(15)

# ── Visualisasi ──
fig, ax = plt.subplots(figsize=(10, 6))
colors = plt.cm.viridis(np.linspace(0.3, 0.9, len(top_features)))
bars = ax.barh(top_features.index, top_features.values, color=colors)
ax.set_xlabel('Feature Importance (MDI)')
ax.set_title('Top 15 Feature Importance — Random Forest')
ax.invert_yaxis()

# Tambahkan nilai di setiap bar
for bar, val in zip(bars, top_features.values):
    ax.text(val + 0.001, bar.get_y() + bar.get_height()/2,
           f'{val:.3f}', va='center', fontsize=9)

plt.tight_layout()
plt.show()

Metode 2 — Permutation Feature Importance

Lebih reliable dari MDI. Cara kerjanya: acak (permutasikan) nilai satu fitur, lalu ukur seberapa besar penurunan performa model. Fitur penting = performa turun drastis saat fitur tersebut diacak.

🔀

Mengapa Permutation Importance Lebih Baik dari MDI? MDI bisa bias karena dihitung saat training (bisa overestimate fitur yang dipakai banyak). Permutation importance dihitung pada test set, sehingga mencerminkan pengaruh fitur terhadap generalisasi, bukan hafalan training.

permutation_importance.py

from sklearn.inspection import permutation_importance

# Hitung permutation importance pada test set
perm_imp = permutation_importance(
    rf, X_test, y_test,
    n_repeats=30,      # Ulangi 30x untuk hasil stabil
    random_state=42,
    scoring='f1'        # Metrik yang digunakan
)

# Buat DataFrame hasil
perm_df = pd.DataFrame({
    'feature'   : feature_names,
    'importance': perm_imp.importances_mean,
    'std'       : perm_imp.importances_std
}).sort_values('importance', ascending=False)

# Plot dengan error bar
fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(perm_df['feature'].head(15),
       perm_df['importance'].head(15),
       xerr=perm_df['std'].head(15),
       color='#6c63ff', alpha=0.8)
ax.set_title('Permutation Feature Importance (Test Set)')
ax.invert_yaxis()
plt.tight_layout()
plt.show()

Metode 3 — SHAP Values (State of the Art)

SHAP (SHapley Additive exPlanations) adalah standar emas interpretabilitas ML modern. Berdasarkan teori game Shapley, SHAP menghitung kontribusi setiap fitur untuk setiap prediksi individual — bukan hanya secara global.

🌍 Global Explanation

Fitur mana yang paling penting secara keseluruhan? Gunakan Summary Plot untuk melihat distribusi SHAP values semua sampel.

🔎 Local Explanation

Mengapa model memprediksi X untuk sampel tertentu? Gunakan Waterfall Plot / Force Plot untuk satu prediksi spesifik.

shap_analysis.py – Interpretasi dengan SHAP

# Install: pip install shap
import shap
import matplotlib.pyplot as plt

# ── Buat SHAP Explainer untuk Tree-based model ──
explainer = shap.TreeExplainer(xgb_model)

# Hitung SHAP values untuk test set
shap_values = explainer.shap_values(X_test)

# ── 1. Summary Plot (Global) ──
plt.figure()
shap.summary_plot(
    shap_values, X_test,
    feature_names=feature_names,
    plot_type="bar",         # Bar chart rata-rata |SHAP|
    show=True
)

# ── 2. Beeswarm Plot (distribusi per fitur) ──
shap.summary_plot(shap_values, X_test, feature_names=feature_names)

# ── 3. Waterfall Plot — Penjelasan Satu Prediksi ──
idx = 0  # Index sampel yang ingin dijelaskan
shap.waterfall_plot(
    shap.Explanation(
        values=shap_values[idx],
        base_values=explainer.expected_value,
        data=X_test[idx],
        feature_names=feature_names
    )
)

# ── 4. Force Plot (interaktif) ──
shap.initjs()  # Untuk Jupyter Notebook
shap.force_plot(
    explainer.expected_value,
    shap_values[idx],
    X_test[idx],
    feature_names=feature_names
)

🏆

Cara Membaca SHAP Summary Plot Setiap titik mewakili satu sampel. Warna merah = nilai fitur tinggi, biru = rendah. Posisi di sumbu X menunjukkan apakah fitur tersebut mendorong prediksi ke kelas positif (+) atau negatif (−). Fitur di atas paling berpengaruh.

Metode	Scope	Kecepatan	Akurasi Interpretasi	Kapan Digunakan
MDI (Built-in)	Global	⚡ Sangat Cepat	⚠️ Bisa bias	Eksplorasi awal, cepat
Permutation	Global	🐇 Cepat	✅ Lebih akurat	Validasi final importance
SHAP	Global & Local	🐢 Lambat	🏆 Paling akurat	Presentasi ke stakeholder

🧠 Uji Pemahaman

Apa keunggulan utama SHAP dibanding metode feature importance lainnya?

A. SHAP lebih cepat dihitung daripada MDI

B. SHAP hanya bisa digunakan untuk Random Forest

C. SHAP menjelaskan kontribusi fitur untuk setiap prediksi individual, bukan hanya secara global

D. SHAP tidak memerlukan data test

Bab 8 · Hands-On Project

Hands-On: Improving Model Performance

Saatnya praktek nyata! Kita akan mengambil model terbaik dari Bab sebelumnya (Logistic Regression dengan F1~0.60) dan meningkatkan performanya secara signifikan menggunakan Ensemble Methods dan pipeline ML profesional.

End-to-End Pipeline Model Improvement Stacking

🎯

Target Hands-On Meningkatkan performa prediksi Customer Churn dari F1-Score ~0.60 (Logistic Regression) menjadi F1-Score ≥ 0.72 menggunakan Random Forest, XGBoost, dan akhirnya teknik Stacking Ensemble.

Langkah 1 — Baseline dari Bab Sebelumnya

📊 Performa Model Sebelumnya (Bab 7)

Logistic Regression (Baseline)F1: 0.598 | ROC-AUC: 0.850

KNNF1: 0.552 | ROC-AUC: 0.815

Decision TreeF1: 0.585 | ROC-AUC: 0.820

Target kita: melewati semua baseline ini dengan Ensemble Learning! 🚀

Langkah 2 — Pipeline Profesional dengan Scikit-learn

Gunakan sklearn Pipeline untuk menyatukan preprocessing dan model dalam satu objek yang bersih dan tidak rentan data leakage.

step1_pipeline_setup.py – Pipeline Preprocessing + Model

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
import xgboost as xgb

# Pisahkan kolom numerik dan kategoris
num_features = X_train.select_dtypes(include=['int64', 'float64']).columns.tolist()
cat_features = X_train.select_dtypes(include=['object']).columns.tolist()

# Preprocessor: Scale numerik + Encode kategoris
preprocessor = ColumnTransformer([
    ('num', StandardScaler(), num_features),
    ('cat', OneHotEncoder(drop='first', sparse_output=False), cat_features)
])

# Pipeline Random Forest
rf_pipeline = Pipeline([
    ('prep', preprocessor),
    ('model', RandomForestClassifier(
        n_estimators=200, oob_score=True,
        class_weight='balanced',  # Handle imbalanced class!
        random_state=42, n_jobs=-1
    ))
])

# Pipeline XGBoost
xgb_pipeline = Pipeline([
    ('prep', preprocessor),
    ('model', xgb.XGBClassifier(
        n_estimators=300, learning_rate=0.05,
        max_depth=6, subsample=0.8,
        scale_pos_weight=2.7,  # Ratio neg/pos untuk class imbalance
        random_state=42, n_jobs=-1,
        eval_metric='logloss'
    ))
])

# Training kedua pipeline
rf_pipeline.fit(X_train, y_train)
xgb_pipeline.fit(X_train, y_train)

Langkah 3 — Stacking Ensemble (Model Meta-Learning)

🔀

Bagaimana Stacking Bekerja? Level 0: Beberapa model “base” (RF, XGBoost, Logistic Regression) menghasilkan prediksi. Level 1: “Meta-model” (biasanya Logistic Regression) belajar dari prediksi Level 0 untuk membuat keputusan akhir. Hasilnya sering lebih baik dari model terbaik manapun secara individual.

step2_stacking.py – Stacking Ensemble

from sklearn.ensemble import StackingClassifier, RandomForestClassifier
from sklearn.linear_model import LogisticRegression
import lightgbm as lgb

# ── Base Models (Level 0) ──
base_models = [
    ('rf'  , RandomForestClassifier(n_estimators=100, class_weight='balanced',
                                        random_state=42, n_jobs=-1)),
    ('xgb' , xgb.XGBClassifier(n_estimators=200, learning_rate=0.05,
                                  scale_pos_weight=2.7, eval_metric='logloss',
                                  random_state=42, n_jobs=-1)),
    ('lgbm', lgb.LGBMClassifier(n_estimators=200, learning_rate=0.05,
                                   class_weight='balanced', verbose=-1,
                                   random_state=42, n_jobs=-1)),
]

# ── Meta Model (Level 1) ──
meta_model = LogisticRegression(C=0.1, max_iter=1000)

# ── Stacking Classifier ──
stacking = StackingClassifier(
    estimators=base_models,
    final_estimator=meta_model,
    cv=5,                     # 5-fold CV untuk generate Level 0 predictions
    stack_method='predict_proba',  # Gunakan probabilitas, bukan kelas
    n_jobs=-1
)

stacking.fit(X_train_sc, y_train)

# ── Evaluasi ──
y_pred_stack = stacking.predict(X_test_sc)
y_proba_stack = stacking.predict_proba(X_test_sc)[:, 1]
print(f"Stacking F1-Score: {f1_score(y_test, y_pred_stack):.4f}")
print(f"Stacking ROC-AUC : {roc_auc_score(y_test, y_proba_stack):.4f}")

Langkah 4 — Perbandingan Final Semua Model

📈 Peningkatan Performa — Sebelum vs Sesudah Ensemble

🏆 Stacking (RF+XGB+LGB)F1 ≈ 0.75 | AUC ≈ 0.875

⚡ XGBoost (Tuned)F1 ≈ 0.73 | AUC ≈ 0.868

💡 LightGBMF1 ≈ 0.72 | AUC ≈ 0.862

🌳 Random ForestF1 ≈ 0.69 | AUC ≈ 0.856

📊 Logistic Regression (Baseline)F1 ≈ 0.60 | AUC ≈ 0.850

Langkah 5 — Export & Deploy Model Terbaik

step3_export.py – Simpan & Deploy Model

import joblib
import json

# Simpan model stacking terbaik
joblib.dump(stacking, 'stacking_churn_v1.pkl')
joblib.dump(scaler,   'scaler_churn_v1.pkl')

# Simpan metadata model
model_info = {
    'model_type'   : 'StackingClassifier',
    'base_models'  : ['RandomForest', 'XGBoost', 'LightGBM'],
    'meta_model'   : 'LogisticRegression',
    'f1_score'     : 0.749,
    'roc_auc'      : 0.875,
    'feature_count': X_train.shape[1],
    'trained_on'   : '2025-01-01'
}
with open('model_metadata.json', 'w') as f:
    json.dump(model_info, f, indent=2)

print("✅ Model tersimpan: stacking_churn_v1.pkl")
print("✅ Metadata tersimpan: model_metadata.json")

# ── Contoh API Endpoint (FastAPI) ──
# from fastapi import FastAPI
# app = FastAPI()
# model = joblib.load('stacking_churn_v1.pkl')
#
# @app.post('/predict')
# def predict(data: dict):
#     X_new = preprocess(data)
#     proba = model.predict_proba(X_new)[0][1]
#     return {'churn_probability': round(float(proba), 4)}

Checklist Praktik Terbaik Ensemble Learning

✓
Selalu mulai dari baseline sederhanaLogistic Regression atau Decision Tree tunggal adalah benchmark awal yang harus dikalahkan sebelum kompleksitas ditambah.
✓
Handle class imbalance sebelum ensembleGunakan class_weight='balanced', SMOTE, atau sesuaikan threshold. Ensemble tidak memperbaiki masalah imbalance secara otomatis.
✓
Gunakan Pipeline untuk mencegah data leakageSelalu bungkus preprocessing dan model dalam sklearn.Pipeline agar transformasi hanya “belajar” dari training data.
✓
Early stopping untuk BoostingSelalu sediakan validation set dan aktifkan early stopping pada XGBoost/LightGBM untuk mencegah overfitting.
✓
Interpretasi dengan SHAPSebelum deploy, pastikan kamu bisa menjelaskan mengapa model membuat prediksi tertentu kepada stakeholder non-teknis.

🎉 Selamat! Bab Ensemble Learning Selesai!

Kamu telah menguasai fondasi dan implementasi Ensemble Learning secara lengkap. Dari memahami mengapa model tunggal gagal, hingga membangun Stacking Ensemble yang powerful dengan XGBoost + LightGBM + Random Forest. Bab berikutnya akan membahas Model Selection & Hyperparameter Tuning — teknik sistematis untuk menemukan konfigurasi terbaik dari model apapun!

✅ Why Single Models Fail

✅ Random Forest

✅ Gradient Boosting

✅ Feature Importance & SHAP

✅ Stacking Pipeline

Pembelajaran Tak Terawasi

6 May 2026

Model Klasifikasi

zenaisy Tak Berkategori 0

Classification Models – Full-Stack AI Engineer

Bab 7 · Sub-bab 1

Logistic Regression Explained

Pahami bagaimana model klasifikasi paling fundamental bekerja — dari konsep probabilitas hingga fungsi sigmoid yang mengubah angka menjadi keputusan “Ya atau Tidak”.

Klasifikasi Probabilitas Sigmoid Supervised Learning

Apa Itu Logistic Regression?

Meskipun namanya mengandung kata “Regression”, Logistic Regression adalah algoritma klasifikasi, bukan regresi. Tujuannya adalah memprediksi probabilitas suatu data termasuk ke dalam kelas tertentu (misal: spam/bukan spam, sakit/sehat, lulus/tidak lulus).

💡

Analogi SederhanaBayangkan kamu dokter. Berdasarkan data pasien (tekanan darah, kadar gula), kamu ingin memprediksi apakah pasien kemungkinan besar terkena diabetes atau tidak. Logistic Regression melakukan hal yang sama — ia menghitung probabilitas, lalu memutuskan kelasnya.

🎯 Linear Regression

Menghasilkan nilai kontinu (misal: harga rumah = Rp450 juta). Output bisa bernilai apa saja dari −∞ hingga +∞.

✅ Logistic Regression

Menghasilkan probabilitas antara 0 dan 1. Jika p ≥ 0.5 → Kelas 1, jika p < 0.5 → Kelas 0.

Fungsi Sigmoid — Jantung dari Logistic Regression

Logistic Regression menggunakan fungsi Sigmoid (σ) untuk memampatkan output Linear Regression ke rentang [0, 1]. Fungsi ini berbentuk kurva S yang elegan.

σ(z) = 1 / (1 + e^−z)

di mana z = w₀ + w₁x₁ + w₂x₂ + … + wₙxₙ (kombinasi linear dari fitur)

🎛️ Coba Sendiri — Simulator Sigmoid Interaktif

Nilai z (input linear)−10 hingga +10

σ(0.0) = 0.5000 → Prediksi: Tidak Pasti

0 → Kelas 0Threshold: 0.51 → Kelas 1

Decision Boundary

Logistic Regression membuat garis batas keputusan (decision boundary) yang memisahkan dua kelas. Semua data di satu sisi → Kelas 0, sisi lainnya → Kelas 1.

Kapan Menggunakan Logistic Regression?

Situasi	Cocok?	Alasan
Klasifikasi biner (2 kelas)	✅ Sangat Cocok	Dirancang khusus untuk ini
Data linear separable	✅ Cocok	Boundary berupa garis lurus
Butuh interpretasi koefisien	✅ Cocok	Koefisien mudah dijelaskan
Data non-linear kompleks	⚠️ Kurang	Boundary tidak bisa melengkung
Banyak kelas (multi-class)	🔄 Perlu modifikasi	Gunakan One-vs-Rest / Softmax

🧠 Uji Pemahaman

Apa output dari fungsi Sigmoid untuk nilai z yang sangat besar (mendekati +∞)?

A. Mendekati 0

B. Mendekati 1

C. Tepat 0.5

D. Bisa lebih dari 1

Bab 7 · Sub-bab 2

Implementing Logistic Regression

Dari teori ke kode nyata — pelajari cara membangun, melatih, dan mengevaluasi model Logistic Regression menggunakan Scikit-learn dengan dataset dunia nyata.

PythonScikit-learn PandasPraktik

Setup & Import Library

Kita akan menggunakan dataset Breast Cancer Wisconsin — dataset klasik untuk memprediksi apakah tumor bersifat ganas (malignant) atau jinak (benign). Dataset ini sudah tersedia di Scikit-learn.

01_setup.py – Import & Load Data

# Import library yang diperlukan
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (accuracy_score, classification_report,
                               confusion_matrix)

# Load dataset
data = load_breast_cancer()
X = data.data        # Fitur (30 kolom)
y = data.target      # Label: 0 = Malignant, 1 = Benign

# Lihat struktur dataset
df = pd.DataFrame(X, columns=data.feature_names)
df['target'] = y
print(df.head())
print(f"\nShape: {df.shape}")
print(f"Distribusi kelas:\n{df['target'].value_counts()}")

Preprocessing: Split & Scaling

⚠️

Mengapa Feature Scaling Penting?Logistic Regression sensitif terhadap skala fitur. Tanpa scaling, fitur dengan nilai besar (misal: area tumor = 1000) akan mendominasi fitur kecil (misal: symmetry = 0.15). Gunakan StandardScaler agar semua fitur berskala sama.

02_preprocessing.py – Split & Scale

# 1. Split data: 80% train, 20% test
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    random_state=42,
    stratify=y        # Pastikan proporsi kelas seimbang
)

print(f"Data latih: {X_train.shape}")
print(f"Data uji  : {X_test.shape}")

# 2. Feature Scaling dengan StandardScaler
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # fit + transform train
X_test_scaled  = scaler.transform(X_test)        # HANYA transform test!

# ✅ PENTING: Jangan fit scaler pada test data — itu data leakage!

Training Model

03_training.py – Fit & Predict

# Inisialisasi model
model = LogisticRegression(
    C=1.0,              # Regularization strength (lebih kecil = lebih regularized)
    max_iter=1000,     # Iterasi maksimum untuk konvergensi
    random_state=42
)

# Training model
model.fit(X_train_scaled, y_train)

# Prediksi pada test set
y_pred       = model.predict(X_test_scaled)
y_pred_proba = model.predict_proba(X_test_scaled)[:, 1]
# predict_proba → probabilitas untuk kelas 1 (Benign)

# Evaluasi dasar
acc = accuracy_score(y_test, y_pred)
print(f"Akurasi Model: {acc:.4f} ({acc*100:.2f}%)")

# Laporan lengkap
print("\nClassification Report:")
print(classification_report(y_test, y_pred,
      target_names=['Malignant', 'Benign']))

Visualisasi Koefisien Model

04_visualize.py – Feature Importance

# Koefisien model — fitur mana yang paling berpengaruh?
coef_df = pd.DataFrame({
    'feature': data.feature_names,
    'coefficient': model.coef_[0]
}).sort_values('coefficient', ascending=False)

# Plot
plt.figure(figsize=(10, 6))
colors = ['#00d4aa' if c > 0 else '#ff6b6b' for c in coef_df['coefficient']]
plt.barh(coef_df['feature'], coef_df['coefficient'], color=colors)
plt.xlabel('Koefisien (Pengaruh terhadap prediksi Benign)')
plt.title('Feature Importance – Logistic Regression')
plt.tight_layout()
plt.show()

📊 Interpretasi Koefisien

Koefisien positif → Nilai fitur yang tinggi meningkatkan probabilitas Kelas 1 (Benign). Koefisien negatif → Nilai tinggi menurunkan probabilitas Kelas 1 (kemungkinan Malignant lebih tinggi). Ini yang membuat Logistic Regression sangat interpretable!

🧠 Uji Pemahaman

Mengapa kita menggunakan scaler.transform() (bukan fit_transform()) pada data test?

A. Karena data test lebih kecil dari data train

B. Agar menghindari data leakage — statistik scaling harus dari data train saja

C. Karena transform() lebih cepat dari fit_transform()

D. Tidak ada perbedaan keduanya

Bab 7 · Sub-bab 3

K-Nearest Neighbors (KNN)

Algoritma paling intuitif di ML — “katakan padaku siapa tetanggamu, dan aku akan tahu kamu siapa.” KNN mengklasifikasikan data berdasarkan kemiripan dengan data latih.

Instance-BasedNo Training Distance MetricLazy Learner

Cara Kerja KNN

KNN tidak membangun model saat training. Ia menyimpan semua data latih, lalu saat prediksi, ia mencari K tetangga terdekat dari data baru dan melakukan voting kelas mayoritas.

1
Pilih nilai KTentukan berapa banyak tetangga yang akan dipertimbangkan. K=3 berarti ambil 3 data terdekat.
2
Hitung JarakHitung jarak antara data baru dengan semua data latih (biasanya menggunakan Euclidean Distance).
3
Temukan K Tetangga TerdekatUrutkan jarak dan ambil K data dengan jarak terkecil.
4
Voting MayoritasKelas yang paling banyak muncul di antara K tetangga menjadi prediksi akhir.

Formula Euclidean Distance

d(p, q) = √( Σ (pᵢ − qᵢ)² )

Jarak antara dua titik p dan q dalam ruang n-dimensi

📐 Euclidean Distance

Jarak garis lurus antara dua titik. Paling umum digunakan. Cocok untuk data kontinu.

🔷 Manhattan Distance

Jumlah selisih absolut. Seperti jarak tempuh di kota berikat. Lebih robust terhadap outlier.

🎛️ Pengaruh Nilai K — Coba Interaktif

Nilai K (jumlah tetangga)1 hingga 20

K = 3 → Seimbang – umum digunakan

K Terlalu Kecil (K=1)

Overfitting: sangat sensitif terhadap noise. Model “hafal” data latih.

K Terlalu Besar

Underfitting: boundary terlalu mulus, banyak detail yang hilang.

Implementasi KNN di Python

knn_classifier.py

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

# Inisialisasi KNN dengan K=5
knn = KNeighborsClassifier(
    n_neighbors=5,      # Jumlah tetangga
    metric='euclidean', # Jenis distance metric
    weights='uniform'   # Semua tetangga bobotnya sama
)

# Training & Evaluasi
knn.fit(X_train_scaled, y_train)
y_pred_knn = knn.predict(X_test_scaled)

print(f"KNN Akurasi: {accuracy_score(y_test, y_pred_knn):.4f}")

# ── Mencari K optimal dengan cross-validation ──
k_range = range(1, 26)
cv_scores = []

for k in k_range:
    knn_k = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn_k, X_train_scaled, y_train,
                              cv=5, scoring='accuracy')
    cv_scores.append(scores.mean())

# Plot: Elbow curve untuk mencari K terbaik
plt.figure(figsize=(10, 5))
plt.plot(k_range, cv_scores, 'o-', color='#6c63ff', linewidth=2)
plt.xlabel('Nilai K')
plt.ylabel('CV Accuracy')
plt.title('Elbow Curve – Mencari K Optimal')
plt.axvline(x=cv_scores.index(max(cv_scores))+1,
           color='#00d4aa', linestyle='--', label='K terbaik')
plt.legend()
plt.show()

🚨

Kelemahan KNN yang Perlu DiketahuiKNN lambat saat prediksi karena harus menghitung jarak ke semua data latih. Untuk dataset dengan jutaan baris, ini tidak efisien. Selalu lakukan Feature Scaling sebelum menggunakan KNN!

🧠 Uji Pemahaman

Jika K=1 dan model memiliki akurasi 100% di training set tapi buruk di test set, masalah apa yang terjadi?

A. Underfitting

B. Overfitting

C. Data leakage

D. Imbalanced class

Bab 7 · Sub-bab 4

Decision Trees – How Splits Work

Pahami bagaimana pohon keputusan memilih “pertanyaan terbaik” untuk memisahkan data — dari konsep Gini Impurity hingga Information Gain yang menggerakkan setiap percabangan.

Tree-BasedInterpretable Gini / EntropyNon-Linear

Anatomi Decision Tree

Decision Tree membuat keputusan layaknya flowchart — dimulai dari root node, melakukan serangkaian pertanyaan di internal nodes, hingga mencapai leaf nodes yang berisi prediksi akhir.

Bagaimana Tree Memilih Split Terbaik?

Algoritma Decision Tree mencari fitur dan threshold yang paling memurnikan kelas di setiap node. Ada dua metrik utama yang digunakan:

🍩 Gini Impurity

Default Scikit-learn. Mengukur seberapa “kotor” node — nilai 0 berarti node murni (satu kelas). Formula: Gini = 1 − Σ(pᵢ)²

📊 Information Gain (Entropy)

Mengukur pengurangan ketidakpastian setelah split. Berbasis konsep entropi dari teori informasi. IG = H(parent) − Σ weighted H(child)

Gini = 1 − (p₀² + p₁²)

Contoh: Node dengan 50% kelas A dan 50% kelas B → Gini = 1−(0.25+0.25) = 0.5 (paling impure)

Implementasi Decision Tree

decision_tree.py

from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

# Inisialisasi Decision Tree
dt = DecisionTreeClassifier(
    criterion='gini',      # Gini impurity (atau 'entropy')
    max_depth=4,           # Batasi kedalaman pohon (cegah overfitting)
    min_samples_split=10, # Min sampel untuk split node
    min_samples_leaf=5,   # Min sampel di leaf node
    random_state=42
)

# Training
dt.fit(X_train, y_train)   # DT tidak perlu scaling!

# Evaluasi
y_pred_dt = dt.predict(X_test)
print(f"Decision Tree Akurasi: {accuracy_score(y_test, y_pred_dt):.4f}")

# Visualisasi pohon
plt.figure(figsize=(20, 8))
plot_tree(dt,
          feature_names=data.feature_names,
          class_names=data.target_names,
          filled=True,
          rounded=True,
          fontsize=9)
plt.title("Decision Tree Visualization")
plt.show()

# Feature Importance
importances = pd.Series(dt.feature_importances_,
                         index=data.feature_names)
importances.sort_values(ascending=False)[:10].plot(kind='bar', color='#6c63ff')
plt.title("Top 10 Feature Importance")
plt.show()

🌳

Overfitting pada Decision TreeTanpa pembatasan (max_depth), tree akan tumbuh sampai setiap leaf berisi 1 sampel — artinya 100% akurasi di training tapi buruk di test. Selalu gunakan hyperparameter untuk memangkas pohon!

Hyperparameter	Fungsi	Nilai Umum
`max_depth`	Batas kedalaman pohon	3–10
`min_samples_split`	Min sampel untuk membagi node	10–20
`min_samples_leaf`	Min sampel di leaf	5–10
`max_features`	Fitur yang dipertimbangkan per split	‘sqrt’, ‘log2’
`criterion`	Metrik kualitas split	‘gini’ atau ‘entropy’

🧠 Uji Pemahaman

Sebuah node Decision Tree memiliki 100 sampel: 50 Kelas A dan 50 Kelas B. Berapa nilai Gini Impurity-nya?

A. 0.0 (node murni)

B. 0.25

C. 0.5 (paling impure)

D. 1.0

Bab 7 · Sub-bab 5

Classification Metrics Explained

Akurasi saja tidak cukup! Pelajari cara mengukur performa model klasifikasi secara menyeluruh — Confusion Matrix, Precision, Recall, F1-Score, dan ROC-AUC.

EvaluasiConfusion Matrix F1-ScoreROC-AUC

Confusion Matrix — Fondasi Semua Metrik

Confusion Matrix menampilkan detail prediksi model: berapa yang benar, berapa yang salah, dan jenis kesalahannya. Dari sinilah semua metrik klasifikasi diturunkan.

Confusion Matrix — Contoh Deteksi Penyakit

← Prediksi Model →

True Positive (TP)

Sakit → Prediksi Sakit ✅

False Positive (FP)

Sehat → Prediksi Sakit ❌

False Negative (FN)

Sakit → Prediksi Sehat ❌

True Negative (TN)

Sehat → Prediksi Sehat ✅

Total: 200 pasien
✅ Benar: 85+90 = 175
❌ Salah: 10+15 = 25
Akurasi: 175/200 = 87.5%

4 Metrik Utama yang Wajib Dikuasai

Accuracy

87.5%

(TP+TN)/(TP+TN+FP+FN) — Seberapa sering model benar secara keseluruhan. Menyesatkan untuk data imbalanced!

Precision

89.5%

TP/(TP+FP) = 85/95 — Dari semua yang diprediksi positif, berapa yang benar-benar positif? Penting saat FP mahal (spam filter).

Recall (Sensitivity)

85.0%

TP/(TP+FN) = 85/100 — Dari semua yang benar-benar positif, berapa yang berhasil terdeteksi? Penting saat FN mahal (deteksi kanker).

F1-Score

87.2%

2 × (P×R)/(P+R) — Harmonic mean antara Precision dan Recall. Gunakan ini saat data imbalanced.

F1 = 2 × (Precision × Recall) / (Precision + Recall)

F1-Score adalah kompromi terbaik antara Precision dan Recall

⚠️

Precision vs Recall — Trade-off Penting!
Meningkatkan Precision biasanya menurunkan Recall, dan sebaliknya. Pilih prioritas berdasarkan konteks bisnis:
• Deteksi Kanker → Prioritas Recall (jangan sampai ada yang missed)
• Filter Spam → Prioritas Precision (jangan hapus email penting)

Implementasi Metrics di Python

classification_metrics.py

from sklearn.metrics import (confusion_matrix, classification_report,
                               precision_score, recall_score, f1_score,
                               roc_auc_score, roc_curve)
import seaborn as sns
import matplotlib.pyplot as plt

# ── 1. Confusion Matrix ──
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
           xticklabels=['Malignant','Benign'],
           yticklabels=['Malignant','Benign'])
plt.xlabel('Prediksi'); plt.ylabel('Aktual')
plt.title('Confusion Matrix'); plt.show()

# ── 2. Classification Report ──
print(classification_report(y_test, y_pred,
      target_names=['Malignant', 'Benign']))

# ── 3. Metrik individual ──
print(f"Precision : {precision_score(y_test, y_pred):.4f}")
print(f"Recall    : {recall_score(y_test, y_pred):.4f}")
print(f"F1-Score  : {f1_score(y_test, y_pred):.4f}")
print(f"ROC-AUC   : {roc_auc_score(y_test, y_pred_proba):.4f}")

# ── 4. ROC Curve ──
fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
auc = roc_auc_score(y_test, y_pred_proba)

plt.figure(figsize=(7, 5))
plt.plot(fpr, tpr, color='#6c63ff', lw=2,
         label=f'ROC Curve (AUC = {auc:.3f})')
plt.plot([0,1], [0,1], '--', color='#546e7a', label='Random Classifier')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.legend()
plt.show()

Perbandingan Metrik — Kapan Menggunakan Yang Mana?

Metrik	Gunakan Ketika	Contoh Kasus
Accuracy	Data balanced, semua error sama pentingnya	Klasifikasi buah: apel/jeruk/mangga
Precision	FP lebih mahal dari FN	Spam detection, fraud alert palsu
Recall	FN lebih mahal dari FP	Deteksi kanker, COVID screening
F1-Score	Data imbalanced, butuh balance P&R	Deteksi penipuan (imbalanced)
ROC-AUC	Membandingkan model, semua threshold	Benchmark perbandingan model

🧠 Uji Pemahaman

Model deteksi COVID memiliki Precision=0.95 tapi Recall=0.60. Apa artinya ini dan apakah ini masalah?

A. Tidak masalah karena Precision-nya tinggi

B. Masalah besar — 40% kasus COVID terlewat (FN tinggi), sangat berbahaya

C. Cukup baik karena rata-ratanya tinggi

D. Perlu dilihat Accuracy-nya dulu

Bab 7 · Mini Project

Mini Project: Binary Classification Model

Saatnya menyatukan semua yang telah dipelajari! Bangun pipeline klasifikasi biner end-to-end — mulai dari eksplorasi data, preprocessing, training 3 model, evaluasi, hingga perbandingan dan kesimpulan.

End-to-EndPipeline Model ComparisonStudi Kasus

🎯

Tujuan Mini ProjectMemprediksi apakah seorang pelanggan akan churn (berhenti berlangganan) atau tidak berdasarkan data perilaku. Kita akan melatih 3 model (Logistic Regression, KNN, Decision Tree) dan memilih yang terbaik.

Dataset: Customer Churn

📊 Dataset

Telco Customer Churn (Kaggle). 7043 baris, 20 fitur. Target: Churn (Yes/No) — imbalanced ~73% No, 27% Yes.

🎯 Target Metrik

Karena imbalanced, kita prioritaskan F1-Score dan ROC-AUC sebagai metrik utama, bukan Accuracy.

Langkah 1 — Load & EDA Singkat

step1_eda.py

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Load dataset
df = pd.read_csv('telco_churn.csv')
print(df.head())
print(f"\nShape: {df.shape}")
print(f"Missing values:\n{df.isnull().sum()}")
print(f"\nDistribusi Target:\n{df['Churn'].value_counts(normalize=True)}")

# Visualisasi distribusi target
df['Churn'].value_counts().plot(kind='bar',
    color=['#00d4aa', '#ff6b6b'], rot=0)
plt.title('Distribusi Target: Churn vs Tidak Churn')
plt.xlabel('Churn'); plt.ylabel('Jumlah Pelanggan')
plt.show()

Langkah 2 — Preprocessing Pipeline

step2_preprocessing.py

from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split

# 1. Drop kolom tidak relevan
df = df.drop(columns=['customerID'])

# 2. Konversi TotalCharges ke numerik
df['TotalCharges'] = pd.to_numeric(df['TotalCharges'], errors='coerce')
df['TotalCharges'].fillna(df['TotalCharges'].median(), inplace=True)

# 3. Label encode kolom biner
binary_cols = ['gender', 'Partner', 'Dependents', 'PhoneService',
               'PaperlessBilling', 'Churn']
le = LabelEncoder()
for col in binary_cols:
    df[col] = le.fit_transform(df[col])

# 4. One-Hot Encoding untuk multi-kategori
df = pd.get_dummies(df, drop_first=True)

# 5. Pisahkan fitur dan target
X = df.drop(columns=['Churn'])
y = df['Churn']

# 6. Split & Scale
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
scaler = StandardScaler()
X_train_sc = scaler.fit_transform(X_train)
X_test_sc  = scaler.transform(X_test)

print(f"Fitur: {X_train.shape[1]} | Train: {len(X_train)} | Test: {len(X_test)}")

Langkah 3 — Training 3 Model Sekaligus

step3_train_all_models.py

from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import (accuracy_score, f1_score,
                               roc_auc_score, classification_report)

# Dictionary berisi semua model
models = {
    'Logistic Regression': LogisticRegression(C=1.0, max_iter=1000, random_state=42),
    'KNN'               : KNeighborsClassifier(n_neighbors=9),
    'Decision Tree'     : DecisionTreeClassifier(max_depth=5, random_state=42),
}

results = {}

for name, model in models.items():
    # Training
    model.fit(X_train_sc, y_train)
    
    # Prediksi
    y_pred  = model.predict(X_test_sc)
    y_proba = model.predict_proba(X_test_sc)[:, 1]
    
    # Simpan hasil
    results[name] = {
        'Accuracy': accuracy_score(y_test, y_pred),
        'F1-Score': f1_score(y_test, y_pred),
        'ROC-AUC' : roc_auc_score(y_test, y_proba),
    }
    print(f"\n{'='*40}")
    print(f"  {name}")
    print(f"  Accuracy : {results[name]['Accuracy']:.4f}")
    print(f"  F1-Score : {results[name]['F1-Score']:.4f}")
    print(f"  ROC-AUC  : {results[name]['ROC-AUC']:.4f}")

# Tampilkan perbandingan dalam DataFrame
results_df = pd.DataFrame(results).T
print("\n=== PERBANDINGAN AKHIR ===")
print(results_df.round(4))

Langkah 4 — Visualisasi Perbandingan Model

step4_comparison_plot.py

# Plot perbandingan semua model
ax = results_df.plot(
    kind='bar',
    figsize=(10, 5),
    color=['#6c63ff', '#00d4aa', '#ffd93d'],
    rot=0,
    edgecolor='none'
)
plt.title('Perbandingan Model: Accuracy, F1-Score, ROC-AUC', fontsize=13)
plt.ylabel('Score')
plt.ylim(0.6, 1.0)
plt.legend(loc='lower right')
plt.tight_layout()
plt.show()

# ROC Curve semua model dalam satu plot
plt.figure(figsize=(8, 6))
colors = ['#6c63ff', '#00d4aa', '#ffd93d']
for (name, model), color in zip(models.items(), colors):
    y_proba = model.predict_proba(X_test_sc)[:, 1]
    fpr, tpr, _ = roc_curve(y_test, y_proba)
    auc = roc_auc_score(y_test, y_proba)
    plt.plot(fpr, tpr, color=color, lw=2,
             label=f'{name} (AUC={auc:.3f})')

plt.plot([0,1],[0,1], '--', color='#546e7a')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate (Recall)')
plt.title('ROC Curve — Semua Model')
plt.legend()
plt.show()

Hasil yang Diharapkan

Model	Accuracy	F1-Score	ROC-AUC	Keunggulan
Logistic Regression	~80.5%	~0.598	~0.850	Interpretable, baseline kuat
KNN (K=9)	~77.0%	~0.552	~0.815	Sederhana, tidak perlu asumsi
Decision Tree	~79.0%	~0.585	~0.820	Mudah divisualisasi

🏆

Kesimpulan: Logistic Regression Menang!Untuk dataset Telco Churn, Logistic Regression memberikan ROC-AUC tertinggi (~0.85) sekaligus paling mudah diinterpretasi. Di dunia nyata, interpretabilitas sangat penting agar bisnis bisa memahami “mengapa” pelanggan diprediksi churn.

Langkah Selanjutnya di Dunia Nyata

1
Handle Imbalanced DataGunakan teknik seperti SMOTE (oversampling), class_weight=’balanced’, atau pengaturan threshold probabilitas.
2
Hyperparameter TuningGunakan GridSearchCV atau RandomizedSearchCV untuk menemukan kombinasi parameter terbaik secara sistematis.
3
Ensemble MethodsCoba Random Forest atau Gradient Boosting (XGBoost, LightGBM) yang sering mengungguli model tunggal.
4
DeploymentSimpan model terbaik dengan joblib.dump(model, 'best_model.pkl') dan buat API dengan FastAPI atau Flask.

step5_save_model.py – Export Model

import joblib

# Simpan model terbaik
best_model = models['Logistic Regression']
joblib.dump(best_model, 'best_churn_model.pkl')
joblib.dump(scaler, 'scaler.pkl')
print("✅ Model tersimpan: best_churn_model.pkl")

# Load dan gunakan kembali
loaded_model  = joblib.load('best_churn_model.pkl')
loaded_scaler = joblib.load('scaler.pkl')

# Prediksi pada data baru
new_customer = np.array([[1, 24, 0, 65.9, 1580.0]])  # contoh
new_scaled   = loaded_scaler.transform(new_customer)
prediction   = loaded_model.predict_proba(new_scaled)[0]
print(f"Probabilitas Churn  : {prediction[1]:.2%}")
print(f"Probabilitas Retain : {prediction[0]:.2%}")

🎉 Selamat! Bab Classification Models Selesai

Kamu telah mempelajari seluruh fondasi klasifikasi dalam Machine Learning: Logistic Regression, KNN, Decision Tree, metrik evaluasi, dan membangun pipeline end-to-end. Bab berikutnya akan membahas Ensemble Methods (Random Forest, Gradient Boosting) yang akan membawa performa modelmu ke level berikutnya!

✅ Logistic Regression

✅ KNN

✅ Decision Tree

✅ Classification Metrics

✅ Mini Project

Pembelajaran Ensemble

6 May 2026

Model Regresi

zenaisy Tak Berkategori 0

Regression Models – Full-Stack AI Engineer

📈 Linear Regression — Intuisi

Bayangkan kamu seorang data analyst di perusahaan properti. Bosmu bertanya: “Kalau rumah ukurannya 120m², kira-kira harganya berapa?”

Kamu punya data historis — luas rumah dan harganya. Linear regression membantu kamu menarik garis lurus terbaik melewati data itu, sehingga kamu bisa memprediksi harga rumah baru.

💡 Analogi Sederhana: Seperti menggambar garis lurus paling pas di antara titik-titik data pada grafik, agar kamu bisa “menebak” nilai baru yang belum pernah kamu lihat.

Kapan Digunakan di Dunia Kerja?

Industri	Use Case
Properti	Prediksi harga rumah
E-Commerce	Prediksi revenue berdasarkan ad spend
HR / People Analytics	Prediksi gaji berdasarkan pengalaman
Manufaktur	Prediksi output produksi
Finance	Forecasting penjualan

Visualisasi Interaktif

Geser slider untuk melihat bagaimana garis regresi berubah:

Slope (kemiringan): 2.0

Intercept (titik potong): 10

Titik biru = data, Garis merah = prediksi regresi. Coba ubah slope & intercept!

🧠 Quick Check

Apa tujuan utama linear regression?

A. Menemukan garis lurus terbaik untuk memprediksi nilai kontinu

B. Mengelompokkan data ke dalam kategori

C. Mengurangi dimensi data

🔢 Linear Regression — Math Explained Simply

Jangan takut dengan matematikanya! Kita akan breakdown pelan-pelan.

Persamaan Garis

ŷ = w · x + b

ŷ = prediksi, w = weight (slope/kemiringan), x = input (fitur), b = bias (intercept)

🏢 Konteks Kerja: Jika x = budget iklan (juta), w = 3.5, b = 10, maka prediksi revenue = 3.5 × budget + 10 juta.

Cost Function — Mengukur Kesalahan

Bagaimana model tahu garisnya sudah bagus? Dengan Mean Squared Error (MSE):

MSE = (1/n) Σ (yᵢ − ŷᵢ)²

Semakin kecil MSE, semakin bagus garis kita. Model berusaha meminimalkan nilai ini.

Gradient Descent — Cara Model Belajar

Bayangkan kamu berdiri di gunung berkabut dan ingin turun ke lembah terendah. Kamu tidak bisa melihat jauh, jadi kamu meraba ke arah paling curam ke bawah, selangkah demi selangkah. Itulah gradient descent!

Mulai acak

→

Hitung error

→

Hitung gradient

→

Update w & b

→

Ulangi

w = w − α · ∂MSE/∂w
b = b − α · ∂MSE/∂b

α (learning rate) = seberapa besar langkah yang diambil. Terlalu besar → melewati lembah. Terlalu kecil → terlalu lama.

Simulasi Learning Rate

Learning Rate (α): 0.05

🧠 Quick Check

Apa yang terjadi jika learning rate terlalu besar?

A. Model belajar terlalu lambat

B. Model bisa melewati titik optimal dan tidak konvergen

C. Tidak ada pengaruh

🐍 Implementasi Linear Regression di Python

Sekarang kita terapkan teori ke kode nyata yang bisa langsung kamu pakai di tempat kerja.

Cara 1: Scikit-Learn (Paling Umum di Industri)

🏢 Production Ready

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Data: luas rumah (m²) → harga (juta rupiah)
X = np.array([30,50,70,90,100,120,150]).reshape(-1,1)
y = np.array([200,350,480,600,700,850,1050])

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train model
model = LinearRegression()
model.fit(X_train, y_train)

# Prediksi
print(f"Slope (w): {model.coef_[0]:.2f}")
print(f"Intercept (b): {model.intercept_:.2f}")
print(f"Prediksi 120m²: {model.predict([[120]])[0]:.0f} juta")

Cara 2: Dari Nol (Untuk Pemahaman Mendalam)

📐 Fundamental

class SimpleLinearRegression:
    def __init__(self, lr=0.0001, epochs=1000):
        self.lr = lr
        self.epochs = epochs

    def fit(self, X, y):
        self.w = 0.0
        self.b = 0.0
        n = len(X)
        for _ in range(self.epochs):
            y_pred = self.w * X + self.b
            dw = (-2/n) * np.sum(X * (y - y_pred))
            db = (-2/n) * np.sum(y - y_pred)
            self.w -= self.lr * dw
            self.b -= self.lr * db

    def predict(self, X):
        return self.w * X + self.b

💼 Tips Dunia Kerja: Di produksi, selalu gunakan scikit-learn — sudah teruji, cepat, dan mudah di-maintain. Implementasi dari nol hanya untuk belajar dan interview.

Interactive: Coba Prediksi

Masukkan luas rumah dan lihat prediksi harga (model: ŷ = 7.1x + 12):

🧠 Quick Check

Kenapa kita perlu reshape(-1, 1) pada array X di scikit-learn?

A. Scikit-learn mengharapkan input 2D (samples × features)

B. Untuk mengurutkan data

C. Untuk menormalisasi data

📊 Model Evaluation: MSE, RMSE & R²

Setelah model dilatih, pertanyaan penting di dunia kerja: “Seberapa bagus model ini?” Ada 3 metrik utama yang wajib kamu kuasai.

1. Mean Squared Error (MSE)

MSE = (1/n) Σ (yᵢ − ŷᵢ)²

Rata-rata dari kuadrat selisih antara nilai aktual dan prediksi. Semakin kecil = semakin baik. Kelemahannya: satuannya dikuadratkan, jadi sulit diinterpretasi langsung.

2. Root Mean Squared Error (RMSE)

RMSE = √MSE

Akar dari MSE — satuannya sama dengan target. Jika target dalam juta rupiah, RMSE juga dalam juta rupiah. Ini yang paling sering dilaporkan ke stakeholder.

3. R² (R-Squared / Coefficient of Determination)

R² = 1 − (SS_res / SS_tot)

Mengukur seberapa baik model menjelaskan variasi data. Nilainya 0–1 (bisa negatif jika model sangat buruk).

R² Value	Interpretasi	Konteks Kerja
> 0.9	Sangat baik	Model siap deploy
0.7 – 0.9	Baik	Perlu review fitur
0.5 – 0.7	Cukup	Cari fitur tambahan
< 0.5	Kurang	Model/data perlu diperbaiki

Implementasi di Python

from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

y_actual = np.array([200, 350, 480, 700])
y_pred   = np.array([210, 340, 500, 680])

mse  = mean_squared_error(y_actual, y_pred)
rmse = np.sqrt(mse)
r2   = r2_score(y_actual, y_pred)

print(f"MSE:  {mse:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"R²:   {r2:.4f}")

Kalkulator Interaktif

Masukkan nilai aktual dan prediksi (pisahkan dengan koma):

Aktual: Prediksi:

🧠 Quick Check

Manakah metrik yang paling mudah dijelaskan ke stakeholder non-teknis?

A. MSE — karena paling akurat

B. RMSE — karena satuannya sama dengan target

C. R² — karena selalu bernilai positif

⚖️ Bias-Variance Tradeoff

Di pekerjaan nyata, model jarang gagal karena “algoritmanya jelek”. Lebih sering gagal karena overfitting atau underfitting. Konsep inti untuk memahami ini adalah bias-variance tradeoff.

Underfitting (Bias Tinggi)

Model terlalu sederhana, tidak mampu menangkap pola data. Biasanya terjadi ketika fitur kurang relevan, model terlalu linear untuk data yang kompleks, atau regularisasi terlalu kuat.

Gejala di metrik: error tinggi di train dan test.

Overfitting (Variance Tinggi)

Model “menghafal” data training, termasuk noise. Di produksi, performanya jatuh saat bertemu data baru.

Gejala di metrik: error rendah di train, tapi tinggi di test.

Kenapa Ini Penting untuk Kebutuhan Kerja?

Stakeholder tidak peduli modelmu “bagus di training”. Mereka peduli hasil di dunia nyata. Jadi kamu harus bisa mengendalikan tradeoff ini lewat data, fitur, regularisasi, dan validasi.

Interaktif: Simulasi Kompleksitas Model

Anggap ini sebagai “tingkat kompleksitas”. Semakin tinggi, semakin mudah overfitting.

Kompleksitas: 3

Cara Praktis Mengatasinya

Masalah	Solusi Praktis
Underfitting	Tambah fitur, gunakan model lebih fleksibel (polynomial, tree-based), kurangi regularisasi
Overfitting	Lebih banyak data, feature selection, regularisasi (Ridge/Lasso), cross-validation

🧠 Quick Check

Jika model bagus di training tetapi buruk di test, kemungkinan besar masalahnya:

A. Underfitting (bias tinggi)

B. Overfitting (variance tinggi)

C. Target leakage selalu

🧩 Mini Project: Predicting Continuous Values

Mini project ini meniru alur kerja yang sering kamu temui di kantor: dari data mentah → model → evaluasi → rekomendasi perbaikan.

Target: membuat model regresi untuk memprediksi nilai kontinu (contoh: harga, demand, revenue, durasi).

Dataset (Simulasi Dunia Kerja)

Kita pakai data sederhana: ad_spend (juta) → revenue (juta). Kamu bisa ganti nanti dengan datasetmu sendiri.

import pandas as pd

# contoh data
df = pd.DataFrame({
    "ad_spend": [5,10,15,20,25,30,35,40],
    "revenue":  [40,55,70,88,103,120,138,150]
})

Langkah Kerja (Checklist)

Pisahkan fitur & target
X=df[['ad_spend']]; y=df['revenue']

Split train/test
train_test_split(...)

Latih model
LinearRegression().fit(...)

Evaluasi
Hitung RMSE dan R²

Analisis error
Cek outlier, cek pola residual

Improvement
Tambah fitur, regularisasi, atau coba model lain

Template Kode End-to-End (Siap Dipakai)

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

X = df[["ad_spend"]]
y = df["revenue"]

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

model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)

print(f"w={model.coef_[0]:.3f}, b={model.intercept_:.3f}")
print(f"RMSE={rmse:.3f}, R2={r2:.3f}")

Deliverable untuk Portofolio / Kerja

Kalau ini jadi proyek portofolio atau tugas kantor, output minimal yang bagus adalah: notebook berisi EDA singkat, training, metrik (RMSE, R²), plot residual, dan rekomendasi 2–3 perbaikan (misalnya menambah fitur musiman, log-transform target, atau mencoba Ridge/Lasso).

🧠 Quick Check

Yang paling penting untuk memastikan model regresi siap dipakai di produksi adalah:

A. Error training sekecil mungkin

B. Performa stabil pada data validasi/test + monitoring setelah deploy

C. Menggunakan algoritma paling kompleks

Selesai! Kamu sudah melewati fondasi regresi dari intuisi sampai praktik yang relevan untuk kerja.

Model Klasifikasi

6 May 2026

Dasar-Dasar Pembelajaran Mesin

zenaisy Tak Berkategori 0

Machine Learning Fundamentals

🤖 Machine Learning Fundamentals

Fondasi Machine Learning
untuk AI Engineer

Pahami konsep inti ML secara mendalam — dari definisi, paradigma belajar, jenis masalah, split data, hingga alur kerja end-to-end yang digunakan di industri nyata.

🧠 Apa itu ML? 📊 Supervised vs Unsupervised 📈 Regression vs Classification ✂️ Train/Val/Test Split 🔄 ML Workflow 🤖 Clawdbot AI Agent

Progress Belajar

Modul 1 / 6

Model Regresi

6 May 2026

Pemahaman & Eksplorasi Data (EDA)

zenaisy Tak Berkategori 0

EDA — Data Understanding & Exploration

🔍 Data Understanding & Exploration

Exploratory Data Analysis
for Machine Learning

Pahami data sebelum membangun model — mulai dari struktur dataset, deteksi anomali, visualisasi, hingga analisis korelasi fitur secara mendalam.

📊 EDA 🧹 Missing Values 📈 Matplotlib 🔗 Correlation 🛠️ Hands-On Project

Progress

Modul 1 / 5

Dasar-Dasar Pembelajaran Mesin

6 May 2026

Dasar-Dasar Python untuk Pembelajaran Mesin

zenaisy Tak Berkategori 0

Python Foundations for Machine Learning

🐍 Python Foundations for Machine Learning

Python Foundations
for Machine Learning

Kuasai dasar-dasar Python yang dibutuhkan seorang AI Engineer — dari sintaks modern hingga NumPy, Pandas, dan clean code patterns.

🐍 Python 3.10+ 🔢 NumPy 🐼 Pandas 🧹 Clean Code

Progress

Modul 1 / 5

Pemahaman & Eksplorasi Data (EDA)

zenaisy

About zenaisy

Posts by :

dhcp

Pipeline ML & Praktik Terbaik

Membangun ML Pipeline yang Handal

🔧 Membangun ML Pipeline

Menggunakan Joblib (Direkomendasikan)

Menggunakan Pickle

🚫 Mencegah Data Leakage

🔁 Reproducibility dalam ML

requirements.txt (Minimal)

Conda Environment (Lebih Kuat)

⚠️ Kesalahan Umum dalam ML yang Harus Dihindari

✅ Yang Harus Selalu Dilakukan

🚫 Yang Harus Selalu Dihindari

Rekayasa Fitur & Optimasi Model

Feature Scaling & Normalization

Perbedaan Utama: StandardScaler vs MinMaxScaler vs RobustScaler

StandardScaler (Z-score)

MinMaxScaler

RobustScaler

Power Transform & Log

Ilustrasi Interaktif — Dampak Scaling

Praktik Terbaik

Kode: Penerapan Scaling di Pipeline

🧠 Uji Pemahaman

Encoding Categorical Variables

1) One-Hot Encoding

Kapan Pakai

2) Ordinal Encoding

3) Target / Mean Encoding (with CV)

Kapan Pakai

4) Binary / Hashing Encoding

5) Count / Frequency Encoding

6) Practical Tips & Pitfalls

✅ Simpan mapping encoder

⚠️ Tangani kategori baru (unseen)

Pipeline Best Practice

🧠 Uji Pemahaman

Feature Selection Techniques

Filter Methods — Cepat & Model-Agnostic

Wrapper Methods — Lebih Akurat tapi Mahal

Embedded Methods — Seleksi Saat Training

Praktik: Gabungkan Teknik

Evaluasi Fitur Secara Praktis

Permutation Importance

Stability Selection

🧠 Uji Pemahaman

Cross-Validation Explained

Jenis Cross-Validation yang Biasa Dipakai

K-Fold CV

Stratified K-Fold

TimeSeriesSplit

Nested Cross-Validation

Visualisasi CV (Ilustrasi K-Fold)

Kode: Contoh Stratified K-Fold CV

Nested CV untuk Model Selection

🧠 Uji Pemahaman

Hyperparameter Tuning (Grid & Random Search)

Grid Search vs Random Search

Grid Search

Randomized Search

Kode: GridSearchCV (Contoh)

Kode: RandomizedSearchCV (Contoh)

Praktik: Early Stopping & Resource Tips

Early Stopping

Resource Tips

Alternatif: Bayesian Optimization

🧠 Uji Pemahaman

Pembelajaran Tak Terawasi

What Is Unsupervised Learning?

Supervised vs Unsupervised Learning

Dua Tugas Utama Unsupervised Learning

🔵 Clustering

📉 Dimensionality Reduction

Kapan Menggunakan Unsupervised Learning?

🧠 Uji Pemahaman

K-Means Clustering Explained

Algoritma K-Means — 4 Langkah Sederhana