Skip to main content

Metrik evaluasi & cross-validation model prediktif

Data Science — pertemuan ke-11

Penulis

Anggit Wirasto, S.Si., M.Eng.

Setelah model regresi atau klasifikasi dilatih, fokus bergeser ke evaluasi: seberapa baik model generalisasi pada data baru, dan metrik mana yang selaras dengan konteks bisnis. Modul ini membahas metrik regresi (MAE, RMSE, \(R^2\)), metrik klasifikasi (confusion matrix, precision, recall, F1, ROC & AUC), serta cross-validation untuk estimasi performa dan tuning hiperparameter tanpa mengutak-atik set uji.

Prasyarat: regresi (DS-09) dan klasifikasi (DS-10).

0.1 Tujuan pembelajaran

Setelah mempelajari materi ini, mahasiswa diharapkan mampu:

  1. Menghitung dan menginterpretasikan metrik regresi: MAE, RMSE, dan \(R^2\) pada data uji, serta memilih metrik yang selaras dengan konteks bisnis.
  2. Membaca confusion matrix dan menghitung accuracy, precision, recall, dan F1-score (kasus biner dan multi-kelas); membangun dan menginterpretasikan kurva ROC serta AUC untuk model probabilistik.
  3. Merancang protokol cross-validation untuk estimasi performa yang stabil dan memilih hiperparameter tanpa menyentuh set uji.

1 Peta materi

Subbab Fokus
9.1 Metrik regresi: MAE, RMSE, \(R^2\)
9.2 Metrik klasifikasi: confusion matrix, precision, recall, F1, ROC & AUC
Latihan 10 contoh kasus pembacaan metrik (regresi + klasifikasi + AUC)
9.3 Cross-validation

2 Landasan evaluasi

Algoritme menjawab bagaimana mempelajari \(f(x)\) dari data latih; evaluasi menjawab seberapa baik \(f\) bekerja pada observasi baru. Prinsip utamanya: ukur performa pada Testing Data — data yang belum pernah dipakai saat latih.

Gambaran overfitting: model sederhana (garis linear) versus model sangat fleksibel (kurva berliku). Yang fleksibel sering pas sempurna di latih tetapi meleset besar di uji — model “menghafal” noise, bukan pola generik.

Subset Makna Peran
Training Data data untuk menyesuaikan parameter model latih garis/pohon/SVM, dll.
Testing Data data baru yang tidak dipakai saat latih estimasi generalisasi; mendeteksi overfitting

Data leakage — memakai data yang sama untuk latih dan uji — membuat skor terlihat lebih baik dari kenyataan. Untuk tuning hiperparameter, gunakan cross-validation di dalam train (bab 9.3), bukan set uji.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline

x_train = np.array([0.4, 1.0, 1.4, 1.9, 2.2, 2.6])
y_train = np.array([1.1, 1.5, 1.7, 2.1, 2.4, 2.7])
x_test = np.array([0.8, 1.6, 2.4, 2.9])
y_test = np.array([1.35, 1.95, 2.55, 2.85])

x_line = np.linspace(0.3, 3.0, 100)
lin = LinearRegression().fit(x_train.reshape(-1, 1), y_train)
poly = make_pipeline(PolynomialFeatures(5), LinearRegression()).fit(
    x_train.reshape(-1, 1), y_train
)

def total_rmse(model, x, y):
    pred = model.predict(x.reshape(-1, 1))
    return float(np.sqrt(mean_squared_error(y, pred)))

fig, axes = plt.subplots(1, 2, figsize=(10, 4.2))
for ax, x, y, title, c in [
    (axes[0], x_train, y_train, "Training Data", "#e74c3c"),
    (axes[1], x_test, y_test, "Testing Data", "#3498db"),
]:
    ax.scatter(x, y, s=80, color=c, edgecolors="white", zorder=3, label=title)
    ax.plot(x_line, lin.predict(x_line.reshape(-1, 1)), "k-", lw=2, label="Garis linear")
    ax.plot(x_line, poly.predict(x_line.reshape(-1, 1)), color="#27ae60", lw=2, label="Polinomial (flexibel)")
    ax.set_xlabel("Weight (contoh)")
    ax.set_ylabel("Height (contoh)")
    ax.set_title(title)
    ax.legend(fontsize=8)
plt.suptitle(
    f"RMSE uji — linear: {total_rmse(lin, x_test, y_test):.3f}  |  polinomial: {total_rmse(poly, x_test, y_test):.3f}",
    y=1.02,
    fontsize=10,
)
plt.tight_layout()
Gambar 1: Garis linear (hitam) vs polinomial derajat tinggi (hijau) pada latih (merah) dan uji (biru). Model fleksibel overfit — error total di uji jauh lebih besar.

Kesimpulan: pilih model berdasarkan error di Testing Data, bukan skor latih.

2.1 Protokol evaluasi

  1. Tetapkan metrik utama (dan metrik pendukung) sebelum melihat hasil uji.
  2. Pisahkan set latih / uji (atau validasi) — set uji dikhususkan untuk laporan akhir.
  3. Semua transformasi (skala, imputasi, encoding) → fit di set latih, transform di set uji (Pipeline).
  4. Tuning hiperparameter → cross-validation di latih, bukan mengulang skor test.

3 Metrik evaluasi regresi (9.1)

Regresi linear dilatih dengan meminimalkan jumlah kuadrat residual pada data latih; pada set uji kita mengukur seberapa dekat prediksi \(\hat{y}_i\) dengan nilai aktual \(y_i\). Selisih per observasi disebut residual:

\[ e_i = y_i - \hat{y}_i \]

Cara membaca notasi umum.

  • \(y_i\) — nilai target aktual observasi ke-\(i\) (contoh: harga rumah dalam juta Rp, konsumsi kWh).
  • \(\hat{y}_i\) — prediksi model untuk observasi yang sama (dibaca “y-hat”).
  • \(i = 1,\ldots,n\) — indeks observasi; \(n\) biasanya ukuran set uji (bukan latih).
  • \(e_i > 0\) → model underestimate (prediksi terlalu rendah); \(e_i < 0\) → overestimate.
import matplotlib.pyplot as plt
import numpy as np

rng = np.random.default_rng(42)
y = np.array([2.1, 3.0, 3.8, 5.2, 6.1, 7.0, 8.5, 9.2, 10.8, 12.0], dtype=float)
yhat = y + rng.normal(0, 0.45, size=len(y))
yhat[3] -= 1.1   # underestimate: ŷ di bawah garis identitas
yhat[8] += 1.4   # overestimate: ŷ di atas garis identitas

fig, ax = plt.subplots(figsize=(7, 6.5))
ax.scatter(
    y,
    yhat,
    s=90,
    color="#3498db",
    edgecolors="white",
    linewidths=0.8,
    zorder=3,
    label="Observasi $(y_i, \\hat{y}_i)$",
)

lo = min(y.min(), yhat.min()) - 0.6
hi = max(y.max(), yhat.max()) + 0.6
ax.plot([lo, hi], [lo, hi], "r--", linewidth=2, label="Prediksi sempurna ($y = \\hat{y}$)")

for yi, yhi in zip(y, yhat):
    ax.plot([yi, yi], [yhi, yi], color="#7f8c8d", linewidth=1.2, zorder=2)

for idx in [3, 8]:
    ei = y[idx] - yhat[idx]
    mid_y = (yhat[idx] + y[idx]) / 2
    ax.annotate(
        f"$e_{{{idx + 1}}} = {ei:+.1f}$",
        xy=(y[idx], mid_y),
        xytext=(10, 0),
        textcoords="offset points",
        fontsize=10,
        color="#2c3e50",
        arrowprops=dict(arrowstyle="-", color="#7f8c8d", lw=0.8),
    )

ax.set_xlabel("$y_i$ — nilai aktual")
ax.set_ylabel("$\\hat{y}_i$ — prediksi model")
ax.set_xlim(lo, hi)
ax.set_ylim(lo, hi)
ax.set_aspect("equal", adjustable="box")
ax.legend(loc="upper left", framealpha=0.95)
ax.set_title("Aktual vs prediksi — panjang garis vertikal = $|e_i|$")
plt.tight_layout()
Gambar 2: Scatter \(y_i\) vs \(\hat{y}_i\): garis putus-putus merah = prediksi sempurna (\(y = \hat{y}\)). Garis vertikal abu-abu = residual \(e_i = y_i - \hat{y}_i\); titik di bawah garis identitas → \(e_i > 0\) (underestimate), di atas → \(e_i < 0\) (overestimate).

