Lewati ke isi

KNN, Decision Tree, dan Random Forest Regressor

Gambaran singkat

Apa ini? Versi regresi dari KNN, pohon keputusan, dan Random Forest, yaitu model yang bisa menangkap hubungan melengkung.

Analogi

Garis lurus tidak cukup untuk jalan yang berkelok. Model ini menaksir dengan merata-ratakan data di sekitar atau dalam kelompok yang mirip, bukan lewat satu garis.

Mengapa penting? Banyak hubungan di dunia nyata tidak lurus. Namun model ini punya batas: taksirannya tidak pernah keluar dari rentang nilai latih, jadi tidak bisa meramal tren yang terus naik.

Yang akan dipelajari, berurutan:

  1. Perbedaan versi regresi dibanding klasifikasi.
  2. Mengatur kompleksitas lewat hyperparameter kunci.
  3. Batasan: taksiran konstan per daun dan tidak mengekstrapolasi.

Istilah awal:

Istilah Arti sederhana
Ekstrapolasi Menaksir di luar rentang data latih
Daun Kelompok akhir pada pohon yang taksirannya tetap
min_samples_leaf Minimal data per daun agar tidak menghafal

Tujuan pembelajaran

  • Menjelaskan versi regresi dari KNN, pohon keputusan, dan Random Forest.
  • Mengatur kompleksitas masing-masing dengan hyperparameter kuncinya.
  • Menyadari batasan model berbasis pohon: prediksi konstan per daun dan tidak mengekstrapolasi.

Prasyarat

Cara kerja dasar ketiga model dibahas pada bab Klasifikasi: KNN, Decision Tree, Random Forest. Di sini hanya dibahas perbedaannya untuk regresi.

Perbedaan untuk regresi

Model Prediksi Kriteria pembagian Hyperparameter kunci
KNN Regressor Rata-rata target \(k\) tetangga terdekat (jarak) n_neighbors, weights
Decision Tree Regressor Rata-rata target pada daun Penurunan galat kuadrat (MSE) max_depth, min_samples_leaf
Random Forest Regressor Rata-rata prediksi semua pohon Seperti pohon, dengan bootstrap dan subset fitur n_estimators, min_samples_leaf, max_features

Konsekuensi: prediksi pohon dan hutan berbentuk tangga (konstan di tiap daun) dan tidak pernah keluar dari rentang target latih, sehingga tidak dapat mengekstrapolasi tren. KNN juga perlu scaling.

Implementasi langkah demi langkah

Dataset Diabetes dengan pembagian 80/20 dan validasi silang 5 lipatan (RMSE; makin kecil makin baik). Program examples/estimation/nonlinear_regressors.py; program lengkap ada di akhir bagian ini.

Langkah 1: fungsi bantu RMSE latih dan RMSE validasi silang

Konsep. Membandingkan galat pada data latih dan galat validasi silang menunjukkan overfitting: galat latih sangat kecil tetapi galat validasi besar.

nonlinear_regressors.py
SEED = 42
X, y = load_diabetes(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=SEED)
cv = KFold(5, shuffle=True, random_state=SEED)


def cv_rmse(model):
    return -cross_val_score(model, X_train, y_train, cv=cv, scoring="neg_root_mean_squared_error").mean()


def train_rmse(model):
    return np.sqrt(mean_squared_error(y_train, model.fit(X_train, y_train).predict(X_train)))

cv_rmse(model) mengembalikan RMSE rata-rata validasi silang (tanda minus mengubah skor negatif menjadi positif). train_rmse(model) melatih model pada data latih, memprediksi data latih yang sama, dan menghitung RMSE-nya, yaitu galat pada data yang sudah dilihat model.

Langkah 2: KNN Regressor, pengaruh k

Konsep. KNN regresi memprediksi rata-rata target dari k tetangga terdekat. k=1 meniru tetangga tunggal (menghafal).

nonlinear_regressors.py
# 1. KNN Regressor: prediksi = rata-rata target k tetangga terdekat
print("KNN k   RMSE latih  RMSE CV")
for k in [1, 5, 10, 20, 40]:
    m = make_pipeline(StandardScaler(), KNeighborsRegressor(n_neighbors=k))
    print(f"{k:<7} {train_rmse(m):<10.2f}  {cv_rmse(m):.2f}")

