Lewati ke isi

Decision Tree

Gambaran singkat

Apa ini? Pohon keputusan menebak kelas lewat rangkaian pertanyaan ya/tidak, seperti diagram alur.

Analogi

Permainan "20 pertanyaan": Anda menebak benda dengan bertanya "Apakah hidup?", "Apakah bisa terbang?". Setiap jawaban mempersempit kemungkinan sampai jawaban akhir ketemu.

Mengapa penting? Hasilnya mudah dibaca manusia dan dijelaskan kepada orang awam. Pohon juga dasar Random Forest. Kelemahannya, pohon yang dibiarkan tumbuh mudah menghafal data.

Yang akan dipelajari, berurutan:

  1. Cara pohon memilih pertanyaan terbaik (ukuran kemurnian).
  2. Membatasi ukuran pohon dengan max_depth dan min_samples_leaf.
  3. Membaca aturan pohon dan feature importance.

Istilah awal:

Istilah Arti sederhana
Simpul / daun Titik pertanyaan / titik jawaban akhir
Kemurnian Seberapa seragam kelas dalam satu simpul
max_depth Batas kedalaman pohon
Feature importance Seberapa penting fitur untuk memisahkan data

Tujuan pembelajaran

  • Menjelaskan bagaimana pohon keputusan membagi data dan memilih pertanyaan.
  • Mengatur kompleksitas pohon dengan max_depth dan min_samples_leaf.
  • Membaca aturan pohon dan menafsirkan feature importance dengan hati-hati.

Intuisi

Pohon keputusan adalah rangkaian pertanyaan ya/tidak ("worst radius ≤ 16,80?"). Data mengalir dari akar ke daun, dan daun menentukan kelas. Pada tiap simpul, pohon memilih pertanyaan yang membuat simpul anak paling murni. Ukuran ketidakmurnian yang umum adalah Gini:

\[ G = 1 - \sum_{c=1}^{C} p_c^2 \]

\(p_c\) adalah proporsi kelas \(c\) pada simpul. Simpul 50%–50% memiliki \(G = 0{,}5\) (paling tidak murni untuk dua kelas); simpul satu kelas memiliki \(G = 0\). Pohon yang dibiarkan tumbuh akan terus membagi sampai daun murni, yang berarti menghafal data latih.

Ringkasan model

Aspek Keterangan
Kelebihan Mudah dijelaskan dan divisualisasikan, menangkap non-linearitas dan interaksi, tidak perlu scaling
Keterbatasan Mudah overfitting, tidak stabil terhadap perubahan kecil data, batas keputusan tegak lurus sumbu
Hyperparameter penting max_depth, min_samples_leaf, min_samples_split, criterion, ccp_alpha
Praproses Scaling tidak diperlukan
Cocok untuk Kasus yang butuh aturan terbaca; fondasi Random Forest

Implementasi langkah demi langkah

Program examples/classification/decision_tree.py memakai data Breast Cancer; pemuatan dan pembagian datanya sama dengan pelajaran dasar klasifikasi. Pohon tidak memerlukan scaling, sehingga tidak ada StandardScaler.

Langkah 1: pengaruh max_depth

Tujuan. Menemukan kedalaman pohon yang cukup rumit untuk menangkap pola, tetapi belum menghafal data.

decision_tree.py
# 1. Pengaruh max_depth (pohon tidak memerlukan scaling)
print("max_depth  akurasi_latih  akurasi_CV  jumlah_daun")
for depth in [1, 2, 3, 4, 6, None]:
    tree = DecisionTreeClassifier(max_depth=depth, random_state=SEED)
    cv = cross_val_score(tree, X_train, y_train, cv=5).mean()
    tree.fit(X_train, y_train)
    print(f"{str(depth):<9}  {tree.score(X_train, y_train):.3f}          {cv:.3f}       {tree.get_n_leaves()}")
