Machine Learning（1）DecisionTree

DecisionTree

1 概述

1.1 决策树原理

决策树（Decision Tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并用树状图的结构来呈现这些规则，以解决分类和回归问题。决策树算法容易理解，适用各种数据，在解决各种问题时都有良好表现，尤其是以树模型为核心的各种集成算法，在各个行业和领域都有广泛的应用。

决策树算法的本质是一种图结构，我们只需要问一系列问题就可以对数据进行分类了。

alcohol	malic_acid	ash	alcalinity_of_ash	magnesium	total_phenols	flavanoids	class
14.23	1.71	2.43	15.6	127.0	2.80	3.06	0
13.20	1.78	2.14	11.2	100.0	2.65	2.76	1
13.16	2.36	2.67	18.6	101.0	2.80	3.24	2

例如上面的数据集，根据红酒数据的不同特征，将其分为不同的类别（Class）

在这个决策过程中，我们一直在对记录的特征进行提问。最初的问题所在的地方叫做根节点，在得到结论前的每一个问题都是中间节点，而得到的每一个结论（动物的类别）都叫做叶子节点。

关键概念：节点

• 根节点：没有进边，有出边。包含最初的，针对特征的提问。

• 中间节点：既有进边也有出边，进边只有一条，出边可以有很多条。都是针对特征的提问。

• 叶子节点：有进边，没有出边，每个叶子节点都是一个类别标签。

• 子节点和父节点：在两个相连的节点中，更接近根节点的是父节点，另一个是子节点。

决策树算法的核心是要解决两个问题：

1. 如何从数据表中找出最佳节点和最佳分枝？

2. 如何让决策树停止生长，防止过拟合？

1.2 sklearn中的决策树

help(tree)

代码	类型
tree.DecisionTreeClassifier	分类树
tree.DecisionTreeRegressor	回归树
tree.export_graphviz	决策树可视化
tree.ExtraTreeCalssifier	高随机版本分类树
tree.ExtraTreeRegressor	高随机版本回归树

• sklearn基本建模流程
  

2 DecisionTreeClassifier

from sklearn import tree
import pandas as pd
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

wine = load_wine()# 载入红酒数据集

print(wine.data.shape)
print(wine.target.shape)
print(wine.target_names)

data = pd.concat([pd.DataFrame(wine.data), pd.DataFrame(wine.target)], axis=1)
col_names = list(wine.feature_names)
col_names.append('calss')
data.columns = col_names
data.head(5)

2.1 重要参数

2.1.1 criterion

为了要将表格转化为一棵树，决策树需要找出最佳节点和最佳的分枝方法，对分类树来说，衡量这个“最佳”的指标叫做“不纯度”。通常来说，不纯度越低，决策树对训练集的拟合越好。现在使用的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。

不纯度基于节点来计算，树中的每个节点都会有一个不纯度，并且子节点的不纯度一定是低于父节点的，也就是说，在同一棵决策树上，叶子节点的不纯度一定是最低的。

Criterion这个参数正是用来决定不纯度的计算方法的。sklearn提供了两种选择：

1. entropy：使用信息熵
2. gini：使用基尼系数

$$Entropy\left(t\right)=-\sum _{i=0}^{c-1}p\left(i|t\right){\log }_{2}p\left(i|t\right)$$

$$Gini\left(t\right)=1-\sum _{i=0}^{c-1}p{\left(i|t\right)}^2$$

其中t代表给定的节点，i代表标签的任意分类，p(i|t)代表标签分类i在节点t上所占的比例。注意，当使用信息熵时，sklearn实际计算的是基于信息熵的信息增益(Information Gain)，即父节点的信息熵和子节点的信息熵之差。

比起基尼系数，信息熵对不纯度更加敏感，对不纯度的惩罚最强。但是在实际使用中，信息熵和基尼系数的效果基本相同。信息熵的计算比基尼系数缓慢一些，因为基尼系数的计算不涉及对数。另外，因为信息熵对不纯度更加敏感，所以信息熵作为指标时，决策树的生长会更加“精细”，因此对于高维数据或者噪音很多的数，信息熵很容易过拟合，基尼系数在这种情况下效果往往比较好。当模型拟合程度不足的时候，即当模型在训练集和测试集上都表现不太好的时候，使用信息熵。当然，这些不是绝对的。

