Decision tree (cây quyết định): plot_tree, export_text
Bài 1/10 · Chương 6
Cây quyết định, Random Forest và boosting
- 11 phút
- Trung cấp
- Python 3.14
- Cập nhật
Trong bài này · 13
Một decision tree, hay cây quyết định, đoán nhãn của một dòng bằng cách hỏi lần lượt từng câu "cột này có vượt ngưỡng kia không?". Trả lời xong một câu thì đi tiếp sang câu khác hay dừng ở một kết luận; cột nào được hỏi, ngưỡng bao nhiêu là do fit tìm ra từ dữ liệu. Bạn dùng nó khi cần một model mà người không đọc code vẫn hiểu được, như một bảng quy tắc nhận diện hội viên dễ rời bỏ để cửa hàng gọi điện trước.
Cần biết trước: logistic regression, ROC-AUC và câu lệnh if else.
Cây đầu tiên trên bảng 12 hội viên
Bảng dưới có 12 hội viên giả lập với hai cột: số lần đăng nhập trong 30 ngày và số lần khiếu nại. DecisionTreeClassifier dùng fit, predict như các model khác của scikit-learn. max_depth=2 cho phép cây hỏi tối đa hai tầng, còn export_text() in cây thành chữ, mỗi tầng thụt vào một bậc:
import pandas as pd
from sklearn.tree import DecisionTreeClassifier, export_text
bang = pd.DataFrame({
"dang_nhap": [12, 3, 8, 1, 15, 2, 9, 0, 6, 4, 11, 2],
"khieu_nai": [0, 2, 0, 0, 1, 3, 0, 1, 2, 0, 0, 1],
"roi_bo": [0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1]})
X, y = bang[["dang_nhap", "khieu_nai"]], bang["roi_bo"]
cay = DecisionTreeClassifier(max_depth=2, random_state=0).fit(X, y)
print(export_text(cay, feature_names=list(X.columns)))KẾT QUẢ
|--- dang_nhap <= 3.50
| |--- class: 1
|--- dang_nhap > 3.50
| |--- khieu_nai <= 1.50
| | |--- class: 0
| |--- khieu_nai > 1.50
| | |--- class: 1
Trong cây, chỗ đặt câu hỏi gọi là nút (node), đường đi theo từng câu trả lời gọi là nhánh (branch), điểm dừng có kết luận gọi là lá (leaf). Cây này có hai nút hỏi và ba lá. Ngưỡng 3.50 nằm giữa hai giá trị kề nhau của cột (3 và 4), vì máy thử các điểm giữa như vậy và giữ ngưỡng tách hai lớp tốt nhất. Viết lại cây bằng if của Python thì được đúng một hàm:
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
bang = pd.DataFrame({
"dang_nhap": [12, 3, 8, 1, 15, 2, 9, 0, 6, 4, 11, 2],
"khieu_nai": [0, 2, 0, 0, 1, 3, 0, 1, 2, 0, 0, 1],
"roi_bo": [0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1]})
X, y = bang[["dang_nhap", "khieu_nai"]], bang["roi_bo"]
cay = DecisionTreeClassifier(max_depth=2, random_state=0).fit(X, y)
def luat(dang_nhap, khieu_nai):
if dang_nhap <= 3.5:
return 1
return 1 if khieu_nai > 1.5 else 0
tay = [luat(d, k) for d, k in zip(X["dang_nhap"], X["khieu_nai"])]
print(tay)
print(cay.predict(X).tolist() == tay)KẾT QUẢ
[0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1]
TrueHàm viết tay và model cho cùng 12 dự đoán; khác ở chỗ ngưỡng do fit chọn. plot_tree() vẽ cùng cây đó lên một ax: filled=True tô màu theo lớp đa số, impurity=False bỏ dòng Gini, proportion=True in tỉ lệ thay cho số đếm:
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.tree import DecisionTreeClassifier, plot_tree
bang = pd.DataFrame({
"dang_nhap": [12, 3, 8, 1, 15, 2, 9, 0, 6, 4, 11, 2],
"khieu_nai": [0, 2, 0, 0, 1, 3, 0, 1, 2, 0, 0, 1],
"roi_bo": [0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1]})
X, y = bang[["dang_nhap", "khieu_nai"]], bang["roi_bo"]
cay = DecisionTreeClassifier(max_depth=2, random_state=0).fit(X, y)
fig, ax = plt.subplots(figsize=(6.4, 3.6), layout="constrained")
plot_tree(cay, feature_names=list(X.columns), ax=ax, filled=True,
impurity=False, proportion=True, precision=2,
class_names=["ở lại", "rời bỏ"], fontsize=9)
ax.set_title("Cây hai tầng trên 12 hội viên")
plt.show()Mỗi ô ghi câu hỏi, samples (phần hội viên đi tới ô), value (tỉ lệ hai lớp) và lớp đa số.
Gini: một nút lẫn lộn đến đâu
Để chọn câu hỏi, cây đo độ vẩn đục (impurity) của mỗi nhóm hội viên: nhóm toàn người ở lại hay toàn người rời bỏ là nhóm "trong", nhóm chia đôi là nhóm "đục" nhất. scikit-learn mặc định đo bằng Gini impurity:
Trong đó:
K: số lớp của nhãn (ở đây 2: ở lại, rời bỏ);p_k(so_mau_lop_k / so_mau_cua_nut): tỉ lệ mẫu thuộc lớp thứ k trong nút;G: Gini của nút, bằng 0 khi mọi mẫu cùng một lớp, lớn nhất là 1 − 1/K khi các lớp chia đều.
Tính tay cho nút dang_nhap > 3.50 của cây trên: nút có 7 hội viên, 6 ở lại và 1 rời bỏ.
Bước | Phép tính | Kết quả |
|---|---|---|
Tỉ lệ ở lại | 6 / 7 | 0,857 |
Tỉ lệ rời bỏ | 1 / 7 | 0,143 |
Tổng bình phương | 0,857² + 0,143² | 0,755 |
Gini | 1 − 0,755 | 0,245 |
Python thuần tính lại đúng các bước đó, rồi so với con số cây đã lưu trong cay.tree_.impurity (một mảng, mỗi phần tử là Gini của một nút, nút 0 là gốc):
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
bang = pd.DataFrame({
"dang_nhap": [12, 3, 8, 1, 15, 2, 9, 0, 6, 4, 11, 2],
"khieu_nai": [0, 2, 0, 0, 1, 3, 0, 1, 2, 0, 0, 1],
"roi_bo": [0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1]})
X, y = bang[["dang_nhap", "khieu_nai"]], bang["roi_bo"]
cay = DecisionTreeClassifier(max_depth=2, random_state=0).fit(X, y)
nhan = bang.loc[bang["dang_nhap"] > 3.5, "roi_bo"].tolist()
ti_le = [nhan.count(c) / len(nhan) for c in (0, 1)]
print("tỉ lệ:", [round(p, 3) for p in ti_le])
print("Gini tính tay:", round(1 - sum(p ** 2 for p in ti_le), 3))
print("Gini mọi nút:", cay.tree_.impurity.round(3).tolist())KẾT QUẢ
tỉ lệ: [0.857, 0.143]
Gini tính tay: 0.245
Gini mọi nút: [0.5, 0.0, 0.245, 0.0, 0.0]Gốc chia đều 6 và 6 nên Gini là 0,5; ba lá có Gini 0. Ở mỗi nút, cây thử từng cột và từng ngưỡng, rồi giữ câu hỏi làm Gini của hai nút con, tính theo tỉ lệ số mẫu mỗi bên, thấp nhất. Với câu hỏi ở gốc: 5/12 × 0 + 7/12 × 0,245 ≈ 0,143, giảm 0,357 so với 0,5. Bài Gini và entropy so bước chọn đó qua nhiều câu hỏi. Đổi (0, 1) thành (1, 0) rồi chạy lại: hai tỉ lệ đổi chỗ nhưng dòng Gini vẫn in 0.245, vì công thức không quan tâm lớp nào đứng trước.
Lá ghi một lớp nhưng giữ cả tỉ lệ
Cắt cây 12 hội viên còn một tầng (max_depth=1): nút bên phải, 6 ở lại và 1 rời bỏ, thành lá. apply() cho biết mỗi dòng rơi vào nút số mấy. Hỏi cây về hai hội viên mới:
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
bang = pd.DataFrame({
"dang_nhap": [12, 3, 8, 1, 15, 2, 9, 0, 6, 4, 11, 2],
"khieu_nai": [0, 2, 0, 0, 1, 3, 0, 1, 2, 0, 0, 1],
"roi_bo": [0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1]})
X, y = bang[["dang_nhap", "khieu_nai"]], bang["roi_bo"]
cay = DecisionTreeClassifier(max_depth=1, random_state=0).fit(X, y)
moi = pd.DataFrame({"dang_nhap": [6, 2], "khieu_nai": [2, 0]})
print("lá:", cay.apply(moi).tolist())
print("predict:", cay.predict(moi).tolist())
print("predict_proba:", cay.predict_proba(moi).round(3).tolist())KẾT QUẢ
lá: [2, 1]
predict: [0, 1]
predict_proba: [[0.857, 0.143], [0.0, 1.0]]Người đăng nhập 6 lần rơi vào lá 2, nơi có 7 hội viên train: predict_proba() trả đúng 6/7 và 1/7, còn predict() chỉ giữ lớp đông hơn là 0. Người đăng nhập 2 lần rơi vào lá 1, nơi cả 5 người đều rời bỏ. Cây có bao nhiêu lá thì predict_proba() có bấy nhiêu mức xác suất.
Cây trên bảng hội viên Sóc Vàng
Bảng hoi_vien.csv (3.000 hội viên giả lập của gói Sóc Vàng) có 10 cột số đầu dùng được làm feature: iloc[:, :10] lấy đúng 10 cột đó, bỏ diem_danh_gia_tb (34% ô thiếu) và cột ghi nhận sau mốc. Chia train, test như bài train test split, rồi so cây ba tầng với logistic regression bằng ROC-AUC trên phần test:
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier
kh = pd.read_csv("hoi_vien.csv")
y = kh.pop("roi_bo")
X = kh.select_dtypes("number").iloc[:, :10]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, random_state=0)
for model in [make_pipeline(StandardScaler(), LogisticRegression()),
DecisionTreeClassifier(max_depth=3, random_state=0)]:
p = model.fit(X_tr, y_tr).predict_proba(X_te)[:, 1]
print(type(model).__name__, round(roc_auc_score(y_te, p), 3))KẾT QUẢ
Pipeline 0.784
DecisionTreeClassifier 0.7Pipeline là logistic regression đặt sau bước chuẩn hóa. Cây ba tầng kém nó 0,08 AUC trên phần test này; qua 200 hạt giống chia khác nhau, khoảng cách trung bình là 0,07 (thường gặp 0,04 đến 0,10). Cây ba tầng có tối đa tám lá, tức tám mức xác suất: hàng trăm hội viên cùng lá nhận cùng một xác suất, nên ROC-AUC không xếp được họ. Bù lại, export_text() in tám lá đó thành tám luật mà người không đọc code vẫn kiểm được.
DecisionTreeRegressor: lá trả một con số
Với nhãn là số, DecisionTreeRegressor hỏi cùng kiểu câu hỏi, chỉ khác ở lá: lá trả trung bình nhãn của các mẫu rơi vào nó. Ví dụ dưới đoán chi tiêu 90 ngày (nghìn đồng) từ số đơn, bằng một câu hỏi duy nhất:
import pandas as pd
from sklearn.tree import DecisionTreeRegressor, export_text
bang = pd.DataFrame({
"so_don": [0, 1, 1, 2, 4, 5, 6, 8],
"chi_tieu": [0, 180, 240, 300, 820, 760, 990, 1250]})
cay = DecisionTreeRegressor(max_depth=1, random_state=0)
cay.fit(bang[["so_don"]], bang["chi_tieu"])
print(export_text(cay, feature_names=["so_don"]))
print(bang.groupby(bang["so_don"] > 3)["chi_tieu"].mean().tolist())KẾT QUẢ
|--- so_don <= 3.00
| |--- value: [180.00]
|--- so_don > 3.00
| |--- value: [955.00]
[180.0, 955.0]Hai lá in value 180 và 955, đúng bằng trung bình chi tiêu của hai nhóm mà groupby tính lại. Với cây hồi quy, độ vẩn đục là phương sai của nhãn trong nút thay cho Gini.
Kiểm tra nhanh
Trong cây của ví dụ 12 hội viên, một hội viên đăng nhập 5 lần và khiếu nại 2 lần được đoán lớp nào?
- Lớp
0, vì đăng nhập hơn 3,5 lần - Lớp
1 - Không đoán được, vì không có hội viên nào giống hệt trong bảng
- Lớp
Một nút có 3 hội viên rời bỏ và 1 hội viên ở lại. Gini của nút bằng bao nhiêu?
0.250.3750.50.75
Những câu nào đúng về lá của cây?
predict_proba()củaDecisionTreeClassifiertrả tỉ lệ các lớp trong lá chứa mẫu- Lá của
DecisionTreeRegressortrả trung bình nhãn của các mẫu train rơi vào lá predict_proba()của cây chỉ trả0.0hay1.0, giốngpredict()- Mọi lá của một cây đã fit đều có Gini bằng 0
export_text(cay)in|--- feature_1 <= 88.00.feature_1là gì?- Cột tên
feature_1trong bảng - Cột thứ hai của
X, vì không truyềnfeature_names - Nút thứ hai của cây
- Cột tên
Bài tập
Tính Gini impurity của một nút
nhan là list nhãn của các mẫu trong một nút, có ít nhất một phần tử, nhãn có thể là số hay chữ và có thể có nhiều hơn hai lớp. Viết thân hàm gini(nhan) tính Gini impurity của nút theo công thức của bài. Hàm không sửa list của nơi gọi.
Trả về: Gini của nút, một float.
Ví dụ: gini([0, 0, 1, 0, 0, 0, 0]) trả khoảng 0.245.
def gini(nhan):
pass # Viết thân hàm thay cho dòng nàyTóm tắt
Cây quyết định hỏi lần lượt từng câu: mỗi nút so một cột với một ngưỡng do
fitchọn, mỗi lá là một kết luận.export_text(cay, feature_names=…)in cây thành chữ,plot_tree(cay, ax=ax)vẽ cây thành sơ đồ.Gini của một nút là 1 trừ tổng bình phương tỉ lệ các lớp: 0 khi nút chỉ có một lớp.
Lá của
DecisionTreeClassifiertrả tỉ lệ các lớp (predict_proba()), cònpredict()chỉ giữ lớp đông hơn; lá củaDecisionTreeRegressortrả trung bình nhãn.Cây chỉ nhận cột số; cột chữ phải mã hóa trước khi fit.
Câu hỏi thường gặp
Thuật toán cây quyết định chọn câu hỏi thế nào?
Ở mỗi nút, thuật toán thử từng cột và từng ngưỡng giữa hai giá trị kề nhau, giữ câu hỏi làm Gini của hai nút con (tính theo tỉ lệ số mẫu mỗi bên) thấp nhất, rồi lặp lại ở từng nút con cho tới khi chạm giới hạn như max_depth.
Cây không giới hạn độ sâu thì sao?
Cây hỏi tiếp cho tới khi mỗi lá chỉ còn một lớp, tức là học thuộc phần train và chấm kém trên dữ liệu khác. Bài tỉa cây chọn max_depth, min_samples_leaf bằng cross validation để tránh điều đó.
Vẽ cây quyết định to quá, chữ chồng lên nhau thì làm sao?
Giảm số tầng cần xem bằng tham số max_depth của chính plot_tree() (chỉ vẽ vài tầng trên), tăng figsize trong giới hạn khung hình, hay giảm fontsize. Với cây sâu, export_text() dễ đọc hơn hình.
Nên dùng cây quyết định hay logistic regression?
Trên bảng hội viên của bài, logistic regression chấm AUC cao hơn cây ba tầng. Cây thắng ở chỗ đọc được thành luật và không cần chuẩn hóa. Nhiều cây gộp lại, như random forest, thường bù được phần điểm thiếu.
Chủ đề
Dữ liệu của bài
- Tải xuống
hoi_vien.csv
CSV · 207.25 KB
Bài này có hữu ích?
Hỏi đáp
Tham vấn chuyên môn
Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE
- Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
- Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
- Xây hệ thống AI cho doanh nghiệp tại VietPlatform.