KNeighborsRegressor(n_neighbors=k) dipasang dalam pipeline dengan StandardScaler (jarak sensitif pada skala). Format {train_rmse(m):<10.2f} menampilkan angka dua desimal dengan lebar 10 rata kiri.

KNN k   RMSE latih  RMSE CV
1       0.00        79.47
5       50.53       62.11
10      53.83       59.53
20      55.45       58.71
40      57.47       59.53

Interpretasi. k=1 menghafal data latih (RMSE latih 0,00) tetapi RMSE CV 79,47, jauh lebih buruk daripada model sederhana (overfitting). RMSE CV terbaik pada k=20 (58,71); k=40 sedikit naik (59,53).

Langkah 3: Decision Tree Regressor, pengaruh max_depth

Konsep. Pohon regresi membagi data dengan pertanyaan ya/tidak, dan prediksinya adalah rata-rata target pada daun. Prediksinya berbentuk tangga, hanya sebanyak jumlah daun.

nonlinear_regressors.py
# 2. Decision Tree Regressor: prediksi = rata-rata target di daun
print("\nTree max_depth  RMSE latih  RMSE CV  jumlah daun")
for depth in [1, 2, 3, 5, None]:
    m = DecisionTreeRegressor(max_depth=depth, min_samples_leaf=5, random_state=SEED)
    leaves = m.fit(X_train, y_train).get_n_leaves()
    print(f"{str(depth):<15} {train_rmse(m):<10.2f}  {cv_rmse(m):<7.2f}  {leaves}")

DecisionTreeRegressor(max_depth=depth, min_samples_leaf=5, ...) membatasi kedalaman dan melarang daun berisi kurang dari 5 sampel. m.fit(...).get_n_leaves() melatih lalu menghitung jumlah daun.

Tree max_depth  RMSE latih  RMSE CV  jumlah daun
1               65.02       71.31    2
2               57.95       63.39    4
3               54.21       65.27    8
5               45.77       67.14    26
None            35.31       69.10    58

Interpretasi. Makin dalam, galat latih turun terus (65,02 → 35,31) sedangkan RMSE CV terbaik pada max_depth=2 (63,39) lalu naik menjadi 69,10 tanpa batas kedalaman (58 daun): pola overfitting. Pada tabel uji dipakai max_depth=3 demi pohon yang tetap mudah dibaca; kedalaman 2 sedikit lebih baik pada validasi silang.

Langkah 4: Random Forest Regressor, pengaruh jumlah pohon

Konsep. Hutan merata-ratakan prediksi banyak pohon yang dilatih pada sampel bootstrap, sehingga lebih stabil daripada satu pohon.

nonlinear_regressors.py
# 3. Random Forest Regressor: rata-rata banyak pohon
print("\nRF n_estimators  RMSE CV")
for n in [1, 10, 100, 300]:
    m = RandomForestRegressor(n_estimators=n, min_samples_leaf=5, random_state=SEED)
    print(f"{n:<16} {cv_rmse(m):.2f}")
RF n_estimators  RMSE CV
1                70.83
10               59.09
100              57.88
300              57.79

Interpretasi. Satu pohon memberi RMSE CV 70,83; 10 pohon 59,09; 100 pohon 57,88; 300 pohon 57,79. Menambah pohon memperbaiki lalu mendatar.

Langkah 5: evaluasi pada data uji

nonlinear_regressors.py
# 4. Evaluasi uji untuk satu pilihan per model
models = {
    "KNN (k=20)": make_pipeline(StandardScaler(), KNeighborsRegressor(n_neighbors=20)),
    "Tree (depth=3)": DecisionTreeRegressor(max_depth=3, min_samples_leaf=5, random_state=SEED),
    "Random Forest": RandomForestRegressor(n_estimators=300, min_samples_leaf=5, random_state=SEED),
}
print("\nmodel            MAE     RMSE    R2")
for name, m in models.items():
    pred = m.fit(X_train, y_train).predict(X_test)
    print(f"{name:<16} {mean_absolute_error(y_test, pred):<7.2f} "
          f"{np.sqrt(mean_squared_error(y_test, pred)):<7.2f} {r2_score(y_test, pred):.3f}")

Tiga model dengan pilihan hyperparameter yang wajar disimpan dalam kamus, dilatih pada data latih, dan diuji sekali pada data uji dengan MAE, RMSE, dan R². (Pilihan k=20 dan max_depth=3 diambil dari langkah sebelumnya.)