• 例子

1. 针对以上数据，划分训练集和测试集

Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data, wine.target, test_size=0.3)
# train_test_split输入自变量，因变量，比例三个参数划分数据集
print('训练集大小：', Xtrain.shape)
print('测试集大小：', Xtest.shape)

# 训练集大小： (124, 13)
# 测试集大小： (54, 13)

2. 建立模型

clf = tree.DecisionTreeClassifier(criterion="entropy")
clf = clf.fit(Xtrain, Ytrain)
score = clf.score(Xtest, Ytest) #返回预测的准确度accuracy

print('accuracy score: %.2f' % score)

# accuracy score: 0.94

3. 决策树绘图

# 决策树绘图
feature_name = ['酒精','苹果酸','灰','灰的碱性','镁','总酚','类黄酮','非黄烷类酚类','花青素','颜色强度','色调','稀释葡萄酒','脯氨酸']

import graphviz
dot_data = tree.export_graphviz(clf, 
                                out_file=None,
                                feature_names = feature_name,
                                class_names=["琴酒","雪莉","贝尔摩德"],
                                filled=True,
                                rounded=True) 
graph = graphviz.Source(dot_data)
graph

4. 查看特征重要性

# 特征重要性
[*zip(feature_name,clf.feature_importances_)]
'''
[('酒精', 0.0),
 ('苹果酸', 0.022446861636353448),
 ('灰', 0.0),
 ('灰的碱性', 0.0),
 ('镁', 0.0),
 ('总酚', 0.014422336735850102),
 ('类黄酮', 0.11855919792009308),
 ('非黄烷类酚类', 0.0),
 ('花青素', 0.037023347251702504),
 ('颜色强度', 0.08787275638401838),
 ('色调', 0.02541551409286573),
 ('稀释葡萄酒', 0.2537216563624776),
 ('脯氨酸', 0.4405383296166392)]
'''

在只了解一个参数的情况下，建立了一棵完整的决策树。但是回到步骤2建立模型，score会在某个值附近波动，引起步骤3中画出来的每一棵树都不一样。它为什么会不稳定呢？如果使用其他数据集，它还会不稳定吗？

由于不纯度是基于节点来计算的，也就是说，决策树在建树时，是靠优化节点来追求一棵优化的树，但最优的节点能够保证最优的树吗？集成算法被用来解决这个问题：

sklearn中，既然一棵树不能保证最优，那就建更多的不同的树，然后从中取最好的。怎样从一组数据集中建不同的树？在每次分枝时，不从使用全部特征，而是随机选取一部分特征，从中选取不纯度相关指标最优的作为分枝用的节点。这样，每次生成的树也就不同了。

2.1.2 random_state & splitter

*random_state*用来设置分枝中的随机模式的参数，默认None，在高维度时随机性会表现更明显，低维度的数据（比如鸢尾花数据集），随机性几乎不会显现。输入任意整数，会一直长出同一棵树，让模型稳定下来。

splitter也是用来控制决策树中的随机选项的，有两种输入值，输入best，决策树在分枝时虽然随机，但是还是会优先选择更重要的特征进行分枝（重要性可以通过属性*feature_importances_查看），输入random*，决策树在分枝时会更加随机，树会因为含有更多的不必要信息而更深更大，并因这些不必要信息而降低对训练集的拟合。这也是防止过拟合的一种方式。当预测到模型会过拟合，用这两个参数来帮助你降低树建之后过拟合的可能性。

2.1.3 剪枝参数

在不加限制的情况下，一棵决策树会生长到衡量不纯度的指标最优，或者没有更多的特征可用为止。这样的决策树往往会过拟合，这就是说，它会在训练集上表现很好，在测试集上却表现糟糕。我们收集的样本数据不可能和整体的状况完全一致，因此当一棵决策树对训练数据有了过于优秀的解释性，它找出的规则必然包含了训练样本中的噪声，并使它对未知数据的拟合程度不足。

#我们的树对训练集的拟合程度如何?
score_train = clf.score(Xtrain, Ytrain)
score_train

# 1.0

为了让决策树有更好的泛化性，我们要对决策树进行剪枝。剪枝策略对决策树的影响巨大，正确的剪枝策略是优化决策树算法的核心。sklearn为我们提供了不同的剪枝策略：

