决策树：理论与实践

信息增益：信息增益是决策树算法中最常用的特征选择方法之一。它是基于信息论的概念，用于度量一个特征对数据集纯度的提升程度。信息增益越大，表示选择该特征后数据集的纯度提高得越多。信息增益的计算过程已在前面的内容中详细介绍。
基尼不纯度：基尼不纯度是另一种用于特征选择的方法。它度量了从数据集中随机选择两个样本，它们类别不一致的概率。基尼不纯度越低，表示数据集的纯度越高。基尼不纯度的计算过程如下：

基尼(𝐷) = 1 - Σ(𝑝𝑖²)

其中，𝑝𝑖表示类别𝑖在数据集𝐷中的比例。

2. 分裂节点

一旦选择了最佳特征，下一步是分裂节点。分裂节点的目标是根据选定的特征将数据集划分成若干子集，每个子集对应一个分支。这个过程是递归的，每个分支又可以看作一个节点，继续选择最佳特征进行分裂，直到达到某个停止条件，如树的深度达到预定值或节点的样本数量小于某个阈值。

示例：假设我们选择了特征“年龄”来进行分裂，可以将数据集划分成多个子集，每个子集对应一个年龄段。

3. 剪枝

剪枝是决策树构建的最后一步，它用于解决过拟合问题。过拟合是指模型在训练数据上表现很好，但在未见过的数据上表现不佳的情况。剪枝的目标是简化决策树，减小决策树的复杂度，从而提高其泛化能力。

剪枝的方法和策略有很多种，包括前剪枝和后剪枝。前剪枝是在构建树的过程中，根据一些预定的条件提前终止树的分裂，例如限制树的最大深度或节点的最小样本数。后剪枝是在树已经构建完成后，根据一些条件来删除一些节点，将其合并为叶节点或删除整个子树。

剪枝是为了在保持决策树的预测能力的同时，减小其复杂性，提高模型的泛化能力。

决策树的代码实现

1. Scikit-Learn库

其中包含了现成的决策树模块，可以方便地构建和训练决策树模型。

首先，我们需要导入Scikit-Learn库并加载示例数据集：

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

# 加载Iris数据集
iris = load_iris()
X = iris.data
y = iris.target

接下来，我们可以创建一个决策树分类器并进行训练：

# 创建决策树分类器
clf = DecisionTreeClassifier()

# 训练模型
clf.fit(X, y)

这样，我们就构建了一个决策树模型并使用Iris数据集进行了训练。

用库实现的一个例子：

# 导入所需库
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier, export_text
import matplotlib.pyplot as plt

# 加载鸢尾花数据集作为示例数据
iris = load_iris()
X = iris.data
y = iris.target

# 创建决策树分类器
tree_classifier = DecisionTreeClassifier(random_state=42)
tree_classifier.fit(X, y)

# 输出决策树的规则
tree_rules = export_text(tree_classifier, feature_names=iris.feature_names)
print("决策树规则:\n", tree_rules)

# 画出决策树
from sklearn.tree import plot_tree
plt.figure(figsize=(12, 8))
plot_tree(tree_classifier, filled=True, feature_names=iris.feature_names, class_names=iris.target_names)
plt.show()

# 使用决策树进行预测
sample_data = [[5.1, 3.5, 1.4, 0.2]]  # 用一个鸢尾花的特征作为示例
predicted_class = tree_classifier.predict(sample_data)
print("预测的类别:", iris.target_names[predicted_class][0])

2.Python实现

可以使用Python和NumPy库来实现，同时附上例子：

import numpy as np


