PricingLoginStart free
Machine Learning Academy · Pelajaran

Memvisualisasikan dan Mentafsir Pepohon Keputusan

Pelajar akan mengeksport dan memaparkan pepohon dengan plot_tree sklearn, membaca peraturan keputusan, dan mengekstrak kepentingan ciri untuk laporan pihak berkepentingan.

Pelajaran 4 daripada 413 langkah

Memvisualisasikan dan Mentafsir Pepohon Keputusan ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 4 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.

Mengapa Visualisasi Pepohon Penting

Pepohon keputusan sering dipanggil model kotak putih kerana logik keputusannya telus sepenuhnya. Memvisualkan pepohon yang telah dilatih membolehkan anda: mengesahkan bahawa model membuat keputusan berdasarkan ciri yang munasabah, menerangkan ramalan kepada pihak berkepentingan bukan teknikal, mengenal pasti isu kualiti data yang berpotensi (contohnya, ciri yang sepatutnya tidak penting tetapi muncul pada akar), dan menyahpepijat tingkah laku yang tidak dijangka. Visualisasi menukarkan struktur matematik pepohon kepada carta alir yang boleh dibaca manusia dan boleh disahkan oleh pakar bidang berdasarkan pengetahuan mereka.

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

X, y = load_iris(return_X_y=True)
feature_names = load_iris().feature_names
class_names   = load_iris().target_names

tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)

plt.figure(figsize=(14, 6))
plot_tree(tree,
          feature_names=feature_names,
          class_names=class_names,
          filled=True,      # Color by majority class
          rounded=True,     # Rounded boxes
          fontsize=10)
plt.title('Iris Decision Tree (depth=3)')
plt.show()

Membaca Nod dalam Output plot_tree

Setiap nod dalam output plot_tree memaparkan empat maklumat: (1) Syarat pembahagian (contohnya, petal length <= 2.45), (2) impurity Gini nod tersebut, (3) bilangan sampel yang sampai ke nod ini semasa latihan, dan (4) taburan kelas sebagai senarai bilangan sampel bagi setiap kelas. Nod daun memaparkan keempat-empat maklumat tetapi tiada syarat pembahagian — kelas majoriti ialah ramalan. Keamatan warna nod menunjukkan ketulenan: lebih gelap = lebih banyak sampel daripada kelas dominan.

# Interpreting node output from plot_tree:
#
# petal length (cm) <= 2.45     <- split condition
# gini = 0.667                  <- impurity before split
# samples = 150                 <- training samples reaching node
# value = [50, 50, 50]          <- samples per class [setosa, versicolor, virginica]
# class = setosa                <- majority class (prediction if leaf)

print('Gini 0.667 = equal 3-class split (maximum 3-class impurity)')
print('samples=150 at root = all training samples')
print('value=[50,50,50] = perfectly balanced classes')

Mengeksport Pepohon sebagai Teks dengan export_text

Untuk pembalakan, laporan atau persekitaran tanpa paparan grafik, export_text() menghasilkan perwakilan pepohon berasaskan teks. Setiap aras inden mewakili satu aras pembahagian. Aksara paip menunjukkan cabang, manakala baris daun menunjukkan kelas yang diramalkan. Format ini berguna untuk memasukkan peraturan keputusan dalam dokumentasi, menyimpan dalam fail log atau memaparkan dalam persekitaran baris perintah. Format ini juga membolehkan struktur pepohon dibandingkan secara berangka merentas konfigurasi hiperparameter yang berbeza.

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)

text_repr = export_text(
    tree,
    feature_names=list(load_iris().feature_names)
)
print(text_repr)

Mengeksport kepada Format Graphviz DOT

