Pokok-pokok keputusan yang paling intuitif dan banyak digunakan algoritma pembelajaran mesin untuk klasifikasi maupun regresi. mereka bekerja dengan membagi data menjadi cabang berdasarkan nilai fitur, meniru cara manusia membuat keputusan. sementara perpustakaan seperti scikit ⁇ learn membuat pohon keputusan menjadi sepele, menerapkan satu dari awal adalah cara yang sangat baik bagi pemula untuk memahami kerja batin algoritma. tutorial ini akan membimbing Anda melalui teori dan kode, sehingga Anda dapat membangun pohon keputusan sendiri dari tanah ke atas.

Apa Pokok Keputusan Itu?

Pohon keputusan adalah struktur seperti flowchart ⁇ seperti di mana setiap node internal mewakili sebuah tes pada sebuah fitur (misalnya, \"Apakah usia > 30?\"), setiap cabang mewakili hasil tes tersebut, dan setiap node daun memegang label kelas atau nilai terus menerus. Tujuannya adalah untuk membuat model yang memprediksi sebuah variabel target dengan mempelajari aturan keputusan sederhana yang diiferensikan dari fitur data.Pepohonan keputusan populer karena mereka mudah untuk menafsirkan dan membutuhkan sedikit praproses data (tidak menskala atau normalisasi).

Pohon zodiak dibangun secara rekursif: dimulai dari akar, algoritme memilih fitur dan titik split terbaik yang memisahkan data paling bersih. Proses ini diulangi pada setiap subset sampai kondisi berhenti dipenuhi. Untuk lebih banyak latar belakang, Wikipedia entry on decision tree learning menyediakan sebuah spion padat.

Konsep Inti Konsep yang Harus Anda Pahami

Node, Cabang, dan Daun

Node akar lenode lenode lendir berisi seluruh set data pelatihan. Node internal menguji sebuah fitur dan membagi data menjadi dua atau lebih node anak. Branch adalah koneksi yang mewakili hasil dari sebuah tes. Node daun (node terminal) mengeluarkan prediksi akhir ⁇ kelas paling umum dalam klasifikasi atau nilai maksud dalam regresi.

Kriteria Pengpecahan

Untuk membangun pohon, Anda perlu cara untuk mengukur kualitas dari pembagian potensial. kriteria yang paling umum adalah:

  • [[EfrondFLT:0]]Gini impurity[]] ⁇ digunakan dalam klasifikasi untuk mengukur seberapa sering elemen yang dipilih secara acak akan salah dilabeli jika dilabel secara acak sesuai dengan distribusi kelas dalam subset. Gini rendah lebih baik.
  • [[Eflat:0]]Entropi ⁇ mengukur jumlah gangguan atau ketidakpastian dalam sebuah set. Tujuannya adalah untuk meminimalkan entropi setelah perpecahan (information gain).
  • [GALALT:0]]Variance reduction]] ⁇ digunakan untuk regresi pohon. Ini menghitung pengurangan dalam perbedaan (atau mean kuadrat error) yang dicapai oleh split.

Algoritme tersebut mengevaluasi setiap kemungkinan terpecah pada setiap fitur dan memilih yang menghasilkan pengurangan ketidakmurnian terbesar (atau perolehan informasi).

Informasi Informasi Informasi Informasi Informasi Gain dan Rasio Gain

Pengenaan informasi oleh karena itu adalah perbedaan antara ketidakmurnian node induk dan jumlah yang diberatkan dari ketidakmurnian anak. Meskipun sederhana, hal ini cenderung menguntungkan fitur dengan banyak nilai. Rasio perolehan (digunakan dalam C4.5) menormalkan hal ini. Untuk tutorial ini kita akan tetap dengan standar perolehan informasi menggunakan ketidakmurnian Gini, yang merupakan default dalam CART (Klasisification and Regresi Trees).

Membina Langkah Pokok Keputusan

1. Siapkan Data Anda

Anda perlu dataset dengan fitur dan label target. Untuk kesederhanaan, gunakan data klasifikasi biner dengan fitur numerik. Sebagai contoh:

  • Features: Usia, Penghasilan
  • Target: Disetujui (1) atau Tidak Disetujui (0)

Bersihkan data: menangani nilai yang hilang, hapus duplikat, dan pastikan tipe angka. Pokok keputusan dapat menangani jenis data campuran tetapi kita akan tetap berangka untuk implementasi.