class DecisionTree:
    def __init__(self, max_depth=None):
        self.max_depth = max_depth
        self.tree = None  # 添加tree属性

    def fit(self, X, y):
        self.tree = self._grow_tree(X, y)

    def _grow_tree(self, X, y, depth=0):
        n_samples, n_features = X.shape
        n_labels = len(np.unique(y))

        # 处理特殊情况：当标签为空时，返回一个叶节点
        if n_labels == 0:
            return Node(value=None)

        if (
            depth >= self.max_depth
            or n_labels == 1
            or n_samples < 2
        ):
            leaf_value = max(set(y), key=list(y).count)
            return Node(value=leaf_value)

        best_feature, best_threshold = self._best_split(X, y)

        if best_feature is not None:
            left_mask = X[:, best_feature] <= best_threshold
            X_left, y_left = X[left_mask], y[left_mask]
            X_right, y_right = X[~left_mask], y[~left_mask]
            left = self._grow_tree(X_left, y_left, depth + 1)
            right = self._grow_tree(X_right, y_right, depth + 1)
            return Node(feature=best_feature, threshold=best_threshold, left=left, right=right)
        else:
            leaf_value = max(set(y), key=list(y).count)
            return Node(value=leaf_value)

    def _best_split(self, X, y):
        n_samples, n_features = X.shape
        if n_samples <= 1:
            return None, None

        gini = self._gini(y)

        best_gini = 1.0
        best_feature, best_threshold = None, None

        for feature_index in range(n_features):
            feature_values = X[:, feature_index]
            thresholds = np.unique(feature_values)
            for threshold in thresholds:
                left_mask = feature_values <= threshold
                y_left = y[left_mask]
                y_right = y[~left_mask]
                gini_left = self._gini(y_left)
                gini_right = self._gini(y_right)
                gini = (len(y_left) * gini_left + len(y_right) * gini_right) / (len(y_left) + len(y_right))
                if gini < best_gini:
                    best_gini = gini
                    best_feature = feature_index
                    best_threshold = threshold

        return best_feature, best_threshold

    def _gini(self, y):
        m = len(y)
        return 1.0 - sum((np.sum(y == c) / m) ** 2 for c in np.unique(y))


class Node:
    def __init__(self, feature=None, threshold=None, value=None, left=None, right=None, gini=None):  # 添加gini属性
        self.feature = feature
        self.threshold = threshold
        self.value = value
        self.left = left
        self.right = right
        self.gini = gini  # 存储Gini不纯度

# 在 _grow_tree 函数中设置 gini 值
def _grow_tree(self, X, y, depth=0):
    # ...
    if best_feature is not None:
        # ...
        left = self._grow_tree(X_left, y_left, depth + 1)
        right = self._grow_tree(X_right, y_right, depth + 1)
        best_gini = self._gini(y)  # 计算 Gini 不纯度
        return Node(feature=best_feature, threshold=best_threshold, left=left, right=right, gini=best_gini)
    else:
        leaf_value = max(set(y), key=list(y).count)
        return Node(value=leaf_value, gini=0.0)  # 对于叶节点，Gini 不纯度设置为 0.0

X = np.array([[5.1, 3.5, 1.4, 0.2],
              [4.9, 3.0, 1.4, 0.2],
              [6.2, 2.2, 4.5, 1.5],
              [6.7, 3.1, 4.7, 1.5],
              [6.7, 3.1, 5.6, 2.4],
              [4.6, 3.6, 1.0, 0.2],
              [5.7, 4.4, 1.5, 0.4]])

y = np.array([0, 0, 1, 1, 2, 0, 1])  # 修改标签以避免空标签

# 创建决策树并训练
tree = DecisionTree(max_depth=3)
tree.fit(X, y)

def print_tree(node, depth=0):
    if node.feature is not None:
        print("  " * depth + f"Feature {node.feature} <= {node.threshold}, Gini={node.gini}")
        print_tree(node.left, depth + 1)
        print("  " * depth + f"Feature {node.feature} > {node.threshold}, Gini={node.gini}")
        print_tree(node.right, depth + 1)
    else:
        print("  " * depth + f"Class {node.value}")

print_tree(tree.tree)

总结

机器学习是一门苦差事，需要学习的内容是相当的多。只能寄托于现有的工具尽量可能夺地去收集资料并学习好这门课程。

不会敲代码的陈序员

关注

5
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
决策树：理论与实践

决策树是一种基于树状结构的监督学习模型，它可以应用于分类和回归问题。决策树的构建类似于人类在做决策时的思维过程：从根节点出发，沿着树的不同分支进行一系列决策，最终到达叶节点，得出最终的决策结果。这个过程使得模型易于理解，能够直观地展示特征对输出的影响。对于一个数据集，假设有 𝐾 个类别，每个类别的概率分别为 𝑝1,𝑝2,...,𝑝𝐾 ，则 Gini系数可以通过以下公式计算：其中，Σ表示对所有类别的概率求和。Gini系数的取值范围在 0 到 1 之间，值越小表示数据集的纯度越高，值越大表示不纯度越高。示例。
复制链接

扫一扫