Lewati ke isi

Random Forest

Gambaran singkat

Apa ini? Random Forest menggabungkan banyak pohon keputusan, lalu hasilnya diambil lewat pemungutan suara.

Analogi

Daripada bertanya pada satu ahli, Anda bertanya pada 100 orang yang masing-masing melihat sebagian data, lalu mengambil jawaban terbanyak. Kesalahan acak satu orang tertutup oleh yang lain.

Mengapa penting? Satu pohon mudah salah karena terlalu bergantung pada data latih. Gabungan banyak pohon jauh lebih stabil dan sering akurat tanpa banyak penyetelan.

Yang akan dipelajari, berurutan:

  1. Cara tiap pohon dibuat berbeda (sampel bootstrap dan fitur acak).
  2. Pengaruh n_estimators dan max_features.
  3. Skor out-of-bag dan dua jenis feature importance.

Istilah awal:

Istilah Arti sederhana
Bagging Melatih banyak model pada contoh data acak lalu menggabungkannya
Bootstrap Sampel acak dengan pengembalian dari data latih
Out-of-bag (OOB) Data yang tidak terpilih, dipakai sebagai data uji gratis
n_estimators Jumlah pohon

Tujuan pembelajaran

  • Menjelaskan bagging dan pemilihan fitur acak pada Random Forest.
  • Memahami pengaruh n_estimators dan max_features.
  • Memakai skor out-of-bag (OOB) dan membandingkan dua jenis feature importance.

Intuisi

Satu pohon cenderung bervarians tinggi. Random Forest melatih banyak pohon yang sengaja dibuat beragam:

  1. Tiap pohon dilatih pada sampel bootstrap (pengambilan acak dengan pengembalian) dari data latih.
  2. Pada tiap pembagian, pohon hanya mempertimbangkan subset fitur acak (max_features).
  3. Prediksi akhir adalah suara mayoritas (atau rata-rata probabilitas) seluruh pohon.

Kesalahan acak tiap pohon saling meredam, sehingga varians turun dibanding satu pohon tanpa menaikkan bias secara berarti. Sekitar sepertiga data tidak terpilih pada tiap bootstrap; data ini (out-of-bag) dapat dipakai menilai model tanpa data validasi terpisah.

Ringkasan model

Aspek Keterangan
Kelebihan Umumnya akurat dan stabil, tahan outlier dan skala fitur, sedikit penyetelan
Keterbatasan Lebih sulit ditafsirkan, memori dan waktu prediksi lebih besar, tidak selalu mengalahkan model sederhana
Hyperparameter penting n_estimators, max_depth, max_features, min_samples_leaf, class_weight
Praproses Scaling tidak diperlukan
Cocok untuk Data tabular dengan hubungan non-linear dan fitur campuran; baseline kuat

Implementasi langkah demi langkah

Program examples/classification/random_forest.py memakai data Breast Cancer; pemuatan dan pembagian datanya sama dengan pelajaran dasar klasifikasi.

Langkah 1: satu pohon sebagai pembanding

Tujuan. Mengetahui seberapa besar perbaikan yang diberikan hutan dibanding satu pohon.

random_forest.py
# 1. Satu pohon vs hutan (validasi silang 5 lipatan)
tree_cv = cross_val_score(DecisionTreeClassifier(random_state=SEED), X_train, y_train, cv=5)
print("1 pohon           : akurasi CV %.3f (+/- %.3f)" % (tree_cv.mean(), tree_cv.std()))

cross_val_score(...) menghasilkan lima akurasi (satu per lipatan); tree_cv.mean() dan tree_cv.std() adalah rata-rata dan simpangan bakunya. %.3f memformat angka dengan tiga desimal.

1 pohon           : akurasi CV 0.910 (+/- 0.019)

Hasil. Satu pohon tanpa batas memberi akurasi validasi silang 0,910 (± 0,019). Angka ini patokan untuk langkah berikutnya.

Langkah 2: pengaruh jumlah pohon (n_estimators)

random_forest.py
# 2. Jumlah pohon (n_estimators)
print("\nn_estimators  akurasi_CV")
for n in [1, 5, 25, 100, 300]:
    rf = RandomForestClassifier(n_estimators=n, random_state=SEED)
    print(f"{n:<13} {cross_val_score(rf, X_train, y_train, cv=5).mean():.3f}")