2. Definisikan Fungsi Kriteria Pengpecahan

Kami akan menerapkan ketidakmurnian Gini. Indeks Gini untuk satu set item adalah:

[[GALAT:0]]

gradadi dimana p i adalah proporsi item dalam kelas i. Untuk pembelahan biner, Gini secara keseluruhan adalah rata-rata berbobot dari node anak.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Untuk setiap fitur, urutkan nilai unik. Uji setiap kemungkinan ambang (midpoint antara nilai diurutkan berurutan). Untuk setiap ambang kandidat, bagi data ke dalam kelompok kiri dan kanan, hitung Gini, dan lacak split terbaik.

Ihwal 4. Binalah pohon dengan Rekursif

¡Agodia membuat fungsi yang mengambil subset data dan kedalaman arus. Ia memeriksa kondisi berhenti (misalnya, kedalaman maksimum dicapai, sampel minimum per node, atau tanpa perolehan informasi). Jika suatu kondisi terpenuhi, membuat node daun dengan kelas mayoritas. Jika tidak, cari split terbaik dan buat node internal, maka secara rekursif sebut fungsi pada split kiri dan kanan.

5. Buat Prediksi

Setelah pohon dibangun, prediksinya terus terang: mulai dari akar, ikuti cabang dengan mengevaluasi tes fitur pada sampel baru, dan mengembalikan nilai daun yang Anda mendaratkan.

Implementasi Penuh dengan nama Python

Di bawah ini adalah implementasi yang lengkap dan minimal dari pohon keputusan untuk klasifikasi menggunakan ketidakmurnian Gini. Kode ini dimaksudkan untuk pembelajaran ⁇ tidak dioptimalkan untuk dataset yang besar.

import numpy as np
from collections import Counter

class DecisionTree:
 def __init__(self, max_depth=None, min_samples_split=2):
 self.max_depth = max_depth
 self.min_samples_split = min_samples_split
 self.tree = None

 def fit(self, X, y):
 dataset = np.column_stack((X, y))
 self.tree = self._grow_tree(dataset)

 def _grow_tree(self, dataset, depth=0):
 X, y = dataset[:, :-1], dataset[:, -1]
 n_samples, n_features = X.shape
 n_labels = len(np.unique(y))

 # Stopping conditions
 if (n_labels == 1 or depth == self.max_depth or n_samples < self.min_samples_split):
 leaf_value = Counter(y).most_common(1)[0][0]
 return {'leaf': True, 'value': leaf_value}

 best_feature, best_threshold = self._best_split(dataset, n_features)
 if best_feature is None:
 leaf_value = Counter(y).most_common(1)[0][0]
 return {'leaf': True, 'value': leaf_value}

 left_idx, right_idx = self._split(dataset[:, best_feature], best_threshold)
 left_subtree = self._grow_tree(dataset[left_idx], depth+1)
 right_subtree = self._grow_tree(dataset[right_idx], depth+1)
 return {'leaf': False,
 'feature': best_feature,
 'threshold': best_threshold,
 'left': left_subtree,
 'right': right_subtree}

 def _best_split(self, dataset, n_features):
 best_gini = float('inf')
 best_feature, best_threshold = None, None
 for feature in range(n_features):
 thresholds = np.unique(dataset[:, feature])
 for i in range(len(thresholds)-1):
 thresh = (thresholds[i] + thresholds[i+1]) / 2
 left_idx, right_idx = self._split(dataset[:, feature], thresh)
 if len(left_idx) == 0 or len(right_idx) == 0:
 continue
 gini = self._gini_gain(dataset, left_idx, right_idx)
 if gini < best_gini:
 best_gini = gini
 best_feature = feature
 best_threshold = thresh
 return best_feature, best_threshold

 def _split(self, values, threshold):
 left_idx = np.where(values <= threshold)[0]
 right_idx = np.where(values > threshold)[0]
 return left_idx, right_idx

 def _gini_gain(self, dataset, left_idx, right_idx):
 total = len(left_idx) + len(right_idx)
 gini_left = self._gini(dataset[left_idx, -1])
 gini_right = self._gini(dataset[right_idx, -1])
 return (len(left_idx)/total) * gini_left + (len(right_idx)/total) * gini_right

 def _gini(self, labels):
 _, counts = np.unique(labels, return_counts=True)
 p = counts / np.sum(counts)
 return 1 - np.sum(p**2)

 def predict(self, X):
 return np.array([self._predict_row(x, self.tree) for x in X])

 def _predict_row(self, x, node):
 if node['leaf']:
 return node['value']
 if x[node['feature']] <= node['threshold']:
 return self._predict_row(x, node['left'])
 else:
 return self._predict_row(x, node['right'])