Pada grafik di atas, semakin dekat titik ke garis identitas \(y = \hat{y}\), semakin kecil \(|e_i|\).

Tiga metrik agregat yang paling lazim: MAE, RMSE, dan \(R^2\).

3.1 Mean Absolute Error (MAE)

\[ \mathrm{MAE} = \frac{1}{n}\sum_{i=1}^n |y_i - \hat{y}_i| \]

Cara membaca rumus MAE. Jumlahkan nilai absolut selisih prediksi–aktual untuk semua observasi uji, lalu bagi \(n\) → rata-rata besar meleset tanpa mempedulikan arah ( atas/bawah).

Simbol Makna
\(\|y_i - \hat{y}_i\|\) kesalahan absolut observasi ke-\(i\); selalu \(\geq 0\)
\(\sum_{i=1}^n\) jumlahkan over \(n\) observasi uji
\(\frac{1}{n}\) rata-rata aritmetika → satuan MAE sama dengan \(y\)

Interpretasi. MAE = 50 (kWh) artinya rata-rata, prediksi meleset sekitar 50 kWh. Metrik ini robust terhadap outlier moderat (error besar dihitung linear).

Implementasi scikit-learn: mean_absolute_error(y_true, y_pred).

3.2 Root Mean Squared Error (RMSE)

\[ \mathrm{RMSE} = \sqrt{\frac{1}{n}\sum_{i=1}^n (y_i - \hat{y}_i)^2} \]

Cara membaca rumus RMSE. Kuadratkan setiap residual \((y_i - \hat{y}_i)^2\) (menghapus tanda ± sekaligus menghukum error besar lebih berat), rata-rata hasil kuadrat → Mean Squared Error (MSE), lalu ambil akar kuadrat agar satuan kembali sama dengan \(y\).

Simbol Makna
\((y_i - \hat{y}_i)^2\) kuadrat residual; error 10× lebih besar → kontribusi 100× lebih besar
\(\sqrt{\cdot}\) mengembalikan satuan ke satuan \(y\) (juta Rp, kWh, …)
MSE (tanpa akar) \(\mathrm{MSE} = \frac{1}{n}\sum (y_i - \hat{y}_i)^2\) — fungsi loss yang dioptimalkan OLS

Interpretasi. RMSE selalu \(\geq\) MAE. Jika RMSE jauh lebih besar dari MAE, ada prediksi ekstrem yang meleset — selaras dengan loss kuadrat yang dioptimalkan OLS/Ridge.

Implementasi scikit-learn: mean_squared_error(y_true, y_pred, squared=False) atau np.sqrt(mean_squared_error(...)).

3.3 Koefisien determinasi (\(R^2\))

\[ R^2 = 1 - \frac{\sum_i (y_i - \hat{y}_i)^2}{\sum_i (y_i - \bar{y})^2} \]

dengan \(\bar{y} = \frac{1}{n}\sum_i y_i\) = rata-rata target pada set yang sama (umumnya uji).

Cara membaca rumus \(R^2\). Bandingkan kesalahan kuadrat model (pembilang) dengan kesalahan kuadrat baseline “tebak rata-rata \(\bar{y}\) saja” (penyebut). Jika model jauh lebih baik dari baseline, rasio mendekati 0 dan \(R^2\) mendekati 1.

Simbol Makna
\(\sum_i (y_i - \hat{y}_i)^2\) SS\(_{\mathrm{res}}\) — total kuadrat residual model (sisa yang belum terjelaskan)
\(\sum_i (y_i - \bar{y})^2\) SS\(_{\mathrm{tot}}\) — total variasi \(y\) di sekitar rata-ratanya
\(1 - \frac{\mathrm{SS}_{\mathrm{res}}}{\mathrm{SS}_{\mathrm{tot}}}\) proporsi variansi target yang “terjelaskan” model relatif terhadap baseline konstan

Interpretasi skala.

  • \(R^2 = 1\) — prediksi sempurna pada set uji (residual nol).
  • \(R^2 = 0\) — setara dengan selalu memprediksi \(\bar{y}\).
  • \(R^2 < 0\) — model lebih buruk dari prediksi konstan \(\bar{y}\) (sering terjadi di uji jika overfitting berat atau distribusi bergeser).
  • \(R^2 = 0{,}85\) — bahasa awam: model menjelaskan ~85% variasi \(y\) dibandingkan baseline rata-rata, pada data yang diukur.

Jebakan penting.

  • Tanpa satuan — \(R^2\) tidak sebanding “50 kWh” atau “5 juta Rp”; hanya proporsi relatif.
  • Tidak comparable lintas dataset — \(R^2 = 0{,}9\) pada dataset A dan B tidak otomatis setara kesulitannya.
  • Latih vs uji — \(R^2\) tinggi di latih, rendah di uji → tanda overfitting.
  • Selalu laporkan di uji (atau CV), bukan hanya di latih.

Implementasi scikit-learn: r2_score(y_true, y_pred).

3.4 Perbandingan & contoh kasus

Metrik Satuan Sensitivitas Kapan diprioritaskan
MAE sama dengan \(y\) residual besar dihitung linear outlier moderat; laporan “rata-rata salah X rupiah/kWh”
RMSE sama dengan \(y\) residual besar dihukum kuadrat selaras dengan optimasi MSE; penalti ekstrem lebih berat
\(R^2\) tanpa satuan (skala 0–1, bisa negatif) proporsi varians terjelaskan perbandingan model pada dataset yang sama

MAE dan RMSE mengukur besar error (satuan \(y\)); \(R^2\) mengukur proporsi variasi relatif terhadap baseline — ketiganya melengkapi satu sama lain.

3.4.1 Contoh kasus 1 — Prediksi tagihan listrik rumah tangga (prioritas MAE)

Perusahaan utilitas melatih model regresi untuk memperkirakan konsumsi listrik bulan depan (satuan kWh). Manajer operasional ingin menjawab pertanyaan sederhana: “Rata-rata, prediksi kita meleset berapa kWh per pelanggan?” — bukan memaksimalkan penalti kuadrat.

Tabel berikut menampilkan delapan rumah tangga pada set uji (data sintetis dengan pola realistis; angka dibulatkan):

import numpy as np
import pandas as pd
from sklearn.metrics import mean_absolute_error, mean_squared_error

rng = np.random.default_rng(7)
aktual_kwh = np.array([210, 285, 340, 410, 520, 610, 780, 920], dtype=float)
# Model cukup baik; error kecil–sedang, tanpa outlier ekstrem
prediksi_kwh = aktual_kwh + rng.integers(-35, 36, size=len(aktual_kwh))

df_listrik = pd.DataFrame(
    {
        "ID pelanggan": [f"RT-{i:03d}" for i in range(1, 9)],
        "Aktual (kWh)": aktual_kwh.astype(int),
        "Prediksi (kWh)": prediksi_kwh.astype(int),
        "|Error| (kWh)": np.abs(aktual_kwh - prediksi_kwh).astype(int),
    }
)
mae1 = mean_absolute_error(aktual_kwh, prediksi_kwh)
rmse1 = float(np.sqrt(mean_squared_error(aktual_kwh, prediksi_kwh)))
df_listrik
Tabel 1: Contoh kasus 1 — prediksi konsumsi listrik (kWh/bulan): aktual vs prediksi model regresi.
ID pelanggan Aktual (kWh) Prediksi (kWh) |Error| (kWh)
0 RT-001 210 242 32
1 RT-002 285 294 9
2 RT-003 340 353 13
3 RT-004 410 438 28
4 RT-005 520 526 6
5 RT-006 610 630 20
6 RT-007 780 804 24
7 RT-008 920 900 20
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(10, 4))
ids = df_listrik["ID pelanggan"]
errs = df_listrik["|Error| (kWh)"]
axes[0].bar(ids, errs, color="#3498db", edgecolor="white")
axes[0].axhline(mae1, color="#e74c3c", linestyle="--", linewidth=1.5, label=f"MAE = {mae1:.0f} kWh")
axes[0].set_ylabel("Kesalahan absolut (kWh)")
axes[0].set_title("Tagihan listrik — |error| per pelanggan")
axes[0].tick_params(axis="x", rotation=45)
axes[0].legend()

