数据结构与算法 决策树内容详解
一、决策树的核心思想
1. 直观理解：
想象一个“二十问”游戏：你心里想一个事物，对方通过问你一系列是/非问题来猜出答案。决策树就是这个过程的形式化。
- 根节点 (Root Node)：代表第一个、也是最关键的问题（例如：“是动物吗？”）。
- 内部节点 (Internal Node)：代表后续的问题（例如：“会飞吗？”）。
- 叶节点 (Leaf Node)：代表最终的决策或分类结果（例如：“鸟”、“鱼”）。
- 分支 (Branch)：代表上一个问题的答案（例如：“是”或“否”）。
决策树的目标是通过提出“最好”的问题，尽可能快地将样本划分到正确的类别中。
2. 算法类型：
决策树既可用于分类（Classification Tree），也可用于回归（Regression Tree）。
- 分类树：叶节点输出的是离散的类别标签（如“垃圾邮件”/“非垃圾邮件”）。
- 回归树：叶节点输出的是连续的数值（如房屋价格）。通常用叶节点内所有样本的目标值的均值作为预测值。
二、构建决策树的关键步骤：分裂与指标
构建决策树的核心是递归地选择“最佳”特征和“最佳”分割点，将数据分成更纯的子集。这个过程称为节点分裂。
如何衡量“最佳”？我们需要一些指标来量化分裂前后的“不纯度”下降程度。
1. 衡量节点不纯度的指标
设节点 ( t ) 中包含的样本来自 ( C ) 个类别，第 ( c ) 类样本的比例为 ( p(c|t) )。
-
基尼不纯度 (Gini Impurity)
- 公式：$ Gini(t) = 1 - \sum_{c=1}^{C} [p(c|t)]^2 $
- 理解：从节点中随机抽取两个样本，它们类别不一致的概率。
- 值域：[0, 0.5]。值越小，纯度越高（完美分类时为0）。
- 特点：计算速度快，CART算法默认使用。
-
信息熵 (Entropy)
- 公式：$ Entropy(t) = - \sum_{c=1}^{C} p(c|t) \log_2 p(c|t) $
- 理解：衡量系统的不确定性或混乱程度。
- 值域：[0, 1]。值越小，纯度越高（完美分类时为0）。
- 特点：对不纯度更敏感，容易生成更“平衡”的树。
-
分类错误 (Classification Error)
- 公式：$ Error(t) = 1 - \max p(c|t) $
- 主要用于剪枝阶段，而不是生长阶段，因为它对节点纯度的变化不够敏感。
2. 选择最佳分裂的指标
我们的目标是找到那个能让子节点不纯度总和下降最多的特征和分割点。
-
信息增益 (Information Gain)
- 公式：$ IG = I(\text{parent}) - \sum_{j=1}^{k} \frac{N_j}{N} I(\text{child}_j) $
- 其中，( I ) 可以是基尼不纯度或信息熵，( N_j ) 是第 ( j ) 个子节点的样本数，( N ) 是父节点样本总数。
- 理解：分裂后，不纯度减少了多少。我们选择能带来最大信息增益的分裂方式。
- 缺点：会天然偏好具有大量类别（取值较多）的特征（如“ID号”、“日期”），因为分裂越多，子节点可能越纯，但这会导致过拟合。
-
信息增益率 (Information Gain Ratio) - C4.5算法
- 公式：$ GainRatio = \frac{IG}{IV} $，其中 ( IV = - \sum_{j=1}^{k} \frac{N_j}{N} \log_2 \frac{N_j}{N} $
- 理解：( IV ) 称为固有值 (Intrinsic Value)，它惩罚了取值较多的特征。增益率是信息增益与固有值的比值。
- 优点：克服了信息增益偏向多值特征的缺点。
-
方差减少 (Variance Reduction) - 回归树
- 对于回归问题，我们通常使用方差来衡量节点的“不纯度”。
- 选择那个能使分裂后子节点方差总和减少最多（即目标值更加集中）的分裂点。
- 公式类似于信息增益：$ VR = Var(\text{parent}) - \sum_{j=1}^{k} \frac{N_j}{N} Var(\text{child}_j) $
三、处理不同类型的数据
-
分类特征 (Categorical Features)：
- 二元分类：直接根据“是/否”分裂。
- 多分类：
- 可以计算每个类别作为一個分支的增益（可能产生很多分支）。
- 更常见的做法是将其转化为“是否属于某类”的二元分裂序列，或者按某种顺序（如目标值的均值）将其视为连续值处理。
-
连续特征 (Continuous Features)：
- 需要找到一个“最佳分割点”。
- 方法：将该特征的所有取值排序，然后取每两个相邻值的中间点作为候选分割点。计算所有候选分割点带来的信息增益（或增益率等），选择增益最大的那个点作为该特征的分割点。
- 然后，再与其他特征的最佳分割点进行比较，最终选出全局最佳的分裂特征和分割点。
-
缺失值处理 (Missing Values)：
- 权重法：这是现代决策树算法（如XGBoost, LightGBM）中常见的方法。将一个有缺失值的样本，按一定权重比例分配到所有子节点中。例如，一个样本在分裂特征上有70%的概率进入左子节点，30%的概率进入右子节点，在计算子节点的不纯度时，该样本的权重就是0.7和0.3。
四、停止条件与剪枝
如果不加限制，树会一直生长直到每个叶节点都完全纯（过拟合）。
1. 停止条件 (Stopping Criteria) - 预剪枝
在树完全生成之前就设置限制条件。
- 树达到最大深度 (
max_depth) - 叶节点包含的最小样本数 (
min_samples_leaf) - 分裂所需的最小不纯度下降值 (
min_impurity_decrease) - 节点包含的最小样本数 (
min_samples_split)
2. 剪枝 (Pruning) - 后剪枝
先让树充分生长，然后再从底部开始，递归地尝试剪掉一些节点，并用其父节点作为新的叶节点。
- 成本复杂度剪枝 (Cost-Complexity Pruning - CCP)
- 公式：$ R_{\alpha}(T) = R(T) + \alpha |\tilde{T}| $
- 其中，( R(T) ) 是树的预测误差（如误分类率），( |\tilde{T}| ) 是叶节点的数量，( \alpha ) 是复杂度参数。
- 目标：找到一个使 ( R_{\alpha}(T) ) 最小的子树。( \alpha ) 越大，树越简单。
- 通过交叉验证来选择一个最佳的 ( \alpha )。
预剪枝 vs. 后剪枝：
- 预剪枝：计算高效，但可能“目光短浅”，过早停止生长，导致欠拟合。
- 后剪枝：通常能得到泛化能力更强的树，但计算开销更大。
五、经典算法
-
ID3 (Iterative Dichotomiser 3)
- 仅支持分类特征。
- 使用信息增益作为分裂标准。
- 不支持剪枝，容易过拟合。
-
C4.5 (ID3的改进版)
- 支持连续特征（通过离散化）和缺失值。
- 使用信息增益率作为分裂标准，克服了ID3的缺点。
- 引入了后剪枝。
-
CART (Classification and Regression Trees)
- 既可分类也可回归。
- 使用基尼系数作为分类树的分裂标准，均方误差作为回归树的分裂标准。
- 总是生成二叉树（问题只能是“是/否”）。
- 使用成本复杂度剪枝。
六、决策树的优缺点
优点：
- 解释性强：模型可可视化，推理过程像白盒一样清晰，符合人类直觉。
- 无需大量数据预处理：对数据分布没有假设，不需要标准化/归一化，能处理混合类型的特征。
- 支持缺失值：有内置的处理机制。
- 特征选择：构建过程本身就会评估特征的重要性。
缺点：
- 非常容易过拟合：如果不剪枝，树会变得极其复杂。这是其最大缺点。
- 不稳定：训练数据的微小变化可能导致生成完全不同的树（高方差模型）。
- 有偏性：倾向于选择那些具有更多层级或更多取值的特征。
- 难以学习复杂关系：如异或（XOR）问题，需要复杂的、不直观的分裂。对线性可分关系建模能力较差。
七、从决策树到集成学习
正因为决策树有不稳定和容易过拟合的缺点，它很少被单独使用。它真正强大的地方是作为弱学习器，构建更强大的集成模型：
-
Bagging：
- 思想：通过自助采样法构建多个训练集，并行训练多个决策树，然后投票（分类）或平均（回归）。
- 代表算法：随机森林。它在Bagging的基础上，进一步在每次分裂时随机选择一部分特征，降低了树之间的相关性，效果更好。
-
Boosting：
- 思想：串行地训练一系列决策树，每棵树都试图修正前一棵树的错误。
- 代表算法：AdaBoost, Gradient Boosting Machine (GBM), XGBoost, LightGBM, CatBoost。这些是当前机器学习竞赛和工业界最主流的算法，性能极其强大。
八、Java 决策树实现 Demo
下面是一个完整的 Java 决策树实现示例，使用经典的"天气预测打网球"数据集进行演示。这个实现包含了决策树的核心功能：信息增益计算、树构建、预测和可视化。
import java.util.*;
import java.util.stream.Collectors;
public class DecisionTreeDemo {
// 定义特征和类别
enum Outlook { SUNNY, OVERCAST, RAINY }
enum Temperature { HOT, MILD, COOL }
enum Humidity { HIGH, NORMAL }
enum Wind { WEAK, STRONG }
enum PlayTennis { NO, YES }
// 数据点类
static class DataPoint {
Outlook outlook;
Temperature temperature;
Humidity humidity;
Wind wind;
PlayTennis playTennis;
public DataPoint(Outlook outlook, Temperature temperature, Humidity humidity, Wind wind, PlayTennis playTennis) {
this.outlook = outlook;
this.temperature = temperature;
this.humidity = humidity;
this.wind = wind;
this.playTennis = playTennis;
}
}
// 决策树节点基类
abstract static class TreeNode {
abstract PlayTennis predict(DataPoint dataPoint);
abstract void print(String prefix);
}
// 决策节点
static class DecisionNode extends TreeNode {
String feature;
Map<Object, TreeNode> children = new HashMap<>();
TreeNode defaultChild;
DecisionNode(String feature) {
this.feature = feature;
}
void addChild(Object value, TreeNode child) {
children.put(value, child);
}
@Override
PlayTennis predict(DataPoint dataPoint) {
Object featureValue = getFeatureValue(dataPoint);
TreeNode child = children.get(featureValue);
if (child != null) {
return child.predict(dataPoint);
}
return defaultChild != null ? defaultChild.predict(dataPoint) : PlayTennis.NO;
}
private Object getFeatureValue(DataPoint dataPoint) {
switch (feature) {
case "outlook": return dataPoint.outlook;
case "temperature": return dataPoint.temperature;
case "humidity": return dataPoint.humidity;
case "wind": return dataPoint.wind;
default: throw new IllegalArgumentException("Unknown feature: " + feature);
}
}
@Override
void print(String prefix) {
System.out.println(prefix + "[" + feature + "]");
for (Map.Entry<Object, TreeNode> entry : children.entrySet()) {
System.out.println(prefix + "├── " + entry.getKey() + " →");
entry.getValue().print(prefix + "│ ");
}
if (defaultChild != null) {
System.out.println(prefix + "└── default →");
defaultChild.print(prefix + " ");
}
}
}
// 叶子节点
static class LeafNode extends TreeNode {
PlayTennis decision;
LeafNode(PlayTennis decision) {
this.decision = decision;
}
@Override
PlayTennis predict(DataPoint dataPoint) {
return decision;
}
@Override
void print(String prefix) {
System.out.println(prefix + "=> " + decision);
}
}
// 决策树构建器
static class DecisionTreeBuilder {
private List<String> features = Arrays.asList("outlook", "temperature", "humidity", "wind");
private double minGain = 0.1;
private int maxDepth = 5;
public TreeNode buildTree(List<DataPoint> dataPoints) {
return buildTree(dataPoints, features, 0);
}
private TreeNode buildTree(List<DataPoint> dataPoints, List<String> availableFeatures, int depth) {
// 如果所有数据点属于同一类别，返回叶子节点
PlayTennis majorityClass = getMajorityClass(dataPoints);
if (isPure(dataPoints) || depth >= maxDepth || availableFeatures.isEmpty()) {
return new LeafNode(majorityClass);
}
// 选择最佳分裂特征
String bestFeature = selectBestFeature(dataPoints, availableFeatures);
if (bestFeature == null) {
return new LeafNode(majorityClass);
}
// 创建决策节点
DecisionNode node = new DecisionNode(bestFeature);
List<String> newFeatures = new ArrayList<>(availableFeatures);
newFeatures.remove(bestFeature);
// 为每个特征值创建子树
Map<Object, List<DataPoint>> splitData = splitByFeature(dataPoints, bestFeature);
for (Map.Entry<Object, List<DataPoint>> entry : splitData.entrySet()) {
TreeNode child = buildTree(entry.getValue(), newFeatures, depth + 1);
node.addChild(entry.getKey(), child);
}
// 设置默认子节点（多数类）
node.defaultChild = new LeafNode(majorityClass);
return node;
}
private boolean isPure(List<DataPoint> dataPoints) {
return dataPoints.stream().map(dp -> dp.playTennis).distinct().count() <= 1;
}
private PlayTennis getMajorityClass(List<DataPoint> dataPoints) {
Map<PlayTennis, Long> counts = dataPoints.stream()
.collect(Collectors.groupingBy(dp -> dp.playTennis, Collectors.counting()));
return counts.entrySet().stream()
.max(Map.Entry.comparingByValue())
.map(Map.Entry::getKey)
.orElse(PlayTennis.NO);
}
private Map<Object, List<DataPoint>> splitByFeature(List<DataPoint> dataPoints, String feature) {
return dataPoints.stream().collect(Collectors.groupingBy(dp -> {
switch (feature) {
case "outlook": return dp.outlook;
case "temperature": return dp.temperature;
case "humidity": return dp.humidity;
case "wind": return dp.wind;
default: throw new IllegalArgumentException("Unknown feature: " + feature);
}
}));
}
private String selectBestFeature(List<DataPoint> dataPoints, List<String> features) {
String bestFeature = null;
double bestGain = -1;
for (String feature : features) {
double gain = calculateInformationGain(dataPoints, feature);
if (gain > bestGain && gain > minGain) {
bestGain = gain;
bestFeature = feature;
}
}
return bestFeature;
}
private double calculateInformationGain(List<DataPoint> dataPoints, String feature) {
double parentEntropy = calculateEntropy(dataPoints);
Map<Object, List<DataPoint>> splitData = splitByFeature(dataPoints, feature);
double childrenEntropy = 0.0;
for (List<DataPoint> subset : splitData.values()) {
double prob = (double) subset.size() / dataPoints.size();
childrenEntropy += prob * calculateEntropy(subset);
}
return parentEntropy - childrenEntropy;
}
private double calculateEntropy(List<DataPoint> dataPoints) {
if (dataPoints.isEmpty()) return 0;
long total = dataPoints.size();
Map<PlayTennis, Long> counts = dataPoints.stream()
.collect(Collectors.groupingBy(dp -> dp.playTennis, Collectors.counting()));
double entropy = 0.0;
for (long count : counts.values()) {
double probability = (double) count / total;
entropy -= probability * (Math.log(probability) / Math.log(2));
}
return entropy;
}
}
public static void main(String[] args) {
// 创建训练数据集（经典的"天气预测打网球"数据集）
List<DataPoint> trainingData = Arrays.asList(
new DataPoint(Outlook.SUNNY, Temperature.HOT, Humidity.HIGH, Wind.WEAK, PlayTennis.NO),
new DataPoint(Outlook.SUNNY, Temperature.HOT, Humidity.HIGH, Wind.STRONG, PlayTennis.NO),
new DataPoint(Outlook.OVERCAST, Temperature.HOT, Humidity.HIGH, Wind.WEAK, PlayTennis.YES),
new DataPoint(Outlook.RAINY, Temperature.MILD, Humidity.HIGH, Wind.WEAK, PlayTennis.YES),
new DataPoint(Outlook.RAINY, Temperature.COOL, Humidity.NORMAL, Wind.WEAK, PlayTennis.YES),
new DataPoint(Outlook.RAINY, Temperature.COOL, Humidity.NORMAL, Wind.STRONG, PlayTennis.NO),
new DataPoint(Outlook.OVERCAST, Temperature.COOL, Humidity.NORMAL, Wind.STRONG, PlayTennis.YES),
new DataPoint(Outlook.SUNNY, Temperature.MILD, Humidity.HIGH, Wind.WEAK, PlayTennis.NO),
new DataPoint(Outlook.SUNNY, Temperature.COOL, Humidity.NORMAL, Wind.WEAK, PlayTennis.YES),
new DataPoint(Outlook.RAINY, Temperature.MILD, Humidity.NORMAL, Wind.WEAK, PlayTennis.YES),
new DataPoint(Outlook.SUNNY, Temperature.MILD, Humidity.NORMAL, Wind.STRONG, PlayTennis.YES),
new DataPoint(Outlook.OVERCAST, Temperature.MILD, Humidity.HIGH, Wind.STRONG, PlayTennis.YES),
new DataPoint(Outlook.OVERCAST, Temperature.HOT, Humidity.NORMAL, Wind.WEAK, PlayTennis.YES),
new DataPoint(Outlook.RAINY, Temperature.MILD, Humidity.HIGH, Wind.STRONG, PlayTennis.NO)
);
// 构建决策树
DecisionTreeBuilder builder = new DecisionTreeBuilder();
TreeNode root = builder.buildTree(trainingData);
// 打印决策树
System.out.println("决策树结构:");
root.print("");
// 测试数据
DataPoint test1 = new DataPoint(Outlook.SUNNY, Temperature.MILD, Humidity.NORMAL, Wind.STRONG, PlayTennis.YES);
DataPoint test2 = new DataPoint(Outlook.RAINY, Temperature.COOL, Humidity.HIGH, Wind.STRONG, PlayTennis.NO);
DataPoint test3 = new DataPoint(Outlook.OVERCAST, Temperature.HOT, Humidity.HIGH, Wind.WEAK, PlayTennis.YES);
DataPoint test4 = new DataPoint(Outlook.SUNNY, Temperature.COOL, Humidity.NORMAL, Wind.WEAK, PlayTennis.YES);
// 进行预测
System.out.println("\n预测结果:");
System.out.println("Test1: " + root.predict(test1));
System.out.println("Test2: " + root.predict(test2));
System.out.println("Test3: " + root.predict(test3));
System.out.println("Test4: " + root.predict(test4));
}
}
代码说明
1. 数据结构
- 枚举类型：定义了天气(Outlook)、温度(Temperature)、湿度(Humidity)、风力(Wind)和是否打网球(PlayTennis)等特征
- DataPoint类：表示单个数据点，包含所有特征值和目标值
- TreeNode类：决策树节点的基类
- DecisionNode类：决策节点，包含特征和子节点映射
- LeafNode类：叶子节点，包含最终决策结果
2. 决策树构建器
- buildTree方法：递归构建决策树
- selectBestFeature方法：基于信息增益选择最佳分裂特征
- calculateInformationGain方法：计算特征的信息增益
- calculateEntropy方法：计算数据集的熵
- splitByFeature方法：根据特征值分割数据集
3. 决策树算法
- 使用信息增益作为特征选择标准
- 递归构建树直到满足停止条件：
- 节点数据纯净（所有实例属于同一类）
- 达到最大深度
- 没有更多特征可用
- 使用多数投票法确定叶子节点的类别
4. 预测功能
- 从根节点开始，根据数据点的特征值遍历决策树
- 到达叶子节点时返回预测结果
5. 可视化
- 实现简单的树结构打印功能，便于理解决策过程
运行结果示例
决策树结构:
[outlook]
├── SUNNY →
│ [humidity]
│ ├── HIGH →
│ │ => NO
│ └── NORMAL →
│ => YES
├── OVERCAST →
│ => YES
└── RAINY →
[wind]
├── WEAK →
│ => YES
└── STRONG →
=> NO
预测结果:
Test1: YES
Test2: NO
Test3: YES
Test4: YES
这个实现展示了决策树的核心概念，包括信息增益计算、树构建和预测。您可以根据需要扩展功能，如添加剪枝策略、处理连续特征或缺失值等。
总结
决策树是机器学习中一个基础而重要的模型。理解其核心——通过不断选择最佳分裂来降低不纯度——是掌握所有树模型的关键。虽然单一决策树能力有限，但它为随机森林、GBDT等“森林”和“Boost”家族奠定了坚实的基础，是通往高级机器学习技术的必经之路。
希望这份详细的解读对您有帮助！如果您对某个特定部分（如剪枝的细节或某个算法）还想深入了解，可以随时提出。
本文来自博客园，作者：NeoLshu，转载请注明原文链接：https://www.cnblogs.com/neolshu/p/19120301
浙公网安备 33010602011771号