Fikul Pohon yang Menguji

Takanles menggunakan dataset sederhana seperti dataset iris klasik (dua fitur untuk klasifikasi binari). scikit ⁇ learn Iris dataset[ bekerja dengan baik. Bandingkan keakuratan pohon Anda dengan ]] untuk memverifikasi kejelasan.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

data = load_iris()
X = data.data[:100] # take only first two classes (binary)
y = data.target[:100]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

tree = DecisionTree(max_depth=3)
tree.fit(X_train, y_train)
preds = tree.predict(X_test)
accuracy = np.mean(preds == y_test)
print(f'Accuracy: {accuracy:.2f}')

Teknik Teknik Teknik Teknik Teknik untuk Meningkatkan Pohon Anda

Dilarang Tidak Berlebihan

Sebuah pohon yang telah tumbuh sepenuhnya dapat memorise noise dalam data pelatihan. Pruning menghapus cabang yang memiliki sedikit kekuatan prediktif. Metode umum adalah pra ⁇ pruning (menghentikan pertumbuhan dini melalui atau ) dan post ⁇ pruning (mengembangkan pohon penuh kemudian menghapus cabang menggunakan set validasi atau biaya ⁇ kompleksitas prunting). implementasi kami sudah mendukung pre ⁇ pruning.

Keupayaan Berkelanjutan dan Categoris yang Berkesinambungan dan Berkemenangan

Untuk fitur yang terus menerus, kami menggunakan titik tengah antara nilai yang diurutkan sebagai ambang. Untuk fitur kategori (misalnya, \"Color = merah/hijau/biru\", setiap kategori dapat menjadi cabang terpisah (multi ⁇ way split) atau Anda dapat biner ⁇ encode mereka. Kebanyakan implementasi modern (seperti scilit ⁇ learn) menggunakan pembelahan biner bahkan untuk fitur kategoris dengan mengevaluasi semua subset.

Berbuat persetujuan dengan Nilai Hilang

Data dunia nyata sering kali memiliki nilai yang hilang. Sebuah pendekatan sederhana adalah untuk menetapkan nilai yang hilang ke cabang yang paling sering digunakan di antara sampel pelatihan yang memiliki fitur. C4.5 menggunakan metode probabilistik. Karena ini adalah tutorial pemula, kita menganggap data telah lengkap.

Membandingkan dengan Perpustakaan dan Bacaan Lebih Lanjut

Sementara wikipedia sedang membangun dari awal adalah pendidikan, sistem produksi menggunakan perpustakaan seperti scikit ⁇ learn yang menyediakan implementasi C yang teroptimalkan. Anda dapat belajar lebih banyak dari situs resmi scikit ⁇ learn decision tree dokumentasi. Untuk teori yang lebih dalam, buku \"The Elements of Statistical Learning\" karya Hastie, Tibshirani, dan Friedman adalah sumber daya yang berwibawa. Referensi lain yang sangat bagus adalah buku CART asli karya Breiman et al.

Kekecualian Kesimpulan

Membina pohon keputusan dari awal yang didemystifikasi salah satu algoritma paling mendasar dalam pembelajaran mesin. Anda telah mempelajari bagaimana prosedur pemisahan rekursif sederhana dapat menghasilkan model yang kuat. Dengan menulis kode sendiri, Anda memperoleh pemahaman yang lebih dalam tentang langkah-langkah ketidakmurnian, seleksi terpecah, dan perdagangan ⁇ off antara bias dan perbedaan. Sebagai langkah berikutnya, cobalah menambahkan dukungan regresi, prunting, atau menangani fitur-fitur kategori. keterampilan yang Anda kembangkan di sini akan melayani Anda dengan baik saat Anda bergerak ke metode ensemble yang lebih kompleks seperti hutan acak dan meningkatkan gradien.