export_graphviz() menjana fail bahasa DOT yang boleh dirender sebagai SVG atau PNG berkualiti tinggi menggunakan Graphviz. Kaedah ini amat sesuai untuk gambar rajah pepohon berkualiti pembentangan dan pepohon besar yang perlu ditatal untuk dilihat. Fail DOT juga boleh ditukar kepada PDF atau dibenamkan dalam laporan. Dalam Jupyter, gunakan graphviz.Source(dot_data) untuk merendernya secara sebaris. Pendekatan ini memberikan kawalan penuh terhadap saiz fon, skema warna dan susun atur — penting apabila pepohon dikongsi dengan pihak berkepentingan perniagaan.

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

X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)

dot_data = export_graphviz(
    tree,
    out_file=None,
    feature_names=load_iris().feature_names,
    class_names=load_iris().target_names,
    filled=True, rounded=True,
    special_characters=True
)
# graph = graphviz.Source(dot_data)  # Renders in Jupyter
# graph.render('iris_tree', format='png')  # Save as PNG

Kepentingan Ciri: Apakah yang Mendorong Model?

Selepas latihan, tree.feature_importances_ menunjukkan sumbangan relatif setiap ciri input terhadap ramalan model. Ciri yang digunakan pada akar dan aras atas biasanya mempunyai kepentingan yang tinggi kerana pecahannya mempengaruhi semua sampel latihan. Ciri yang hanya digunakan pada daun yang dalam mempunyai kepentingan yang rendah. Memetakan kepentingan ciri sebagai carta bar ialah langkah standard dalam mana-mana analisis berasaskan pepohon — langkah ini mengesahkan bahawa model bergantung pada ciri yang munasabah dan berkaitan dengan domain, bukannya korelasi palsu yang kebetulan berkesan pada data latihan.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
import pandas as pd
import matplotlib.pyplot as plt

X, y = load_breast_cancer(return_X_y=True)
features = load_breast_cancer().feature_names

tree = DecisionTreeClassifier(max_depth=5, random_state=42)
tree.fit(X, y)

imp = pd.Series(tree.feature_importances_, index=features).sort_values(ascending=False)

imp.head(10).plot(kind='barh')
plt.title('Top 10 Feature Importances')
plt.xlabel('Importance')
plt.gca().invert_yaxis()
plt.show()

print('Top feature:', imp.index[0], '(importance:', imp.iloc[0].round(3), ')')

Menjejaki Satu Ramalan

Kaedah decision_path() mengembalikan matriks penunjuk jarang yang menunjukkan nod yang dilalui oleh setiap sampel. Dengan menggabungkannya dengan tree.tree_, anda boleh membina semula urutan keputusan yang tepat bagi mana-mana ramalan. Inilah asas sistem penerangan automatik: bagi setiap ramalan, anda boleh menjana senarai peraturan yang mudah difahami manusia seperti 'panjang kelopak ialah 1.4 cm (≤2.45), jadi bergerak ke kiri; berakhir pada daun yang meramalkan setosa.' Tahap ketelusan ini diperlukan dalam domain yang dikawal selia, apabila setiap keputusan mesti boleh diaudit.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
import numpy as np

X, y = load_iris(return_X_y=True)
features = load_iris().feature_names
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)

# Trace the path for sample 0
node_indicator = tree.decision_path(X[[0]])
nodes_visited = node_indicator.indices

T = tree.tree_
for node in nodes_visited[:-1]:  # All except leaf
    feature = features[T.feature[node]]
    threshold = T.threshold[node]
    val = X[0, T.feature[node]]
    direction = 'left (<= )' if val <= threshold else 'right (> )'
    print(f'Node {node}: {feature} = {val:.2f}, threshold={threshold:.2f} -> {direction}')

Mentafsir Syarat Pecahan untuk Pihak Berkepentingan

Apabila menerangkan keputusan pepohon kepada pihak berkepentingan bukan teknikal, tukarkan syarat pecahan matematik kepada pernyataan dalam bahasa mudah. Daripada 'petal length (cm) <= 2.45: gini=0.0, samples=50', katakan 'Jika kelopak lebih pendek daripada 2.45 cm, bunga itu hampir pasti Setosa.' Bingkaikan setiap cabang berdasarkan makna perniagaan ciri tersebut. Pepohon keputusan amat sesuai untuk komunikasi dengan pihak berkepentingan berbanding model ML lain kerana setiap keputusan sepadan dengan peraturan perniagaan yang boleh diuji dan ditafsir.

