决策树（Decision Tree）

• 决策树的原理

    决策树算法是一种基于树结构的分类和回归算法。它通过对数据集进行递归地分割，构建一个树形模型，用于预测目标变量的值。

    决策树的构建过程基于以下原理：
    1. 特征选择：选择最佳的特征来进行数据集的分割。常用的特征选择指标有信息增益、信息增益比、基尼指数等。
    2. 样本划分：根据选定的特征将数据集划分为不同的子集。每个子集中的样本具有相同的特征值。
    3. 递归构建：对每个子集递归地应用上述步骤，直到满足终止条件，例如达到最大深度、样本数小于阈值或者没有更多特征可供选择。
    4. 叶节点生成：当终止条件满足时，将子集划分为叶节点，该叶节点表示一个分类或回归结果。

    在分类问题中，每个叶节点表示一种类别；在回归问题中，每个叶节点表示一个数值。

    决策树算法具有以下优点：
    1、可解释性强，易于理解和解释生成的模型。
    2、能够处理离散和连续型特征。
    3、能够处理多输出问题。
    4、对缺失值和异常值具有一定的鲁棒性（鲁棒性是指一个系统或算法在面对噪声、异常值、失效或者意外情况时，能够保持稳定的表现）。

    然而，决策树算法也存在一些缺点：
    1、容易过拟合（过拟合（overfitting）是指机器学习模型过于复杂，过于精细地拟合了训练数据集中的每一个样本，以至于在新的数据集上表现不佳的现象），特别是在处理复杂数据集时。
    2、对于包含大量特征的数据集，决策树可能过于复杂，容易产生过度分支。
    3、对于类别数量不平衡的数据集，决策树可能偏向于拟合样本较多的类别。

    为了克服这些问题，可以采用剪枝技术、随机森林（小蒟蒻还没学）等方法对决策树进行改进和优化。

• 决策树的构建

    1. ID3算法：ID3（Iterative Dichotomiser 3）是一种基于信息增益的决策树构建算法。它通过计算每个属性的信息增益来选择最优的划分属性，递归地构建决策树。

    2. C4.5算法：C4.5是ID3算法的改进版本，它使用信息增益率来选择最优的划分属性。与ID3相比，C4.5还能处理缺失值，并且支持连续型属性。

    3. CART算法：CART（Classification and Regression Trees）是一种既能构建分类树又能构建回归树的决策树算法。CART算法通过基尼指数或均方差来选择最优的划分属性，并采用二叉树结构进行构建。

    以上是常见的决策树构建方法，不同的算法在属性选择和剪枝策略上有所差异，选择适合问题需求的方法可以提高决策树的性能和准确度。

（本文以CART方法为例，基于鸢尾花数据集实现CART分类决策树算法）

一、CART决策树算法简介

    CART（Classification and Regression Trees）是一种常用的策树算法，可以用于分类和回归问题。CART算法通过对数据集进行递归的二分划分，构建出一棵二叉树模型。

    CART算法的划分准则是基于Gini指数或基尼不纯度。在分类问题中，Gini指数衡量了一个样本集合中不同类别样本的不均匀程度。选择划分特征时，CART算法通过计算每个特征的Gini指数，选择使得Gini指数最小的特征作为划分特征。

    CART算法通过递归地对数据集进行划分，直到满足停止条件。停止条件可以是达到最大深度、叶子节点的样本数小于某个阈值等。划分过程中，每次选择Gini指数最小的特征进行划分，并将数据集按照该特征的取值分为两部分。

    对于分类问题，CART算法构建出的决策树可以用于预测新样本的类别。对于回归问题，CART算法构建出的决策树可以用于预测新样本的实数值。

    CART算法具有较好的可解释性和较高的准确性，在实际应用中被广泛使用。它能够处理离散和连续特征，并且对异常值和缺失值具有较好的鲁棒性。同时，CART算法还可以通过剪枝来提高模型的泛化能力，避免过拟合问题。