Kode Penjelasan
DecisionTreeClassifier(max_depth=depth, random_state=SEED) Menginisialisasi pohon. max_depth = jumlah maksimum tingkat pertanyaan (None = tanpa batas); random_state memastikan hasil sama bila ada seri antar pembagian.
cross_val_score(tree, X_train, y_train, cv=5).mean() Akurasi validasi silang rata-rata pada data latih (objek tree yang belum dilatih tetap dapat diberikan, karena fungsi ini melatih salinannya per lipatan).
tree.fit(X_train, y_train) Melatih pohon pada seluruh data latih (diperlukan agar score dan get_n_leaves dapat dipakai).
tree.get_n_leaves() Jumlah simpul daun; ukuran kompleksitas pohon.
max_depth  akurasi_latih  akurasi_CV  jumlah_daun
1          0.923          0.897       2
2          0.958          0.919       4
3          0.976          0.925       7
4          0.987          0.938       11
6          0.998          0.919       18
None       1.000          0.910       19

Interpretasi. Akurasi latih naik terus (0,923 → 1,000) karena pohon makin leluasa menghafal, tetapi akurasi validasi silang tertinggi pada max_depth=4 (0,938), lalu turun ke 0,910 pada pohon tanpa batas (19 daun). Itulah pola overfitting: skor latih naik, skor validasi turun.

Langkah 2: pengaruh min_samples_leaf

decision_tree.py
# 2. Pengaruh min_samples_leaf pada pohon tanpa batas kedalaman
print("\nmin_samples_leaf  akurasi_CV")
for leaf in [1, 5, 10, 20]:
    tree = DecisionTreeClassifier(min_samples_leaf=leaf, random_state=SEED)
    print(f"{leaf:<16}  {cross_val_score(tree, X_train, y_train, cv=5).mean():.3f}")

min_samples_leaf=leaf melarang daun yang berisi kurang dari leaf sampel; daun besar berarti pohon tidak dapat menghafal sampel tunggal. Di sini kedalaman tidak dibatasi, hanya ukuran daun.

min_samples_leaf  akurasi_CV
1                 0.910
5                 0.934
10                0.919
20                0.905

Interpretasi. min_samples_leaf=5 mencapai 0,934, jauh lebih baik daripada 1 (0,910); batas terlalu besar (20) menurunkannya ke 0,905 (underfitting). Ada nilai tengah yang ideal.

Langkah 3: membaca aturan pohon

decision_tree.py
# 3. Pohon kecil yang dapat dibaca manusia (max_depth=3)
small = DecisionTreeClassifier(max_depth=3, random_state=SEED).fit(X_train, y_train)
print("\n" + export_text(small, feature_names=list(X.columns)))

export_text(small, feature_names=...) mencetak pohon sebagai teks. Cara membaca: tiap baris |--- fitur <= nilai adalah pertanyaan; bagian yang menjorok di bawahnya adalah cabang jawaban "ya"; baris fitur > nilai adalah cabang "tidak". class: 1 di ujung adalah prediksi.

|--- worst radius <= 16.80
|   |--- worst concave points <= 0.14
|   |   |--- area error <= 91.56
|   |   |   |--- class: 1
|   |   |--- area error >  91.56
|   |   |   |--- class: 0
|   |--- worst concave points >  0.14
|   |   |--- worst texture <= 25.62
|   |   |   |--- class: 1
|   |   |--- worst texture >  25.62
|   |   |   |--- class: 0
|--- worst radius >  16.80
|   |--- texture error <= 0.47
|   |   |--- class: 1
|   |--- texture error >  0.47
|   |   |--- worst concavity <= 0.19
|   |   |   |--- class: 1
|   |   |--- worst concavity >  0.19
|   |   |   |--- class: 0

Interpretasi. Pertanyaan pertama: apakah worst radius <= 16.80? Bila ya, tanyakan worst concave points <= 0.14; bila ya lagi, tanyakan area error <= 91.56, dan bila ya, prediksinya kelas 1 (jinak). Setiap sampel mengikuti satu jalur dari atas ke daun. Aturan seperti ini dapat langsung dijelaskan kepada orang lain, kelebihan utama pohon.

Langkah 4: pentingnya fitur dan evaluasi uji