metrics = ["MAE", "RMSE"]
vals = [mae1, rmse1]
colors = ["#3498db", "#9b59b6"]
axes[1].bar(metrics, vals, color=colors, edgecolor="white", width=0.5)
axes[1].set_ylabel("kWh")
axes[1].set_title(f"Metrik agregat (RMSE/MAE = {rmse1/mae1:.2f})")
for i, v in enumerate(vals):
    axes[1].text(i, v + 1.5, f"{v:.0f}", ha="center", fontsize=11)
plt.tight_layout()
Gambar 3: Kiri: |error| per pelanggan — skala linear, mudah dibaca stakeholder. Kanan: MAE vs RMSE; rasio RMSE/MAE ≈ 1,2 menandakan tidak ada outlier prediksi yang dominan.

Interpretasi: MAE (satuan kWh, sama dengan target) langsung terbaca sebagai rata-rata meleset per pelanggan. RMSE hanya sedikit di atas MAE — rasio RMSE/MAE mendekati 1 — sehingga tidak ada prediksi yang jauh melenceng. Untuk komunikasi ke manajemen operasional, MAE biasanya dipilih karena mudah dijelaskan tanpa rumus; metrik ini cocok ketika setiap kWh yang meleset diperlakukan hampir setara biayanya.

3.4.2 Contoh kasus 2 — Prediksi harga jual properti (RMSE mengekspos outlier)

Dua model (A dan B) dipakai memprediksi harga jual (juta Rp) pada 10 unit apartemen serupa. MAE keduanya hampir sama, tetapi RMSE model B jauh lebih besar — karena satu unit mewah diprediksi jauh di bawah harga pasar.

harga_aktual = np.array([420, 445, 460, 480, 495, 510, 525, 540, 555, 2800], dtype=float)
pred_model_a = np.array([435, 430, 470, 465, 505, 500, 515, 530, 545, 2650], dtype=float)
pred_model_b = np.array([430, 440, 455, 490, 488, 505, 520, 535, 550, 1200], dtype=float)

rows = []
for i in range(len(harga_aktual)):
    rows.append(
        {
            "Unit": f"U-{i+1}",
            "Aktual (jt Rp)": int(harga_aktual[i]),
            "Model A (jt Rp)": int(pred_model_a[i]),
            "|Error| A": int(abs(harga_aktual[i] - pred_model_a[i])),
            "Model B (jt Rp)": int(pred_model_b[i]),
            "|Error| B": int(abs(harga_aktual[i] - pred_model_b[i])),
        }
    )
df_properti = pd.DataFrame(rows)

def metrik(y, yhat):
    mae = mean_absolute_error(y, yhat)
    rmse = float(np.sqrt(mean_squared_error(y, yhat)))
    return mae, rmse

mae_a, rmse_a = metrik(harga_aktual, pred_model_a)
mae_b, rmse_b = metrik(harga_aktual, pred_model_b)
ringkasan = pd.DataFrame(
    {
        "Model": ["A", "B"],
        "MAE (jt Rp)": [mae_a, mae_b],
        "RMSE (jt Rp)": [rmse_a, rmse_b],
        "RMSE / MAE": [rmse_a / mae_a, rmse_b / mae_b],
    }
)
print("Ringkasan metrik:\n", ringkasan.round(1).to_string(index=False), "\n")
df_properti
Ringkasan metrik:
 Model  MAE (jt Rp)  RMSE (jt Rp)  RMSE / MAE
    A         25.5          48.8         1.9
    B        165.7         506.0         3.1 
Tabel 2: Contoh kasus 2 — prediksi harga jual properti (juta Rp): dua model dengan MAE mirip, RMSE berbeda.
Unit Aktual (jt Rp) Model A (jt Rp) |Error| A Model B (jt Rp) |Error| B
0 U-1 420 435 15 430 10
1 U-2 445 430 15 440 5
2 U-3 460 470 10 455 5
3 U-4 480 465 15 490 10
4 U-5 495 505 10 488 7
5 U-6 510 500 10 505 5
6 U-7 525 515 10 520 5
7 U-8 540 530 10 535 5
8 U-9 555 545 10 550 5
9 U-10 2800 2650 150 1200 1600
fig, axes = plt.subplots(1, 2, figsize=(10, 4.2))
units = df_properti["Unit"]
x = np.arange(len(units))
w = 0.35
axes[0].bar(x - w / 2, df_properti["|Error| A"], w, label="Model A", color="#2ecc71")
axes[0].bar(x + w / 2, df_properti["|Error| B"], w, label="Model B", color="#e67e22")
axes[0].set_xticks(x)
axes[0].set_xticklabels(units, rotation=45)
axes[0].set_ylabel("Kesalahan absolut (jt Rp)")
axes[0].set_title("Harga properti — |error| per unit")
axes[0].legend()

x2 = np.arange(2)
width = 0.35
axes[1].bar(x2 - width / 2, [mae_a, mae_b], width, label="MAE", color="#3498db")
axes[1].bar(x2 + width / 2, [rmse_a, rmse_b], width, label="RMSE", color="#e74c3c")
axes[1].set_xticks(x2)
axes[1].set_xticklabels(["Model A", "Model B"])
axes[1].set_ylabel("jt Rp")
axes[1].set_title("MAE mirip — RMSE model B melonjak")
axes[1].legend()
plt.tight_layout()
Gambar 4: Kiri: |error| per unit — unit U-10 (villa mewah) membuat model B meleset ekstrem. Kanan: MAE hampir sama, RMSE model B jauh lebih besar.

Interpretasi: Jika stakeholder hanya melihat MAE, model A dan B tampak setara. RMSE model B jauh lebih besar karena unit U-10 (villa senilai 2,8 M) diprediksi hanya 1,2 M — kesalahan 1,6 M yang fatal untuk penawaran atau penilaian agunan. Konteks seperti ini:

  • MAE → laporan “rata-rata meleset X juta” untuk mayoritas transaksi tipikal.
  • RMSE → alarm jika beberapa prediksi ekstrem tidak boleh dibiarkan (penalti kuadrat selaras dengan optimasi MSE dan risiko finansial besar).

Rasio RMSE / MAE ≈ 1 → error seragam; > 1,5 → ada outlier prediksi dominan.

3.5 Demo & visualisasi (California housing)

import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

housing = fetch_california_housing(as_frame=True)
X = housing.data
y = housing.target
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

def report_reg(name, y_true, y_pred):
    rmse = float(np.sqrt(mean_squared_error(y_true, y_pred)))
    mae = float(mean_absolute_error(y_true, y_pred))
    r2 = float(r2_score(y_true, y_pred))
    print(f"{name:22s} | RMSE={rmse:.4f} | MAE={mae:.4f} | R²={r2:.4f}")

y_mean = np.full_like(y_test, y_train.mean())
report_reg("Baseline (mean train)", y_test, y_mean)

ols = LinearRegression().fit(X_train, y_train)
report_reg("OLS (test)", y_test, ols.predict(X_test))

ridge = Pipeline(
    [("sc", StandardScaler()), ("m", Ridge(alpha=1.0))]
).fit(X_train, y_train)
report_reg("Ridge+scale (test)", y_test, ridge.predict(X_test))
Baseline (mean train)  | RMSE=1.1503 | MAE=0.9100 | R²=-0.0000
OLS (test)             | RMSE=0.7356 | MAE=0.5297 | R²=0.5911
Ridge+scale (test)     | RMSE=0.7356 | MAE=0.5297 | R²=0.5911

Interpretasi: baseline memberi lantai performa; model ML harus secara jelas mengalahkannya. Grafik berikut memakai model OLS yang sama:

import matplotlib.pyplot as plt

pred = ols.predict(X_test)
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
axes[0].scatter(y_test, pred, alpha=0.35, s=12)
lo, hi = y_test.min(), y_test.max()
axes[0].plot([lo, hi], [lo, hi], "r--", linewidth=1.5, label="y = ŷ")
axes[0].set_xlabel("y aktual (test)")
axes[0].set_ylabel("ŷ")
axes[0].set_title("Prediksi vs aktual — OLS")
axes[0].legend()

res = y_test - pred
axes[1].scatter(pred, res, alpha=0.35, s=12)
axes[1].axhline(0, color="red", linestyle="--")
axes[1].set_xlabel("ŷ")
axes[1].set_ylabel("Residual")
axes[1].set_title("Residual vs ŷ")
plt.tight_layout()
Gambar 5: Kiri: prediksi vs aktual. Kanan: residual vs prediksi — pola melengkung mengindikasikan miskalibrasi.