二、基尼系数

    基尼系数代表模型的不纯度，基尼系数越小，则不纯度越低。

    在分类问题中，假设有K个类，样本点属于第k类的概率为pk，则概率分布的基尼系数定义为:

                                  

     对给定的样本集合D，其基尼指数：

                                

三、CART决策树生成

1. 初始化：将整个训练集作为输入数据，选择一个目标变量（分类问题中是分类变量，回归问题中是连续变量）。

2. 选择最佳切分特征：根据某种指标（如信息增益、基尼系数等），计算每个特征的切分点，选择最佳的特征和切分点作为当前节点的切分标准。

3. 根据切分标准将数据集分割为两个子集：根据最佳切分特征和切分点，将数据集划分为两个子集，一个子集包含满足切分标准的样本，另一个子集包含不满足切分标准的样本。

4. 递归生成子树：对于每个子集，重复步骤2和步骤3，直到满足停止条件（如达到预定的树深度、样本数量小于阈值等）。

5. 构建决策树：将生成的子树连接到当前节点上，形成完整的决策树。

6. 剪枝处理：对生成的决策树进行剪枝处理，通过损失函数最小化或交叉验证选择最优的剪枝参数，以避免过拟合。

7. 输出决策树模型：将生成的决策树模型输出。 

以上是CART决策树生成算法的基本流程，它是一种基于贪心策略的自上而下生成方法。

四、CART决策树代码

手敲实现：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import numpy as np

class Node:          # 特征          阈值             标签        左子树     右子树
    def __init__(self, feature=None, threshold=None, label=None, left=None, right=None):
        self.feature = feature
        self.threshold = threshold
        self.label = label
        self.left = left
        self.right = right

