一文上手决策树：从理论到实战

一、基础概念

决策树是一类极为常用的机器学习方法，尤其是在分类场景。决策树通过树形结构来递归地将样本分割到不同的叶子结点中去，并根据每个叶子结点中的样本构成对该结点中的样本进行分类。

我们可以从两个视角来理解决策树模型。

• 第一种视角是将决策树视为一组规则的集合。对一棵完整的决策树来说，从根节点到每一个叶子结点都对应了一条规则，不同的规则之间互斥且完备。
• 第二种视角是从条件概率的角度来理解决策树。我们对每个叶子结点的分类，都是依据该结点包含的样本集合分属于不同分类的概率来决定的。从这个角度来看，决策树本质上也是一种概率模型。

与其他机器学习方法一样，使用决策树进行预测时，我们的目标是尽可能地在新样本上预测得更准确。那么，一方面我们要在训练集上得到尽可能高的预测精度，另一方面，我们要通过正则化参数来保证模型没有过拟合。

假设树$T$的叶子结点个数为$|T|$，$t$为树$T$的叶子结点，每个叶子结点有$N_t$个样本，假设$k$类的样本有$N_{tk}$个，其中$k=1,2,\cdots ,K$，$H_t(T)$为叶子结点上的经验熵（empirical entropy），$\alpha \ge 0$为正则化参数，那么决策树学习的损失函数可以表示为：

$$L_{\alpha }(T)=\sum _{t=1}^{|T|}{N}_t{H}_t(T)+\alpha |T|$$

决策树学习的目标就是最小化上述函数，该函数无法使用常规的梯度下降来直接求解，因此我们一般使用启发式的方法来寻找最优决策树，具体来说，就是递归地选择最优特征来分割数据集。如果某次分割后的子集可以完全正确划分到某一类，那么该子集可以归到一个叶子结点；否则，继续从这些子集中选择最优特征进行下一次划分，直到所有子集都能被正确分类。

以上思路会构建一棵完整的树，但是正如前文所述，我们还需要保证模型没有过拟合，因此我们需要对决策树进行剪枝。决策树剪枝通常有预剪枝和后剪枝两种方法。

总的来说，完整的决策树包含特征选择、决策树构建和决策树剪枝三大方面。

二、特征选择

为了构建一棵性能良好的决策树，我们需要从训练集中不断选取最具有区分度（分类能力）的特征。一般来说，我们通过三个指标来实现这一目标。

1. 信息增益

为了说明信息增益，我们需要引入信息熵的概念。在信息论和概率论中，熵是一种描述随机变量不确定性的度量方式，也可以用来描述样本集合的不纯度。熵越低，样本的不确定性就越低，纯度则越高。

假设当前样本数据集$D$中的第$k$个类所占比例为$p_k(k=1,2,\cdots ,Y)$，那么该样本数据集的熵可以定义为：

$$E(D)=-\sum _{i=1}^Y{p}_{k}log(p_k)$$

假设离散随机变量$(X,Y)$的联合概率分布为：

$$P(X=x_i,Y=y_i)=p_{ij}(i=1,2,\cdots ,m,j=1,2,\cdots ,n)$$

条件熵$E(Y|X)$表示在已知随机变量$X$的条件下对$Y$的不确定性的度量，它可以定义为在给定$X$的条件下$Y$的条件概率分布的熵对$X$的数学期望。条件熵可以表示为：

$$E(Y|X)=\sum _{i=1}^m{p}_i\cdot E(Y|X=x_i)$$

其中，$p_i=P(X=x_i),i=1,2,\cdots ,m$。在利用实际数据进行计算时，熵和条件熵中的概率计算都是基于极大似然估计得到，对应的熵和条件熵也叫经验熵和经验条件熵。

信息增益是指在得到了某个特征X的信息之后，使得类Y的信息不确定性减少的程度。或者说，信息增益代表了某特征带来的分类确定性的增量，特征的信息增益越大，目标分类的确定性也就越大。