RandomForestClassifier(n_estimators=n, random_state=SEED) menginisialisasi hutan berisi n pohon. Tiap pohon dilatih pada sampel bootstrap yang berbeda, dan prediksi akhir adalah suara mayoritas seluruh pohon. random_state mengunci keacakan sampel bootstrap dan pemilihan fitur.

n_estimators  akurasi_CV
1             0.908
5             0.941
25            0.954
100           0.954
300           0.958

Interpretasi. Satu pohon memberi 0,908 (mirip pohon tunggal sebelumnya). Menambah pohon memperbaiki hasil dengan cepat lalu mendatar: 0,941 (5), 0,954 (25 dan 100), 0,958 (300). Menambah pohon tidak menyebabkan overfitting, hanya menambah biaya komputasi dan memori.

Langkah 3: jumlah fitur per pembagian (max_features)

random_forest.py
# 3. Jumlah fitur yang dipertimbangkan per pembagian (max_features)
print("\nmax_features  akurasi_CV")
for mf in ["sqrt", 0.5, 1.0]:
    rf = RandomForestClassifier(n_estimators=200, max_features=mf, random_state=SEED)
    print(f"{str(mf):<13} {cross_val_score(rf, X_train, y_train, cv=5).mean():.3f}")

max_features menentukan berapa fitur yang dipertimbangkan pada setiap pembagian: "sqrt" = akar kuadrat jumlah fitur (sekitar 5 dari 30), 0.5 = separuh fitur, 1.0 = semua fitur. Nilai lebih kecil membuat pohon lebih beragam satu sama lain. str(mf) mengubah angka atau teks menjadi teks agar dapat diratakan dengan :<13.

max_features  akurasi_CV
sqrt          0.960
0.5           0.958
1.0           0.958

Interpretasi. "sqrt" (0,960), 0,5 (0,958), dan 1,0 (0,958) hampir sama pada data ini; perbedaannya jauh di bawah ketidakpastian validasi silang. Pada data lain pengaruhnya bisa lebih besar.

Langkah 4: model akhir, skor OOB, dan evaluasi uji

Konsep. Setiap pohon dilatih pada sampel bootstrap sehingga sekitar sepertiga data tidak terpakai oleh pohon itu (out-of-bag, OOB). Data OOB dapat dipakai menilai model tanpa data validasi terpisah.

random_forest.py
# 4. Model akhir, skor out-of-bag (OOB), dan evaluasi uji
rf = RandomForestClassifier(n_estimators=300, oob_score=True, random_state=SEED).fit(X_train, y_train)
print("\nOOB score: %.3f" % rf.oob_score_)
print(classification_report(y_test, rf.predict(X_test), digits=3))

oob_score=True meminta skor OOB dihitung saat fit; hasilnya di atribut rf.oob_score_ (berakhiran _ = hasil pelatihan). classification_report menilai pada data uji.

OOB score: 0.956
              precision    recall  f1-score   support

           0      0.929     0.929     0.929        42
           1      0.958     0.958     0.958        72

    accuracy                          0.947       114
   macro avg      0.943     0.943     0.943       114
weighted avg      0.947     0.947     0.947       114

Interpretasi. Skor OOB 0,956 sangat dekat dengan akurasi validasi silang, memberi estimasi performa gratis. Pada data uji akurasi 0,947 dan recall kelas ganas 0,929 (3 dari 42 terlewat). Pada data ini Random Forest tidak lebih baik daripada regresi logistik (0,982); Random Forest tidak selalu menang.

Langkah 5: dua cara menghitung pentingnya fitur

Konsep. Impurity importance menghitung seberapa sering fitur dipakai menurunkan ketidakmurnian saat pelatihan. Permutation importance mengacak satu fitur lalu melihat seberapa turun skor model; makin besar penurunan, makin penting.

random_forest.py
# 5. Pentingnya fitur: impurity vs permutation (dihitung pada data uji)
imp = pd.Series(rf.feature_importances_, index=X.columns).sort_values(ascending=False)
perm = permutation_importance(rf, X_test, y_test, n_repeats=10, random_state=SEED)
perm = pd.Series(perm.importances_mean, index=X.columns).sort_values(ascending=False)
print("Top 3 impurity   :", list(imp.head(3).index))
print("Top 3 permutation:", list(perm.head(3).index))