class DecisionTree:
    def __init__(self, max_depth=None):
        self.max_depth = max_depth # 可以用于剪枝
    
    def _gini(self, y): # 计算基尼不纯度
        classes, counts = np.unique(y, return_counts=True) # 获取y中的所有唯一类别和它们对应的出现次数
        impurity = 1 - np.sum((counts / np.sum(counts)) ** 2) # 根据基尼不纯度的公式计算不纯度值
        return impurity
    
    def _best_split(self, X, y):
        best_gini = float('inf')
        best_feature = None # 最佳特征
        best_threshold = None # 最佳分割点
        
        for feature in range(X.shape[1]): # X.shape[1]，特征数量
            
            # thresholds代表鸢尾花的一列特征值(唯一值)
            thresholds:numpy.ndarray = np.unique(X[:, feature]) # 获取该特征的所有唯一值作为候选分割点的阈值。
            
            for threshold in thresholds: # 遍历每个候选分割点的阈值。对于每个阈值，根据特征值与阈值的比较，将样本分为左子集和右子集。
                
                # 对于每个阈值，根据特征值与阈值的比较，将样本分为左子集和右子集。
                left_indices:bool = X[:, feature] < threshold # left_indices 是一个布尔数组，表示哪些样本属于左子集。
                right_indices:bool = X[:, feature] >= threshold
                
                left_gini = self._gini(y[left_indices]) # 计算左子集的基尼系数（基尼不纯度）
                right_gini = self._gini(y[right_indices]) # 计算右子集的基尼系数（基尼不纯度）
                
                '''
                根据左右子集的基尼系数和样本数量计算加权平均基尼系数 gini，并与当前的最佳基尼系数 best_gini 进行比较。
                如果当前 gini 值小于 best_gini，则更新 best_gini、best_feature 和 best_threshold。
                '''
                gini = (left_gini * np.sum(left_indices) + right_gini * np.sum(right_indices)) / len(y) # 加权平均基尼系数
                
                if gini < best_gini:
                    best_gini = gini
                    best_feature = feature
                    best_threshold = threshold
        
        return best_feature, best_threshold # 返回找到的最佳特征和最佳分割点的信息。
    
    def _build_tree(self, X, y, depth):
        
        # 检查是否达到了最大深度或者标签只有一种类别，如果满足其中一种条件，就创建一个叶子节点，并将最常见的标签作为节点的标签值。
        if depth == self.max_depth or len(np.unique(y)) == 1: # 起到了剪枝的作用
            '''
            set(y)：将列表 y 转换为一个集合。集合是无序且不包含重复元素的数据结构。
            y.tolist()：将集合 y 转换为列表。这是因为集合对象本身不支持 count 方法，而列表对象支持。
            y.tolist().count：使用列表的 count 方法，返回每个元素在列表中出现的次数。
            max(set(y), key=y.tolist().count)：使用 max 函数，根据元素的出现次数找出最大值，并返回该元素。
            最终，变量 label 将被赋值为列表 y 中出现次数最多的元素。
            '''
            label = max(set(y), key=y.tolist().count)
            return Node(label=label)
        
        feature, threshold = self._best_split(X, y) # 最佳特征和最佳分割点的信息。
        
        if feature is None or threshold is None: # 起到了剪枝的作用
            label = max(set(y), key=y.tolist().count)
            return Node(label=label)
        
        # 代码根据分割特征和阈值将训练数据划分为左子节点和右子节点的索引。
        left_indices = X[:, feature] < threshold # left_indices 是一个布尔数组，表示哪些样本属于左子集。
        right_indices = X[:, feature] >= threshold
        
        # 递归调用 _build_tree 方法，传入左子节点和右子节点对应的训练数据和标签，以及增加了深度的值。
        left_node = self._build_tree(X[left_indices], y[left_indices], depth+1)
        right_node = self._build_tree(X[right_indices], y[right_indices], depth+1)
        
        # 代码创建一个节点对象，并将分割特征、阈值、左子节点和右子节点赋值给节点对象，并返回该节点。
        node = Node(feature=feature, threshold=threshold, left=left_node, right=right_node)
        return node
    
    def fit(self, X, y): # fit方法用于训练模型
        self.root = self._build_tree(X, y, 0) # _build_tree方法用于构建决策树的节点
    
    def _predict_single(self, x, node):  # _predict_single方法用于递归地预测单个样本的类别
        
        # 如果 node.label 不是 None 的话，就返回 node.label
        if node.label is not None:
            return node.label
        
        if x[node.feature] < node.threshold:
            return self._predict_single(x, node.left)
        
        else:
            return self._predict_single(x, node.right)
    
    def predict(self, X): # 用于预测新的样本的类别
        y_pred = []
        
        for x in X:
            label = self._predict_single(x, self.root)
            y_pred.append(label)
        
        return np.array(y_pred)
    '''
    在预测过程中，根据节点的特征和阈值，将样本分配到左子树或右子树，直到叶子节点得到最终的预测结果。
    最终将预测结果存储在y_pred列表中，并返回一个numpy数组。
    '''

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

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 创建决策树模型并训练
tree = DecisionTree(max_depth=3)
tree.fit(X_train, y_train)

# 预测测试集
y_pred = tree.predict(X_test)

# 输出准确率
accuracy = np.sum(y_pred == y_test) / len(y_test)
print("准确率:", accuracy)


'''
运行结果：
准确率: 1.0
'''

掉包实现：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

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

# 将数据集拆分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

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

# 在训练集上训练决策树模型
clf.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print("准确率:", accuracy)


'''
运行结果：
准确率: 1.0
'''

与knn算法进行试验对比：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = load_iris()
X, y = iris.data, iris.target

# 将数据集分为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=50)

# 使用决策树算法进行训练和预测
dt_clf = DecisionTreeClassifier()
dt_clf.fit(X_train, y_train)
dt_pred = dt_clf.predict(X_test)
dt_accuracy = accuracy_score(y_test, dt_pred)

# 使用knn算法进行训练和预测
knn_clf = KNeighborsClassifier(n_neighbors=5)
knn_clf.fit(X_train, y_train)
knn_pred = knn_clf.predict(X_test)
knn_accuracy = accuracy_score(y_test, knn_pred)

# 输出结果
print("决策树算法准确率：", dt_accuracy)
print("knn算法准确率：", knn_accuracy)


'''
运行结果：
决策树算法准确率： 0.9555555555555556
knn算法准确率： 0.9333333333333333
'''