model            MAE     RMSE    R2
KNN (k=20)       45.45   55.21   0.425
Tree (depth=3)   45.18   55.63   0.416
Random Forest    43.36   53.52   0.459

Interpretasi. KNN (k=20): MAE 45,45, RMSE 55,21, R² 0,425; pohon (depth=3): MAE 45,18, RMSE 55,63, R² 0,416; Random Forest: MAE 43,36, RMSE 53,52, R² 0,459. Ketiganya berdekatan dan hampir setara dengan regresi linear (RMSE uji 53,85). Pada dataset kecil dan berderau ini, fleksibilitas ekstra tidak memberi keuntungan besar.

Program lengkap (nonlinear_regressors.py)
nonlinear_regressors.py
import numpy as np
from sklearn.datasets import load_diabetes
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.model_selection import KFold, cross_val_score, train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeRegressor

SEED = 42
X, y = load_diabetes(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=SEED)
cv = KFold(5, shuffle=True, random_state=SEED)


def cv_rmse(model):
    return -cross_val_score(model, X_train, y_train, cv=cv, scoring="neg_root_mean_squared_error").mean()


def train_rmse(model):
    return np.sqrt(mean_squared_error(y_train, model.fit(X_train, y_train).predict(X_train)))


# 1. KNN Regressor: prediksi = rata-rata target k tetangga terdekat
print("KNN k   RMSE latih  RMSE CV")
for k in [1, 5, 10, 20, 40]:
    m = make_pipeline(StandardScaler(), KNeighborsRegressor(n_neighbors=k))
    print(f"{k:<7} {train_rmse(m):<10.2f}  {cv_rmse(m):.2f}")

# 2. Decision Tree Regressor: prediksi = rata-rata target di daun
print("\nTree max_depth  RMSE latih  RMSE CV  jumlah daun")
for depth in [1, 2, 3, 5, None]:
    m = DecisionTreeRegressor(max_depth=depth, min_samples_leaf=5, random_state=SEED)
    leaves = m.fit(X_train, y_train).get_n_leaves()
    print(f"{str(depth):<15} {train_rmse(m):<10.2f}  {cv_rmse(m):<7.2f}  {leaves}")

# 3. Random Forest Regressor: rata-rata banyak pohon
print("\nRF n_estimators  RMSE CV")
for n in [1, 10, 100, 300]:
    m = RandomForestRegressor(n_estimators=n, min_samples_leaf=5, random_state=SEED)
    print(f"{n:<16} {cv_rmse(m):.2f}")

# 4. Evaluasi uji untuk satu pilihan per model
models = {
    "KNN (k=20)": make_pipeline(StandardScaler(), KNeighborsRegressor(n_neighbors=20)),
    "Tree (depth=3)": DecisionTreeRegressor(max_depth=3, min_samples_leaf=5, random_state=SEED),
    "Random Forest": RandomForestRegressor(n_estimators=300, min_samples_leaf=5, random_state=SEED),
}
print("\nmodel            MAE     RMSE    R2")
for name, m in models.items():
    pred = m.fit(X_train, y_train).predict(X_test)
    print(f"{name:<16} {mean_absolute_error(y_test, pred):<7.2f} "
          f"{np.sqrt(mean_squared_error(y_test, pred)):<7.2f} {r2_score(y_test, pred):.3f}")

Kesalahan umum

Hindari

  • Memakai KNN tanpa scaling (di Diabetes fitur sudah diskalakan, tetapi tidak di data lain).
  • Mengira pohon atau hutan dapat memperkirakan nilai di luar rentang latih.
  • Memilih kedalaman pohon dari galat latih.
  • Membandingkan model berdasarkan satu angka uji pada data kecil.

Latihan

  1. Ubah weights="distance" pada KNN. Apakah RMSE CV berubah?
  2. Tambahkan max_features=0.5 pada Random Forest.
  3. Buat prediksi tiap model untuk satu sampel dengan bmi jauh lebih tinggi dari data latih. Bagaimana perilaku pohon vs regresi linear?

Ringkasan

Versi regresi KNN, pohon, dan Random Forest memprediksi rata-rata target lokal. Mereka menangkap non-linearitas tetapi tidak mengekstrapolasi, dan pada data kecil belum tentu mengalahkan model linear.

Berikutnya: Perbandingan Model Regresi.