Membina Pepohon: Pecahan, Nod dan Daun
Pelajar akan menjejaki cara pepohon keputusan membahagikan data secara rekursif pada setiap nod, daripada akar hingga daun, dan membuat ramalan dengan mengikuti cabang.
Membina Pepohon: Pecahan, Nod dan Daun ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah Itu Pepohon Keputusan?
Pepohon keputusan ialah struktur seperti carta alir yang setiap nod dalamannya mengemukakan soalan ya/tidak tentang satu ciri, setiap cabang mewakili satu jawapan dan setiap nod daun mengandungi satu ramalan. Untuk mengelaskan sampel baharu, anda bermula pada akar, mengikuti cabang berdasarkan nilai ciri dan tiba di daun yang labelnya menjadi ramalan. Pepohon keputusan mudah ditafsir melalui reka bentuknya — anda boleh menjejaki dengan tepat sebab sesuatu ramalan dibuat dengan membaca urutan soalan yang dijawab. Inilah yang menjadikannya popular dalam industri yang dikawal selia seperti kewangan dan penjagaan kesihatan.
# Conceptual tree for predicting loan default:
#
# Is income > 50000?
# |--- Yes: Is credit_score > 700?
# | |--- Yes: APPROVE (leaf)
# | |--- No: Is debt_ratio < 0.4?
# | |--- Yes: APPROVE (leaf)
# | |--- No: REJECT (leaf)
# |--- No: REJECT (leaf)
print('Decision tree makes predictions by asking questions')
print('Each path from root to leaf = one decision rule')Nod, Cabang dan Daun
Pokok keputusan mempunyai tiga jenis komponen: nod akar (soalan pertama yang ditanya — pemisahan paling bermaklumat bagi keseluruhan himpunan data), nod dalaman (soalan perantaraan yang membahagikan lagi subset data), dan nod daun (nod terminal tempat ramalan disimpan). Setiap nod dalaman membahagikan data kepada dua atau lebih subset berdasarkan ambang sesuatu ciri. Kedalaman pokok ialah panjang laluan terpanjang dari akar ke mana-mana daun. Pokok yang lebih dalam boleh mewakili corak yang lebih kompleks tetapi lebih mudah mengalami padanan berlebihan.
# Tree anatomy example
print('Root node: first split on most informative feature')
print('Internal nodes: further splits on subsets')
print('Leaf nodes: final predictions')
print()
print('Depth=1 tree (stump): one question, two leaves')
print('Depth=2 tree: up to three questions, four leaves')
print('Depth=d tree: up to 2^d leaves')
print()
print('More depth = more flexible but higher overfitting risk')Pembahagian Rekursif: Cara Algoritma Membahagi
Pembinaan pokok keputusan ialah algoritma tamak dan rekursif. Pada setiap nod, algoritma menilai setiap pemisahan yang mungkin bagi setiap ciri dan ambang, memilih pemisahan yang paling baik mengasingkan kelas (diukur menggunakan kekotoran Gini atau perolehan maklumat), menggunakan pemisahan itu, kemudian mengulangi proses secara rekursif pada setiap subset yang terhasil. Proses ini berterusan sehingga kriteria pemberhentian dipenuhi: kedalaman maksimum dicapai, bilangan sampel minimum bagi setiap nod dicapai, atau tiada lagi pemisahan yang berguna. Tamak bermaksud pemisahan terbaik secara setempat dipilih pada setiap langkah, tanpa pengunduran — ini mungkin terlepas pemisahan yang optimum secara keseluruhan tetapi menjadikan algoritma lebih mudah dilaksanakan.
# Pseudocode for recursive tree building
def build_tree(X, y, depth=0, max_depth=3):
# Stopping conditions
if len(set(y)) == 1: # All same class
return {'leaf': True, 'prediction': y[0]}
if depth >= max_depth: # Max depth reached
from collections import Counter
return {'leaf': True, 'prediction': Counter(y).most_common(1)[0][0]}
# Find best split
best_feature, best_threshold = find_best_split(X, y)
# Partition data
left_mask = X[:, best_feature] <= best_threshold
right_mask = ~left_mask
return {
'leaf': False,
'feature': best_feature,
'threshold': best_threshold,
'left': build_tree(X[left_mask], y[left_mask], depth+1, max_depth),
'right': build_tree(X[right_mask], y[right_mask], depth+1, max_depth)
}Pemisahan Sejajar Paksi: Ambang pada Ciri Tunggal
Pokok keputusan dalam scikit-learn sentiasa menggunakan pemisahan sejajar paksi (ortogon): setiap soalan bertanya sama ada satu ciri berada di atas atau di bawah sesuatu ambang (contohnya, umur <= 35?). Ini menghasilkan rantau keputusan berbentuk segi empat tepat dalam ruang ciri 2D. Walaupun pendekatan ini mudah dan mudah ditafsirkan, pendekatan ini tidak dapat mewakili sempadan keputusan pepenjuru dengan cekap — contohnya, mengasingkan dua kelas sepanjang garis 45 darjah memerlukan banyak pemisahan. Ensembel pokok (Hutan Rawak) mengatasi masalah ini dengan menggabungkan banyak pokok, setiap satunya dengan pemisahan sejajar paksi yang berbeza dan bersama-sama menghampiri sebarang bentuk sempadan.
import numpy as np
# Simulate finding a split on one feature
feature_values = np.array([10, 20, 30, 40, 50])
labels = np.array([0, 0, 0, 1, 1])
# For each possible threshold between consecutive values:
for threshold in [15, 25, 35, 45]:
left_labels = labels[feature_values <= threshold]
right_labels = labels[feature_values > threshold]
print(f'Threshold {threshold}: left={list(left_labels)}, right={list(right_labels)}')
# Threshold 35 gives perfect separation [0,0,0] vs [1,1]Melatih Pokok Keputusan dengan scikit-learn
DecisionTreeClassifier scikit-learn dilatih melalui satu panggilan kepada fit(). Parameter utama termasuk max_depth (kedalaman maksimum pokok — penting untuk mengawal padanan berlebihan), criterion (ukuran kualiti pemisahan: 'gini' atau 'entropy'), dan min_samples_split (bilangan sampel minimum untuk membahagikan nod — menghalang pembahagian kumpulan yang terlalu kecil). Pokok sedia membuat ramalan sebaik sahaja latihan selesai. Tidak seperti KNN, ramalan mengambil masa O(log N) — hanya ikuti cabang yang telah dipelajari — menjadikan pokok keputusan pantas semasa inferens.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
tree = DecisionTreeClassifier(
max_depth=3,
criterion='gini',
random_state=42
)
tree.fit(X_train, y_train)
print('Train accuracy:', tree.score(X_train, y_train).round(3))
print('Test accuracy:', tree.score(X_test, y_test).round(3))
print('Tree depth:', tree.get_depth())
print('Number of leaves:', tree.get_n_leaves())Mengikuti Laluan Ramalan
Kekuatan pokok keputusan ialah anda boleh menjejaki setiap langkah ramalan satu demi satu. Kaedah decision_path() mengembalikan matriks jarang yang menunjukkan nod yang dilalui oleh setiap sampel. Kaedah apply() mengembalikan indeks nod daun bagi setiap sampel. Alat ini membolehkan anda menerangkan kepada pengguna dengan tepat soalan yang ditanya dan jawapan yang membawa kepada ramalan tersebut — penting untuk pematuhan, penyahpepijatan dan membina kepercayaan dengan pihak berkepentingan bukan teknikal.
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
# Print human-readable decision rules
rules = export_text(tree, feature_names=load_iris().feature_names)
print(rules[:500]) # First 500 chars of the rule printout
# Which leaf does sample 0 land in?
leaf = tree.apply(X[[0]])
print('Sample 0 lands in leaf node:', leaf)Ramalan Pokok pada Nod Daun
Setiap nod daun menyimpan taburan kelas daripada sampel latihan yang sampai kepadanya. Untuk pengelasan, kelas yang diramalkan ialah kelas majoriti dalam daun tersebut. Untuk anggaran kebarangkalian, predict_proba() mengembalikan pecahan bagi setiap kelas dalam daun. Daun yang mengandungi 10 sampel: 9 kelas A dan 1 kelas B meramalkan kelas A dengan kebarangkalian 0.9. Pokok dengan lebih sedikit sampel bagi setiap daun menghasilkan anggaran kebarangkalian yang kurang boleh dipercayai, sebab itulah parameter regularisasi seperti min_samples_leaf penting untuk output kebarangkalian yang ditentukur.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np
X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
# Predicted class and probabilities for first three samples
preds = tree.predict(X[:3])
probas = tree.predict_proba(X[:3])
for i in range(3):
print(f'Sample {i}: class={preds[i]}, probabilities={probas[i].round(3)}')Pokok Keputusan untuk Regresi
DecisionTreeRegressor berfungsi dengan cara yang sama seperti pengelas tetapi meramalkan nilai sasaran min bagi sampel latihan dalam setiap daun. Kriteria pemisahan berubah: bukannya kekotoran Gini, algoritma meminimumkan ralat kuasa dua min (atau ralat mutlak min) dalam setiap nod anak yang terhasil. Pokok regresi menghasilkan ramalan berbentuk fungsi tangga — nilai malar dalam rantau berbentuk segi empat tepat. Dengan kedalaman yang mencukupi, pokok ini boleh memadankan mana-mana data latihan dengan tepat, tetapi hal ini menyebabkan padanan berlebihan yang teruk. Kawal kedalaman dan min_samples_leaf untuk melakukan regularisasi pada pokok regresi.
from sklearn.tree import DecisionTreeRegressor
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(0)
X = np.sort(5 * np.random.rand(80, 1), axis=0)
y = np.sin(X).ravel() + np.random.randn(80) * 0.3
for depth in [1, 3, 10]:
reg = DecisionTreeRegressor(max_depth=depth)
reg.fit(X, y)
mse = np.mean((reg.predict(X) - y)**2)
print(f'max_depth={depth}: train MSE={mse:.4f}')
# depth=10 nearly zero MSE (memorised training data)Kepentingan Ciri daripada Pokok Keputusan
Selepas latihan, tree.feature_importances_ memberikan ukuran tentang sejauh mana setiap ciri menyumbang kepada pemisahan. Kepentingan ciri dikira sebagai jumlah pengurangan kekotoran (Gini atau entropi) yang dikaitkan dengan setiap ciri, dengan pemberat berdasarkan pecahan sampel yang sampai ke setiap pemisahan. Nilainya berjumlah 1.0. Ciri yang paling penting mendapat skor tertinggi. Ini menyediakan cara yang pantas dan mudah ditafsirkan untuk mengenal pasti input yang paling mempengaruhi ramalan — berguna untuk pemilihan ciri, mendapatkan pandangan perniagaan dan mengesan kemungkinan isu data.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import pandas as pd
X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)
importances = pd.Series(tree.feature_importances_, index=feature_names)
print('Feature Importances:')
print(importances.sort_values(ascending=False))Ketakubahan Skala: Pokok Tidak Memerlukan Penskalaan
Satu kelebihan praktikal utama pokok keputusan ialah pokok ini langsung tidak berubah mengikut skala. Pemisahan pada pendapatan <= 50000 dan pemisahan pada pendapatan_ribuan <= 50 menghasilkan struktur pokok yang sama. Menambah 100 kepada semua nilai dalam sesuatu ciri atau mendarabkannya dengan 1000 tidak mengubah pemisahan yang dipilih. Anda tidak perlu menggunakan StandardScaler atau MinMaxScaler sebelum pokok keputusan. Ini juga bermaksud pokok keputusan dapat mengendalikan ciri dengan skala yang sangat berbeza tanpa prapemprosesan, sekali gus memudahkan saluran paip.
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
import numpy as np
X, y = load_iris(return_X_y=True)
# Without scaling
tree1 = DecisionTreeClassifier(random_state=42)
tree1.fit(X, y)
# With scaling (same result expected)
X_scaled = StandardScaler().fit_transform(X)
tree2 = DecisionTreeClassifier(random_state=42)
tree2.fit(X_scaled, y)
print('Without scaling accuracy:', tree1.score(X, y).round(3))
print('With scaling accuracy: ', tree2.score(X_scaled, y).round(3))
# Identical -- scaling has no effect on tree splitsMengendalikan Nilai Hilang dalam Pokok
Pokok keputusan mengendalikan nilai hilang dengan lebih baik berbanding banyak algoritma lain. DecisionTreeClassifier daripada scikit-learn menyokong nilai hilang secara asli apabila splitter='best' — sampel yang mempunyai nilai hilang pada ciri pemisahan dihantar kepada anak yang meminimumkan kekotoran berdasarkan data yang tidak hilang. Sebagai alternatif, anda boleh menggunakan pemisahan pengganti: apabila ciri pemisahan utama hilang bagi sesuatu sampel, ciri yang berkorelasi digunakan sebagai gantinya. Ketahanan terhadap data hilang ini ialah salah satu kelebihan praktikal model berasaskan pokok berbanding kaedah berasaskan jarak seperti KNN yang memerlukan vektor ciri lengkap.
from sklearn.tree import DecisionTreeClassifier
import numpy as np
# Tree can handle NaN values with missing_values support
# In scikit-learn >= 1.0, DecisionTreeClassifier accepts NaN
X = np.array([
[1, 2], [np.nan, 3], [3, np.nan], [4, 5]
])
y = np.array([0, 1, 0, 1])
tree = DecisionTreeClassifier(random_state=42)
tree.fit(X, y)
preds = tree.predict(X)
print('Predictions with NaN features:', preds)
# Tree routes NaN samples gracefullySemakan Pantas
Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.
Imbas Kembali Pelajaran
Dalam pelajaran ini, anda telah mempelajari: cara pokok keputusan membahagikan data secara rekursif menggunakan pemisahan sejajar paksi, bahawa setiap daun menyimpan taburan kelas untuk ramalan berdasarkan undian majoriti, dan bahawa pokok keputusan tidak berubah mengikut skala serta tidak memerlukan penskalaan ciri. Seterusnya, kita akan meneroka kekotoran Gini dan perolehan maklumat — kriteria yang menentukan pemisahan yang perlu dipilih pada setiap nod.
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “Membina Pepohon: Pecahan, Nod dan Daun” percuma?
Ya — teks penuh “Membina Pepohon: Pecahan, Nod dan Daun” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Membina Pepohon: Pecahan, Nod dan Daun”?
Pelajar akan menjejaki cara pepohon keputusan membahagikan data secara rekursif pada setiap nod, daripada akar hingga daun, dan membuat ramalan dengan mengikuti cabang. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.
Berapa lamakah pelajaran “Membina Pepohon: Pecahan, Nod dan Daun” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Membina Pepohon: Pecahan, Nod dan Daun
- Ketulenan Gini dan Perolehan Maklumat
- Mengawal Kedalaman Pepohon untuk Mencegah Terlebih Muat
- Memvisualisasikan dan Mentafsir Pepohon Keputusan