permutation_importance(rf, X_test, y_test, n_repeats=10, ...) mengacak tiap fitur 10 kali pada data uji dan merata-ratakan penurunan skor (.importances_mean). list(imp.head(3).index) mengambil nama tiga fitur teratas.

Top 3 impurity   : ['worst perimeter', 'worst area', 'worst concave points']
Top 3 permutation: ['mean concave points', 'mean radius', 'mean fractal dimension']

Interpretasi. Kedua metode memberi daftar berbeda: impurity menempatkan worst perimeter, worst area, worst concave points di puncak, sedangkan permutation menempatkan mean concave points, mean radius, mean fractal dimension. Fitur ukuran (radius, perimeter, area) sangat berkorelasi sehingga pentingnya saling berbagi; permutation pada 114 data uji juga cukup berisik. Jangan menyimpulkan "fitur X yang terpenting" dari satu metode.

Program lengkap (random_forest.py)
random_forest.py
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.tree import DecisionTreeClassifier

SEED = 42
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)

# 1. Satu pohon vs hutan (validasi silang 5 lipatan)
tree_cv = cross_val_score(DecisionTreeClassifier(random_state=SEED), X_train, y_train, cv=5)
print("1 pohon           : akurasi CV %.3f (+/- %.3f)" % (tree_cv.mean(), tree_cv.std()))

# 2. Jumlah pohon (n_estimators)
print("\nn_estimators  akurasi_CV")
for n in [1, 5, 25, 100, 300]:
    rf = RandomForestClassifier(n_estimators=n, random_state=SEED)
    print(f"{n:<13} {cross_val_score(rf, X_train, y_train, cv=5).mean():.3f}")

# 3. Jumlah fitur yang dipertimbangkan per pembagian (max_features)
print("\nmax_features  akurasi_CV")
for mf in ["sqrt", 0.5, 1.0]:
    rf = RandomForestClassifier(n_estimators=200, max_features=mf, random_state=SEED)
    print(f"{str(mf):<13} {cross_val_score(rf, X_train, y_train, cv=5).mean():.3f}")

# 4. Model akhir, skor out-of-bag (OOB), dan evaluasi uji
rf = RandomForestClassifier(n_estimators=300, oob_score=True, random_state=SEED).fit(X_train, y_train)
print("\nOOB score: %.3f" % rf.oob_score_)
print(classification_report(y_test, rf.predict(X_test), digits=3))

# 5. Pentingnya fitur: impurity vs permutation (dihitung pada data uji)
imp = pd.Series(rf.feature_importances_, index=X.columns).sort_values(ascending=False)
perm = permutation_importance(rf, X_test, y_test, n_repeats=10, random_state=SEED)
perm = pd.Series(perm.importances_mean, index=X.columns).sort_values(ascending=False)
print("Top 3 impurity   :", list(imp.head(3).index))
print("Top 3 permutation:", list(perm.head(3).index))

Kesalahan umum

Hindari

  • Mengira lebih banyak pohon selalu menyebabkan overfitting (tidak; ia mendatar).
  • Menafsirkan impurity importance sebagai kebenaran mutlak, terutama pada fitur berkorelasi atau bervariasi tinggi.
  • Tidak membatasi max_depth/min_samples_leaf pada data berderau.
  • Memakai Random Forest tanpa baseline sederhana sebagai pembanding.

Latihan

  1. Tambahkan max_depth=3 pada hutan. Apakah akurasi CV berubah?
  2. Hitung permutation importance pada data latih dan bandingkan dengan data uji.
  3. Gunakan class_weight="balanced". Apakah recall kelas ganas berubah?

Ringkasan

Random Forest menggabungkan banyak pohon yang dilatih pada bootstrap dan subset fitur acak. Hasilnya lebih stabil daripada satu pohon, dengan OOB sebagai estimasi bawaan; tetapi kurang mudah dijelaskan dan tidak otomatis unggul.

Berikutnya: Support Vector Machine (SVM).