1.前言

决策树是一种常用的机器学习算法，既可以做分类任务也可以做回归任务，本文主要讨论用于分类任务的决策树。决策树与数据结构中的树相同，也是由一个根结点、若干个内部结点和若干个叶结点构成。这里我们以在相亲过程中女生的决策过程来直观的理解决策树，如下图所示，图片来自于《百面机器学习》。在决策树中根结点和内部结点对应于一个特征测试，如图中的年龄就是一个特征，通过测试年龄是不是大于30将实例分配到其不同的子结点中，如此自上而下一直循环下去，直到走到叶结点，给出最后的决策结果，即见或不见。

最著名的决策树学习算法有ID3算法、C4.5算法和CART算法，本文主要讨论ID3算法和C4.5算法，CART将会在后面一篇文章中讨论。决策树模型的学习过程可以分为3个步骤：特征选择、决策树的生成和决策树的剪枝。 特征选择是为了选取对训练数据有分类能力的特征，决策树的生成其实就是在不断进行特征选择并划分训练数据的过程，直到叶结点结束。比如在上图中，首先根据年龄这个特征，将训练数据分为大于30的子集和小于30的子集，年龄小于30的子集又根据长相继续将数据分为很丑、一般和很帅三个子集。最后，因为生成的决策树往往会对训练数据分类准确，而对测试数据分类效果不好，即出现过拟合现象，所以要对生成的决策树进行简化，即减少叶结点的数量，这就需要对决策树进行剪枝。

2. ID3算法

2.1 信息增益

不同的算法进行特征选择的准则不同，ID3算法采用的是最大信息增益准则，C4.5算法采用的是最大信息增益比，而CART算法采用的是最小基尼指数。
为了说明信息增益是什么，首先要给出经验熵和经验条件熵的定义。在信息论与概率统计中，熵(entropy)是表示随机变量不确定性的度量。假设数据集为DDD，∣D∣|D|∣D∣表示数据集中的样本个数，DDD中的样本共有KKK个类别，则数据集DDD的经验熵H(D)H(D)H(D)的计算公式为：
H(D)=−∑k=1K∣Ck∣∣D∣log2∣Ck∣∣D∣H(D)=-\sum_{k=1}^{K}\frac{|C_k|}{|D|}\text{log}_2\frac{|C_k|}{|D|} H(D)=−k=1∑K∣D∣∣Ck∣log2∣D∣∣Ck∣其中CkC_kCk是数据集DDD中属于第kkk类的样本子集，∣Ck∣|C_k|∣Ck∣则表示该子集的样本个数。其代码实现如下：

from collections import Counter
from math import log
#计算数据集的经验熵def calc_HD(self,dataset):dataset = np.array(dataset)data_length = len(dataset)label = dataset[:,-1]  #要求数据集的最后一列为类别label_count = Counter(label)  #得到一个字典，key为类别，value为对应的类的数量HD = -sum([(p/data_length)*log(p/data_length,2) for p in label_count.values()]) #课本式（5.7）return HD

假设样本的某一个特征为AAA，且特征AAA有nnn个不同的取值a1,a2,...,ana_1,a_2,...,a_na1,a2,...,an,根据特征AAA将数据集DDD划分为nnn个子集D1,D2,...,Dn,∣Di∣D_1,D_2,...,D_n,|D_i|D1,D2,...,Dn,∣Di∣为子集DiD_iDi中的样本个数，子集DiD_iDi中属于CkC_kCk类的样本集合为DikD_{ik}Dik,∣Dik∣|D_{ik}|∣Dik∣为DikD_{ik}Dik中的样本个数，则特征AAA对于数据集DDD的经验条件熵的计算公式为：
H(D∣A)=∑i=1n∣Di∣∣D∣H(Di)=−∑i=1n∣Di∣∣D∣∑k=1K∣Dik∣∣Di∣log2∣Dik∣∣Di∣H(D|A)=\sum_{i=1}^{n}\frac{|D_i|}{|D|}H(D_i) \\ =-\sum_{i=1}^{n}\frac{|D_i|}{|D|}\sum_{k=1}^{K}\frac{|D_{ik}|}{|D_i|}\text{log}_2\frac{|D_{ik}|}{|D_i|} H(D∣A)=i=1∑n∣D∣∣Di∣H(Di)=−i=1∑n∣D∣∣Di∣k=1∑K∣Di∣∣Dik∣log2∣Di∣∣Dik∣计算经验条件熵的代码实现如下：

