Learn AI with Python · บทเรียน

ต้นไม้ตัดสินใจ: ทฤษฎีและการนำไปใช้

ความไม่บริสุทธิ์ของ Gini สารสนเทศที่เพิ่มขึ้น ความลึกของต้นไม้ การฟิตเกิน และ sklearn DecisionTreeClassifier

ต้นไม้ตัดสินใจ: ทฤษฎีและการนำไปใช้ เป็นบทเรียน Learn AI with Python ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn AI with Python และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน

ต้นไม้ตัดสินใจคืออะไร

ต้นไม้ตัดสินใจแบ่งข้อมูลออกเป็นกิ่งตามค่าคุณลักษณะ โดยถามคำถามใช่หรือไม่ใช่ไปเรื่อย ๆ จนได้การทำนายที่โหนดใบ

โหนดภายในแต่ละโหนดจะทดสอบคุณลักษณะหนึ่งรายการ แต่ละกิ่งคือผลลัพธ์หนึ่งแบบ และแต่ละใบจะกำหนดประเภท ต้นไม้อธิบายได้ง่าย เพราะคุณสามารถติดตามเส้นทางของการตัดสินใจได้

ความไม่บริสุทธิ์ของ gini

ความไม่บริสุทธิ์ของ giniใช้วัดว่าประเภทต่าง ๆ ในโหนดปะปนกันมากเพียงใด โหนดบริสุทธิ์ (มีประเภทเดียวทั้งหมด) มีค่า gini เท่ากับ 0

สูตรคือ Gini = 1 - sum(p_i^2) โดย p_i คือสัดส่วนของประเภท i ต้นไม้จะเลือกการแบ่งที่ลดความไม่บริสุทธิ์ได้มากที่สุด

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)

การเพิ่มพูนสารสนเทศและ entropy

เกณฑ์การแบ่งอีกแบบหนึ่งคือ การเพิ่มพูนสารสนเทศ ซึ่งอาศัย entropy โดย entropy คือ -sum(p_i * log2(p_i))

การเพิ่มพูนสารสนเทศ = entropy(โหนดแม่) - entropy(โหนดลูก) แบบถ่วงน้ำหนัก โดยทั่วไป gini และ entropy ให้ต้นไม้ที่คล้ายกัน ส่วน gini คำนวณได้เร็วกว่าเล็กน้อย

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

การฝึก DecisionTreeClassifier

Scikit-learn มี DecisionTreeClassifier ให้ใช้ คุณเลือกเกณฑ์การแบ่งได้ด้วยพารามิเตอร์ criterion (gini หรือ 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))

การปรับเข้ากับข้อมูลมากเกินไปและความลึกสูงสุด

ต้นไม้ที่ไม่มีข้อจำกัดจะเติบโตจนใบทุกใบบริสุทธิ์ และจดจำสัญญาณรบกวนไว้ทั้งหมด นี่คือการปรับเข้ากับข้อมูลมากเกินไป

พารามิเตอร์ max_depth จำกัดความลึกที่ต้นไม้จะเติบโตได้ ทำให้ต้นไม้ต้องสรุปใช้กับข้อมูลใหม่ได้ ความลึกที่น้อยลง = แบบจำลองที่เรียบง่ายขึ้น = การปรับเข้ากับข้อมูลมากเกินไปน้อยลง

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

พารามิเตอร์การตัดแต่งล่วงหน้าอื่น ๆ

นอกจาก max_depth แล้ว คุณยังควบคุมการเติบโตได้ด้วย:

min_samples_split จำนวนตัวอย่างขั้นต่ำสำหรับแบ่งโหนด
min_samples_leaf จำนวนตัวอย่างขั้นต่ำในใบ
max_leaf_nodes ขีดจำกัดจำนวนใบทั้งหมด

พารามิเตอร์เหล่านี้ช่วยลดความแปรปรวนและจัดการกับการปรับเข้ากับข้อมูลมากเกินไป

from sklearn.tree import DecisionTreeClassifier

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

การแสดงภาพด้วย plot_tree

