一棵完全生长的决策树会面临一个很严重的问题，即过拟合。当模型过拟合进行预测时，在测试集上的效果将会很差。因此我们需要对决策树进行剪枝，剪掉一些枝叶，提升模型的泛化能力。
决策树的剪枝通常有两种方法，预剪枝（ Pre-Pruning ）和后剪枝( Post-Pruning ）。

文章目录

一、预剪枝
- 1.什么是预剪枝
- 2.预剪枝的优缺点
二、后剪枝
- 1.什么是后剪枝
- 2.后剪枝的优缺点
三、代码
- 1、导入数据
- 2、创建基础函数（如计算熵、计算条件熵、信息增益、信息增益率等）
- 3、创建树生成相关函数（如特征选取、数据分割、多数投票、树生成、使用树分类、树信息统计）
- 4、树的可视化
- 5、预剪枝和预剪枝测试
- 6、后剪枝
四、总结

一、预剪枝

1.什么是预剪枝

预剪枝，即在生成决策树的过程中提前停止树的增长。核心思想是在树中结点进行扩展之前，先计算当前的划分是否能带来模型泛化能力的提升，如果不能，则不再继续生长子树。此时可能存在不同类别的样本同时存于结点中，按照多数投票的原则判断该结点所属类别。预剪枝对于何时停止决策树的生长有以下几种方法：

( 1 ）当树到达一定深度的时候，停止树的生长。
( 2 ）当到达当前结点的样本数量小于某个阈值的时候，停止树的生长。
( 3 ）计算每次分裂对测试集的准确度提升，当小于某个阈值的时候，不再继续扩展。

2.预剪枝的优缺点

预剪枝具有思想直接、算法简单、效率高等特点，适合解决大规模问题。但如何准确地估计何时停止树的生长（即上述方法中的深度或阈值），针对不同问题会有很大差别，需要一定经验判断。且预剪枝存在一定局限性，高欠拟合的风险，虽然当前的划分会导致测试集准确率降低，但在之后的划分中，准确率可能会高显著上升。

二、后剪枝

1.什么是后剪枝

后剪枝，是在已经生成的过拟合决策树上进行剪枝，得到简化版的剪枝决策树。核心思想是让算法生成一棵完全生长的决策树，然后从最底层向上计算是否剪枝。剪枝过程将子树删除，用一个叶子结点替代，该结点的类别同样按照多数投票的原则进行判断。同样地，后剪枝也可以通过在测试集上的准确率进行判断，如果剪枝过后准确率有所提升，则进行剪枝。相比于预剪枝，后剪枝方法通常可以得到泛化能力更强的决策树，但时间开销会更大。

常见的后剪枝方法包括错误率降低剪枝（ Reduced Error Pruning, REP ）、悲观剪枝（ Pessimistic Error Pruning, PEP ）、代价复杂度剪枝（ Cost Complexity Pruning, CCP ）、最小误差剪枝（ Minimum Error Pruning, MEP ）、 CVP ( Critical Value Pruning ）、 OPP ( Optimal Pruning ）等方法，这些剪枝方法各有利弊，关注不同的优化角度。

2.后剪枝的优缺点

-后剪枝比预剪枝保留了更多的分支，欠拟合风险小，泛化性能往往优于预剪枝决策树
-训练时间开销大:后剪枝过程是在生成完全决策树之后进行的，需要自底向上对所有非叶结点逐- -计算

三、代码

1、导入数据

import math
import numpy as np # 创建西瓜书数据集2.0
def createDataXG20():data = np.array([['青绿', '蜷缩', '浊响', '清晰', '凹陷', '硬滑'], ['乌黑', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑'], ['乌黑', '蜷缩', '浊响', '清晰', '凹陷', '硬滑'], ['青绿', '蜷缩', '沉闷', '清晰', '凹陷', '硬滑'], ['浅白', '蜷缩', '浊响', '清晰', '凹陷', '硬滑'], ['青绿', '稍蜷', '浊响', '清晰', '稍凹', '软粘'], ['乌黑', '稍蜷', '浊响', '稍糊', '稍凹', '软粘'], ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '硬滑'], ['乌黑', '稍蜷', '沉闷', '稍糊', '稍凹', '硬滑'], ['青绿', '硬挺', '清脆', '清晰', '平坦', '软粘'], ['浅白', '硬挺', '清脆', '模糊', '平坦', '硬滑'], ['浅白', '蜷缩', '浊响', '模糊', '平坦', '软粘'], ['青绿', '稍蜷', '浊响', '稍糊', '凹陷', '硬滑'], ['浅白', '稍蜷', '沉闷', '稍糊', '凹陷', '硬滑'], ['乌黑', '稍蜷', '浊响', '清晰', '稍凹', '软粘'], ['浅白', '蜷缩', '浊响', '模糊', '平坦', '硬滑'], ['青绿', '蜷缩', '沉闷', '稍糊', '稍凹', '硬滑']])label = np.array(['是', '是', '是', '是', '是', '是', '是', '是', '否', '否', '否', '否', '否', '否', '否', '否', '否'])name = np.array(['色泽', '根蒂', '敲声', '纹理', '脐部', '触感'])return data, label, namedef splitXgData20(xgData, xgLabel):xgDataTrain = xgData[[0, 1, 2, 5, 6, 9, 13, 14, 15, 16],:]xgDataTest = xgData[[3, 4, 7, 8, 10, 11, 12],:]xgLabelTrain = xgLabel[[0, 1, 2, 5, 6, 9, 13, 14, 15, 16]]xgLabelTest = xgLabel[[3, 4, 7, 8, 10, 11, 12]]return xgDataTrain, xgLabelTrain, xgDataTest, xgLabelTest

2、创建基础函数（如计算熵、计算条件熵、信息增益、信息增益率等）

# 定义一个常用函数 用来求numpy array中数值等于某值的元素数量
equalNums = lambda x,y: 0 if x is None else x[x==y].size# 定义计算信息熵的函数
def singleEntropy(x):"""计算一个输入序列的信息熵"""# 转换为 numpy 矩阵x = np.asarray(x)# 取所有不同值xValues = set(x)# 计算熵值entropy = 0for xValue in xValues:p = equalNums(x, xValue) / x.size entropy -= p * math.log(p, 2)return entropy# 定义计算条件信息熵的函数
def conditionnalEntropy(feature, y):"""计算 某特征feature 条件下y的信息熵"""# 转换为numpy feature = np.asarray(feature)y = np.asarray(y)# 取特征的不同值featureValues = set(feature)# 计算熵值 entropy = 0for feat in featureValues:# 解释：feature == feat 是得到取feature中所有元素值等于feat的元素的索引（类似这样理解）#       y[feature == feat] 是取y中 feature元素值等于feat的元素索引的 y的元素的子集p = equalNums(feature, feat) / feature.size entropy += p * singleEntropy(y[feature == feat])return entropy# 定义信息增益
def infoGain(feature, y):return singleEntropy(y) - conditionnalEntropy(feature, y)# 定义信息增益率
def infoGainRatio(feature, y):return 0 if singleEntropy(feature) == 0 else infoGain(feature, y) / singleEntropy(feature)

3、创建树生成相关函数（如特征选取、数据分割、多数投票、树生成、使用树分类、树信息统计）

# 特征选取
def bestFeature(data, labels, method = 'id3'):assert method in ['id3', 'c45'], "method 须为id3或c45"data = np.asarray(data)labels = np.asarray(labels)# 根据输入的method选取 评估特征的方法：id3 -> 信息增益; c45 -> 信息增益率def calcEnt(feature, labels):if method == 'id3':return infoGain(feature, labels)elif method == 'c45' :return infoGainRatio(feature, labels)# 特征数量  即 data 的列数量featureNum = data.shape[1]# 计算最佳特征bestEnt = 0 bestFeat = -1for feature in range(featureNum):ent = calcEnt(data[:, feature], labels)if ent >= bestEnt:bestEnt = ent bestFeat = feature# print("feature " + str(feature + 1) + " ent: " + str(ent)+ "\t bestEnt: " + str(bestEnt))return bestFeat, bestEnt # 根据特征及特征值分割原数据集  删除data中的feature列，并根据feature列中的值分割 data和label
def splitFeatureData(data, labels, feature):"""feature 为特征列的索引"""# 取特征列features = np.asarray(data)[:,feature]# 数据集中删除特征列data = np.delete(np.asarray(data), feature, axis = 1)# 标签labels = np.asarray(labels)uniqFeatures = set(features)dataSet = {}labelSet = {}for feat in uniqFeatures:dataSet[feat] = data[features == feat]labelSet[feat] = labels[features == feat]return dataSet, labelSet# 多数投票
def voteLabel(labels):uniqLabels = list(set(labels))labels = np.asarray(labels)finalLabel = 0labelNum = []for label in uniqLabels:# 统计每个标签值得数量labelNum.append(equalNums(labels, label))# 返回数量最大的标签return uniqLabels[labelNum.index(max(labelNum))]# 创建决策树
def createTree(data, labels, names, method = 'id3'):data = np.asarray(data)labels = np.asarray(labels)names = np.asarray(names)# 如果结果为单一结果if len(set(labels)) == 1: return labels[0] # 如果没有待分类特征elif data.size == 0: return voteLabel(labels)# 其他情况则选取特征 bestFeat, bestEnt = bestFeature(data, labels, method = method)# 取特征名称bestFeatName = names[bestFeat]# 从特征名称列表删除已取得特征名称names = np.delete(names, [bestFeat])# 根据选取的特征名称创建树节点decisionTree = {bestFeatName: {}}# 根据最优特征进行分割dataSet, labelSet = splitFeatureData(data, labels, bestFeat)# 对最优特征的每个特征值所分的数据子集进行计算for featValue in dataSet.keys():decisionTree[bestFeatName][featValue] = createTree(dataSet.get(featValue), labelSet.get(featValue), names, method)return decisionTree # 树信息统计 叶子节点数量 和 树深度
def getTreeSize(decisionTree):nodeName = list(decisionTree.keys())[0]nodeValue = decisionTree[nodeName]leafNum = 0treeDepth = 0 leafDepth = 0for val in nodeValue.keys():if type(nodeValue[val]) == dict:leafNum += getTreeSize(nodeValue[val])[0]leafDepth = 1 + getTreeSize(nodeValue[val])[1] else :leafNum += 1 leafDepth = 1 treeDepth = max(treeDepth, leafDepth)return leafNum, treeDepth # 使用模型对其他数据分类
def dtClassify(decisionTree, rowData, names):names = list(names)# 获取特征feature = list(decisionTree.keys())[0]# 决策树对于该特征的值的判断字段featDict = decisionTree[feature]# 获取特征的列feat = names.index(feature)# 获取数据该特征的值featVal = rowData[feat]# 根据特征值查找结果，如果结果是字典说明是子树，调用本函数递归if featVal in featDict.keys():if type(featDict[featVal]) == dict:classLabel = dtClassify(featDict[featVal], rowData, names)else:classLabel = featDict[featVal] return classLabel

4、树的可视化

# 可视化 主要源自《机器学习实战》
import matplotlib.pyplot as plt decisionNodeStyle = dict(boxstyle = "sawtooth", fc = "0.8")
leafNodeStyle = {"boxstyle": "round4", "fc": "0.8"}
arrowArgs = {"arrowstyle": "<-"}# 画节点
def plotNode(nodeText, centerPt, parentPt, nodeStyle):createPlot.ax1.annotate(nodeText, xy = parentPt, xycoords = "axes fraction", xytext = centerPt, textcoords = "axes fraction", va = "center", ha="center", bbox = nodeStyle, arrowprops = arrowArgs)# 添加箭头上的标注文字
def plotMidText(centerPt, parentPt, lineText):xMid = (centerPt[0] + parentPt[0]) / 2.0yMid = (centerPt[1] + parentPt[1]) / 2.0 createPlot.ax1.text(xMid, yMid, lineText)# 画树
def plotTree(decisionTree, parentPt, parentValue):# 计算宽与高leafNum, treeDepth = getTreeSize(decisionTree) # 在 1 * 1 的范围内画图，因此分母为 1# 每个叶节点之间的偏移量plotTree.xOff = plotTree.figSize / (plotTree.totalLeaf - 1)# 每一层的高度偏移量plotTree.yOff = plotTree.figSize / plotTree.totalDepth# 节点名称nodeName = list(decisionTree.keys())[0]# 根节点的起止点相同，可避免画线；如果是中间节点，则从当前叶节点的位置开始，#      然后加上本次子树的宽度的一半，则为决策节点的横向位置centerPt = (plotTree.x + (leafNum - 1) * plotTree.xOff / 2.0, plotTree.y)# 画出该决策节点plotNode(nodeName, centerPt, parentPt, decisionNodeStyle)# 标记本节点对应父节点的属性值plotMidText(centerPt, parentPt, parentValue)# 取本节点的属性值treeValue = decisionTree[nodeName]# 下一层各节点的高度plotTree.y = plotTree.y - plotTree.yOff# 绘制下一层for val in treeValue.keys():# 如果属性值对应的是字典，说明是子树，进行递归调用； 否则则为叶子节点if type(treeValue[val]) == dict:plotTree(treeValue[val], centerPt, str(val))else:plotNode(treeValue[val], (plotTree.x, plotTree.y), centerPt, leafNodeStyle)plotMidText((plotTree.x, plotTree.y), centerPt, str(val))# 移到下一个叶子节点plotTree.x = plotTree.x + plotTree.xOff# 递归完成后返回上一层plotTree.y = plotTree.y + plotTree.yOff# 画出决策树
def createPlot(decisionTree):fig = plt.figure(1, facecolor = "white")fig.clf()axprops = {"xticks": [], "yticks": []}createPlot.ax1 = plt.subplot(111, frameon = False, **axprops)# 定义画图的图形尺寸plotTree.figSize = 1.5 # 初始化树的总大小plotTree.totalLeaf, plotTree.totalDepth = getTreeSize(decisionTree)# 叶子节点的初始位置x 和 根节点的初始层高度yplotTree.x = 0 plotTree.y = plotTree.figSizeplotTree(decisionTree, (plotTree.figSize / 2.0, plotTree.y), "")plt.show()

# 使用西瓜数据测试函数  p75-p77
xgData, xgLabel, xgName = createDataXG20()
xgTree = createTree(xgData, xgLabel, xgName, method = 'id3')
print(xgTree)
createPlot(xgTree)

5、预剪枝和预剪枝测试

# 创建预剪枝决策树
def createTreePrePruning(dataTrain, labelTrain, dataTest, labelTest, names, method = 'id3'):"""预剪枝 需要使用测试数据对每次的划分进行评估策略说明：原本如果某节点划分前后的测试结果没有提升，根据奥卡姆剃刀原则将不进行划分（即执行剪枝），但考虑到这种策略容易造成欠拟合，且不能排除后续划分有进一步提升的可能，因此，没有提升仍保留划分，即不剪枝另外：周志华的书上评估的是某一个节点划分前后对该层所有数据综合评估，如评估对脐部 凹陷下色泽是否划分，书上取的色泽划分前的精度是71.4%(5/7)，划分后的精度是57.1%(4/7)，都是脐部下三个特征（凹陷，稍凹，平坦）所有的数据的精度，计算也不易而我觉得实际计算时，只对当前节点下的数据划分前后进行评估即可，如脐部凹陷时有三个测试样本，三个样本色泽划分前的精度是2/3=66.7%，色泽划分后的精度是1/3=33.3%，因此判断不划分"""trainData = np.asarray(dataTrain)labelTrain = np.asarray(labelTrain)testData = np.asarray(dataTest)labelTest = np.asarray(labelTest)names = np.asarray(names)# 如果结果为单一结果if len(set(labelTrain)) == 1: return labelTrain[0] # 如果没有待分类特征elif trainData.size == 0: return voteLabel(labelTrain)# 其他情况则选取特征 bestFeat, bestEnt = bestFeature(dataTrain, labelTrain, method = method)# 取特征名称bestFeatName = names[bestFeat]# 从特征名称列表删除已取得特征名称names = np.delete(names, [bestFeat])# 根据最优特征进行分割dataTrainSet, labelTrainSet = splitFeatureData(dataTrain, labelTrain, bestFeat)# 预剪枝评估# 划分前的分类标签labelTrainLabelPre = voteLabel(labelTrain)labelTrainRatioPre = equalNums(labelTrain, labelTrainLabelPre) / labelTrain.size# 划分后的精度计算 if dataTest is not None: dataTestSet, labelTestSet = splitFeatureData(dataTest, labelTest, bestFeat)# 划分前的测试标签正确比例labelTestRatioPre = equalNums(labelTest, labelTrainLabelPre) / labelTest.size# 划分后 每个特征值的分类标签正确的数量labelTrainEqNumPost = 0for val in labelTrainSet.keys():labelTrainEqNumPost += equalNums(labelTestSet.get(val), voteLabel(labelTrainSet.get(val))) + 0.0# 划分后 正确的比例labelTestRatioPost = labelTrainEqNumPost / labelTest.size # 如果没有评估数据 但划分前的精度等于最小值0.5 则继续划分if dataTest is None and labelTrainRatioPre == 0.5:decisionTree = {bestFeatName: {}}for featValue in dataTrainSet.keys():decisionTree[bestFeatName][featValue] = createTreePrePruning(dataTrainSet.get(featValue), labelTrainSet.get(featValue), None, None, names, method)elif dataTest is None:return labelTrainLabelPre # 如果划分后的精度相比划分前的精度下降, 则直接作为叶子节点返回elif labelTestRatioPost < labelTestRatioPre:return labelTrainLabelPreelse :# 根据选取的特征名称创建树节点decisionTree = {bestFeatName: {}}# 对最优特征的每个特征值所分的数据子集进行计算for featValue in dataTrainSet.keys():decisionTree[bestFeatName][featValue] = createTreePrePruning(dataTrainSet.get(featValue), labelTrainSet.get(featValue), dataTestSet.get(featValue), labelTestSet.get(featValue), names, method)return decisionTree # 将西瓜数据2.0分割为测试集和训练集
xgDataTrain, xgLabelTrain, xgDataTest, xgLabelTest = splitXgData20(xgData, xgLabel)
# 生成不剪枝的树
xgTreeTrain = createTree(xgDataTrain, xgLabelTrain, xgName, method = 'id3')
# 生成预剪枝的树
xgTreePrePruning = createTreePrePruning(xgDataTrain, xgLabelTrain, xgDataTest, xgLabelTest, xgName, method = 'id3')
# 画剪枝前的树
print("剪枝前的树")
createPlot(xgTreeTrain)
# 画剪枝后的树
print("剪枝后的树")
createPlot(xgTreePrePruning)

剪枝前：

剪枝后：

6、后剪枝

# 创建决策树 带预划分标签
def createTreeWithLabel(data, labels, names, method = 'id3'):data = np.asarray(data)labels = np.asarray(labels)names = np.asarray(names)# 如果不划分的标签为votedLabel = voteLabel(labels)# 如果结果为单一结果if len(set(labels)) == 1: return votedLabel # 如果没有待分类特征elif data.size == 0: return votedLabel# 其他情况则选取特征 bestFeat, bestEnt = bestFeature(data, labels, method = method)# 取特征名称bestFeatName = names[bestFeat]# 从特征名称列表删除已取得特征名称names = np.delete(names, [bestFeat])# 根据选取的特征名称创建树节点 划分前的标签votedPreDivisionLabel=_vpdldecisionTree = {bestFeatName: {"_vpdl": votedLabel}}# 根据最优特征进行分割dataSet, labelSet = splitFeatureData(data, labels, bestFeat)# 对最优特征的每个特征值所分的数据子集进行计算for featValue in dataSet.keys():decisionTree[bestFeatName][featValue] = createTreeWithLabel(dataSet.get(featValue), labelSet.get(featValue), names, method)return decisionTree # 将带预划分标签的tree转化为常规的tree
# 函数中进行的copy操作，原因见有道笔记 【YL20190621】关于Python中字典存储修改的思考
def convertTree(labeledTree):labeledTreeNew = labeledTree.copy()nodeName = list(labeledTree.keys())[0]labeledTreeNew[nodeName] = labeledTree[nodeName].copy()for val in list(labeledTree[nodeName].keys()):if val == "_vpdl": labeledTreeNew[nodeName].pop(val)elif type(labeledTree[nodeName][val]) == dict:labeledTreeNew[nodeName][val] = convertTree(labeledTree[nodeName][val])return labeledTreeNew# 后剪枝 训练完成后决策节点进行替换评估  这里可以直接对xgTreeTrain进行操作
def treePostPruning(labeledTree, dataTest, labelTest, names):newTree = labeledTree.copy()dataTest = np.asarray(dataTest)labelTest = np.asarray(labelTest)names = np.asarray(names)# 取决策节点的名称 即特征的名称featName = list(labeledTree.keys())[0]# print("\n当前节点：" + featName)# 取特征的列featCol = np.argwhere(names==featName)[0][0]names = np.delete(names, [featCol])# print("当前节点划分的数据维度：" + str(names))# print("当前节点划分的数据：" )# print(dataTest)# print(labelTest)# 该特征下所有值的字典newTree[featName] = labeledTree[featName].copy()featValueDict = newTree[featName]featPreLabel = featValueDict.pop("_vpdl")# print("当前节点预划分标签：" + featPreLabel)# 是否为子树的标记subTreeFlag = 0# 分割测试数据 如果有数据 则进行测试或递归调用  np的array我不知道怎么判断是否None, 用is None是错的dataFlag = 1 if sum(dataTest.shape) > 0 else 0if dataFlag == 1:# print("当前节点有划分数据！")dataTestSet, labelTestSet = splitFeatureData(dataTest, labelTest, featCol)for featValue in featValueDict.keys():# print("当前节点属性 {0} 的子节点：{1}".format(featValue ,str(featValueDict[featValue])))if dataFlag == 1 and type(featValueDict[featValue]) == dict:subTreeFlag = 1 # 如果是子树则递归newTree[featName][featValue] = treePostPruning(featValueDict[featValue], dataTestSet.get(featValue), labelTestSet.get(featValue), names)# 如果递归后为叶子 则后续进行评估if type(featValueDict[featValue]) != dict:subTreeFlag = 0 # 如果没有数据  则转换子树if dataFlag == 0 and type(featValueDict[featValue]) == dict: subTreeFlag = 1 # print("当前节点无划分数据！直接转换树："+str(featValueDict[featValue]))newTree[featName][featValue] = convertTree(featValueDict[featValue])# print("转换结果：" + str(convertTree(featValueDict[featValue])))# 如果全为叶子节点， 评估需要划分前的标签，这里思考两种方法，#     一是，不改变原来的训练函数，评估时使用训练数据对划分前的节点标签重新打标#     二是，改进训练函数，在训练的同时为每个节点增加划分前的标签，这样可以保证评估时只使用测试数据，避免再次使用大量的训练数据#     这里考虑第二种方法 写新的函数 createTreeWithLabel，当然也可以修改createTree来添加参数实现if subTreeFlag == 0:ratioPreDivision = equalNums(labelTest, featPreLabel) / labelTest.sizeequalNum = 0for val in labelTestSet.keys():equalNum += equalNums(labelTestSet[val], featValueDict[val])ratioAfterDivision = equalNum / labelTest.size # print("当前节点预划分标签的准确率：" + str(ratioPreDivision))# print("当前节点划分后的准确率：" + str(ratioAfterDivision))# 如果划分后的测试数据准确率低于划分前的，则划分无效，进行剪枝，即使节点等于预划分标签# 注意这里取的是小于，如果有需要 也可以取 小于等于if ratioAfterDivision < ratioPreDivision:newTree = featPreLabel return newTree# 书中的树结构 p81 p83
xgTreeBeforePostPruning = {"脐部": {"_vpdl": "是", '凹陷': {'色泽':{"_vpdl": "是", '青绿': '是', '乌黑': '是', '浅白': '否'}}, '稍凹': {'根蒂':{"_vpdl": "是", '稍蜷': {'色泽': {"_vpdl": "是", '青绿': '是', '乌黑': {'纹理': {"_vpdl": "是", '稍糊': '是', '清晰': '否', '模糊': '是'}}, '浅白': '是'}}, '蜷缩': '否', '硬挺': '是'}}, '平坦': '否'}}
xgTreePostPruning = treePostPruning(xgTreeBeforePostPruning, xgDataTest, xgLabelTest, xgName)
createPlot(convertTree(xgTreeBeforePostPruning))
createPlot(xgTreePostPruning)