Awan titik mengikuti garis identitas → kalibrasi baik; residual berpola → pertimbangkan transformasi atau model lebih fleksibel.

4 Metrik evaluasi klasifikasi (9.2)

Latih beberapa kandidat model, lalu bandingkan dengan confusion matrix dan metrik turunannya.

4.1 Confusion matrix (klasifikasi biner)

Matriks disusun dengan baris = Actual (aktual), kolom = Predicted (prediksi). Untuk masalah biner (Yes/No):

Pred Yes (+) Pred No (−)
Actual Yes (+) TP (True Positive) FN (False Negative)
Actual No (−) FP (False Positive) TN (True Negative)

Cara membaca:

  • TP — aktual Yes, prediksi Yes → benar mengenali positif.
  • FN — aktual Yes, prediksi No → positif terlewat.
  • TN — aktual No, prediksi No → benar mengenali negatif.
  • FP — aktual No, prediksi Yes → alarm palsu.

Pada multi-kelas, matriks \(C \times C\): baris = aktual, kolom = prediksi; diagonal = benar per kelas.

Bahasa awam: bayangkan skrining penyakit — diagonal = tepat sasaran; FN (positif terlewat) sering lebih berbahaya daripada FP (alarm palsu), tergantung konteks. Akurasi saja menyesatkan pada kelas tidak seimbang: model yang selalu prediksi kelas mayoritas bisa tampak akurat tetapi gagal menemukan minoritas.

4.2 Metrik dari confusion matrix

Empat sel confusion matrix (TP, FN, FP, TN) dapat dirangkum menjadi satu angka agar mudah dibandingkan model. Setiap metrik menjawab pertanyaan berbeda — tidak ada satu metrik yang selalu “paling benar”.

Kunci membaca: perhatikan pembilang (bagian atas pecahan) dan penyebut (bagian bawah). Pembilang = “berapa yang benar menurut definisi metrik”; penyebut = “dari populasi mana kita menghitung proporsi”.

4.2.1 Accuracy (akurasi)

\[ \mathrm{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN} \]

Cara membaca rumus. Jumlahkan semua prediksi benar (TP + TN), bagi total semua observasi uji.

Simbol Makna
\(TP + TN\) semua keputusan model yang tepat (positif benar + negatif benar)
\(TP + TN + FP + FN\) ukuran set uji \(n\)

Interpretasi. Accuracy = 0,92 artinya 92% baris uji diklasifikasi benar. Mudah dipahami stakeholder, tetapi menyesatkan jika kelas tidak seimbang: model yang hampir selalu memprediksi kelas mayoritas bisa accuracy tinggi sambil gagal total pada kelas minoritas (lihat Kasus 5 di latihan).

Implementasi: accuracy_score(y_true, y_pred).

4.2.2 Precision (presisi)

\[ \mathrm{Precision} = \frac{TP}{TP + FP} \]

Cara membaca rumus. Dari semua observasi yang model labeli positif (\(TP + FP\)), berapa proporsi yang benar-benar positif (\(TP\))?

Simbol Makna
\(TP\) prediksi positif yang tepat
\(TP + FP\) semua prediksi positif (benar + alarm palsu)

Bahasa awam: “Jika model bilang YA, seberapa sering YA itu benar?” — fokus pada kepercayaan terhadap alarm positif.

Contoh angka: \(TP = 90\), \(FP = 10\) → Precision \(= 90/100 = 0{,}90\). Dari 100 kali model bilang “positif”, 90 kali memang positif; 10 kali FP (alarm palsu).

Kapan diprioritaskan: biaya FP tinggi — email penting salah masuk spam, iklan salah ke pengguna premium, penahanan tanpa bukti. Naikkan precision biasanya dengan threshold lebih tinggi atau model yang lebih konservatif memprediksi positif.

Implementasi: precision_score(y_true, y_pred) — untuk kelas positif biner (label 1).

4.2.3 Recall = Sensitivity (sensitivitas / recall)

\[ \mathrm{Recall} = \frac{TP}{TP + FN} = \mathrm{Sensitivity} \]

Cara membaca rumus. Dari semua observasi yang benar-benar positif di dunia nyata (\(TP + FN\)), berapa yang berhasil ditangkap model (\(TP\))?

Simbol Makna
\(TP\) aktual positif yang terdeteksi
\(TP + FN\) semua aktual positif (terdeteksi + terlewat)

Bahasa awam: “Dari semua yang memang positif, berapa persen yang kita dapat?” — fokus pada kelengkapan penangkapan kelas positif, bukan pada prediksi positif model.

Contoh angka: \(TP = 80\), \(FN = 20\) → Recall \(= 80/100 = 0{,}80\). Ada 100 kasus positif nyata; model hanya menemukan 80; 20 FN (terlewat).

Kapan diprioritaskan: biaya FN tinggi — penyakit tidak terdiagnosis, fraud terlewat, kebocoran keamanan. Naikkan recall dengan threshold lebih rendah atau model yang lebih agresif memprediksi positif.

Catatan istilah: Recall (istilah ML) dan Sensitivity (istilah kedokteran / uji diagnostik) = rumus identik.

Implementasi: recall_score(y_true, y_pred) ≡ sensitivity.

4.2.4 Specificity (spesifisitas)

\[ \mathrm{Specificity} = \frac{TN}{TN + FP} \]

Cara membaca rumus. Dari semua observasi yang benar-benar negatif (\(TN + FP\)), berapa yang benar dikenali sebagai negatif (\(TN\))?

Simbol Makna
\(TN\) aktual negatif yang tepat diprediksi negatif
\(TN + FP\) semua aktual negatif (benar + salah dinyatakan positif)

Bahasa awam: “Dari semua yang memang negatif, seberapa sering model bilang TIDAK dengan benar?” — kebalikan dari FPR (False Positive Rate): \(\mathrm{FPR} = FP/(FP+TN) = 1 - \mathrm{Specificity}\).

Contoh angka: \(TN = 950\), \(FP = 50\) → Specificity \(= 950/1000 = 0{,}95\). Dari 1000 yang sehat, 950 benar dinyatakan sehat; 50 FP.

Kapan diprioritaskan: penting memastikan negatif yang sehat tidak salah masuk jalur positif — rule-out sebelum tindakan invasif, atau menjaga pengalaman pengguna mayoritas yang bukan target kampanye.

Pasangan dengan Recall: Recall menjaga positif tidak terlewat; Specificity menjaga negatif tidak salah positif. Keduanya bisa trade-off saat threshold digeser.

4.2.5 \(F_1\)-score (harmonic mean precision–recall)

\[ F_1 = 2 \cdot \frac{\mathrm{Precision} \cdot \mathrm{Recall}}{\mathrm{Precision} + \mathrm{Recall}} \]

Cara membaca rumus. \(F_1\) adalah rata-rata harmonik precision dan recall — lebih berat menghukum jika salah satu sangat rendah (berbeda dari rata-rata aritmetika biasa).

Situasi Precision Recall \(F_1\) (kira-kira)
Seimbang baik 0,80 0,80 0,80
Precision tinggi, recall rendah 0,95 0,40 ≈ 0,56
Recall tinggi, precision rendah 0,50 0,95 ≈ 0,66

Interpretasi. \(F_1 = 0{,}75\) artinya precision dan recall berada pada keseimbangan yang cukup untuk kelas positif — berguna saat Anda ingin satu angka perbandingan model dan kelas tidak terlalu seimbang (accuracy menipu).

Kapan diprioritaskan: tidak tahu pasti mana yang lebih mahal antara FP dan FN, tetapi keduanya sama-sama penting; juga lazim pada imbalanced classification sebagai pengganti accuracy.

Implementasi: f1_score(y_true, y_pred); multi-kelas: average="macro"|"weighted".

4.2.6 Ringkas: pertanyaan yang dijawab setiap metrik

Metrik Pertanyaan inti “Dunia” yang dihitung
Accuracy Berapa % semua prediksi benar? seluruh uji
Precision Prediksi positif kita seberapa bisa dipercaya? subkumpulan prediksi +
Recall / Sensitivity Aktual positif seberapa banyak tertangkap? subkumpulan aktual +
Specificity Aktual negatif seberapa sering benar? subkumpulan aktual −
\(F_1\) Keseimbangan precision & recall pada +? kelas positif (agregat)