假设训练集$D$的经验熵为$E(D)$，给定特征$A$的条件下$D$的经验条件熵为$E(D|A)$，那么信息增益可定义为经验熵$E(D)$与经验条件熵之差：

$$g(D,A)=E(D)-E(D|A)$$

构建决策树时可以使用信息增益进行特征选择，特征的信息增益越大，代表了其分类能力越强，ID3算法就是基于信息增益做特征选择的。

我们举一个例子来演示信息增益的计算。

例1：假设有20位同学，其中有10位喜欢篮球，10位不喜欢篮球。在20位同学中有12位男同学，其中9位喜欢篮球，3位不喜欢篮球；有8位女同学，其中1位喜欢篮球，7位不喜欢篮球。那么性别（男/女）的信息增益是多少？

import numpy as np

def entropy(freq: list) -> float:
    """计算信息熵
    """
    freq = np.array([i for i in freq if i > 0])
    proba = freq / freq.sum()
    entropy = - (proba * np.log2(proba)).sum()
  
    return entropy

if __name__ == '__main__':
    # 原始数据
    like_basketball = [10, 10]
    male_like_basketball = [9, 3]
    female_like_basketball = [1, 7]
  
    # 经验熵
    entropy_init = entropy(like_basketball)
  
    # 条件熵 
    entropy_cond = 10 / 20 * entropy(male_like_basketball) + \
        10 / 20 * entropy(female_like_basketball)
  
    # 信息增益
    info_gain = entropy_init - entropy_cond
  
    print('经验熵：{0}\n条件熵：{1}\n信息增益：{2}'.format(
        entropy_init, entropy_cond, info_gain))

结果为：

经验熵：1.0
条件熵：0.6774212838293646
信息增益：0.3225787161706354

2. 信息增益率

信息增益存在一个问题：当某个特征分类取值较多时，该特征的信息增益计算结果会放大。取极端情况，如有一个特征为编号，每个样本对应了唯一的一个编号，这种情况下的信息纯度很高，那么基于这个特征得到的信息增益就很大。

信息增益率可以解决信息增益的上述问题。特征$A$对数据集$D$的信息增益率可以定义为其信息增益$g(D,A)$与数据集$D$关于特征$A$取值的熵$E_A(D)$的比值：

$$g_R(D,A)=\frac{g(D,A)}{E_A(D)}$$

其中，

$$E_A(D)=-\sum _{i=1}^n\frac{|D_i|}{|D|}lo{g}_2\frac{|D_i|}{|D|}$$

$n$表示特征$A$的取值个数。C4.5算法是基于信息增益率进行特征选择的。

我们仍以例1来演示，通过前文可知，一共有10名男同学和10名女同学，那么我们可以据此计算出$E_A(D)$：

gender_cnt = [12, 8]
entropy_gender = entropy(gender_cnt)
gain_rate = info_gain / entropy_gender

print('信息增益率：{0}'.format(gain_rate))

结果为：

信息增益率：0.33222979419649123

3. 基尼系数

基尼系数也是一种较好的特征选择方法。假设样本有$K$个类，样本属于第$k$类的概率为$p_k$，则该样本类别概率分布的基尼系数为：

$$Gini(p)=\sum _{k=1}^k{p}_k(1-p_k)=1-\sum _{k=1}^K{p}_k^2$$

对于给定训练集$D$，$C_k$是属于第$k$类样本的集合，则该训练集的基尼指数为：

$$Gini(D)=1-\sum _{k=1}^K{\left(\frac{|C_k|}{|D|}\right)}^2$$

如果训练集$D$根据特征$A$的某一取值$a$划分为$D_1$和$D_2$两个部分，那么在特征$A$这个条件下，训练集$D$的基尼系数为：

$$Gini(D,A)=\frac{|D_1|}{|D|}Gini(D_1)+\frac{|D_2|}{|D|}Gini(D_2)$$

