1. 理解决策树的基本概念
决策树是一种监督学习算法，可以用于分类和回归任务。决策树通过一系列规则将数据划分为不同的类别或值。树的每个节点表示一个特征，节点之间的分支表示特征的可能取值，叶节点表示分类或回归结果。
2. 决策树的构建过程
2.1. 特征选择
特征选择是构建决策树的第一步，通常使用信息增益、基尼指数或增益率等指标。
- 信息增益（Information Gain）
信息增益表示通过某个特征将数据集划分后的纯度增加量，公式如下：
其中：
D 是数据集。
A 是特征。
V(A) 是特征 A 的所有可能取值。
Dv 是数据集中特征 A 取值为 v 的子集。
∣Dv∣ 是 Dv 中样本的数量。
∣D∣ 是数据集 D 中样本的总数量。
Entropy(D) 是数据集 D 的熵，表示数据集本身的纯度。
选择信息增益最大的特征作为当前节点的划分特征。
熵的计算公式为：
其中：
c 是类别的数量。
pi 是数据集中属于第 i 类的样本所占的比例。
以下代码展示了如何计算熵、信息增益，并选择最优特征。
import numpy as np
from collections import Counter
from sklearn.datasets import load_iris
def entropy(y):
hist = np.bincount(y)
ps = hist / len(y)
return -np.sum([p * np.log2(p) for p in ps if p > 0])
def information_gain(X, y, feature):
# Entropy before split
entropy_before = entropy(y)
# Values and counts
values, counts = np.unique(X[:, feature], return_counts=True)
# Weighted entropy after split
entropy_after = 0
for v, count in zip(values, counts):
entropy_after += (count / len(y)) * entropy(y[X[:, feature] == v])
return entropy_before - entropy_after
def best_feature_by_information_gain(X, y):
features = X.shape[1]
gains = [information_gain(X, y, feature) for feature in range(features)]
return np.argmax(gains), max(gains)
# Load dataset
iris = load_iris()
X = iris.data
y = iris.target
# Find best feature
best_feature, best_gain = best_feature_by_information_gain(X, y)
print(f'Best feature: {iris.feature_names[best_feature]}, Information Gain: {best_gain}')
- 基尼指数（Gini Index）
也称为基尼不纯度（Gini Impurity），是一种衡量数据集纯度的指标。基尼指数越小，数据集的纯度越高。
基尼指数的计算公式：
对于一个包含 k 个类别的分类问题，基尼指数 G(D) 定义如下：
其中：
D 是数据集。
k 是类别的数量。
pi 是数据集中属于第 i 类的样本所占的比例。
条件基尼指数：
在某个特征 A 的条件下，数据集 D 的条件基尼指数 G(D∣A) 定义如下：
其中：
values(A) 是特征 A 的所有可能取值。
Dv 是数据集中特征 A 取值为 v 的子集。
∣Dv∣ 是 Dv 中样本的数量。
∣D∣ 是数据集 D 中样本的总数量。
G(Dv) 是子集 Dv 的基尼指数。
基尼增益（Gini Gain）：
基尼增益 GG(D,A) 是通过特征 A 划分数据集 D 后基尼指数的减少量。计算公式如下：
参数解释
D：整个数据集，包含了所有的样本。
A：某个特征，用于划分数据集。
G(D)：数据集 D 的基尼指数，表示数据集本身的纯度。
G(D∣A)：在特征 A 的条件下，数据集 D 的条件基尼指数，表示在特征 A 的条件下数据集的纯度。
选择基尼增益最大的特征及其分割点作为当前节点的划分特征。
以下代码展示如何使用上述步骤来选择基尼增益最大的特征：
import numpy as np
from sklearn.datasets import load_iris
def gini(y):
hist = np.bincount(y)
ps = hist / len(y)
return 1 - np.sum([p**2 for p in ps if p > 0])
def gini_gain(X, y, feature):
# Gini index before split
gini_before = gini(y)
# Values and counts
values, counts = np.unique(X[:, feature], return_counts=True)
# Weighted gini after split
gini_after = 0
for v, count in zip(values, counts):
gini_after += (count / len(y)) * gini(y[X[:, feature] == v])
return gini_before - gini_after
def best_feature_by_gini_gain(X, y):
features = X.shape[1]
gains = [gini_gain(X, y, feature) for feature in range(features)]
return np.argmax(gains), max(gains)
# Load dataset
iris = load_iris()
X = iris.data
y = iris.target
# Find best feature
best_feature, best_gain = best_feature_by_gini_gain(X, y)
print(f'Best feature: {iris.feature_names[best_feature]}, Gini Gain: {best_gain}')
- 增益率（Gain Ratio）
决策树中的增益率（Gain Ratio）用于选择最优的划分属性，以便构建决策树。增益率是基于信息增益（Information Gain）的一个修正版本，用于克服信息增益在处理属性取值多样性时可能出现的偏向问题。
信息增益是指选择某一属性划分数据集后，信息熵的减少量。信息增益公式为：
其中：
IG(T,A)：属性 A 对数据集 T 的信息增益。
H(T)：数据集 T 的熵。
H(T∣A)：在给定属性 A 的条件下数据集 T 的条件熵。
增益率通过将信息增益除以属性的固有值（Intrinsic Value）来计算。固有值是衡量属性取值多样性的一种指标。增益率公式为：
其中：
GR(T,A)：属性 A 对数据集 T 的增益率。
IG(T,A)：属性 A 对数据集 T 的信息增益。
IV(A)：属性 A 的固有值。
固有值（Intrinsic Value）
固有值反映了属性的取值多样性，计算公式为：
其中：
Ti：属性 A 的第 i 个取值所对应的样本子集。
∣Ti∣：属性 A 的第 i 个取值所对应的样本子集的样本数量。
∣T∣：数据集 T 的总样本数量。
n：属性 A 取值的个数。
通过计算每个属性的增益率，选择增益率最高的属性作为决策树节点的划分属性，从而构建最优的决策树。
2.2. 划分节点
根据选定的特征和阈值，数据集被划分成多个子集。
2.3. 递归构建
递归地对每个子集进行特征选择和划分，直到满足停止条件（如当前数据子集中的所有实例都属于同一个类别，或达到预设的最大树深度）。
特征选择以增益率为例，在决策树构建过程中，选择每个节点的分裂特征是基于当前数据集的增益率计算结果的。对于每个分裂点，我们都会重新计算剩余特征的增益率，并选择其中最高的作为下一个分裂特征。
import numpy as np
import pandas as pd
# 计算熵
def entropy(y):
unique_labels, counts = np.unique(y, return_counts=True)
probabilities = counts / counts.sum()
return -np.sum(probabilities * np.log2(probabilities))
# 计算信息增益
def information_gain(data, split_attribute, target_attribute):
total_entropy = entropy(data[target_attribute])
values, counts = np.unique(data[split_attribute], return_counts=True)
weighted_entropy = np.sum([
(counts[i] / np.sum(counts)) * entropy(data[data[split_attribute] == values[i]][target_attribute])
for i in range(len(values))
])
info_gain = total_entropy - weighted_entropy
return info_gain
# 计算固有值
def intrinsic_value(data, split_attribute):
values, counts = np.unique(data[split_attribute], return_counts=True)
probabilities = counts / counts.sum()
return -np.sum(probabilities * np.log2(probabilities))
# 计算增益率
def gain_ratio(data, split_attribute, target_attribute):
info_gain = information_gain(data, split_attribute, target_attribute)
iv = intrinsic_value(data, split_attribute)
return info_gain / iv if iv != 0 else 0
# 递归构建决策树
def build_decision_tree(data, original_data, features, target_attribute, parent_node_class=None):
# 条件1: 所有数据点属于同一类别
if len(np.unique(data[target_attribute])) <= 1:
return np.unique(data[target_attribute])[0]
# 条件2: 数据子集为空
elif len(data) == 0:
return np.unique(original_data[target_attribute])[np.argmax(np.unique(original_data[target_attribute], return_counts=True)[1])]
# 条件3: 没有更多的特征可以分裂
elif len(features) == 0:
return parent_node_class
else:
parent_node_class = np.unique(data[target_attribute])[np.argmax(np.unique(data[target_attribute], return_counts=True)[1])]
gain_ratios = {feature: gain_ratio(data, feature, target_attribute) for feature in features}
best_feature = max(gain_ratios, key=gain_ratios.get)
tree = {best_feature: {}}
features = [i for i in features if i != best_feature]
for value in np.unique(data[best_feature]):
sub_data = data[data[best_feature] == value]
subtree = build_decision_tree(sub_data, original_data, features, target_attribute, parent_node_class)
tree[best_feature][value] = subtree
return tree
# 可视化决策树
def visualize_tree(tree, depth=0):
if isinstance(tree, dict):
for attribute, subtree in tree.items():
if isinstance(subtree, dict):
for value, subsubtree in subtree.items():
print(f"{'| ' * depth}|--- {attribute} = {value}")
visualize_tree(subsubtree, depth + 1)
else:
print(f"{'| ' * depth}|--- {attribute} = {value}: {subtree}")
else:
print(f"{'| ' * depth}|--- {tree}")
# 示例数据
data = pd.DataFrame({
'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rain', 'Rain', 'Rain', 'Overcast', 'Sunny', 'Sunny', 'Rain', 'Sunny', 'Overcast', 'Overcast', 'Rain'],
'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Cool', 'Mild', 'Cool', 'Mild', 'Mild', 'Mild', 'Hot', 'Mild'],
'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'High'],
'Wind': ['Weak', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Strong'],
'PlayTennis': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No']
})
# 构建决策树
features = ['Outlook', 'Temperature', 'Humidity', 'Wind']
target_attribute = 'PlayTennis'
tree = build_decision_tree(data, data, features, target_attribute)
# 可视化决策树
print("Decision Tree:")
visualize_tree(tree)
通过运行代码，可以看到每个节点选择的分裂特征以及决策树的结构：
Decision Tree:
|--- Temperature = Cool
| |--- PlayTennis = Yes
|--- Temperature = Hot
| |--- PlayTennis = No
|--- Temperature = Mild
| |--- Outlook = Sunny
| | |--- Humidity = High
| | | |--- PlayTennis = No
| | |--- Humidity = Normal
| | | |--- PlayTennis = Yes
| |--- Outlook = Rain
| | |--- Wind = Weak
| | | |--- PlayTennis = Yes
| | |--- Wind = Strong
| | | |--- PlayTennis = No
| |--- Outlook = Overcast
| | |--- PlayTennis = Yes
解释决策树的结构：
根节点是 Temperature，这是第一个选择的分裂特征。
Temperature 的每个取值（Cool, Hot, Mild）对应一个子节点。
如果 Temperature 是 Cool，则 PlayTennis 是 Yes。
如果 Temperature 是 Hot，则 PlayTennis 是 No。
如果 Temperature 是 Mild，则继续分裂 Outlook 属性：
Outlook 是 Sunny 时，进一步分裂 Humidity 属性：
Humidity 是 High 时，PlayTennis 是 No。
Humidity 是 Normal 时，PlayTennis 是 Yes。
Outlook 是 Rain 时，进一步分裂 Wind 属性：
Wind 是 Weak 时，PlayTennis 是 Yes。
Wind 是 Strong 时，PlayTennis 是 No。
Outlook 是 Overcast 时，PlayTennis 是 Yes。
通过这种方式，决策树会根据每个节点选择最佳的分裂特征，直到所有数据点都被正确分类或没有更多的特征可供分裂。
2.4. 防止过拟合
防止决策树过拟合的方法主要包括剪枝、设置深度限制和样本数量限制。以下是一些常用的方法及其实现：
- 预剪枝 (Pre-pruning)
预剪枝是在构建决策树时限制树的增长。常用的方法包括：
设置最大深度：限制树的深度，防止树过深导致过拟合。
设置最小样本分裂数：如果节点中的样本数小于某个阈值，则不再分裂该节点。
设置最小信息增益：如果信息增益小于某个阈值，则不再分裂该节点。
- 后剪枝 (Post-pruning)
后剪枝是在决策树完全生长后，剪去一些不重要的分支。常用的方法包括：
代价复杂度剪枝 (Cost Complexity Pruning)：基于一个代价复杂度参数 α，剪去那些对降低训练误差贡献较小但增加了模型复杂度的分支。
代价复杂度剪枝 (CCP) 是一种后剪枝技术，用于简化已经完全生长的决策树。CCP 通过引入一个复杂度惩罚参数 α 来权衡决策树的复杂度与其在训练集上的误差。通过调整 α，我们可以控制模型的复杂度，防止过拟合。
原理
CCP 的基本思想是通过最小化以下代价复杂度函数来选择最佳的子树：
其中：
Rα(T) 是带有复杂度惩罚项的代价复杂度。
R(T)是子树 T 的误差。
α 是复杂度惩罚项，控制模型复杂度与误差之间的权衡。
∣T∣ 是子树 T 的叶节点数量。
较小的 α 值允许更多的节点，使树更加复杂；较大的 α 值会剪去更多的节点，使树更加简单。
代价复杂度剪枝步骤：
构建完全生长的决策树：首先，生成一棵完全生长的决策树，使其充分拟合训练数据。
计算每个子树的误差：对子树中的所有节点计算其误差 R(T)。
计算代价复杂度：对于每个子树，计算其代价复杂度 Rα(T)。
选择合适的 α：通过关系图或交叉验证结果选择最佳的 α 值。
剪枝：根据选定的 α 值，剪去那些对降低误差贡献不大但增加了复杂度的节点。
import numpy as np
import pandas as pd
from sklearn.tree import DecisionTreeClassifier, export_text
import matplotlib.pyplot as plt
# 示例数据
data = pd.DataFrame({
'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rain', 'Rain', 'Rain', 'Overcast', 'Sunny', 'Sunny', 'Rain', 'Sunny', 'Overcast', 'Overcast', 'Rain'],
'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Cool', 'Mild', 'Cool', 'Mild', 'Mild', 'Mild', 'Hot', 'Mild'],
'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'High'],
'Wind': ['Weak', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Strong'],
'PlayTennis': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No']
})
# 将特征和目标变量转换为数值编码
data_encoded = pd.get_dummies(data[['Outlook', 'Temperature', 'Humidity', 'Wind']])
target = data['PlayTennis'].apply(lambda x: 1 if x == 'Yes' else 0)
# 拆分数据集
X = data_encoded
y = target
# 构建完全生长的决策树
clf = DecisionTreeClassifier(random_state=0)
clf.fit(X, y)
# 导出决策树规则
tree_rules = export_text(clf, feature_names=list(data_encoded.columns))
print("Original Decision Tree Rules:")
print(tree_rules)
# 计算代价复杂度剪枝路径
path = clf.cost_complexity_pruning_path(X, y)
ccp_alphas, impurities = path.ccp_alphas, path.impurities
# 训练不同复杂度惩罚项的决策树
clfs = []
for ccp_alpha in ccp_alphas:
clf = DecisionTreeClassifier(random_state=0, ccp_alpha=ccp_alpha)
clf.fit(X, y)
clfs.append(clf)
# 绘制复杂度惩罚项与树结构的关系图
node_counts = [clf.tree_.node_count for clf in clfs]
depth = [clf.tree_.max_depth for clf in clfs]
fig, ax = plt.subplots(3, 1, figsize=(10, 10))
ax[0].plot(ccp_alphas, node_counts, marker='o', drawstyle="steps-post")
ax[0].set_xlabel("alpha")
ax[0].set_ylabel("number of nodes")
ax[0].set_title("Number of nodes vs alpha")
ax[1].plot(ccp_alphas, depth, marker='o', drawstyle="steps-post")
ax[1].set_xlabel("alpha")
ax[1].set_ylabel("depth")
ax[1].set_title("Depth vs alpha")
ax[2].plot(ccp_alphas, impurities, marker='o', drawstyle="steps-post")
ax[2].set_xlabel("alpha")
ax[2].set_ylabel("impurity")
ax[2].set_title("Impurity vs alpha")
plt.tight_layout()
plt.show()
# 选择合适的 alpha 进行剪枝并可视化决策树，例如选择 impurity 最小对应的 alpha
# Impurity 反映了决策树在分裂节点时的纯度，纯度越高（impurity 越低），节点中样本越一致，分类效果越好。
optimal_alpha = ccp_alphas[np.argmin(impurities)]
pruned_tree = DecisionTreeClassifier(random_state=0, ccp_alpha=optimal_alpha)
pruned_tree.fit(X, y)
# 导出剪枝后的决策树规则
pruned_tree_rules = export_text(pruned_tree, feature_names=list(data_encoded.columns))
print("Pruned Decision Tree Rules:")
print(pruned_tree_rules)
3. 使用集成方法
- 随机森林：通过构建多棵决策树并结合它们的预测结果，可以减少单棵树的过拟合。
使用随机森林（Random Forest）是一种有效的方法来防止单个决策树模型的过拟合问题。随机森林通过构建多棵决策树并集成它们的预测结果，从而提高模型的泛化能力。
随机森林防止过拟合的机制：
1. 集成学习：
随机森林是一种集成学习方法，通过构建多棵决策树，并将它们的预测结果进行投票或平均，从而得到最终的预测结果。这种方式可以有效地减少单棵决策树的高方差，提高模型的稳定性和泛化能力。
2. 随机特征选择：
在每棵决策树的节点分裂时，随机森林不会考虑所有特征，而是从所有特征中随机选择一个子集来进行分裂。这样可以减少树之间的相关性，提高集成效果。
3. Bootstrap 重采样：
每棵决策树都是通过对原始训练数据进行 bootstrap 重采样（有放回抽样）得到的不同样本集进行训练。这样每棵树都有不同的训练数据，进一步减少了树之间的相关性。
- 梯度提升树：通过逐步构建一系列决策树，每棵树修正前一棵树的错误，可以提高模型的泛化能力。
梯度提升树（Gradient Boosting Trees, GBT）是一种集成学习方法，通过逐步构建一系列决策树来提高模型的预测性能。每棵新树的构建是为了修正之前所有树的误差。
梯度提升树防止过拟合的机制：
1. 分阶段训练：
梯度提升树采用逐步训练的方法。每次构建新树时，模型会根据之前所有树的预测误差来调整新树的结构。这种逐步优化的方法可以有效减少过拟合。
2. 学习率：
学习率（learning rate）控制每棵树对最终模型的贡献。较小的学习率使得每棵树的影响较小，从而需要更多的树来拟合训练数据。尽管这会增加计算成本，但可以显著降低过拟合的风险。
3. 树的深度：
限制每棵树的最大深度可以防止单棵树过于复杂，从而避免过拟合。浅层树（通常 3-5 层）虽然不能完全拟合数据，但可以捕捉到数据的主要结构，从而与其他树一起构成一个强大的集成模型。
4. 子样本采样：
在构建每棵树时，梯度提升树可以对训练数据进行子样本采样（subsampling）。这种方法通过引入训练数据的随机性，减少了模型的方差，从而防止过拟合。
5. 正则化：
梯度提升树可以引入正则化参数，如 L1 和 L2 正则化，来进一步防止模型的过拟合。
4. 实际应用中的决策树
决策树可以用于多个实际应用，如客户分类、疾病诊断、风险评估等。在实际应用中，需要根据具体问题调整决策树的参数（如树的最大深度、最小样本分裂数等），以达到最佳效果。
使用 TensorFlow 和 NumPy 实现一个简单的决策树分类器
![[Linux] 历史根源](https://img-blog.csdnimg.cn/direct/040a034bd0214b4f9ae4a38ab5dd06df.png)
![[面试题]消息队列](https://img-blog.csdnimg.cn/direct/6507af77273149edbd66e3abcb940ebf.jpeg#pic_left)