Memilih metrik: Precision jika FP mahal; Recall jika FN mahal; Specificity jika menjaga negatif benar sangat penting; \(F_1\) jika perlu ringkasan seimbang; Accuracy hanya jika kelas relatif seimbang dan biaya kesalahan simetris.

4.2.7 Contoh perbandingan dua model

Model TP FN FP TN
Naive Bayes 142 22 29 110
Logistic Regression 137 22 29 115

Dengan FN dan FP sama, Naive Bayes unggul di TP, Logistic Regression di TN. Jika keempat sel berbeda, bandingkan Sensitivity, Specificity, dan Precision.

4.3 Demo: data tidak seimbang

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
    accuracy_score,
    classification_report,
    confusion_matrix,
    f1_score,
    precision_score,
    recall_score,
)
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

X, y = make_classification(
    n_samples=4000,
    n_features=12,
    weights=[0.92, 0.08],
    random_state=42,
)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, stratify=y, random_state=42
)
clf = Pipeline(
    [("sc", StandardScaler()), ("m", LogisticRegression(max_iter=500))]
).fit(X_train, y_train)
pred = clf.predict(X_test)

print("Confusion matrix (baris=aktual, kol=pred):\n", confusion_matrix(y_test, pred))
print("Accuracy:", round(accuracy_score(y_test, pred), 4))
print("Precision (+):", round(precision_score(y_test, pred), 4))
print("Recall (+):", round(recall_score(y_test, pred), 4))
print("F1 (+):", round(f1_score(y_test, pred), 4))
print("\n", classification_report(y_test, pred, digits=3))
Confusion matrix (baris=aktual, kol=pred):
 [[911   4]
 [ 25  60]]
Accuracy: 0.971
Precision (+): 0.9375
Recall (+): 0.7059
F1 (+): 0.8054

               precision    recall  f1-score   support

           0      0.973     0.996     0.984       915
           1      0.938     0.706     0.805        85

    accuracy                          0.971      1000
   macro avg      0.955     0.851     0.895      1000
weighted avg      0.970     0.971     0.969      1000

Perhatikan recall kelas minoritas — sering lebih relevan daripada akurasi mentah.

4.4 Visual confusion matrix (Breast cancer)

import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC

data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.25, stratify=data.target, random_state=42
)
clf = SVC(kernel="linear", C=1.0).fit(X_train, y_train)
pred = clf.predict(X_test)
fig, ax = plt.subplots(figsize=(5.5, 4.5))
ConfusionMatrixDisplay.from_predictions(
    y_test, pred, display_labels=data.target_names
).plot(ax=ax, cmap="Purples", colorbar=False)
ax.set_title("Confusion matrix — SVM linear (test)")
plt.tight_layout()
(a) Confusion matrix SVM linear pada set uji Breast cancer Wisconsin.
(b)
Gambar 6

4.5 Multi-kelas: macro vs weighted F1

  • F1-macro: rata-rata F1 per kelas (bobot sama) — adil jika setiap kelas sama penting.
  • F1-weighted: rata-rata berbobot ukuran kelas — mendekati akurasi jika kelas besar dominan.

sklearn.metrics.f1_score(..., average="macro"|"weighted"|"micro")

Micro-F1 pada multi-kelas sering setara dengan akurasi jika setiap observasi satu label.

4.6 Memilih metrik — contoh domain

Konteks Metrik yang sering diprioritaskan
Harga / permintaan (regresi) RMSE + MAE; \(R^2\) sebagai pelengkap
Deteksi fraud / penyakit Recall kelas positif, F1; PR-AUC jika kelas sangat langka
Filter spam / rekomendasi iklan Precision (kurangi gangguan FP)
Klasifikasi multi-kelas seimbang F1-macro, confusion matrix per kelas
Model probabilistik / ranking skor ROC & AUC; lalu precision/recall pada threshold operasional

4.7 ROC curve & AUC (klasifikasi probabilistik)

Metrik precision, recall, dan F1 di atas mengasumsikan keputusan biner sudah dibuat (mis. predict() dengan ambang default 0,5). Banyak model klasifikasi modern — Logistic Regression, Random Forest, Gradient Boosting, jaringan saraf — justru mengeluarkan skor atau probabilitas \(P(Y=1 \mid x) \in [0,1]\). Pertanyaan evaluasi bergeser:

  1. Seberapa baik skor memisahkan kelas positif dan negatif (tanpa memilih satu ambang)?
  2. Jika bisnis memilih ambang tertentu, berapa TPR, FPR, precision, dan recall di titik itu?

ROC (Receiver Operating Characteristic) dan AUC menjawab pertanyaan (1). Pertanyaan (2) tetap memakai confusion matrix pada threshold yang dipilih.

4.7.1 Dari skor ke label: peran threshold

Aturan umum (kelas positif = 1):

\[ \hat{y} = \begin{cases} 1 & \text{jika } P(Y{=}1 \mid x) \geq \tau \\ 0 & \text{jika } P(Y{=}1 \mid x) < \tau \end{cases} \]

\(\tau\) = threshold (ambang). Default scikit-learn: \(\tau = 0{,}5\), tetapi \(\tau\) bisa diturunkan (lebih banyak prediksi positif → recall naik, FP naik) atau dinaikkan (precision naik, FN naik).

\(\tau\) Efek umum Contoh konteks
Rendah (0,2) Recall ↑, FP ↑ skrining penyakit — jangan lewatkan kasus
Sedang (0,5) kompromi default eksplorasi awal
Tinggi (0,8) Precision ↑, FN ↑ spam filter — hindari blok email penting

Setiap \(\tau\) menghasilkan confusion matrix berbeda → precision/recall/F1 berbeda. ROC merangkum performa seluruh rentang \(\tau\) dalam satu kurva.

4.7.2 TPR dan FPR — sumbu kurva ROC

Dari confusion matrix pada threshold \(\tau\):

\[ \mathrm{TPR}(\tau) = \frac{TP}{TP + FN} = \mathrm{Recall} = \mathrm{Sensitivity} \]

\[ \mathrm{FPR}(\tau) = \frac{FP}{FP + TN} = 1 - \mathrm{Specificity} \]

Sumbu ROC Alias Pertanyaan yang dijawab
TPR (vertikal) Sensitivity, Recall Berapa proporsi aktual positif yang tertangkap?
FPR (horizontal) \(1 -\) Specificity Berapa proporsi aktual negatif yang salah dinyatakan positif?

Cara membangun kurva ROC (konseptual):

  1. Urutkan observasi uji menurut skor \(P(Y{=}1 \mid x)\) menurun.
  2. Geser \(\tau\) dari 1 → 0; setiap perubahan \(\tau\) yang memindahkan satu titik dari negatif ke positif (atau sebaliknya) menambah satu titik \((\mathrm{FPR}, \mathrm{TPR})\).
  3. Hubungkan titik-titik → kurva ROC. Titik (0, 0) = tidak ada yang diprediksi positif; (1, 1) = semua diprediksi positif.

Garis diagonal dari (0,0) ke (1,1) = klasifikator acak (AUC = 0,5). Kurva menjauhi diagonal ke kiri-atas = pemisahan lebih baik.

4.7.3 AUC — luas di bawah kurva ROC

\[ \mathrm{AUC} = \int_0^1 \mathrm{TPR}(\mathrm{FPR})\, d(\mathrm{FPR}) \]

Pada praktik dihitung numerik dari pasangan \((\mathrm{FPR}, \mathrm{TPR})\) — sklearn.metrics.auc(fpr, tpr) atau roc_auc_score(y_true, y_score).

AUC Interpretasi praktis
1,0 pemisahan sempurna (jarang di data nyata)
0,9 – 1,0 sangat baik
0,8 – 0,9 baik
0,7 – 0,8 cukup / usable tergantung domain
0,5 tidak lebih baik dari tebak acak
< 0,5 lebih buruk dari acak (skor terbalik — cek encoding label)

Bahasa probabilitas (opsional): AUC ≈ probabilitas bahwa skor observasi positif acak lebih tinggi dari skor observasi negatif acak — ukuran ranking kelas.

Yang AUC tidak beri tahu: precision, biaya FP/FN, atau metrik pada satu threshold operasional. Setelah membandingkan model dengan AUC, tetap pilih \(\tau\) sesuai kebijakan bisnis dan laporkan confusion matrix / precision / recall di titik itu.