• max_depth

限制树的最大深度，超过设定深度的树枝全部剪掉这是用得最广泛的剪枝参数，在高维度低样本量时非常有效。决策树多生长一层，对样本量的需求会增加一倍，所以限制树深度能够有效地限制过拟合。在集成算法中也非常实用。实际使用时，建议从n=3开始尝试，看看拟合的效果再决定是否增加设定深度。

• min_samples_leaf & min_samples_split

*min_samples_leaf限定，一个节点在分枝后的每个子节点都必须包含至少min_samples_leaf个训练样本，否则分枝就不会发生，或者，分枝会朝着满足每个子节点都包含min_samples_leaf*个样本的方向去发生。

一般搭配*max_depth*使用，在回归树中有神奇的效果，可以让模型变得更加平滑。这个参数的数量设置得太小会引起过拟合，设置得太大就会阻止模型学习数据。一般来说，建议从=5开始使用。如果叶节点中含有的样本量变化很大，建议输入浮点数作为样本量的百分比来使用。同时，这个参数可以保证每个叶子的最小尺寸，可以在回归问题中避免低方差，过拟合的叶子节点出现。对于类别不多的分类问题，=1通常就是最佳选择。

*min_samples_split限定，一个节点必须要包含至少min_samples_split*个训练样本，这个节点才允许被分枝，否则分枝就不会发生。

clf = tree.DecisionTreeClassifier(criterion="entropy", # 可以选择entropy，gini
                                  random_state=30, # 随机特征选择
                                  splitter="random", # random随机分枝，防止过拟合
                                  # 剪枝参数
                                  max_depth=4, 
                                  min_samples_leaf=10,
                                  min_samples_split=10) 
clf = clf.fit(Xtrain, Ytrain)
score = clf.score(Xtest, Ytest)# 返回预测的准确度

print('accuracy score: %.2f' % score)

# accuracy score: 0.93

dot_data = tree.export_graphviz(clf, 
                                out_file=None,
                                feature_names = feature_name,
                                class_names=["琴酒","雪莉","贝尔摩德"],
                                filled=True,
                                rounded=True) 
graph = graphviz.Source(dot_data)
graph

（本部分笔者仅作演示，感兴趣可自行尝试最优参数和拟合结果）

• max_feature & min_impurity_decrease

*max_features限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃。和max_depth异曲同工，max_features*是用来限制高维度数据的过拟合的剪枝参数，但其方法比较暴力，是直接限制可以使用的特征数量而强行使决策树停下的参数，在不知道决策树中的各个特征的重要性的情况下，强行设定这个参数可能会导致模型学习不足。如果希望通过降维的方式防止过拟合，建议使用PCA，ICA或者特征选择模块中的降维算法。

• 确定最优剪枝参数

使用超参数曲线判断参数选择，使用已经训练好的决策树模型clf。超参数的学习曲线，是一条以超参数的取值为横坐标，模型的度量指标为纵坐标的曲线，它是用来衡量不同超参数取值下模型的表现的线。在建好的决策树里，模型度量指标就是score。

import matplotlib.pyplot as plt
test = []
for i in range(10):
    clf = tree.DecisionTreeClassifier(max_depth=i+1
                                    ,criterion="entropy"
                                    ,random_state=30
                                    ,splitter="random"
                                    )
    clf = clf.fit(Xtrain, Ytrain)
    score = clf.score(Xtest, Ytest)
    test.append(score)
plt.plot(range(1,11),test,color="red",label="max_depth")
plt.legend()
plt.show()

2.2 重要属性和接口

属性是在模型训练之后，能够调用查看的模型的各种性质。对决策树来说，最重要的是**feature_importances_**，能够查看各个特征对模型的重要性。

sklearn中许多算法的接口都是相似的，比如说我们之前已经用到的fit和score，几乎对每个算法都可以使用。除了这两个接口之外，决策树最常用的接口还有apply和predict。apply（）中输入测试集返回每个测试样本所在的叶子节点的索引，predict（）输入测试集返回每个测试样本的标签。

在这里不得不提的是，**所有接口中要求输入X_train和X_test的部分，输入的特征矩阵必须至少是一个二维矩阵。sklearn接受任何一维矩阵作为特征矩阵被输入。如果你的数据的确只有一个特征，那必须用reshape(-1,1)来给矩阵增维；如果你的数据只有一个特征和一个样本，使用reshape(1,-1)来给你的数据增维。

