Pelajari AI dengan Python · Pelajaran

Pepohon Keputusan: Teori dan Pelaksanaan

Ketidakmurnian Gini, perolehan maklumat, kedalaman pepohon dan terlebih suai — sklearn DecisionTreeClassifier.

Pelajaran 1 daripada 413 langkah

Pepohon Keputusan: Teori dan Pelaksanaan ialah pelajaran Pelajari AI dengan Python percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pelajari AI dengan Python, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pelajari AI dengan Python merangkumi sejumlah 4 pelajaran.

Apakah Pepohon Keputusan

Pepohon keputusan membahagikan data kepada cabang berdasarkan nilai ciri, dengan mengemukakan soalan ya atau tidak sehingga mencapai ramalan pada nod daun.

Setiap nod dalaman menguji satu ciri, setiap cabang ialah satu hasil dan setiap daun menetapkan satu kelas. Pepohon mudah ditafsir kerana anda boleh mengikuti laluan keputusan.

Ketidakmurnian Gini

Ketidakmurnian Gini mengukur sejauh mana kelas bercampur dalam sesuatu nod. Nod tulen (semuanya daripada satu kelas) mempunyai nilai Gini 0.

Formulanya ialah Gini = 1 - sum(p_i^2), dengan p_i ialah pecahan kelas i. Pepohon memilih pemisahan yang paling banyak mengurangkan ketidakmurnian.

import numpy as np

def gini(labels):
    classes, counts = np.unique(labels, return_counts=True)
    probs = counts / counts.sum()
    return 1 - np.sum(probs ** 2)

print(gini([0, 0, 1, 1]))   # 0.5 (max mix)
print(gini([0, 0, 0, 0]))   # 0.0 (pure)

Perolehan Maklumat dan Entropy

Kriteria pemisahan alternatif ialah perolehan maklumat, yang berdasarkan entropy. Entropy ialah -sum(p_i * log2(p_i)).

Perolehan maklumat = entropy (induk) - entropy berwajaran (anak). Gini dan entropy biasanya menghasilkan pepohon yang serupa; Gini sedikit lebih pantas untuk dikira.

import numpy as np

def entropy(labels):
    _, counts = np.unique(labels, return_counts=True)
    p = counts / counts.sum()
    return -np.sum(p * np.log2(p))

print(entropy([0, 0, 1, 1]))   # 1.0
print(entropy([0, 0, 0, 1]))   # ~0.81

Melatih DecisionTreeClassifier

Scikit-learn menyediakan DecisionTreeClassifier. Anda memilih kriteria pemisahan dengan parameter criterion (gini atau entropy).

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

X, y = load_iris(return_X_y=True)
Xtr, Xte, ytr, yte = train_test_split(X, y, random_state=0)

clf = DecisionTreeClassifier(criterion="gini", random_state=0)
clf.fit(Xtr, ytr)
print("Accuracy:", clf.score(Xte, yte))

Terlebih Suaian dan max_depth

Pepohon tanpa kekangan berkembang sehingga setiap daun menjadi tulen dan menghafal hingar. Pepohon itu mengalami terlebih suaian.

Parameter max_depth mengehadkan kedalaman pertumbuhan pepohon, lalu memaksanya membuat generalisasi. Kedalaman yang lebih kecil = model yang lebih ringkas = kurang terlebih suaian.

from sklearn.tree import DecisionTreeClassifier

shallow = DecisionTreeClassifier(max_depth=3, random_state=0)
deep = DecisionTreeClassifier(max_depth=None, random_state=0)
# shallow generalizes better on unseen data;
# deep often overfits the training set

Parameter Pemangkasan Awal Lain

Selain max_depth, anda boleh mengawal pertumbuhan dengan:

min_samples_split bilangan minimum sampel untuk memisahkan nod
min_samples_leaf bilangan minimum sampel dalam daun
max_leaf_nodes had jumlah daun

Semua parameter ini mengurangkan varians dan menangani terlebih suaian.

from sklearn.tree import DecisionTreeClassifier

clf = DecisionTreeClassifier(
    max_depth=5,
    min_samples_split=10,
    min_samples_leaf=5,
    random_state=0,
)

Memvisualkan dengan plot_tree