4.7.4 Demo: kurva ROC & perbandingan AUC (Breast cancer)

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (
    RocCurveDisplay,
    auc,
    confusion_matrix,
    precision_score,
    recall_score,
    roc_auc_score,
    roc_curve,
)
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data,
    data.target,
    test_size=0.25,
    stratify=data.target,
    random_state=42,
)

lr = Pipeline(
    [("sc", StandardScaler()), ("m", LogisticRegression(max_iter=1000))]
).fit(X_train, y_train)
proba_lr = lr.predict_proba(X_test)[:, 1]

dummy = DummyClassifier(strategy="stratified", random_state=42).fit(X_train, y_train)
proba_dummy = dummy.predict_proba(X_test)[:, 1]

fpr_lr, tpr_lr, thr_lr = roc_curve(y_test, proba_lr)
fpr_dum, tpr_dum, _ = roc_curve(y_test, proba_dummy)
auc_lr = roc_auc_score(y_test, proba_lr)
auc_dum = roc_auc_score(y_test, proba_dummy)

fig, axes = plt.subplots(1, 2, figsize=(10, 4.5))
RocCurveDisplay(fpr=fpr_lr, tpr=tpr_lr, roc_auc=auc_lr, name="Logistic Regression").plot(
    ax=axes[0], curve_kwargs={"color": "#2980b9"}
)
RocCurveDisplay(fpr=fpr_dum, tpr=tpr_dum, roc_auc=auc_dum, name="Dummy (acak)").plot(
    ax=axes[0], curve_kwargs={"color": "#95a5a6"}
)
axes[0].plot([0, 1], [0, 1], "k--", linewidth=1, label="Acak (AUC=0,5)")
axes[0].set_title("Kurva ROC — Breast cancer (test)")
axes[0].legend(loc="lower right", fontsize=8)

rows = []
for tau in [0.3, 0.5, 0.7]:
    pred = (proba_lr >= tau).astype(int)
    tn, fp, fn, tp = confusion_matrix(y_test, pred).ravel()
    rows.append(
        {
            "Threshold τ": tau,
            "TPR (Recall)": round(recall_score(y_test, pred), 3),
            "FPR": round(fp / (fp + tn), 3),
            "Precision": round(precision_score(y_test, pred), 3),
            "TP": tp,
            "FP": fp,
            "FN": fn,
            "TN": tn,
        }
    )
df_thr = pd.DataFrame(rows)
axes[1].axis("off")
axes[1].set_title(f"Logistic Regression — AUC = {auc_lr:.3f}")
tbl = axes[1].table(
    cellText=df_thr.values,
    colLabels=df_thr.columns,
    loc="center",
    cellLoc="center",
)
tbl.auto_set_font_size(False)
tbl.set_fontsize(8)
tbl.scale(1.1, 1.4)
plt.tight_layout()
df_thr
Threshold τ TPR (Recall) FPR Precision TP FP FN TN
0 0.3 1.000 0.057 0.968 90 3 0 50
1 0.5 0.989 0.019 0.989 89 1 1 52
2 0.7 0.933 0.019 0.988 84 1 6 52

Kiri: kurva ROC Logistic Regression vs Dummy (acak) pada uji Breast cancer. Kanan: AUC dan metrik pada tiga threshold untuk model terbaik.

Interpretasi demo:

  • AUC Logistic Regression jauh di atas 0,5 dan di atas dummy → skor probabilitas memisahkan malignan vs benign dengan baik.
  • Kurva ROC di kiri: semakin ke kiri-atas, semakin baik. Dummy mengikuti diagonal → AUC ≈ 0,5.
  • Tabel threshold: \(\tau = 0{,}3\) → TPR tinggi (lebih banyak malignan tertangkap) tetapi FPR naik; \(\tau = 0{,}7\) → Precision naik, FN naik. Tidak ada \(\tau\) “terbaik” tanpa konteks biaya.
fig, ax = plt.subplots(figsize=(6, 5))
ax.plot(fpr_lr, tpr_lr, color="#2980b9", lw=2, label=f"LR (AUC={auc_lr:.3f})")
ax.plot([0, 1], [0, 1], "k--", lw=1, label="Acak")
for tau, marker, c in [(0.3, "o", "#e74c3c"), (0.5, "s", "#27ae60"), (0.7, "^", "#8e44ad")]:
    pred = (proba_lr >= tau).astype(int)
    fpr_t = confusion_matrix(y_test, pred).ravel()
    tn, fp, fn, tp = fpr_t
    fpr_val = fp / (fp + tn)
    tpr_val = tp / (tp + fn)
    ax.scatter(fpr_val, tpr_val, s=120, marker=marker, color=c, zorder=5, edgecolors="white")
    ax.annotate(f"τ={tau}", (fpr_val, tpr_val), textcoords="offset points", xytext=(8, 6), fontsize=9)
ax.set_xlabel("False Positive Rate (FPR)")
ax.set_ylabel("True Positive Rate (TPR = Recall)")
ax.set_title("Titik operasional pada kurva ROC")
ax.legend(loc="lower right")
ax.set_xlim(-0.02, 1.02)
ax.set_ylim(-0.02, 1.02)
plt.tight_layout()
Gambar 7: Tiga titik operasional pada kurva ROC (τ = 0,3, 0,5, 0,7) — setiap titik = pasangan (FPR, TPR) dari tabel di atas.

4.7.5 Memilih threshold setelah melihat ROC

Alur yang disarankan:

  1. Bandingkan model dengan AUC (atau kurva ROC) pada set uji yang sama — model dengan AUC lebih tinggi biasanya ranking skor lebih baik.
  2. Tentukan \(\tau\) operasional dari kebijakan bisnis (biaya FN vs FP, kuota intervensi manusia, dll.) — bisa dengan memindai tabel precision/recall per \(\tau\) atau kurva precision–recall.
  3. Laporkan confusion matrix dan metrik hanya pada \(\tau\) terpilih untuk stakeholder operasional.

Implementasi scikit-learn:

  • roc_curve(y_true, y_score) → fpr, tpr, thresholds
  • roc_auc_score(y_true, y_score)
  • RocCurveDisplay.from_estimator(estimator, X, y) / from_predictions(y, y_score)

4.7.6 ROC vs kurva Precision–Recall (PR)

Aspek ROC + AUC PR + AUC (PR-AUC)
Sumbu TPR vs FPR Precision vs Recall
Kelas sangat tidak seimbang FPR bisa terlihat kecil meski banyak FP absolut sering lebih informatif
Kapan diprioritaskan perbandingan model ranking umum deteksi langka (fraud, penyakit)

Keduanya melengkapi: AUC-ROC untuk membandingkan pemisahan skor; PR-AUC jika kelas positif jarang dan Anda peduli pada precision pada recall tinggi.

4.7.7 Jebakan ROC/AUC

  • AUC tinggi ≠ model siap produksi — tetap validasi pada threshold dan subset bisnis.
  • Data leakage pada skor → AUC optimis; pipeline harus fit hanya di latih.
  • Kelas tidak seimbang — AUC-ROC bisa tetap tinggi sementara precision rendah; baca PR curve atau metrik pada \(\tau\) operasional.
  • Multi-kelas — gunakan ROC one-vs-rest per kelas atau metrik macro; materi inti DS-11 fokus biner.

5 Latihan pembacaan: 10 contoh kasus metrik evaluasi

Sepuluh skenario berikut memakai data uji sintetis (angka dibulatkan agar mudah dilacak). Setiap kasus menampilkan data mentah atau confusion matrix, metrik yang relevan, lalu interpretasi dalam bahasa operasional. Gunakan sebagai latihan setelah bab 9.1–9.2; contoh regresi mendalam (listrik & properti) tetap ada di atas.

Ringkasan numerik — verifikasi hitungan 10 contoh kasus (sel tidak ditampilkan di narasi).
Kasus MAE RMSE RMSE/MAE R² Accuracy Precision Recall F1 Specificity
0 1 MAE pengiriman 3.67 4.73 1.29 0.920 NaN NaN NaN NaN NaN
1 2 RMSE gaji 10.97 26.54 2.42 0.415 NaN NaN NaN NaN NaN
2 3 R² baik 3.80 4.07 1.07 0.997 NaN NaN NaN NaN NaN
3 4 R² negatif 24.00 28.28 1.18 -3.000 NaN NaN NaN NaN NaN
4 5 klasifikasi NaN NaN NaN NaN 0.900 0.600 0.273 0.375 0.978
5 6 klasifikasi NaN NaN NaN NaN 0.945 0.989 0.450 0.619 0.999
6 7 klasifikasi NaN NaN NaN NaN 0.981 0.760 0.950 0.844 0.982
7 8 klasifikasi NaN NaN NaN NaN 0.950 0.800 0.727 0.762 0.978
8 9 klasifikasi NaN NaN NaN NaN 0.982 0.118 0.400 0.182 0.985