#计算特征A对数据集的经验条件熵def calc_HDA(self,dataset,A=0): data_length = len(dataset)feature_sets = {}#构建以特征A的取值划分的各个数据子集for i in range(data_length):feature = dataset[i][A]if feature not in feature_sets:feature_sets[feature] = []feature_sets[feature].append(dataset[i])HDA = 0#课本式（5.8）for D in feature_sets.values():HDA += (len(D)/data_length)*self.calc_HD(D)return HDA

有了经验熵和经验条件熵之后便可以得到信息增益(information gain)了，信息增益g(D∣A)g(D|A)g(D∣A)即为二者之差：
g(D∣A)=H(D)−H(D∣A)g(D|A)=H(D)-H(D|A) g(D∣A)=H(D)−H(D∣A)

2.2 决策树生成

ID3算法选择特征的过程就是计算出所有特征对数据集DDD的信息增益，然后选择信息增益最大的特征。
上面的定义有点套娃的感觉，有点绕，下面以贷款申请的例子来说明经验熵和经验条件熵的计算过程，假设有15个人在申请贷款，最后的类别即为申请成功与否，如下表所示。

ID	年龄	有工作	有自己的房子	信贷情况	类别
1	青年	否	否	一般	否
2	青年	否	否	好	否
3	青年	是	否	好	是
4	青年	是	是	一般	是
5	青年	否	否	一般	否
6	中年	否	否	一般	否
7	中年	否	否	好	否
8	中年	是	是	好	是
9	中年	否	是	非常好	是
10	中年	否	是	非常好	是
11	老年	否	是	非常好	是
12	老年	否	是	好	是
13	老年	是	否	好	是
14	老年	是	否	非常好	是
15	老年	否	否	一般	否

在这个数据集中，样本的类别数K=2K=2K=2，即贷款申请是否成功两种类别，每个样本有4个特征，分别为年龄、是否有工作、是否有自己的房子和信贷情况，这里分别用A1,A2,A3和A4A_1,A_2,A_3和A_4A1,A2,A3和A4来表示这几个特征。在上面的定义中，我觉得最绕的就是样本子集CkC_kCk和样本子集DiD_iDi，一定要区分清楚，在上面这个数据集中，CkC_kCk是根据样本类别来分的，即C1={3,4,8,9,10,11,12,13,14}C_1=\{3,4,8,9,10,11,12,13,14\}C1={3,4,8,9,10,11,12,13,14},C2={1,2,5,6,7,15}C_2=\{1,2,5,6,7,15\}C2={1,2,5,6,7,15}，而DiD_iDi是根据特征来分的，比如根据年龄这个特征的取值老和年轻就将数据集DDD分成了D1={1,2,3,4,5}D_1=\{1,2,3,4,5\}D1={1,2,3,4,5}、D2={6,7,8,9,10}D_2=\{6,7,8,9,10\}D2={6,7,8,9,10}和D3={11,12,13,14,15}D_3=\{11,12,13,14,15\}D3={11,12,13,14,15}三个子集。而在D1D_1D1中又可以根据样本类别将D1D_1D1分成D11={3,4}和D12={1,2,5}D_{11}=\{3,4\}和D_{12}=\{1,2,5\}D11={3,4}和D12={1,2,5}两个子集，在D2D_2D2中可以根据样本类别将D2D_2D2分成D21={8,9,10}和D22={6,7}D_{21}=\{8,9,10\}和D_{22}=\{6,7\}D21={8,9,10}和D22={6,7}两个子集，在D3D_3D3中可以根据样本类别将D3D_3D3分成D31={11,12,13，14}和D32={15}D_{31}=\{11,12,13，14\}和D_{32}=\{15\}D31={11,12,13，14}和D32={15}两个子集。
ID3算法生成决策树的过程为：从根结点开始，对结点计算所有特征的信息增益，选择信息增益最大的特征作为结点的特征，由该特征的不同取值建立子结点；再对子结点递归的执行以上过程，构建决策树；直到所有特征的信息增益均很小或者没有特征可以选择为止。ID3算法的具体过程如下：