与信息熵的定义相似，训练集$D$的基尼指数$Gini(D)$表示该集合的不确定性（不纯度），$Gini(D,A)$表示训练集经过$A$的划分后的不确定性（不纯度）。在分类过程中，我们总是希望不确定性越低越好，即$Gini(D,A)$越小越好。CART算法使用基尼系数来进行特征选择。

仍以例1来演示基尼系数的计算。

def gini(freq: list) -> float:
    """计算基尼系数
    """
    freq = np.array([i for i in freq if i > 0])
    proba = freq / freq.sum()
    g = 1 - (proba ** 2).sum()
  
    return g

gini_male = 12 / 20 * gini(male_like_basketball) + 8 / 20 * gini(female_like_basketball)

print('基尼系数：{0}'.format(gini_male))

结果为：

基尼系数：0.3125

三、决策树模型

三大经典决策树模型分别为ID3、C4.5、CART，它们都是通过递归地选择最优特征来构建决策树。如前文所述，在评估最优特征时，它们分别使用了信息增益、信息增益率和基尼系数三个指标。

ID3和C4.5算法仅有决策树的生成，不包含决策树剪枝的部分，因此容易过拟合。CART算法除了用于分类外，还可用于回归，也包含决策树剪枝，因此现在应用更为广泛。

1. ID3

ID3算法的全称为Iterative Dichotomiser 3，即迭代二叉树。其核心是基于信息增益递归地选择最优特征构造决策树。

简单来阐述，ID3算法的思路为：

1. 首先预设一个决策树根节点，然后对所有特征计算信息增益；
2. 选择一个信息增益最大的特征作为最优特征，根据该特征的不同取值建立子结点；
3. 接着对每个子结点递归地调用上述方法，直到信息增益很小或者没有特征可选时，将这些子结点作为叶子结点，并以该叶子结点上的多数类作为预测类。

给定训练集$D$、特征集合$A$以及信息增益阈值$ϵ$，ID3算法的流程如下：

1. 如果$D$中所有实例属于同一类别$C_k$，那么所构建的决策树$T$为单结点树，并且类$C_k$即为该结点的预测类。
2. 如果$T$不是单结点树，则计算特征集合$A$中各特征对$D$的信息增益，选择信息增益最大的特征$A_g$。
3. 如果$A_g$的信息增益小于阈值$ϵ$，则将$T$视为单结点树，并将$D$中所属数量最多的类$C_k$作为该结点的预测类，并返回$T$。
4. 否则，对$A_g$的每一取值$a_i$，按照$A_g=a_i$将$D$划分为若干非空子集$D_i$，以$D_i$中的多数类作为预测类并构建子结点，由结点和子结点构成树$T$并返回。
5. 对第$i$个子结点，以$D_i$为训练集，以$A-A_g$为特征集，递归地调用上述步骤，即可得到决策树子树$T_i$并返回。

2. C4.5

C4.5算法实际上是对ID3算法的改进。

1. ID3算法使用信息增益做特征选择，倾向于选择取值水平较多的特征。针对这一问题，C4.5算法改为使用信息增益率。
2. ID3算法不可以处理缺失值，C4.5算法可以。
3. ID3算法不支持连续值特征，C4.5算法支持。
4. ID3算法不支持后剪枝，C4.5算法支持后剪枝。

给定训练集$D$、特征集合$A$以及信息增益阈值$ϵ$，C4.5算法的流程如下：

1. 如果$D$中所有实例属于同一类别$C_k$，那么所构建的决策树$T$为单结点树，并且类$C_k$即为该结点的预测类。
2. 如果$T$不是单结点树，则计算特征集合$A$中各特征对$D$的信息增益，选择信息增益最大的特征$A_g$。
3. 如果$A_g$的信息增益率小于阈值$ϵ$，则将$T$视为单结点树，并将$D$中所属数量最多的类$C_k$作为该结点的预测类，并返回$T$。
4. 否则，对$A_g$的每一取值$a_i$，按照$A_g=a_i$将$D$划分为若干非空子集$D_i$，以$D_i$中的多数类作为预测类并构建子结点，由结点和子结点构成树$T$并返回。
5. 对第$i$个子结点，以$D_i$为训练集，以$A-A_g$为特征集，递归地调用上述步骤，即可得到决策树子树$T_i$并返回。