# Human-readable rule extraction from a trained tree
from sklearn.tree import _tree

def extract_rules(tree, feature_names, class_names):
    T = tree.tree_
    rules = []
    
    def recurse(node, path):
        if T.feature[node] != _tree.TREE_UNDEFINED:
            feat = feature_names[T.feature[node]]
            thresh = T.threshold[node]
            recurse(T.children_left[node],  path + [f'{feat} <= {thresh:.2f}'])
            recurse(T.children_right[node], path + [f'{feat} > {thresh:.2f}'])
        else:
            majority_class = class_names[T.value[node].argmax()]
            rules.append(' AND '.join(path) + f' => {majority_class}')
    
    recurse(0, [])
    return rules

Plot Kebergantungan Separa bagi Ciri Individu

Walaupun kepentingan ciri menunjukkan ciri yang mana paling penting, Plot Kebergantungan Separa (PDP) menunjukkan cara sesuatu ciri mempengaruhi ramalan. PDP meminggirkan semua ciri lain dan memplot output ramalan model sebagai fungsi bagi satu atau dua ciri. Bagi pepohon keputusan, PDP menghasilkan bentuk fungsi tangga yang mencerminkan ambang pecahan yang sejajar dengan paksi. PartialDependenceDisplay Scikit-learn menjana plot ini terus daripada pepohon yang telah dipasang, sekali gus memudahkan penerangan tentang kesan ciri individu kepada pakar domain.

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

X, y = load_iris(return_X_y=True)
features = load_iris().feature_names

tree = DecisionTreeClassifier(max_depth=4, random_state=42)
tree.fit(X, y)

# PDP for the two most important features
fig, ax = plt.subplots(figsize=(10, 4))
PartialDependenceDisplay.from_estimator(
    tree, X, features=[2, 3],  # petal length and petal width
    feature_names=features, ax=ax
)
plt.tight_layout()
plt.show()

Membandingkan Struktur Pepohon Merentas Hiperparameter

Memvisualkan perubahan struktur pepohon mengikut kedalaman membantu membina intuisi. Pepohon berkedalaman 1 (tunggul) mempunyai satu pecahan dan dua daun — ciri tunggal yang paling penting. Pepohon berkedalaman 2 memperincikan kedua-dua cabang dengan aras soalan kedua. Membandingkan pepohon pada kedalaman 1, 3 dan 5 menggunakan set data yang sama menunjukkan cara model membina logik keputusan yang semakin kompleks. Jika pepohon berkedalaman 5 menggunakan ciri yang sama seperti pepohon berkedalaman 3 pada aras teratasnya, ciri tersebut benar-benar penting. Jika ciri baharu yang kurang jelas muncul pada kedalaman 5, ciri itu berkemungkinan menangkap hingar.

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

X, y = load_iris(return_X_y=True)
feat_names = list(load_iris().feature_names)

for depth in [1, 3, 5]:
    tree = DecisionTreeClassifier(max_depth=depth, random_state=42)
    tree.fit(X, y)
    print(f'\n--- max_depth={depth}, leaves={tree.get_n_leaves()} ---')
    print(export_text(tree, feature_names=feat_names)[:300])

Menggunakan Pepohon untuk Menjana Peraturan Perniagaan

Salah satu kegunaan pepohon keputusan yang paling bernilai dalam industri ialah menjana peraturan perniagaan yang jelas yang boleh dilaksanakan dalam enjin peraturan, hamparan atau sistem legasi yang tidak dapat menjalankan model ML. Setiap laluan dari akar ke daun ialah peraturan IF-THEN yang lengkap. Peraturan ini boleh diterjemahkan kepada klausa SQL WHERE, kamus Python atau kad skor penilaian kredit. Dengan mengawal kedalaman pepohon dan kekangan sampel minimum dengan teliti, anda boleh menjana set peraturan yang kecil dan berketepatan tinggi untuk disemak, diluluskan dan diselenggara secara manual oleh penganalisis perniagaan.