5.1 Kasus 1 — Membaca MAE (estimasi waktu pengiriman)

Konteks: Kurir memprediksi waktu tiba paket (menit) untuk enam pengiriman same-day.

ID Aktual (menit) Prediksi (menit) |Error| (menit)
P-01 32 30 2
P-02 48 52 4
P-03 55 54 1
P-04 61 58 3
P-05 70 68 2
P-06 85 95 10
Metrik (uji) Nilai
MAE 3,7 menit
RMSE 4,7 menit

Interpretasi: MAE ≈ 3,7 menit berarti rata-rata prediksi meleset sekitar 3–4 menit per paket — mudah disampaikan ke operasional (“biasanya salah kurang dari 5 menit”). Satu pengiriman (P-06) meleset 10 menit; MAE tetap moderat karena error besar dihitung linear. RMSE hanya sedikit di atas MAE → tidak ada satu prediksi yang mendominasi keseluruhan.


5.2 Kasus 2 — RMSE vs MAE (prediksi gaji karyawan baru)

Konteks: HR memprediksi gaji awal (juta Rp). Mayoritas karyawan junior (5–9 juta); satu outlier direktur (100 juta) diprediksi jauh terlalu rendah.

ID Aktual (jt) Prediksi (jt) |Error| (jt)
K-01 … K-05 5–9 5,2–9,1 0,1–0,2
K-06 100 35 65
Metrik Nilai
MAE ≈ 11,0 jt
RMSE ≈ 26,5 jt
RMSE / MAE ≈ 2,4

Interpretasi: MAE ≈ 11 jt terdengar “lumayan” meski lima karyawan hampir tepat — karena satu kesalahan 65 jt ikut dirata-rata secara linear. RMSE ≈ 26,5 jt jauh lebih besar: kuadrat error 65 jt mendominasi. Rasio RMSE/MAE > 2 adalah sinyal outlier prediksi; stakeholder risiko kompensasi harus melihat RMSE (ataun residual terbesar), bukan hanya MAE.


5.3 Kasus 3 — Membaca \(R^2\) tinggi (penjualan harian toko)

Konteks: Model regresi memprediksi penjualan harian (juta Rp) pada lima hari uji; pola naik linier.

Hari Aktual Prediksi
Sen 100 105
Sel 150 148
Rab 200 205
Kam 250 248
Jum 300 295
\(R^2\) (uji) ≈ 0,997

Interpretasi: \(R^2\) mendekati 1 → model menjelaskan hampir seluruh variasi penjualan di set uji ini, jauh lebih baik daripada baseline “tebak rata-rata”. Tetap ingat: \(R^2\) tanpa satuan — tidak menggantikan MAE/RMSE untuk “salah berapa juta per hari”. Laporkan juga MAE/RMSE jika keputusan operasional butuh satuan rupiah.


5.4 Kasus 4 — \(R^2\) negatif (model salah arah di uji)

Konteks: Model yang overfit di latih dipakai pada uji dengan pola berbeda; prediksi hampir terbalik terhadap aktual.

Obs. Aktual Prediksi
1–5 10 → 50 (naik) 50 → 10 (turun)
\(R^2\) (uji) ≈ −3,5

Interpretasi: \(R^2 < 0\) artinya model lebih buruk daripada selalu memprediksi \(\bar{y}\) pada set uji. Ini bukan “sedikit kurang bagus”, melainkan gagal generalisasi — cek distribusi latih/uji, leakage, atau model terlalu kompleks. Jangan membandingkan \(R^2\) negatif ini dengan \(R^2\) = 0,85 di dataset lain.


5.5 Kasus 5 — Akurasi menyesatkan (gagal bayar kredit)

Konteks: 1.000 nasabah uji; 9% gagal bayar (kelas positif = risiko). Model jarang memprediksi “gagal bayar”.

Pred. gagal (+) Pred. lancar (−)
Aktual gagal (+) TP = 30 FN = 80
Aktual lancar (−) FP = 20 TN = 870
Metrik Nilai
Accuracy 90,0%
Recall (+) 27,3%
Precision (+) 60,0%

Interpretasi: Akurasi 90% terdengar bagus karena mayoritas lancar. Namun Recall = 27,3% → dari 110 yang benar-benar gagal bayar, model hanya menangkap 30; 80 terlewat (FN). Untuk mitigasi kredit, recall kelas risiko (atau F1) lebih relevan daripada akurasi. Model “selalu lancar” bisa mencapil ~91% akurasi tanpa nilai bisnis.


5.6 Kasus 6 — Prioritas Precision (filter spam email)

Konteks: 10.000 email uji; 10% spam. Salah klasifikasi email penting sebagai spam (FP) sangat merugikan.

Pred. spam (+) Pred. bukan spam (−)
Aktual spam (+) TP = 450 FN = 550
Aktual bukan spam (−) FP = 5 TN = 8.995
Metrik Nilai
Precision (+) ≈ 98,9%
Recall (+) 45,0%
Accuracy 94,5%

Interpretasi: Precision ≈ 99% → hampir semua yang dilabel spam memang spam; hanya 5 FP dari ribuan email penting. Trade-off: Recall 45% → lebih dari setengah spam lolos (FN). Untuk kotak masuk eksekutif, precision tinggi bisa diterima; untuk keamanan massal, naikkan recall (threshold lebih rendah) meski FP naik.


5.7 Kasus 7 — Prioritas Recall (skrining penyakit dini)

Konteks: 10.000 pasien uji; 5% positif penyakit. FN (sakit tetapi dinyatakan sehat) berisiko tinggi.

Pred. positif (+) Pred. negatif (−)
Aktual positif (+) TP = 475 FN = 25
Aktual negatif (−) FP = 150 TN = 8.350
Metrik Nilai
Recall (Sensitivity) 95,0%
Precision (+) 76,0%
Specificity 98,2%

Interpretasi: Recall 95% → 475 dari 500 kasus positif tertangkap; 25 FN masih perlu tindak lanjut protokol. Precision 76% → sekitar seperempat alarm positif palsu (150 FP); biaya tes lanjutan vs biaya melewatkan penyakit menentukan ambang. Specificity 98,2% tinggi — sehat yang sehat jarang salah dinyatakan sakit.


5.8 Kasus 8 — Menghitung & membaca \(F_1\) (shortlist kandidat)

Konteks: 500 lamaran uji; 11% diterima (positif). HR ingin keseimbangan antara FP (interview sia-sia) dan FN (talenta terlewat).

Pred. terima (+) Pred. tolak (−)
Aktual terima (+) TP = 40 FN = 15
Aktual tolak (−) FP = 10 TN = 435
Metrik Nilai
Precision (+) 80,0%
Recall (+) 72,7%
\(F_1\) ≈ 0,76

Interpretasi: \(F_1 = 2 \cdot \frac{0{,}80 \times 0{,}727}{0{,}80 + 0{,}727} \approx 0{,}76\) merangkum kompromi precision–recall pada kelas positif. Akurasi \((40+435)/500 = 95\%\) tinggi tetapi menutupi performa pada 55 kandidat “layak” (40+15). Bandingkan dua model dengan \(F_1\) (bukan akurasi saja) jika kelas tidak seimbang.


5.9 Kasus 9 — Membaca Specificity (tes konfirmasi langka)

Konteks: Penyakit sangat langka (0,5% prevalensi di uji). Tes dipakai untuk memastikan pasien sehat bisa dipulangkan (rule-out).

Pred. positif (+) Pred. negatif (−)
Aktual positif (+) TP = 2 FN = 3
Aktual negatif (−) FP = 15 TN = 980
Metrik Nilai
Specificity ≈ 98,5%
Recall (Sensitivity) 40,0%
Precision (+) ≈ 11,8%