3. CART

CART算法的全称为分类与回归树（classification and regression tree），它既可用于分类，又可用于回归，这是它与ID3/C4.5之间的主要区别之一，此处我们仅讨论CART算法用于分类的场景。此外，CART算法中的特征选择使用的是基尼系数。最后，CART算法不仅包含了决策树的生成算法，还包括了决策树的剪枝算法。

CART生成的决策树为二叉树，内部结点取值为“是”和“否”，这种方法等价于递归地二分每个特征，将特征空间划分为有限个子空间，并在这些子空间上确定预测的概率分布，即前述的预测条件概率分布。

其算法流程为：

1. 给定训练集$D$和特征集$A$，对于每个特征$a$及其所有取值$a_i$，根据$a=a_i$将数据集划分为$D_1$和$D_2$两个部分，并计算$a=a_i$时的基尼系数。
2. 取基尼系数最小的特征及其相应的划分点作为最优特征和最优化分点，据此将当前结点划分为两个子结点，将训练集根据特征取值分配到两个子结点中。
3. 对两个子结点递归地调用上述步骤，直至满足停止条件，最终生成CART分类决策树。

4. 对比

决策树	模型分类	树结构	特征选择	连续值处理	缺失值处理	剪枝处理
ID3	分类	多叉树	信息增益	不可以	不可以	不可以
C4.5	分类	多叉树	信息增益率	可以	可以	可以
CART	分类	二叉树	基尼系数	可以	可以	可以

四、决策树剪枝

决策树剪枝一般包含两种方法：预剪枝（pre-pruning）和后剪枝（post-pruning）。

1. 预剪枝

预剪枝，是指在决策树生成过程中提前停止树的增长的一种剪枝算法。其主要思路有：

• 提前设定决策树的深度，当达到这一深度时，停止生长。
• 当某结点的所有样本属于同一类别，停止生长。
• 提前设定某个阈值，当某结点的样本数小于该阈值时，停止生长。
• 提前设定某个阈值，当分裂带来的性能提升小于该阈值时，停止生长。

预剪枝方法直接、简单高效，适用于大规模求解问题。目前在主流的集成学习模型中，很多算法用到了预剪枝的思想。但因为决策树的构建使用的是启发式方法，具有局部最优的问题，预剪枝提前停止树的生长，存在一定的欠拟合风险。

2. 后剪枝

主流的后剪枝方法有四种：悲观错误剪枝（Pessimistic Error Pruning，PEP），最小错误剪枝（Minimum Error Pruning，MEP），代价复杂度剪枝（Cost-Complexity Pruning，CCP）和基于错误的剪枝（Error-Based Pruning，EBP）。C4.5采用悲观错误剪枝，CART采用代价复杂度剪枝。

后剪枝主要通过极小化决策树整体损失函数来实现。前文我们提到，决策树学习的目标是最小化如下损失函数：

$$L_{\alpha }(T)=\sum _{t=1}^{|T|}{N}_t{H}_t(T)+\alpha |T|$$

其中，经验熵$H_t(T)$可以表示为：

$$H_t(T)=-\sum _k\frac{N_{tk}}{N_t}log\frac{N_{tk}}{N_t}$$

两式合并有：

$$\begin{array}{rl}{L}_{\alpha }(T)& =\sum _{t=1}^{|T|}{N}_t{H}_t(T)+\alpha |T|\\ & =-\sum _{t=1}^{|T|}\sum _{k=1}^K{N}_{tk}log\frac{N_{tk}}{N_t}+\alpha |T|\\ & =L(T)+\alpha |T|\end{array}$$

其中，$L(T)$为模型的经验误差项，$|T|$表示决策树的复杂度（结点数），$\alpha \ge 0$为正则化参数，用于调控经验误差项和正则化项之间的权重关系。