# Generate SQL-like rules from a trained decision tree
from sklearn.tree import _tree

def tree_to_sql(tree, feature_names, class_names):
    T = tree.tree_
    rules = []
    
    def traverse(node, conditions):
        if T.feature[node] != _tree.TREE_UNDEFINED:
            fname = feature_names[T.feature[node]]
            thresh = T.threshold[node]
            traverse(T.children_left[node],
                     conditions + [f'{fname} <= {thresh:.3f}'])
            traverse(T.children_right[node],
                     conditions + [f'{fname} > {thresh:.3f}'])
        else:
            pred = class_names[T.value[node].argmax()]
            where = ' AND '.join(conditions)
            rules.append(f'WHEN {where} THEN {pred!r}')
    
    traverse(0, [])
    return 'CASE\n  ' + '\n  '.join(rules) + '\nEND',

Menyimpan Visualisasi Pepohon dalam Fail

Menyimpan visualisasi pepohon dalam fail menjadikannya mudah dikongsi dalam laporan, pembentangan dan dokumentasi model. Dengan plot_tree dan matplotlib, simpan sebagai PNG atau SVG menggunakan plt.savefig(). Dengan Graphviz, render terus kepada PDF. Untuk penerokaan interaktif dalam buku nota Jupyter, SVG sebaris memberikan output yang paling jelas kerana ia boleh diskalakan tanpa had — berguna untuk pepohon dalam yang akan kelihatan kabur jika disimpan sebagai PNG beresolusi tetap. Untuk bahan yang disediakan bagi pihak berkepentingan, sentiasa eksport pada DPI tinggi (300+) atau dalam format SVG vektor supaya teks dalam nod kekal tajam apabila dizum.

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

X, y = load_iris(return_X_y=True)
tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X, y)

# Save as high-DPI PNG for reports
fig, ax = plt.subplots(figsize=(16, 8))
plot_tree(tree, feature_names=load_iris().feature_names,
          class_names=load_iris().target_names,
          filled=True, rounded=True, ax=ax, fontsize=10)
fig.savefig('iris_decision_tree.png', dpi=200, bbox_inches='tight')
fig.savefig('iris_decision_tree.svg', format='svg', bbox_inches='tight')
print('Saved PNG and SVG tree visualisations')

Semakan Pantas

Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini, anda mempelajari: cara memvisualkan pepohon keputusan menggunakan plot_tree, export_text dan export_graphviz, cara membaca maklumat nod (syarat pecahan, Gini, sampel, nilai), serta cara mengekstrak kepentingan ciri dan laluan keputusan untuk komunikasi dengan pihak berkepentingan. Seterusnya, kita akan meneroka Naive Bayes — pengelas kebarangkalian yang menggunakan teorem Bayes untuk membuat ramalan.

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
30
Pelajaran
120
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Memvisualisasikan dan Mentafsir Pepohon Keputusan” percuma?

Ya — teks penuh “Memvisualisasikan dan Mentafsir Pepohon Keputusan” 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 “Memvisualisasikan dan Mentafsir Pepohon Keputusan”?

Pelajar akan mengeksport dan memaparkan pepohon dengan plot_tree sklearn, membaca peraturan keputusan, dan mengekstrak kepentingan ciri untuk laporan pihak berkepentingan. 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 4 daripada 4.

Berapa lamakah pelajaran “Memvisualisasikan dan Mentafsir Pepohon Keputusan” 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

  1. Membina Pepohon: Pecahan, Nod dan Daun
  2. Ketulenan Gini dan Perolehan Maklumat
  3. Mengawal Kedalaman Pepohon untuk Mencegah Terlebih Muat
  4. Memvisualisasikan dan Mentafsir Pepohon Keputusan
← Kembali ke Machine Learning Academy