Interpretasi: Specificity 98,5% → dari 995 yang benar-benar negatif, 980 dikenali benar; 15 FP (positif palsu). Recall hanya 40% → banyak kasus positif terlewat; tes ini bukan skrining sensitif tinggi. Precision 11,8% rendah karena positif langka — banyak alarm palsu meski specificity tinggi. Pilih metrik sesuai peran tes: rule-out (specificity) vs skrining massal (recall).


5.10 Kasus 10 — Membaca ROC-AUC (dua model scoring kredit)

Konteks: Dua model memberi skor risiko (0–1); evaluasi dengan AUC pada set uji yang sama (lihat bab ROC curve & AUC di atas untuk definisi TPR/FPR dan kurva).

Model AUC Threshold operasional Recall @ threshold FPR @ threshold
A — Gradient boosting 0,91 0,35 0,88 0,08
B — Regresi logistik 0,73 0,35 0,62 0,22

Interpretasi: AUC mengukur pemisahan kelas di semua ambang, bukan satu keputusan biner. AUC 0,91 (A) >> 0,73 (B) → skor A lebih konsisten menempatkan gagal bayar di atas lancar. Pada threshold sama (0,35), A lebih tinggi recall dengan FPR lebih rendah — selaras dengan AUC lebih besar. AUC ≈ 0,5 setara tebak acak; 0,73 usable tetapi lemah dibanding A. Tetap validasi precision/recall pada threshold bisnis yang dipilih, karena AUC tidak menggantikan biaya FP vs FN.


Ringkas latihan: regresi → utamakan MAE (laporan satuan), RMSE (outlier), \(R^2\) (proporsi variasi, satu dataset); klasifikasi → baca confusion matrix dulu, lalu metrik yang selaras biaya (precision, recall, \(F_1\), specificity); pemisahan skor → AUC + metrik pada threshold operasional.

6 Cross-validation (9.3)

Satu pembagian latih/uji acak bisa keberuntungan. Cross-validation (CV) memecah set latih menjadi lipatan: setiap iterasi satu lipatan = validasi, sisanya = latih; diulang sampai setiap lipatan pernah jadi validasi. Rata-rata skor antar lipatan memberi estimasi lebih stabil; set uji tetap disimpan untuk laporan akhir sekali.

Manfaat: (1) estimasi performa lebih andal, (2) tuning hiperparameter tanpa menyentuh set uji, (3) mendeteksi varians tinggi antar lipatan.

6.1 Skema k-fold

import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import numpy as np

k = 5
n = 20
fold_size = n // k
train_color = (0.85, 0.85, 0.85, 1)
val_color = "#e74c3c"

fig, ax = plt.subplots(figsize=(9, 3.6))
for f in range(k):
    for i in range(n):
        is_val = (i // fold_size) == f
        ax.add_patch(
            plt.Rectangle(
                (i, f),
                1,
                0.8,
                color=val_color if is_val else train_color,
                ec="white",
                linewidth=0.8,
            )
        )

for b in range(1, k):
    ax.axvline(b * fold_size, color="#555555", linewidth=0.8, linestyle=":", alpha=0.7)

for b in range(k):
    ax.text(
        b * fold_size + fold_size / 2,
        k + 0.12,
        f"L{b + 1}",
        ha="center",
        va="bottom",
        fontsize=9,
        fontweight="bold",
    )

ax.set_xlim(0, n)
ax.set_ylim(-0.5, k + 0.45)
ax.set_yticks(range(k))
ax.set_yticklabels([f"Lipatan {i + 1} validasi" for i in range(k)])
ax.set_xlabel("Observasi (5 lipatan kontigu, masing-masing 4 sampel)")
ax.set_xticks([i * fold_size + fold_size / 2 for i in range(k)])
ax.set_xticklabels([f"{i * fold_size + 1}–{(i + 1) * fold_size}" for i in range(k)])
ax.set_title("5-fold CV — rotasi lipatan validasi")
ax.legend(
    handles=[
        mpatches.Patch(color=train_color, label="Latih"),
        mpatches.Patch(color=val_color, label="Validasi"),
    ],
    loc="upper right",
    framealpha=0.95,
)
plt.tight_layout()
Gambar 8: 5-fold CV: 20 observasi dibagi 5 lipatan kontigu (L1–L5). Setiap baris = satu iterasi; merah = validasi, abu-abu = latih (4/5 data).

6.2 Memilih \(k\) dan varian CV

Skema Kapan dipakai Catatan praktik
10-fold dataset besar lazim di literatur; cv=10
5-fold kompromi biaya/stabilitas default umum di kuliah & GridSearchCV
Leave-One-Out (LOO) dataset sangat kecil (\(k = n\)) mahal jika \(n\) besar; setiap iterasi \(n-1\) latih, 1 uji

Di scikit-learn: cross_val_score(..., cv=5) atau StratifiedKFold(5).

StratifiedKFold — proporsi kelas di tiap lipatan mendekati proporsi global (penting untuk klasifikasi tidak seimbang). RepeatedKFold — ulangi pembagian \(r\) kali untuk estimasi mean ± std yang lebih andal.

6.3 Demo: cross_val_score & GridSearchCV

from sklearn.datasets import load_wine
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

wine = load_wine()
X, y = wine.data, wine.target
pipe = Pipeline(
    [
        ("sc", StandardScaler()),
        ("m", SVC(kernel="rbf", C=2.0, gamma="scale")),
    ]
)
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(pipe, X, y, cv=cv, scoring="f1_macro")
print("F1-macro per lipatan:", np.round(scores, 3))
print("Mean ± std:", round(scores.mean(), 3), "±", round(scores.std(), 3))

rf = RandomForestClassifier(n_estimators=200, random_state=42)
scores_rf = cross_val_score(rf, X, y, cv=cv, scoring="f1_macro")
print("RF F1-macro mean ± std:", round(scores_rf.mean(), 3), "±", round(scores_rf.std(), 3))
F1-macro per lipatan: [0.972 1.    0.971 1.    1.   ]
Mean ± std: 0.989 ± 0.014
RF F1-macro mean ± std: 0.978 ± 0.02

Std kecil → performa konsisten antar lipatan; std besar → waspadai data kecil atau model tidak stabil.

from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier

param_grid = {"m__n_neighbors": [3, 5, 7, 11, 15]}
knn = Pipeline([("sc", StandardScaler()), ("m", KNeighborsClassifier())])
search = GridSearchCV(
    knn,
    param_grid,
    cv=StratifiedKFold(5, shuffle=True, random_state=42),
    scoring="f1_macro",
    n_jobs=-1,
)
search.fit(X, y)
print("Best k:", search.best_params_)
print("Best CV F1-macro:", round(search.best_score_, 3))
print("Best estimator (refit on full X):", search.best_estimator_)
Best k: {'m__n_neighbors': 15}
Best CV F1-macro: 0.979
Best estimator (refit on full X): Pipeline(steps=[('sc', StandardScaler()),
                ('m', KNeighborsClassifier(n_neighbors=15))])

best_score_ = rata-rata skor CV di data latih penuh — bukan skor test.

6.4 Nested CV & train / validation / test

Nested CV (penelitian): lipatan luar = estimasi performa, lipatan dalam = tuning — menghindari estimasi optimis bila skor CV yang sama dipakai untuk tuning sekaligus pelaporan.

Subset Peran
Train latih parameter model
Validation pilih hiperparameter (CV memutar peran ini di dalam train)
Test laporan akhir sekali

7 Alur evaluasi end-to-end

Data → validasi & split → Pipeline(latih) → CV tuning
     → evaluasi final (test) → dokumentasi metrik & versi

Setiap langkah harus terdokumentasi (versi data, seed, metrik, tanggal evaluasi).

8 Ringkasan

  • Prinsip: evaluasi pada Testing Data; waspadai overfitting dan data leakage.
  • 9.1 Regresi: MAE, RMSE (turunan sum of squared errors), \(R^2\) — ukur Observed vs Predicted di uji.
  • 9.2 Klasifikasi: confusion matrix; Precision / Recall / F1; ROC (TPR vs FPR) & AUC; pilih threshold operasional; latihan 10 contoh kasus.
  • 9.3 CV: rotasi lipatan (5-/10-fold, LOO jika \(n\) kecil); cross_val_score, GridSearchCV; set uji tetap suci.

9 Referensi

  • James et al., An Introduction to Statistical Learning — validasi resampling, metrik klasifikasi.
  • Dokumentasi scikit-learn: metrics (roc_curve, roc_auc_score, RocCurveDisplay), model_selection, Pipeline.