#apply返回每个测试样本所在的叶子节点的索引
clf.apply(Xtest)

array([ 9, 27, 27, 16,  4, 10,  4,  4, 27, 27, 10, 22, 24, 16, 22, 27, 16,
       27,  4,  4, 16, 16, 16, 27, 22,  8, 27,  4, 22, 24,  8, 22,  4,  4,
       27, 16, 13, 22, 16, 13, 16, 27,  4, 22, 22, 27, 16, 27,  9,  6, 16,
       10, 27,  4], dtype=int64)
       
#predict返回每个测试样本的分类/回归结果
clf.predict(Xtest)

array([1, 0, 0, 1, 2, 1, 2, 2, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 2, 2, 1, 1,
       1, 0, 1, 2, 0, 2, 1, 0, 2, 1, 2, 2, 0, 1, 1, 1, 1, 1, 1, 0, 2, 1,
       1, 0, 1, 0, 1, 2, 1, 1, 0, 2])

3 DecisionTreeRegressor

需要注意的是，在回归树中，没有标签分布是否均衡的问题，因此没有class_weight这样的参数。

3.1 重要参数和属性，接口

回归树衡量分枝质量的指标，支持的标准有三种：

1. 输入"mse"使用均方误差mean squared error(MSE)，父节点和叶子节点之间的均方误差的差额将被用来作为特征选择的标准，这种方法通过使用叶子节点的均值来最小化L2损失。
2. 输入“friedman_mse”使用费尔德曼均方误差，这种指标使用弗里德曼针对潜在分枝中的问题改进后的均方误差
3. 输入"mae"使用绝对平均误差MAE（mean absolute error），这种指标使用叶节点的中值来最小化L1损失

属性中最重要的依然是**feature_importances_**，接口依然是apply, fit, predict, score最核心。
$$MSE=\frac{1}{N}\sum _{i=1}^N{\left(f_i-y_i\right)}^2$$
其中 N 是样本数量，i 是每一个数据样本，fit 是模型回归出的数值，y_i 是样本点 i 实际的数值标签。所以MSE的本质，其实是样本真实数据与回归结果的差异。在回归树中，MSE不只是分枝质量衡量指标，也是最常用的衡量回归树回归质量的指标，当我们在使用交叉验证，或者其他方式获取回归树的结果时，我们往往选择均方误差作为我们的评估（在分类树中这个指标是score代表的预测准确率）。在回归中，我们追求的是，MSE越小越好。

然而，回归树的接口score返回的是R平方，并不是MSE。
$$R^2=1-\frac{{\sum }_{i=1}^N{\left(f_i-y_i\right)}^2}{{\sum }_{i=1}^N{\left(y_i-y_i\right)}^2}$$
值得一提的是，虽然均方误差永远为正，但是sklearn当中使用均方误差作为评判标准时，却是计算负均方误差（neg_mean_squared_error）。这是因为sklearn在计算模型评估指标的时候，会考虑指标本身的性质，均方误差本身是一种误差，所以被sklearn划分为模型的一种损失(loss)，因此在sklearn当中，都以负数表示。真正的均方误差MSE的数值，其实就是neg_mean_squared_error去掉负号的数字。(了解即可)

4 案例：泰坦尼克号幸存者预测

1. 导入需要的库

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

2. 导入数据集，数据预处理

data = pd.read_csv("data.csv",index_col = 0)

data.head()
data.info()