接下来就通过上面贷款申请的数据来讲解利用ID3算法建立决策树的过程。首先，计算数据集DDD经验熵：
H(D)=−915log2915−615log2615=0.971H(D)=-\frac{9}{15}\text{log}_2\frac{9}{15}-\frac{6}{15}\text{log}_2\frac{6}{15}=0.971 H(D)=−159log2159−156log2156=0.971然后计算各个特征对数据集DDD的信息增益：
g(D,A1)=H(D)−[515H(D1)+515H(D2)+515H(D3)]g(D,A_1)=H(D)-[\frac{5}{15}H(D_1)+\frac{5}{15}H(D_2)+\frac{5}{15}H(D_3)] g(D,A1)=H(D)−[155H(D1)+155H(D2)+155H(D3)]
=0.971−[515(−25log225−35log235)+515(−35log235−25log225)+515(−45log245−15log215]=0.971-[\frac{5}{15}(-\frac{2}{5}\text{log}_2\frac{2}{5}-\frac{3}{5}\text{log}_2\frac{3}{5})+\frac{5}{15}(-\frac{3}{5}\text{log}_2\frac{3}{5}-\frac{2}{5}\text{log}_2\frac{2}{5})+\frac{5}{15}(-\frac{4}{5}\text{log}_2\frac{4}{5}-\frac{1}{5}\text{log}_2\frac{1}{5}] =0.971−[155(−52log252−53log253)+155(−53log253−52log252)+155(−54log254−51log251]
=0.971−0.888=0.083=0.971-0.888=0.083 =0.971−0.888=0.083同理可计算出A2,A3和A4A_2,A_3和A_4A2,A3和A4对数据集DDD的信息增益：
g(D,A2)=0.324g(D,A3)=0.420g(D,A2)=0.363g(D,A_2)=0.324 \\ g(D,A_3)=0.420 \\ g(D,A_2)=0.363 g(D,A2)=0.324g(D,A3)=0.420g(D,A2)=0.363可以发现，特征A3A_3A3即是否有自己的房子的信息增益最大，所以选择特征A3A_3A3作为根结点的特征。特征A3A_3A3将数据集DDD划分为两个子集,即两个子结点：D1={4,8,9,10,11,12}D_1=\{4,8,9,10,11,12\}D1={4,8,9,10,11,12}和D2={1,2,3,5,6,7,13,14,15}D_2=\{1,2,3,5,6,7,13,14,15\}D2={1,2,3,5,6,7,13,14,15}。由于D1D_1D1的样本都属于同一类，所以它成为一个叶结点，结点类标记为“是”。对于D2D_2D2，则需要继续从A1,A2,A4A_1,A_2,A_4A1,A2,A4中选择新的特征对其进行划分，计算A1,A2,A4A_1,A_2,A_4A1,A2,A4对D2D_2D2的的信息增益：
g(D2,A1)=H(D2)−H(D2∣A1)=0.918−0.667=0.251g(D2,A2)=H(D2)−H(D2∣A2)=0.918g(D2,A4)=H(D2)−H(D2∣A4)=0.474g(D_2,A_1)=H(D_2)-H(D_2|A_1)=0.918-0.667=0.251 \\ g(D_2,A_2)=H(D_2)-H(D_2|A_2)=0.918 \\ g(D_2,A_4)=H(D_2)-H(D_2|A_4)=0.474 g(D2,A1)=H(D2)−H(D2∣A1)=0.918−0.667=0.251g(D2,A2)=H(D2)−H(D2∣A2)=0.918g(D2,A4)=H(D2)−H(D2∣A4)=0.474所以我们选择信息最大的特征A2A_2A2来作为此结点的特征，特征A2A_2A2将数据集D2D_2D2划分为两个子结点{3,13,14}\{3,13,14\}{3,13,14}和{1,2,5,6,7,15}\{1,2,5,6,7,15\}{1,2,5,6,7,15},由于两个结点中的样本都分别属于同一类，所以这两个结点都是叶结点，因为没有可以再进行划分的结点了，所以决策树就生成完毕了，生成的决策树如下图所示：

ID3算法的代码实现如下：

#找出信息增益最大的特征def calcBestFeature(self,dataset):feature_count = len(dataset[0]) - 1    #特征的个数GDA = [0]*feature_countfor i in range(feature_count):#计算信息增益，课本式（5.9）GDA[i] = self.calc_HD(dataset) - self.calc_HDA(dataset,A=i)max_GDA = max(GDA)     #最大的信息增益best_feature = GDA.index(max_GDA)    #最大的信息增益对应的特征索引return best_feature,max_GDA#利用ID3算法递归生成决策树def createTree(self,train_data):label_train = train_data.iloc[:,-1]     #要求输入的数据为pd.DataFrame类型features = train_data.columns[:-1]      #并要求最后一列为类别标记列# 1,若D中实例属于同一类Ck，则T为单结点树，并将类Ck作为结点的类标记，返回Tif len(label_train.value_counts()) == 1:return Node(root=True, label=label_train.iloc[0])# 2, 若A为空，则T为单结点树，将D中实例树最大的类Ck作为该结点的类标记，返回Tif len(features) == 0:return Node(root=True, label=label_train.value_counts().index[0])# 3,计算最大信息增益 ，Ag为信息增益最大的特征best_feature, max_GDA = self.calcBestFeature(np.array(train_data))best_feature_name = features[best_feature]# 4,Ag的信息增益小于阈值eta,则置T为单结点树，并将D中是实例数最大的类Ck作为该结点的类标记，返回Tif max_GDA < self.threshold:return Node(root=True, label=label_train.value_counts().index[0])# 5,根据Ag的取值构建数据子集node_tree = Node(root=False, feature_name=best_feature_name, feature=best_feature)# 得到特征的取值列表feature_list = train_data[best_feature_name].value_counts().indexfor f in feature_list:sub_train_df = train_data.loc[train_data[best_feature_name] ==f].drop([best_feature_name], axis=1)# 6, 递归生成决策树sub_tree = self.createTree(sub_train_df)node_tree.add_node(f, sub_tree)return node_tree

3. C4.5算法

3.1 信息增益比

ID3算法采用的最大信息增益准则存在偏向于选择取值较多的特征的问题，信息增益比则是对这个问题进行了改进，信息增益比记为gR(D∣A)g_R(D|A)gR(D∣A),其计算公式如下：
gR(D∣A)=g(D∣A)HA(D)g_R(D|A)=\frac{g(D|A)}{H_A(D)} gR(D∣A)=HA(D)g(D∣A)其中，HA(D)H_A(D)HA(D)为数据集DDD关于特征AAA的取值的熵，其计算公式如下：
HA(D)=−∑i=1n∣Di∣∣D∣log2∣Di∣∣D∣H_A(D)=-\sum_{i=1}^{n}\frac{|D_i|}{|D|}\text{log}_2\frac{|D_i|}{|D|} HA(D)=−i=1∑n∣D∣∣Di∣log2∣D∣∣Di∣其中nnn为特征AAA的取值个数。

3.2 决策树生成

C4.5算法与ID3算法很相似，只是选择特征的准则不同，C4.5算法根据最大增益比准则来选择特征，其算法过程如下：

我们还是以上面的贷款申请的例子来讲解C4.5算法生成决策树的过程，各个特征的信息增益我们已经在上文得到了，要求得信息增益比，则只需求得每个特征的取值对数据集的熵即可，计算过程如下：
HA1(D)=−515log2515−515log2515−515log2515=1.585H_{A_1}(D)=-\frac{5}{15}\text{log}_2\frac{5}{15}-\frac{5}{15}\text{log}_2\frac{5}{15}-\frac{5}{15}\text{log}_2\frac{5}{15}=1.585 HA1(D)=−155log2155−155log2155−155log2155=1.585
HA2(D)=−1015log21015−515log2515=0.918H_{A_2}(D)=-\frac{10}{15}\text{log}_2\frac{10}{15}-\frac{5}{15}\text{log}_2\frac{5}{15}=0.918 HA2(D)=−1510log21510−155log2155=0.918
HA3(D)=−915log2915−615log2615=0.971H_{A_3}(D)=-\frac{9}{15}\text{log}_2\frac{9}{15}-\frac{6}{15}\text{log}_2\frac{6}{15}=0.971 HA3(D)=−159log2159−156log2156=0.971
HA4(D)=−515log2515−615log2615−415log2415=1.800H_{A_4}(D)=-\frac{5}{15}\text{log}_2\frac{5}{15}-\frac{6}{15}\text{log}_2\frac{6}{15}-\frac{4}{15}\text{log}_2\frac{4}{15}=1.800 HA4(D)=−155log2155−156log2156−154log2154=1.800
于是便可得到各个特征对数据集DDD的信息增益比：
gR(D∣A1)=g(D∣A1)HA1(D)=0.0831.585=0.052g_R(D|A_1)=\frac{g(D|A_1)}{H_{A_1}(D)}=\frac{0.083}{1.585}=0.052 gR(D∣A1)=HA1(D)g(D∣A1)=1.5850.083=0.052
gR(D∣A2)=g(D∣A2)HA2(D)=0.3240.918=0.353g_R(D|A_2)=\frac{g(D|A_2)}{H_{A_2}(D)}=\frac{0.324}{0.918}=0.353 gR(D∣A2)=HA2(D)g(D∣A2)=0.9180.324=0.353
gR(D∣A3)=g(D∣A3)HA3(D)=0.4200.971=0.433g_R(D|A_3)=\frac{g(D|A_3)}{H_{A_3}(D)}=\frac{0.420}{0.971}=0.433 gR(D∣A3)=HA3(D)g(D∣A3)=0.9710.420=0.433
gR(D∣A4)=g(D∣A4)HA4(D)=0.3631.800=0.202g_R(D|A_4)=\frac{g(D|A_4)}{H_{A_4}(D)}=\frac{0.363}{1.800}=0.202 gR(D∣A4)=HA4(D)g(D∣A4)=1.8000.363=0.202
根据最大增益比准则，选择特征A3A_3A3作为根结点的特征，接下来与ID3算法相似，继续求A1,A2,A4A_1,A_2,A_4A1,A2,A4对D2D_2D2的信息增益比,D2D_2D2的样本集合为{1,2,3,5,6,7,13,14,15}\{1,2,3,5,6,7,13,14,15\}{1,2,3,5,6,7,13,14,15}，首先求特征A1,A2,A4A_1,A_2,A_4A1,A2,A4的取值对D2D_2D2对子数据集D2D_2D2的熵：
HA1(D2)=−49log249−29log229−39log239=1.53H_{A_1}(D_2)=-\frac{4}{9}\text{log}_2\frac{4}{9}-\frac{2}{9}\text{log}_2\frac{2}{9}-\frac{3}{9}\text{log}_2\frac{3}{9}=1.53 HA1(D2)=−94log294−92log292−93log293=1.53同理可求得：
HA2(D2)=0.918HA4(D2)=1.392H_{A_2}(D_2)=0.918 \\ H_{A_4}(D_2)=1.392 HA2(D2)=0.918HA4(D2)=1.392所以可求得A1,A2,A4A_1,A_2,A_4A1,A2,A4对D2D_2D2的信息增益比为：
gR(D2∣A1)=g(D2∣A1)HA1(D2)=0.2511.53=0.164g_R(D_2|A_1)=\frac{g(D_2|A_1)}{H_{A_1}(D_2)}=\frac{0.251}{1.53}=0.164 gR(D2∣A1)=HA1(D2)g(D2∣A1)=1.530.251=0.164
gR(D2∣A2)=g(D2∣A2)HA2(D2)=0.9180.918=1g_R(D_2|A_2)=\frac{g(D_2|A_2)}{H_{A_2}(D_2)}=\frac{0.918}{0.918}=1 gR(D2∣A2)=HA2(D2)g(D2∣A2)=0.9180.918=1
gR(D2∣A4)=g(D2∣A4)HA4(D2)=0.4741.392=0.34g_R(D_2|A_4)=\frac{g(D_2|A_4)}{H_{A_4}(D_2)}=\frac{0.474}{1.392}=0.34 gR(D2∣A4)=HA4(D2)g(D2∣A4)=1.3920.474=0.34
因为特征A2A_2A2的信息增益比最大，所以选择A2A_2A2作为此结点的特征，可以发现，C4.5算法与ID3算法对于此贷款申请数据集生成的决策树是一样的，但是通过比较特征的信息增益比和信息增益可以发现，特征取值多的特征（比如年龄和信贷情况）的信息增益比相较于其信息增益有了一定程度的下降，而特征取值少的特征（比如是否有工作和是否有房子）的信息增益比相较于其信息增益有了一定程度的上升，这就展示了信息增益比确实对信息增益所存在的偏向于选择取值较多的特征的问题进行了改进。

C4.5算法与ID3算法只有特征选择的准则不同，其特征选择的代码如下：

    # 计算数据集D关于特征A的值的熵def calc_HAD(self,dataset,A=0):dataset = np.array(dataset)data_length = len(dataset)feature = dataset[:,A]  feature_values = Counter(feature)  #得到一个字典，key为类别，value为对应的类的数量HD = -sum([(p/data_length)*log(p/data_length,2) for p in feature_values.values()]) return HAD#找出信息增益比最大的特征def calcBestFeature(self,dataset):feature_count = len(dataset[0]) - 1    #特征的个数GRDA = [0]*feature_countfor i in range(feature_count):#计算信息增益，课本式（5.9）GDA[i] = self.calc_HD(dataset) - self.calc_HDA(dataset,A=i)#计算信息增益比，课本式（5.10）GRDA[i] = GDA[i] / self.calc_HAD(dataset, A=i)max_GRDA = max(GRDA)     #最大的信息增益比best_feature = GRDA.index(max_GRDA)    #最大的信息增益比对应的特征索引return best_feature,max_GRDA

4.决策树的剪枝

为了提高决策树模型的泛化能力，避免过拟合，往往需要对生成的决策树进行剪枝。
决策树的剪枝通常有两种方法，分别为预剪枝(pre-pruning)和后剪枝(post-pruning)。
预剪枝的核心思想是在树中结点进行扩展之前，先计算当前的划分是否能够带来模型泛化能力的提升，如果不能则不在继续生长子树。此时可能存在不同类别的样本同时存在与结点中，按照多数投票的原则判断该结点所属类别。预剪枝对于何时停止树的生长有以下几种方法：

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

后剪枝的核心思想是让算法生成一颗完全生长的决策树，然后自下而上计算是否剪枝。剪枝的过程是将子树删除，用一个叶结点替代，该结点的类别同样按照多数投票的原则进行判断。相比于预剪枝，后剪枝通常可以得到泛化能力更强的决策树，但时间开销会更大。
常见的后剪枝方法有错误率降低剪枝、悲观剪枝、代价复杂度剪枝和最小误差剪枝等等。下面我们主要讨论代价复杂度剪枝(Cost Complexity Pruning,CCP)的实现过程。如果想了解其他剪枝方法可以去B站https://space.bilibili.com/406882224/search/video?keyword=%E5%89%AA%E6%9E%9D观看，我感觉这个UP主讲的很好。
决策树的剪枝通常通过极小化决策树整体的损失函数或代价函数来实现。设完全生长的决策树为TTT，其叶结点个数为∣T∣|T|∣T∣,ttt为决策树TTT的叶结点，且该叶结点上有NtN_tNt个样本点，其中属于第kkk类的样本点有NtkN_{tk}Ntk个，k=1,2,3,...,Kk=1,2,3,...,Kk=1,2,3,...,K，则决策树的损失函数可以定义为：
Cα(T)=∑t=1∣T∣NtHt(T)+α∣T∣C_{\alpha}(T)=\sum_{t=1}^{|T|}N_tH_t(T)+\alpha|T| Cα(T)=t=1∑∣T∣NtHt(T)+α∣T∣其中Ht(T)H_t(T)Ht(T)为叶结点ttt的经验熵，其计算公式如下：
Ht(T)=−∑k=1KNtkNtlog2NtkNtH_t(T)=-\sum_{k=1}^{K}\frac{N_{tk}}{N_t}\text{log}_2\frac{N_{tk}}{N_t} Ht(T)=−k=1∑KNtNtklog2NtNtk损失函数中的第一项表示模型对训练数据的拟合程度，第二项中的∣T∣|T|∣T∣表示模型的复杂度，即叶结点越多，模型越复杂。参数α\alphaα是用来平衡模型拟合能力与复杂度的参数，较大的α\alphaα促使选择比较简单的模型，但是拟合能力相对较弱，较小的α\alphaα促使选择相对复杂的模型，此时拟合能力更强。损失函数就是为了在保证拟合能力的基础上来降低模型的复杂度。值得注意的是，在ID3算法和C4.5算法的剪枝中，参数α\alphaα是人为指定的，而在CART算法中，则不再是人为指定，详细的内容会在下一篇文章中介绍。

代价复杂度剪枝的实现过程如下：

输入：ID3算法或C4.5算法生成的决策树，参数α\alphaα;
输出：剪枝后的子树TαT_{\alpha}Tα。

(1) 计算每个结点的经验熵。

(2) 递归的从树的叶结点向上回缩。设剪枝前后的树分别为TAT_ATA和TBT_BTB,如果：
Cα(TB)≤Cα(TA)C_{\alpha}(T_B) \le C_{\alpha}(T_A) Cα(TB)≤Cα(TA)
则进行剪枝。
(3) 重复步骤(2)，直到不能继续为止(只剩下根结点和叶结点)，此时就得到了损失函数最小的子树TαT_{\alpha}Tα。
剪枝过程的示意图如下所示：

5.参考资料

1.李航《统计学习方法》
2.诸葛越《百面机器学习》
3.周志华《机器学习》
4.https://www.zhihu.com/question/22697086
5.https://www.bilibili.com/video/BV1mf4y1L7Ko?spm_id_from=333.999.0.0
6.https://github.com/fengdu78/lihang-code

推荐阅读：
逻辑回归模型——公式推导与python代码实现
SMO算法求解支持向量机的理论推导与代码实现
机器学习算法——支持向量机(3)
机器学习算法——支持向量机(2)
机器学习算法——支持向量机(1)

公众号：MyLearningNote

决策树(1)——ID3算法与C4.5算法的理论基础与python实现相关推荐

数据挖掘十大经典算法之——C4.5 算法
数据挖掘十大经典算法系列,点击链接直接跳转: 数据挖掘简介及十大经典算法(大纲索引) 1. 数据挖掘十大经典算法之--C4.5 算法 2. 数据挖掘十大经典算法之--K-Means 算法 3. 数据挖 ...
决策树模型 - （ID3算法、C4.5算法） - Python代码实现
目录算法简介信息熵(Entropy) 信息增益(Information gain) - ID3算法信息增益率(gain ratio) - C4.5算法源数据代码实现 - ID3算法代码实现 ...
决策树算法——ID3算法，C4.5算法
目录(?)[-] 决策树算法 1摘要 2决策树引导 3决策树的构造 31ID3算法 32C45算法 4关于决策树的几点补充说明 41如果属性用完了怎么办 42关于剪枝决策树算法 1.摘要在前面两篇 ...
机器学习：决策树及ID3,C4.5,CART算法描述
文章目录概念理解熵: 条件熵: 信息增益,互信息: 信息增益比基尼指数 ID3算法描述 C4.5算法描述 CART (Classification and Regression Tree)算法描 ...
决策树的生成之ID3与C4.5算法
跟我一起机器学习系列文章将首发于公众号:月来客栈,欢迎文末扫码关注! 1 基本概念在正式介绍决策树的生成算法前,我们先将上一篇文章中介绍的几个概念重新梳理一下:并且同时再通过一个例子来熟悉一下计算过 ...
决策树之 C4.5 算法
前言由于 C4.5 算法是建立在 ID3 算法基础之上的,所以在讲解 C4.5 的时候,会有很多与 ID3 重合的内容,这里就不过多冗余地说明了.本文旨在阐明 ID3 存在的问题,以及 C4.5 的 ...
【机器学习基础】数学推导+纯Python实现机器学习算法4：决策树之ID3算法
Python机器学习算法实现 Author:louwill 作为机器学习中的一大类模型,树模型一直以来都颇受学界和业界的重视.目前无论是各大比赛各种大杀器的XGBoost.lightgbm还是像随机森 ...
c4.5算法程序语言,决策树之C4.5算法详解-Go语言中文社区
决策树之C4.5算法详解主要内容 C4.5算法简介分裂属性的选择--信息增益率连续型属性的离散化处理剪枝--PEP(Pessimistic Error Pruning)剪枝法缺失属性值的处理 ...
c4.5决策树算法 c语言,决策树（三）：C4.5算法和CART算法
ID3选择属性的依据是信息增益: ![Information Gain][equtation] [equtation]: http://latex.codecogs.com/svg.latex?g_r ...

决策树(1)——ID3算法与C4.5算法的理论基础与python实现