决策树后剪枝就是在正则化参数$\alpha$确定的情况下，选择损失函数$L_{\alpha }(T)$最小的决策树模型。给定算法生成的决策树$T$和正则化参数$\alpha$，后剪枝算法的流程如下：

1. 计算每个树节点的经验熵$H_t(T)$。
2. 递归地自底向上回缩，假设一组叶子结点回缩到父节点前后的数分别为$T_{before}$和$T_{after}$，其对应的损失函数分别为$L_{\alpha }(T_{before})$和$L_{\alpha }(T_{after})$，如果$L_{\alpha }(T_{before})\ge L_{\alpha }(T_{after})$，则进行剪枝，将父节点变为新的叶子结点。
3. 重复上一步，直至得到损失函数最小的子树$T_{\alpha }$。

CART算法使用的正是后剪枝方法。CART后剪枝首先通过计算子树的损失函数来实现剪枝并得到一个子树序列，然后通过交叉验证的方法从子树序列中选取最优子树。

1. 初始化${\alpha }_{best}=\infty$，最优子树集合$\omega =T$。
2. 从叶子结点开始自下而上计算内部节点$t$的损失函数$L_{\alpha }(T_t)$、叶子结点数$|T_t|$，以及正则化阈值$\alpha =min\{\frac{L(T)-L(T_t)}{|T_t|-1},{\alpha }_{best}\}$，更新${\alpha }_{best}=\alpha$。
3. 得到所有节点的$\alpha$值集合$M$。
4. 从M中选择最大的值${\alpha }_k$，自上而下地访问子树$t$的内部节点，如果$\frac{L(T)-L(T_t)}{|T_t|-1}\le {\alpha }_k$，则进行剪枝，并决定叶子结点$t$的预测值。
5. $\omega =\omega \cup T_k$，$M=M-{\alpha }_k$。
6. 如果$M$不为空，则回到步骤4。否则已得到了所有的可选最优子树集合$w$。
7. 采用交叉验证在$w$选择最优子树$T_{\alpha }$。

五、优缺点

1. 优点

1. 简单直观，生成的决策树很直观。
2. 基本不需要预处理，不需要提前归一化和处理缺失值。
3. 使用决策树预测的代价是$O(log2N)$。$N$为样本数。
4. 既可以处理离散值也可以处理连续值。很多算法只是专注于离散值或者连续值。
5. 可以处理多维度输出的分类问题。
6. 相比于神经网络之类的黑盒分类模型，决策树在逻辑上可以很好解释。
7. 可以交叉验证的剪枝来选择模型，从而提高泛化能力。
8. 对于异常点的容错能力好，健壮性高。

2. 缺点

1. 决策树算法非常容易过拟合，导致泛化能力不强。可以通过设置节点最少样本数量和限制决策树深度来改进。
2. 决策树会因为样本发生一点的改动，导致树结构的剧烈改变。这个可以通过集成学习之类的方法解决。
3. 寻找最优的决策树是一个NP难题，我们一般是通过启发式方法，容易陷入局部最优。可以通过集成学习的方法来改善。
4. 有些比较复杂的关系，决策树很难学习，比如异或。这个就没有办法了，一般这种关系可以换神经网络分类方法来解决。
5. 如果某些特征的样本比例过大，生成决策树容易偏向于这些特征。这个可以通过调节样本权重来改善。

六、代码实战

1. sklearn

在sklearn中，使用决策树进行分类预测非常简单，下面是一个来自官方文档的例子。

from sklearn.tree import DecisionTreeClassifier

X = [[0, 0], [1, 1]]
Y = [0, 1]
clf = DecisionTreeClassifier()
clf = clf.fit(X, Y)