<class 'pandas.core.frame.DataFrame'>
Index: 891 entries, 1 to 891
Data columns (total 11 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   Survived  891 non-null    int64  
 1   Pclass    891 non-null    int64  
 2   Name      891 non-null    object 
 3   Sex       891 non-null    object 
 4   Age       714 non-null    float64
 5   SibSp     891 non-null    int64  
 6   Parch     891 non-null    int64  
 7   Ticket    891 non-null    object 
 8   Fare      891 non-null    float64
 9   Cabin     204 non-null    object 
 10  Embarked  889 non-null    object 
dtypes: float64(2), int64(4), object(5)
memory usage: 83.5+ KB

#删除缺失值过多的列，和观察判断来说和预测的y没有关系的列
data.drop(["Cabin","Name","Ticket"],inplace=True,axis=1)

#处理缺失值，对缺失值较多的列进行填补，有一些特征只确实一两个值，可以采取直接删除记录的方法
data["Age"] = data["Age"].fillna(data["Age"].mean())
data = data.dropna()

#将分类变量转换为数值型变量

#将二分类变量转换为数值型变量
#astype能够将一个pandas对象转换为某种类型，和apply(int(x))不同，astype可以将文本类转换为数字，用这个方式可以很便捷地将二分类特征转换为0~1
data["Sex"] = (data["Sex"]== "male").astype("int")

#将三分类变量转换为数值型变量
labels = data["Embarked"].unique().tolist()
data["Embarked"] = data["Embarked"].apply(lambda x: labels.index(x))

#查看处理后的数据集
data.head()

3. 提取标签和特征矩阵，划分测试集和训练集

X = data.iloc[:,data.columns != "Survived"]
y = data.iloc[:,data.columns == "Survived"]

Xtrain, Xtest, Ytrain, Ytest = train_test_split(X,y,test_size=0.3)

#修正测试集和训练集的索引
for i in [Xtrain, Xtest, Ytrain, Ytest]:
    i.index = range(i.shape[0])
    
#查看分好的训练集和测试集
Xtrain.head()

4. 初试模型结果

clf = DecisionTreeClassifier(random_state=25)
clf = clf.fit(Xtrain, Ytrain)
accuracy_score = clf.score(Xtest, Ytest)
cross_score = cross_val_score(clf, X, y, cv=10).mean()

print('accuracy_score: %.2f' % accuracy_score)
print('cross_val_score: %.2f' % cross_score)

accuracy_score: 0.78
cross_val_score: 0.77

这里的交叉验证是用来观察模型的稳定性的一种方法，我们将数据划分为n份，依次使用其中一份作为测试集，其他n-1份作为训练集，多次计算模型的精确性来评估模型的平均准确程度。训练集和测试集的划分会干扰模型的结果，因此用交叉验证n次的结果求出的平均值，是对模型效果的一个更好的度量。

5. 模型调参

tr = []
te = []
for i in range(10):
    clf = DecisionTreeClassifier(random_state=25,
                                max_depth=i+1,
                                criterion="entropy")
    clf = clf.fit(Xtrain, Ytrain)
    score_tr = clf.score(Xtrain, Ytrain)
    score_te = cross_val_score(clf, X, y, cv=10).mean()
    tr.append(score_tr)
    te.append(score_te)
print(max(te))
plt.plot(range(1,11),tr,color="red",label="train")
plt.plot(range(1,11),te,color="blue",label="test")
plt.xticks(range(1,11))
plt.legend()
plt.show()

6. 网格搜索调参

在机器学习模型中，需要人工选择的参数称为超参数。比如随机森林中决策树的个数，人工神经网络模型中隐藏层层数和每层的节点个数，正则项中常数大小等等，他们都需要事先指定。超参数选择不恰当，就会出现欠拟合或者过拟合的问题。而在选择超参数的时候，有两个途径，一个是凭经验微调，另一个就是选择不同大小的参数，带入模型中，挑选表现最好的参数。

微调的一种方法是手工调制超参数，直到找到一个好的超参数组合，这么做的话会非常冗长，你也可能没有时间探索多种组合，所以可以使用Scikit-Learn的**GridSearchCV**来做这项搜索工作。

class sklearn.model_selection.GridSearchCV(estimator, # 选择使用的分类器，并且传入除需要确定最佳的参数之外的其他参数。
                                           param_grid, # 需要最优化的参数的取值，值为字典或者列表
                                           scoring=None, # 模型评价标准
                                           fit_params=None, 
                                           n_jobs=1, # CPU核数
                                           iid=True, # 默认为各个样本fold概率分布一致，误差估计为所有样本之和而非平均
                                           refit=True, 
                                           cv=None, # 交叉验证参数，默认None
                                           verbose=0, 
                                           pre_dispatch=‘2*n_jobs’, 
                                           error_score=’raise’, 
                                           return_train_score=’warn’)

gini_thresholds = np.linspace(0,0.5,20)

parameters = {'splitter':('best','random')
              ,'criterion':("gini","entropy")
              ,"max_depth":[*range(1,10)]
              ,'min_samples_leaf':[*range(1,50,5)]
              ,'min_impurity_decrease':[*np.linspace(0,0.5,20)]
             }

clf = DecisionTreeClassifier(random_state=25)
GS = GridSearchCV(clf, 
                  parameters, 
                  cv=10)
GS.fit(Xtrain,Ytrain)

print(GS.best_params_)

{'criterion': 'entropy', 'max_depth': 6, 'min_impurity_decrease': 0.0, 'min_samples_leaf': 6, 'splitter': 'best'}

5 总结

5.1 决策树优点

1. 易于理解和解释，因为树木可以画出来被看见
2. 需要很少的数据准备。其他很多算法通常都需要数据规范化，需要创建虚拟变量并删除空值等。但请注意，sklearn中的决策树模块不支持对缺失值的处理。
3. 使用树的成本（比如说，在预测数据的时候）是用于训练树的数据点的数量的对数，相比于其他算法，这是一个很低的成本。
4. 能够同时处理数字和分类数据，既可以做回归又可以做分类。其他技术通常专门用于分析仅具有一种变量类型的数据集。
5. 能够处理多输出问题，即含有多个标签的问题，注意与一个标签中含有多种标签分类的问题区别开
6. 是一个白盒模型，结果很容易能够被解释。如果在模型中可以观察到给定的情况，则可以通过布尔逻辑轻松解释条件。相反，在黑盒模型中（例如，在人工神经网络中），结果可能更难以解释。
7. 可以使用统计测试验证模型，这让我们可以考虑模型的可靠性。
8. 即使其假设在某种程度上违反了生成数据的真实模型，也能够表现良好。

5.2 决策树缺点

1. 决策树学习者可能创建过于复杂的树，这些树不能很好地推广数据。这称为过度拟合。修剪，设置叶节点所需的最小样本数或设置树的最大深度等机制是避免此问题所必需的，而这些参数的整合和调整对初学者来说会比较晦涩。
2. 决策树可能不稳定，数据中微小的变化可能导致生成完全不同的树，这个问题需要通过集成算法来解决。
3. 决策树的学习是基于贪婪算法，它靠优化局部最优（每个节点的最优）来试图达到整体的最优，但这种做法不能保证返回全局最优决策树。这个问题也可以由集成算法来解决，在随机森林中，特征和样本会在分枝过程中被随机采样。
4. 有些概念很难学习，因为决策树不容易表达它们，例如XOR，奇偶校验或多路复用器问题。
5. 如果标签中的某些类占主导地位，决策树学习者会创建偏向主导类的树。因此，建议在拟合决策树之前平衡数据集。

6 附录

ID3算法构建决策树

ID3算法原型见于J.R Quinlan的博士论文，是基础理论较为完善，使用较为广泛的决策树模型，在此基础上J.R Quinlan进行优化后，陆续推出了C4.5和C5.0决策树算法，后二者现已称为当前最流行的决策树算法，我们先从ID3开始讲起，再讨论如何从ID3逐渐优化至C4.5。

为了要将表格转化为一棵树，决策树需要找出最佳节点和最佳的分枝方法，而衡量这个“最佳”的指标叫做**“不纯度”**。不纯度基于叶子节点来计算的，所以树中的每个节点都会有一个不纯度，并且子节点的不纯度一定是低于父节点的，也就是说，在同一棵决策树上，叶子节点的不纯度一定是最低的。

决策树的每个叶子节点中都会包含一组数据，在这组数据中，如果有某一类标签占有较大的比例，我们就说叶子节点“纯”，分枝分得好。某一类标签占的比例越大，叶子就越纯，不纯度就越低，分枝就越好。如果没有哪一类标签的比例很大，各类标签都相对平均，则说叶子节点”不纯“，分枝不好，不纯度高。

这个其实非常容易理解。分类型决策树在叶子节点上的决策规则是少数服从多数，在一个叶子节点上，如果某一类标签所占的比例较大，那所有进入这个叶子节点的样本都回被认为是这一类别。距离来说，如果90%根据规则进入叶子节点的样本都是类别0（叶子比较纯），那新进入叶子节点的测试样本的类别也很有可能是0。但是，如果51%的样本是0，49%的样本是1（极端情况），叶子节点还是会被认为是0类叶子节点，但此时此刻进入这个叶子的测试样本点几乎有一半的可能性应该是类别1。从数学上来说，类分布为（0,100%）的结点具有零不纯性，而均衡分布（50%,50%）的结点具有最高的不纯性。如果叶子本身不纯，那测试样本就很有可能被判断错误，相对的叶子越纯，那样本被判断错误的可能性就越小。

通常来说，不纯度越低，决策树对训练集的拟合越好。现在使用的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。若我们定义t代表决策树的某节点， 是t节点所对应的数据集，设 p(i|t) 表示给定结点 t 中属于类别 i 的样本所占的比例，这个比例越高，则代表叶子越纯。

决策树最终的优化目标是使得叶节点的总不纯度最低，即对应衡量不纯度的指标最低。ID3采用信息熵来衡量不纯度，此处就先以信息熵为例进行讨论。ID3最优条件是叶节点的总信息熵最小，因此ID3决策树在决定是否对某节点进行切分的时候，会尽可能选取使得该节点对应的子节点信息熵最小的特征进行切分。换言之，就是要求父节点信息熵和子节点总信息熵之差要最大。对于ID3而言，二者之差就是信息增益，即Information gain。

• 如何选择属性，需要看信息增益（Information Gain）。也就是说，信息增益是相对于属性而言的，信息增益越大，属性对最终的分类结果影响也就越大，应该选择对最终分类结果影响最大的那个属性作为分类属性。属性A对训练数据集D的信息增益g(D,A)，定义为集合D的信息熵H(D)与属性A给定条件下D的条件熵H(D|A)之差：

$$g(D,A)=H(D)-H(D,A)$$

• 可以理解为：引入某一个条件后，不确定性减小了，这个减小的量=信息增益=信息熵-条件熵。信息增益越大，则说明引入的条件能更好地消除不确定性。

总的来说，决策树模型是一个典型的贪心模型，总目标是一个全局最优解，即一整套合理的分类规则使得最终叶节点的纯度最高，但全局最优解在随特征增加而呈现指数级增加的搜索空间内很难高效获取，因此我们退而求其次，考虑采用局部最优来一步步推导结果——只要保证信息增益最大，我们就能得到次最优的模型。当然，局部最优不一定等于全局最优，接下来我们就ID3可能存在的一些问题及改进方向进行一些讨论。

ID3的局限性

1. 分支度越高（分类水平越多）的离散变量往往子节点的总信息熵会更小，ID3是按照某一列进行切分，有一些列的分类可能不会对我需要的结果有足够好的指示。极限情况下取ID作为切分字段，每个分类的纯度都是100%，因此这样的分类方式是没有效益的。
2. 不能直接处理连续型变量，若要使用ID3处理连续型变量，则首先需要对连续变量进行离散化。
3. 对缺失值较为敏感，使用ID3之前需要提前对缺失值进行处理。
4. 没有剪枝的设置，容易导致过拟合，即在训练集上表现很好，测试集上表现很差。

C4.5算法

有些时候，使用信息增益会比较粗暴，效果也不一定好。因为增益这个指标天然地偏向于选择那些分支比较多的属性。这种偏向性是必须消除的，算法应该公正地评价所有的属性，因此，信息增益率（Gain Ratio）被提出：
$$Gainratio=\frac{InforamtionGain}{InformationValue}$$
根据信息增益率进行决策的过程，称为C4.5决策树学习算法。

下面笔者自行创造了一套数据集示例，并给出了两种算法的计算过程，感兴趣可自行尝试：

#DecsionTree算法
#构建数据集
def createDataSet():
    dataSet = [[0, 2, 0, 0, 'N'], 
               [0, 2, 0, 1, 'N'], 
               [1, 2, 0, 0, 'Y'], 
               [2, 1, 0, 0, 'Y'], 
               [2, 0, 1, 0, 'Y'], 
               [2, 0, 1, 1, 'N'], 
               [1, 0, 1, 1, 'Y'],
               [0, 1, 0, 0, 'N'], 
               [0, 0, 1, 0, 'Y'], 
               [2, 1, 1, 0, 'Y'], 
               [0, 1, 1, 1, 'Y'], 
               [1, 1, 0, 1, 'Y'], 
               [1, 2, 1, 0, 'Y'],
               [2, 1, 0, 1, 'N']]
    labels = ['Age', 'Income', 'Job', 'Credit']
    return dataSet, labels

dS1,lab = createDataSet()
print(dS1)
print(lab)

#计算数据集的信息熵
#参数：dataset-List列表，训练集，包含了样本数据和分类结果
#返回值：shannonEnt-浮点数，训练集的香农熵
def calcShannonEnt(dataSet):
    numEntries = len(dataSet)
    labelCounts = {}
    for featVec in dataSet:
#featVec[-1]表示列表featVec中的最后一项，就是Y/N的分类结果        
        currentLabel = featVec[-1]
#对currentLabel计数，对应的分类为Y/N的样本各有多少个
        if currentLabel not in labelCounts.keys():
            labelCounts[currentLabel] = 0
        labelCounts[currentLabel] += 1
    shannonEnt = 0.0
#计算信息熵
    for key in labelCounts:
        prob = float(labelCounts[key])/numEntries
        shannonEnt -= prob * log(prob, 2)
    return shannonEnt

snEnt = calcShannonEnt(dS1)
print('原始数据集香农熵：')
print(snEnt)

#按照feat指定的标签分割数据集
#参数：dataset-List列表，待分割样本集合
#      axie-数值，属性列表项序号，按照此属性的取值来分割样本集合
#      value-数值，属性取值
#返回值：retDataSet-List列表，分割后的样本集合，去除了分割属性
def splitDataSet(dataSet, axis, value):
    retDataSet = []
    for featVec in dataSet:
        if featVec[axis] == value:
            reduceFeatVec = featVec[:axis]
            reduceFeatVec.extend(featVec[axis+1:])
            retDataSet.append(reduceFeatVec)
    return retDataSet

print('splitDataSet函数示例')
print('将原始样本分割出Income（在labels中序号为1）值为0的集合：')
retDS1 = splitDataSet(dS1,1, 0)
print(retDS1)

#决策树ID3算法
#按照信息熵增益来确定用于分割的属性
#参数：dataset-List列表，待分割样本集合
#返回值：bestFeature-数值，分割属性对应在labels中的序号
def ID3(dataSet):
#属性数量=样本列表元素数量-1（最后一项是分类结果，不是属性）
    numFeatures = len(dataSet[0]) - 1
#计算原始数据集信息熵
    baseEntropy = calcShannonEnt(dataSet)
    bestInfoGain= 0.0
    bestFeature = -1
    for i in range(numFeatures):
#当前属性下，所有样本的值构成列表
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList)
        newEntropy = 0.0
        for value in uniqueVals:
#当使用该属性分割时，计算其香农信息熵
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet)/float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)
        infoGain = baseEntropy - newEntropy
#找出最大熵增益对应的属性
        if (infoGain > bestInfoGain):
            bestInfoGain = infoGain
            bestFeature = i
    return bestFeature

bFID3=ID3(dS1)
print('ID3第一次选择的最佳分割属性:')
print(bFID3)

#决策树C45算法
#按照信息熵增益率来确定用于分割的属性
#参数：dataset-List列表，待分割样本集合
#返回值：bestFeature-数值，分割属性对应在labels中的序号
def C45(dataSet):
    numFeatures = len(dataSet[0]) - 1
    baseEntropy = calcShannonEnt(dataSet)
#用于找出最大增益率的变量
    bestInfoGainRatio = 0.0
    bestFeature = -1
    for i in range(numFeatures):
        featList = [example[i] for example in dataSet]
        uniqueVals = set(featList)
        newEntropy = 0.0
#用于计算分离信息
        splitInfo = 0.0
        for value in uniqueVals:
            subDataSet = splitDataSet(dataSet, i, value)
            prob = len(subDataSet)/float(len(dataSet))
            newEntropy += prob * calcShannonEnt(subDataSet)
            splitInfo += -prob * log(prob, 2)
        infoGain = baseEntropy - newEntropy
        if (splitInfo == 0): 
            continue
#属性选取标准改为增益率
        infoGainRatio = infoGain / splitInfo
        if (infoGainRatio > bestInfoGainRatio):
            bestInfoGainRatio = infoGainRatio
            bestFeature = i
    return bestFeature

bFC45=C45(dS1)
print('C45第一次选择的最佳分割属性:')
print(bFC45)