decision_tree.py
# 4. Pentingnya fitur (berdasarkan penurunan impurity) dan evaluasi uji
imp = pd.Series(small.feature_importances_, index=X.columns).sort_values(ascending=False)
print(imp.head(3).round(3).to_string())
print(classification_report(y_test, small.predict(X_test), digits=3))

small.feature_importances_ adalah seberapa besar tiap fitur menurunkan ketidakmurnian (Gini) pada pohon yang dilatih; total semua fitur = 1. pd.Series(..., index=X.columns) memberi nama dan sort_values(ascending=False) mengurutkannya dari terbesar.

worst radius            0.764
worst concave points    0.127
texture error           0.048
              precision    recall  f1-score   support

           0      0.927     0.905     0.916        42
           1      0.945     0.958     0.952        72

    accuracy                          0.939       114
   macro avg      0.936     0.932     0.934       114
weighted avg      0.938     0.939     0.938       114

Interpretasi. worst radius (0,764) menyumbang paling besar pada pohon ini. Nilai ini bukan bukti sebab-akibat; fitur yang berkorelasi dapat saling menggantikan. Pada data uji (pohon max_depth=3) akurasi 0,939; recall kelas ganas 0,905, yaitu 4 dari 42 kasus ganas terlewat, lebih buruk daripada regresi logistik. Perbedaan ini wajar bagi satu pohon, tetapi dengan 114 data uji ketidakpastiannya besar.

Program lengkap (decision_tree.py)
decision_tree.py
import pandas as pd
from sklearn.datasets import load_breast_cancer
from sklearn.metrics import classification_report
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.tree import DecisionTreeClassifier, export_text

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. Pengaruh max_depth (pohon tidak memerlukan scaling)
print("max_depth  akurasi_latih  akurasi_CV  jumlah_daun")
for depth in [1, 2, 3, 4, 6, None]:
    tree = DecisionTreeClassifier(max_depth=depth, random_state=SEED)
    cv = cross_val_score(tree, X_train, y_train, cv=5).mean()
    tree.fit(X_train, y_train)
    print(f"{str(depth):<9}  {tree.score(X_train, y_train):.3f}          {cv:.3f}       {tree.get_n_leaves()}")

# 2. Pengaruh min_samples_leaf pada pohon tanpa batas kedalaman
print("\nmin_samples_leaf  akurasi_CV")
for leaf in [1, 5, 10, 20]:
    tree = DecisionTreeClassifier(min_samples_leaf=leaf, random_state=SEED)
    print(f"{leaf:<16}  {cross_val_score(tree, X_train, y_train, cv=5).mean():.3f}")

# 3. Pohon kecil yang dapat dibaca manusia (max_depth=3)
small = DecisionTreeClassifier(max_depth=3, random_state=SEED).fit(X_train, y_train)
print("\n" + export_text(small, feature_names=list(X.columns)))

# 4. Pentingnya fitur (berdasarkan penurunan impurity) dan evaluasi uji
imp = pd.Series(small.feature_importances_, index=X.columns).sort_values(ascending=False)
print(imp.head(3).round(3).to_string())
print(classification_report(y_test, small.predict(X_test), digits=3))

Kesalahan umum

Hindari

  • Membiarkan pohon tumbuh tanpa batas lalu melaporkan akurasi latih.
  • Menganggap pohon pasti stabil; data latih yang sedikit berbeda dapat menghasilkan struktur berbeda.
  • Menafsirkan feature importance sebagai pengaruh kausal.
  • Memakai random_state berbeda tanpa menyadari hasil dapat berubah.

Latihan

  1. Ubah criterion menjadi "entropy". Apakah hasil validasi silang berubah?
  2. Coba ccp_alpha antara 0 dan 0,02. Bagaimana jumlah daun dan akurasi CV?
  3. Ganti random_state beberapa kali untuk pohon tanpa batas. Seberapa bervariasi akurasi CV-nya?

Ringkasan

Pohon keputusan membagi data dengan pertanyaan yang meningkatkan kemurnian simpul. Mudah dibaca tetapi mudah overfitting; batasi dengan max_depth dan min_samples_leaf, dan validasi pilihannya dengan validasi silang.

Berikutnya: Random Forest.