# 预测
print(clf.predict([[2, 2]])

# 预测概率
print(clf.predict_proba([[2, 2]])

我们还可以将决策树通过可视化的方式呈现出来。

from sklearn.datasets import load_iris
from sklearn import tree
import matplotlib.pyplot as plt

# 以iris数据为例
iris = load_iris()
clf = tree.DecisionTreeClassifier()
clf = clf.fit(iris.data, iris.target)

# 可视化
plt.figure(figsize=(36, 24))
tree.plot_tree(clf, feature_names=iris.feature_names, 
               filled=True, proportion=True, fontsize=14)

​​

2. PySpark

在PySpark中使用决策树模型稍显复杂。

import numpy as np
import pandas as pd
from pyspark.sql import SparkSession
from pyspark.ml import Pipeline
from pyspark.ml.feature import VectorAssembler
from pyspark.ml.classification import DecisionTreeClassifier, RandomForestClassifier
from pyspark.ml.tuning import ParamGridBuilder, CrossValidator, TrainValidationSplit
from pyspark.ml.evaluation import BinaryClassificationEvaluator


spark = SparkSession.builder.appName('test').getOrCreate()


# 准备数据
# 数据可以从Hive中读取，或从pandas.DataFrame格式创建等。
# 此处假设一份用于二分类预测模型训练的数据已准备好，
data = YOUR_PYSPARK_DATAFRAME
features = YOUR_FEATURE_COLUMN_NAMES
label_col = YOUR_LABEL_COLUMNS

# 数据集分割
traindf, testdf = data.randomSplit([0.8, 0.2], seed=1)

# 特征向量化
vec_assembler = VectorAssembler(inputCols=features, outputCol='features')

# 决策树
dtree = DecisionTreeClassifier(
    seed=1,
    labelCol=label_col,
    featuresCol='features',
    predictionCol='pred',
    probabilityCol='proba',
    maxDepth=5,
    minInstancesPerNode=3,
    impurity='gini',
    maxBins=10
)

# 训练模型
pipeline = Pipeline(stages=[vec_assembler, dtree])
model = pipeline.fit(traindf)

# 特征重要性
feat_importances = list(zip(features, model.stages[1].featureImportances))
df_importances = pd.DataFrame(sorted(feat_importances, key=lambda x: x[1], reverse=True), 
                              columns=['feature', 'importances'])
df_importances.head()

# 预测
df_pred = model.transform(testdf) 
to_array = F.udf(lambda x: x.toArray().tolist(), ArrayType(DoubleType()))
df_pred = df_pred.withColumn('proba_score', to_array('proba')[1])

‍

我们还可以在PySpark中使用网格搜索来确定最佳参数。

# 特征向量化
vec_assembler = VectorAssembler(inputCols=features, outputCol='features')

# 随机森林
dtree = DecisionTreeClassifier(
    seed=1,
    labelCol=label_col,
    featuresCol='features',
    predictionCol='pred',
    probabilityCol='proba',
    impurity='gini',
    # maxDepth=5,
    # minInstancesPerNode=3,
    # maxBins=10
)

# 流水线
pipeline = Pipeline(stages=[vec_assembler, dtree])

# 设置网格参数
param_grid = ParamGridBuilder() \
    .baseOn({dtree.labelCol:'label'}) \
    .baseOn({dtree.featuresCol: 'features'}) \
    .baseOn({dtree.predictionCol: 'pred'}) \
    .baseOn({dtree.probabilityCol: 'proba'}) \
    .addGrid(dtree.minInstancesPerNode, [3, 5, 7]) \
    .addGrid(dtree.maxDepth, [10, 12, 15, 20]) \
    .addGrid(dtree.maxBins, [5, 10, 15]) \
    .build()


# 模型评估
evaluator = BinaryClassificationEvaluator()

# 交叉验证
cv = CrossValidator(
    estimator=pipeline,
    estimatorParamMaps=param_grid,
    evaluator=evaluator,
    numFolds=5,
    seed=1024
)

# 开始执行
a = time.time()
cvModel = cv.fit(traindf)
b = time.time()
print(b - a)

# 打印最佳参数
params = cvModel.getEstimatorParamMaps()
avg_metrics = cvModel.avgMetrics
all_params = list(zip(params, avg_metrics))
best_param = sorted(all_params, key=lambda x: x[1], reverse=True)[0]
for p, v in best_param[0].items():
    print("{}: {}".format(p.name, v))

‍