plot_tree วาดต้นไม้ทั้งต้น เพื่อให้คุณอ่านการแบ่งทุกครั้ง ค่า gini และการกระจายของประเภทในแต่ละโหนดได้

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()

ความสำคัญของคุณลักษณะ

หลังฝึกแบบจำลองแล้ว feature_importances_ จะบอกว่าคุณลักษณะแต่ละรายการลดความไม่บริสุทธิ์ลงมากเพียงใดจากการแบ่งทั้งหมด ค่าต่าง ๆ sum รวมกันได้ 1.0

นี่เป็นวิธีที่รวดเร็วในการจัดอันดับว่าข้อมูลนำเข้าใดสำคัญต่อแบบจำลองมากที่สุด

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}")

การตัดแต่งตามความซับซ้อนของต้นไม้

การตัดแต่งภายหลังจะสร้างต้นไม้ให้เต็มที่ก่อน แล้วจึงตัดกิ่งที่อ่อนแอออก พารามิเตอร์ ccp_alpha ควบคุมความเข้มงวดของการตัดแต่ง โดยค่า alpha ที่สูงขึ้นจะลบโหนดออกมากขึ้น

ใช้ cost_complexity_pruning_path เพื่อค้นหาค่า alpha ที่เป็นตัวเลือก

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)

การเลือกค่าอัลฟาที่ดีที่สุด

ในการเลือก ccp_alpha ให้ฝึกต้นไม้หนึ่งต้นต่อค่า alpha ที่เป็นตัวเลือกแต่ละค่า แล้วเปรียบเทียบความแม่นยำจากการตรวจสอบ ค่า alpha ที่ดีที่สุดจะสร้างสมดุลระหว่างความแม่นยำและความเรียบง่าย

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])

จุดแข็งและจุดอ่อน

ข้อดี: อธิบายได้ง่าย ไม่ต้องปรับมาตราส่วน รองรับขอบเขตที่ไม่เป็นเชิงเส้น และรองรับชนิดข้อมูลผสม

ข้อเสีย: ความแปรปรวนสูง (การเปลี่ยนแปลงข้อมูลเพียงเล็กน้อยก็ทำให้ต้นไม้เปลี่ยนได้) มีแนวโน้มปรับเข้ากับข้อมูลมากเกินไป และแบ่งตามแนวแกนเท่านั้น จุดอ่อนเหล่านี้เป็นเหตุผลให้ใช้วิธีรวมแบบจำลอง เช่น ป่าสุ่ม

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจแนวคิดเกี่ยวกับต้นไม้ตัดสินใจ

สรุป

สรุป: ต้นไม้ตัดสินใจแบ่งข้อมูลโดยใช้ ความไม่บริสุทธิ์ของ gini หรือ การเพิ่มพูนสารสนเทศ ควบคุมการปรับเข้ากับข้อมูลมากเกินไปด้วยการตัดแต่งล่วงหน้า (max_depth, min_samples_leaf) หรือการตัดแต่งภายหลัง (ccp_alpha) ตรวจสอบแบบจำลองด้วย plot_tree และ feature_importances_ ความแปรปรวนสูงของต้นไม้เป็นเหตุผลให้ใช้วิธีรวมแบบจำลอง

คำถามที่พบบ่อย

บทเรียน “ต้นไม้ตัดสินใจ: ทฤษฎีและการนำไปใช้” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ต้นไม้ตัดสินใจ: ทฤษฎีและการนำไปใช้” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn AI with Python ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ต้นไม้ตัดสินใจ: ทฤษฎีและการนำไปใช้”

ความไม่บริสุทธิ์ของ Gini สารสนเทศที่เพิ่มขึ้น ความลึกของต้นไม้ การฟิตเกิน และ sklearn DecisionTreeClassifier คุณปฏิบัติ Learn AI with Python ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn AI with Python หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn AI with Python บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “ต้นไม้ตัดสินใจ: ทฤษฎีและการนำไปใช้” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn AI with Python นี้ได้ไหม

ได้ บทเรียน Learn AI with Python ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn AI with Python