plot_tree melukis keseluruhan pepohon supaya anda boleh membaca setiap pemisahan, nilai Gini dan taburan kelas pada setiap nod.

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
clf = DecisionTreeClassifier(max_depth=3).fit(X, y)

plt.figure(figsize=(12, 6))
plot_tree(clf, filled=True, feature_names=load_iris().feature_names)
plt.show()

Kepentingan Ciri

Selepas melatih model, feature_importances_ memberitahu anda sejauh mana setiap ciri mengurangkan ketidakmurnian merentas semua pemisahan. Jumlah nilainya ialah 1.0.

Ini ialah cara pantas untuk menyusun ciri masukan yang paling penting bagi model.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris

data = load_iris()
clf = DecisionTreeClassifier(max_depth=3).fit(data.data, data.target)

for name, imp in zip(data.feature_names, clf.feature_importances_):
    print(f"{name}: {imp:.3f}")

Pemangkasan Kerumitan Kos (ccp_alpha)

Pemangkasan selepas latihan membesarkan pepohon penuh kemudian memangkas cabang yang lemah. Parameter ccp_alpha mengawal keagresifan pemangkasan: nilai alpha yang lebih tinggi membuang lebih banyak nod.

Gunakan cost_complexity_pruning_path untuk mencari nilai alpha calon.

from sklearn.tree import DecisionTreeClassifier

base = DecisionTreeClassifier(random_state=0)
path = base.cost_complexity_pruning_path(Xtr, ytr)
alphas = path.ccp_alphas

pruned = DecisionTreeClassifier(ccp_alpha=0.01, random_state=0)
pruned.fit(Xtr, ytr)

Memilih Nilai Alpha Terbaik

Untuk memilih ccp_alpha, latih satu pepohon bagi setiap nilai alpha calon dan bandingkan ketepatan pengesahan. Nilai alpha terbaik mengimbangi ketepatan dan kesederhanaan.

from sklearn.tree import DecisionTreeClassifier

scores = []
for a in alphas:
    t = DecisionTreeClassifier(ccp_alpha=a, random_state=0)
    t.fit(Xtr, ytr)
    scores.append((a, t.score(Xte, yte)))

best = max(scores, key=lambda s: s[1])
print("Best alpha:", best[0])

Kekuatan dan Kelemahan

Kelebihan: mudah ditafsir, tidak memerlukan penskalaan, mengendalikan sempadan tak linear dan jenis data bercampur.

Kekurangan: varians tinggi (perubahan kecil pada data boleh mengubah pepohon), mudah mengalami terlebih suaian dan hanya menggunakan pemisahan sejajar paksi. Kelemahan ini mendorong penggunaan ensembel seperti hutan rawak.

Semakan Pantas

Uji pemahaman anda tentang konsep pepohon keputusan.

Jawab dalam pelajaran interaktif

Ringkasan

Ringkasan: Pepohon keputusan membahagikan data menggunakan ketidakmurnian Gini atau perolehan maklumat. Kawal terlebih suaian dengan pemangkasan awal (max_depth, min_samples_leaf) atau pemangkasan selepas latihan (ccp_alpha). Periksa model dengan plot_tree dan feature_importances_. Variansnya yang tinggi mendorong penggunaan kaedah ensembel.

Percuma untuk bermula

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: 53
Pelajaran: 225

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pepohon Keputusan: Teori dan Pelaksanaan” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Pelajari AI dengan Python, termasuk “Pepohon Keputusan: Teori dan Pelaksanaan”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Pelajari AI dengan Python merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pepohon Keputusan: Teori dan Pelaksanaan”?

Ketidakmurnian Gini, perolehan maklumat, kedalaman pepohon dan terlebih suai — sklearn DecisionTreeClassifier. Anda berlatih Pelajari AI dengan Python 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 Pelajari AI dengan Python?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pelajari AI dengan Python 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 “Pepohon Keputusan: Teori dan Pelaksanaan” 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 Pelajari AI dengan Python ini?

Ya. Setiap pelajaran Pelajari AI dengan Python 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

Pepohon Keputusan: Teori dan Pelaksanaan
Hutan Rawak dan Bagging
Peningkatan Kecerunan: GBM dan XGBoost
LightGBM dan CatBoost

← Kembali ke Pelajari AI dengan Python