C45算法的源代码全解
C45决策树工具
C45决策树工具使用说明1. 简介：本文档给出了有关C45决策树方法相关的一些资料，面向对象是研究人员。
本文档的内容安排如下：1． C45决策树方法的使用场合描述；2． C45决策树如何训练，即C45_VC.exe使用说明；3． C45决策树训练结果如何在代码中使用，即CAskC45编程说明；4． C45的外围工具简介；5． C45的原理说明；6．联系方式。
2. 适合用C45解决的问题C45是一种决策树的算法，可以理解为数据挖掘算法的一种。
从大规模的数据中挖掘规律，这里的大规模数据一般是用属性来描述，属性本身可以是连续量，如语音数据的基频值；也可以使离散量，如句子中词的个数；还可以使枚举量，如26个词类，声韵母类型等。
属性分为输入属性，和结论属性（或称决策属性）。
结论属性就是我们希望从输入属性中得到的结果，如希望从输入的词性序列中预测某个位置是不是L3边界，或者根据前后的音调、基频等预测当前的音节应该是哪一类的韵律曲线。
结论属性必须是枚举量（当然包括布尔量）。
而规律则以决策树的形式来表示，其形式如，在C45_VC.txt或者Screen.txt中可以看到类似的输出结果：Decision Tree:e_lv <= 47.6 : 如果e_lv属性值小于等于47.6的话| n_lv <= 45.8 : NeiWen (76.0/2.0) 如果n_lv值小于等于45.8，结论属性应该是NewiWen。
| n_lv > 45.8 : NeiBuWen (44.0) 如果n_lv值大于45.8，结论属性应该是NewiBuWen。
e_lv > 47.6 : 如果e_lv属性值大于47.6的话| n_lv <= 45.8 : WaiWen (147.0) …| n_lv > 45.8 : WaiBuWen (32.0) …注：n_lv <= 45.8 : NeiWen (76.0/2.0)中的76.0表示到这个决策分支的有76个例子，其中2.0是错误的例子数目。
决策树C4.5算法总结
即选择outlook作为决策树的根节点时，信息增益为0.94-0.693=0.247，然后计算 outlook属性的熵，得增益比。同样方法计算当选择temperature、humidity、 windy作为根节点时系统的信息增益和属性熵，选择增益比最大的作为最终的根 节点。
选择节点分裂属性的问题
• ID3算法：使用信息增益作为选择节点分裂属性 的指标。增益准则的一个缺陷是它偏向于选择具 有更多取值的属性作为节点分裂属性。 • C4.5算法：使用信息增益率作为选择节点分裂属 性的指标，克服了ID3算法的缺点。
过拟合问题
• 过拟合：有监督的算法需要考虑泛化能力，在有限样本的 条件下，决策树超过一定规模后，训练错误率减小，但测 试错误率会增加。 • 剪枝：控制决策树规模的方法称为剪枝，一种是先剪枝， 一种是后剪枝。所谓先剪枝，实际上是控制决策树的生长； 后剪枝是指，对完全生成的决策树进行修剪。 • 先剪枝： 1) 数据划分法。划分数据成训练样本和测试样本，使用用训练 样本进行训练，使用测试样本进行树生长检验。 2) 阈值法。当某节点的信息增益小于某阈值时，停止树生长。 3) 信息增益的统计显著性分析。从已有节点获得的所有信息增 益统计其分布，如果继续生长得到的信息增 益与该分布相比 不显著，则停止树的生长。 优点：简单直接； 缺点：对于不回溯的贪婪算法，缺乏后效性考虑，可能导致树 提前停止。
C4.5算法学习
C4.5算法学习C4.5属于决策树算法的分类树决策树更是常见的机器学习⽅法，可以帮助我们解决分类与回归两类问题。
以决策树作为起点的原因很简单，因为它⾮常符合我们⼈类处理问题的⽅法，⽽且逻辑清晰，可解释性好。
从婴⼉到长者，我们每天都使⽤⽆数次！决策树的总体流程；总体流程分⽽治之（devide and conquer）⾃根结点的递归过程从每⼀个中间结点寻找⼀个划分（split and test）的属性三种停⽌条件：当前结点包含的样本属于同⼀类别，⽆需划分当前属性集为空，或是所有样本在所有属性值上取值相同，⽆法划分当前结点包含的样本集合为空，不能划分核⼼数学概念：熵信息熵（entropy）是度量样本集合“纯度”最常⽤的⼀种指标C4.5算法流程C4.5算法优缺点分析优点：（1）通过信息增益率选择分裂属性，克服了ID3算法中通过信息增益倾向于选择拥有多个属性值的属性作为分裂属性的不⾜；（2）能够处理离散型和连续型的属性类型，即将连续型的属性进⾏离散化处理；（3）构造决策树之后进⾏剪枝操作；（4）能够处理具有缺失属性值的训练数据。
缺点：（1）算法的计算效率较低，特别是针对含有连续属性值的训练样本时表现的尤为突出。
（2）算法在选择分裂属性时没有考虑到条件属性间的相关性，只计算数据集中每⼀个条件属性与决策属性之间的期望信息，有可能影响到属性选择的正确性。
算法详解：算法程序while（当前节点不纯）1.计算当前节点的类别熵Info（D）(以类别取值计算)2.计算当前节点的属性熵info(Ai)(按照当前属性取值下的类别取值计算)3.计算各个属性的信息增益Gain(Ai) = Info(D)-info(Ai)4.计算各个属性的分类信息度量H（Ai）(按照属性取值计算)5.计算各个属性的信息增益率 IGR = Gain(Ai)/H(Ai)and while当前节点设置为叶⼦节点。
C4.5算法概述汇编
目录1决议树算法 (2)1.1详细应用处景和意义 (2)1.2现状剖析 (3)2C4.5算法对 ID3 算法的改良 (4)3C4.5算法描绘 (7)3.1C4.5算法原理 (7)3.2算法框架 (8)3.3C4.5算法伪代码 (9)4实例剖析 (9)5C4.5算法的优势与不足 (12)5.1C4.5算法的优势 (12)5.2C4.5算法的不足： (12)参照文件 (12)C4.5 算法综述纲要最早的决议树算法是由Hunt 等人于 1966 年提出的 CLS。
目前最有影响的决策树算法是 Quinlan 于 1986 年提出的 ID3 和 1993 年提出的 C4.5。
ID3 只好办理失散型描绘属性，它选择信息增益最大的属性区分训练样本，其目的是进行分枝时系统的熵最小，进而提升算法的运算速度和精准度。
ID3 算法的主要缺点是，用信息增益作为选择分枝属性的标准时，偏向于取值许多的属性，而在某些状况下，这种属性可能不会供给太多有价值的信息。
C4.5 是 ID3 算法的改良算法，不单能够办理失散型描绘属性，还可以办理连续性描绘属性。
C4.5 采纳了信息增益比作为选择分枝属性的标准，填补了 ID3 算法的不足。
C4.5 算法在 ID3 算法的基础长进行了改良，关于展望变量的缺值办理、剪枝技术、派生规则等方面作了较大的改良，既合适于分类问题，又合适于回归问题，是目前应用最为宽泛的概括推理算法之一，在数据发掘中收到研究者的宽泛关注。
1决议树算法1.1 详细应用处景和意义决议树（ Decision Tree）是用于分类和展望的主要技术，它着眼于从一组无规则的案例推理出决议树表示形式的分类规则，采纳自顶向下的递归方式，在决议树的内部节点进行属性值的比较，并依据不一样属性判断从该节点向下分支，在决议树的叶节点获得结论。
所以，从根节点到叶节点就对应着一条合理规则，整棵树就对应着一组表达式规则。
鉴于决议树算法的一个最大的长处是它在学习过程中不需要使用者认识好多背景知识，只需训练案例能够用属性即结论的方式表达出来，就能使用该算法进行学习。
C4.5
根据计算得到的信息增益率进行选择属性集 中的属性作为决策树结点，对该结点进行分 裂。
Gain为信息增益
H(S,A)为信息熵
C4.5 采用信息增益率作为对选择分枝属 性的分枝准则，表示了由分枝产生的有用 信息的比率，值越大，分枝包含有用信息 越多。
与ID3算法相比，ID3算法选择信息增益最 大的属性进行分支，而C4.5算法选择信息 增益率最大的属性进行分支，整体上看， 分支更明确，获得有用信息更多。
C4.5算法介绍
2014/11/10
一、概述
C4.5算法是在ID3算法的基础上进一步改 进形成的，此算法用信息增益率来选择决 策属性，继承了ID3算法的优点，并在一些 方面进行了改进。
二、C4.5优点
（1）用信息增益率代替信息增益来选择属性： 信息增益率定义为：
Gain(S, A) GainRatio S , A H(S, A)
离散化处理时，C4.5算法对节点上的每个 属性都要计算信息增益决策树构造过程中或者构造完成之 后进行剪枝： 决策树的修剪的目的是抛弃一个或更多的 子树，并用叶代替子树，是决策树简单化。 修剪可以避免树的无节制增长，避免过度拟 合数据，去掉对未知检验样本的分类精度 无帮助的树。
(2)能够完成对连续属性的离散化处理： C4.5将连续型属性的值分成不同的区间， 具体步骤是： 先寻找连续型属性的最小值，赋值给min， 最大值赋值给max；然后设置区间[min， max]中的N个等分断点Ci；再计算将（min， Ci）和（Ci，max）作为区间值的信息增益 率，并比较；最后选取信息增益率最大的C， 作为断点，将属性值设置为[min,A]和 [A,max]。
根据上面计算结果，我们可以计算信息增益率，如下 所示：
一种改进的C4.5决策树算法
一种改进的C4.5决策树算法作者：王志春刘丽娜来源：《电子技术与软件工程》2016年第09期【关键词】数据挖掘决策树 C4.5算法信息增益率1 引言数据挖掘中决策树是解决分类问题的方法之一，是一种归纳学习算法。
通过一组属性值向量和相应的类，采用归纳学习算法构造分类器和预测模型，能够从一组无序和无规则的数据中生成决策树形式的分类规则。
决策树基本不依赖于任何专业领域的知识，所以在分类，预测和规则提取等领域都被广泛的应用。
70 年代末，J.ROSS Quinlan提出了ID3算法后，在机器学习和知识发现领域决策树算法都得到了进一步应用和发展。
ID3算法的核心是选择属性时，用信息增益（information gain）作为选择属性的度量标准，在测试每一个非叶子结点时，能获得关于被测试记录最大的类别信息。
虽然ID3算法具有算法清晰，方法简单和学习能力较强的优点，但是ID3算法不能处理连续的属性值，并且依赖于训练数据集的质量，只对数据集较小的情况有效，训练数据集在逐渐变大时，决策树可能会随之改变。
由于ID3算法存在着许多需要改进的地方，为此，J.ROSS.Quinlan于1993提出了C4.5算法，对ID3算法进行了补充和改进。
C4.5 算法具有ID3 算法优点的同时也改进和扩展了算法，使其产生易于理解和准确率较高的分类规则。
相比于ID3算法，C4.5算法用信息增益率来选择属性，而不是ID3算法所用的信息增益；在ID3算法的基础上还增加了对连续属性的离散化、对不完整属性的处理能力和产生规则等功能。
2 C4.5算法2.1 信息增益和信息增益率设D是m个不同值的训练集有m个不同类Ci （i=1，2，…，m），设Ci， d是元组的集合，D和Ci， d中的元组个数是|D|和|Ci， d|。
2.1.1 信息增益ID3算法中选择具有最高信息增益的属性作为节点N的分裂属性，使元组分类的信息量最小。
期望信息为：用|Ci， d|/|D|估计D中任意元组属于类Ci的概率Pi。
决策树的经典算法ID3与C45
决策树的经典算法ID3与C45决策树是一种常用的机器学习算法，用于分类和回归任务。
决策树算法可以看作是一种基于树结构的分类方法，它将数据集拆分成若干个子集，每个子集对应一个属性测试条件，通过不断递归地划分数据集，最终形成一棵决策树。
经典的决策树算法包括ID3和C5，本文将对这两种算法进行介绍。
ID3（Iterative Dichotomiser 3）是由Ross Quinlan提出的，它是最早的决策树算法之一。
ID3算法采用了信息增益作为属性选择度量，通过计算每个属性的信息增益，选择信息增益最大的属性进行分裂。
我们计算每个属性的信息增益。
信息增益被定义为父节点与子节点之间的信息差异，计算公式为：Gain(S,A)=H(S)-sum(P(a) * H(S_a))其中，H(S)表示节点S的熵，P(a)表示属性A的取值a在节点S中出现的概率，H(S_a)表示子节点S_a的熵。
选择信息增益最大的属性作为当前节点的分裂属性。
根据当前节点的分裂属性将数据集划分成若干个子集，对每个子集递归地执行步骤1和步骤2，直到满足停止条件（例如子集中所有样本都属于同一类别，或每个属性都已使用过）。
C5算法是ID3算法的改进版，它使用了增益率作为属性选择度量，以解决ID3算法中偏好于选择取值较多的属性的问题。
增益率定义为信息增益与分裂信息的比值，分裂信息被定义为：split_info(S,A)=-sum(P(a) * log2(P(a)))其中，P(a)表示属性A 的取值a在节点S中出现的概率。
C5算法的步骤与ID3算法类似，但在选择分裂属性时优先考虑增益率较高的属性。
C5算法还引入了剪枝技术，通过设置一个置信度阈值来避免过拟合，从而生成更加健壮的决策树。
ID3算法和C5算法都是经典的决策树算法，它们在处理分类问题时具有较高的准确率和可解释性。
然而，这两种算法也存在一些局限性，例如对于连续属性和处理缺失值的处理能力有限。
后续的许多研究者对决策树算法进行了改进和优化，如CART、CHD、BOOSTING等，这些算法在处理复杂问题、提高分类准确率和处理连续属性方面做出了更多的探索和实践。
python决策树之C4.5算法详解
python决策树之C4.5算法详解本⽂为⼤家分享了决策树之C4.5算法，供⼤家参考，具体内容如下1. C4.5算法简介 C4.5算法是⽤于⽣成决策树的⼀种经典算法，是ID3算法的⼀种延伸和优化。
C4.5算法对ID3算法主要做了⼀下⼏点改进： （1）通过信息增益率选择分裂属性，克服了ID3算法中通过信息增益倾向于选择拥有多个属性值的属性作为分裂属性的不⾜； （2）能够处理离散型和连续型的属性类型，即将连续型的属性进⾏离散化处理； （3）构造决策树之后进⾏剪枝操作； （4）能够处理具有缺失属性值的训练数据。
2. 分裂属性的选择——信息增益率 分裂属性选择的评判标准是决策树算法之间的根本区别。
区别于ID3算法通过信息增益选择分裂属性，C4.5算法通过信息增益率选择分裂属性。
属性A的“分裂信息”(split information)：其中，训练数据集S通过属性A的属性值划分为m个⼦数据集，|Sj|表⽰第j个⼦数据集中样本数量，|S|表⽰划分之前数据集中样本总数量。
通过属性A分裂之后样本集的信息增益：信息增益的详细计算⽅法，可以参考博客“”中信息增益的计算。
通过属性A分裂之后样本集的信息增益率： 通过C4.5算法构造决策树时，信息增益率最⼤的属性即为当前节点的分裂属性，随着递归计算，被计算的属性的信息增益率会变得越来越⼩，到后期则选择相对⽐较⼤的信息增益率的属性作为分裂属性。
3. 连续型属性的离散化处理 当属性类型为离散型，⽆须对数据进⾏离散化处理；当属性类型为连续型，则需要对数据进⾏离散化处理。
C4.5算法针对连续属性的离散化处理，核⼼思想：将属性A的N个属性值按照升序排列；通过⼆分法将属性A的所有属性值分成两部分（共有N-1种划分⽅法，⼆分的阈值为相邻两个属性值的中间值）；计算每种划分⽅法对应的信息增益，选取信息增益最⼤的划分⽅法的阈值作为属性A⼆分的阈值。
详细流程如下：（1）将节点Node上的所有数据样本按照连续型属性A的具体取值，由⼩到⼤进⾏排列，得到属性A的属性值取值序列(xA1,...,xAN)。
C4 5算法
信息增益实际上是ID3算法中用来进行属性选择度量的。它选择具有最高信息增益的属性来作为节点N的分裂 属性。该属性使结果划分中的元组分类所需信息量最小。对D中的元组分类所需的期望信息为下式：
Info(D)又称为熵。
现在假定按照属性A划分D中的元组，且属性A将D划分成v个不同的类。
其它特征
C4.5算法与ID3算法一样使用了信息熵的概念，并和ID3一用在机器学习和数据挖掘的分类问题中的算法。它的目标是监督学习：给定一个数据集，其中 的每一个元组都能用一组属性值来描述，每一个元组属于一个互斥的类别中的某一类。C4.5的目标是通过学习， 找到一个从属性值到类别的映射关系，并且这个映射能用于对新的类别未知的实体进行分类。
C4.5算法
ID3算法的一个扩展
01 产品介绍
目录
02 改进表现
03 优缺点
04 算法描述
05 属性选择度量
06 其它特征
C4.5算法是由Ross Quinlan开发的用于产生决策树的算法。该算法是对Ross Quinlan之前开发的ID3算法的 一个扩展。C4.5算法产生的决策树可以被用作分类目的，因此该算法也可以用于统计分类。
对非离散数据也能处理。
能够对不完整数据进行处理 。
优缺点
C4.5算法优点：产生的分类规则易于理解，准确率较高。
缺点：在构造树的过程中，需要对数据集进行多次的顺序扫描和排序，因而导致算法的低效。此外，C4.5只 适合于能够驻留于内存的数据集，当训练集大得无法在内存容纳时程序无法运行。
算法描述
C4.5并不一个算法，而是一组算法—C4.5，非剪枝C4.5和C4.5规则。以下算法将给出C4.5的基本工作流程： Input:an attibute-valued dataset D 1:Tree={} 2:if D is "pure"OR other stopping criteria met then 3: terminate 4: end if 5:for all attribute a∈ D do 6: Compute inforation-theoretic criteria if we split on a 7:end for 8:a(best)=Best attribute according to above computed criteria 9: Tree=Create a decision node that tests a(best) in the root
C4.5算法源代码
}
while ((iDepart[m] != -1)&&(m!=MAX))
{
for (n = 0;n<l;n++)
{
if (iInput[iSamples[n]][iAttribute[k]] == iDepart[m])
{
iSamples[a] = (int)malloc(sizeof(int));
iSamples[a] = a;
}
a = 0;
fclose(fp);
fp=fopen("c:\\input.txt","r");
iGet = getc(fp);
while(EOF ! iGet)&&('\n' != iGet))
{
iInput[a][b] = iGet - 48;
b++;
}
if (b == i)
{
a++;
b = 0;
}
iGet = getc(fp);
}
fp1 = fopen("d:\\output.txt","w");
int choose_attribute(int* iSamples, int* iAttribute)
{
int iTestAttribute = -1;
int k = 0;
int l = 0;
int m = 0;
int n = 0;
int iTrue = 0;
int iFalse = 0;
C45算法ppt课件
)
1.387
政治成绩的信息增益为：
Gain(政治成绩） I(r1, r2 , r3 , r4 ) E(政治成绩） 0.559
政治成绩的信息增益率为： Ratio(政治成绩） GEa（ in政 (政治治成成绩绩）） 0.4029096
由Fayyad 边界点判定定理可知, 无需检查每一个阈 值点, 只要检查相邻不同类别的边界点即可。为了保持与 C4.5 的一致性, 这里边界点选为相邻不同类别的属性值 中较小的一个。例如, 当排序后的实例属性值为{ v1 , v2 , ⋯, v10 } , 其中前3 个属于类别C1 , 中间4 个属于类别 C2 , 最后3个属于类别C3 , 因此只需考察两个边界点v3 与v7 而无需检查其余7 个阈值点, 然后选择v3 与v7 中使得平 均类熵最小的那个作为最优阈值。
10
二、C4.5算法的具体实现
(1)用信息增益率代替信息增益来选择属性; (2)能够完成对连续属性的离散化处理; (3)在决策树构造过程中或者构造完成之后,进 行剪枝; (4)能够对不完整数据进行处理,如未知的属性 值; (5) C4.5可以用决策树形式形成产生式规则。
11
(2)能够完成对连续属性的离散化处理
n i 1
| Ti |T
| |
log 2
| Ti
|
T
|
|
split
_ inf
o(V )
8
(1)用信息增益率代替信息增益来选择属性;
信息增益率：
Gain _ ratio Gain(V ) H (V )
C4.5 采用了信息增益率作为对选择分枝属性的分枝 准则。信息增益率表示了由分枝产生的有用信息的 比率。因此,这个值越大, 分枝包含的有用信息越多。
C4.5算法在未知恶意代码识别中的应用
在植人、 安装阶段会表现出显著的有别于一般合 法程 序 的一 系列行 为特征 ， 如 自删 除 、 自我复制 、
文献 标 识 码 ： Ａ
目前 ， 主流杀 毒软 件采 用 的技 术是 特征 码技 术， 其 原理是 在待 检测 文件 中查 找二进 制代码 特 征， 如 果 与 既 有 特 征 码 相 匹 配 就 判 定 为 病 毒 程 序． 其优 点 是能 快 速 、 准 确地 检 测 出 已知 恶 意代 码； 缺 点是 对 变种 及 未 知恶 意 代码 无 能 为力 ． 文 献［ ｉ 一 ２ ］ 已经证 明对 计算 机病 毒 的检 测 不 可判 定． 因此 ， 目前 对于未 知恶 意代 码 的识 别 ， 就是采 用 近似算 法 ， 包括两类 ： （ １ ） 静 态 启 发 式 扫 描技 术． 其 原 理是 在 代码 不 运行 时 ， 通 过 分 析代 码 中 的特 征序 列来 识别 恶意 代码 的方 法 ， 如文 献 ［ ３ ］ 通 过分 析可执 行文 件 静 态调 用 的 ＡＰ Ｉ 序 列 来识 别 已知 恶意代 码 的变种 ， 它 的依据 是恶 意代码 和 它的 变种一 定 有 足 够 多 相 似 的 ＡＰ Ｉ调 用 序 列 ． 文献［ ４ ］ 是 提 取 已知 恶 意 代 码 中的 特 征 字 节 序 列， 采 用 多 重 贝 叶 斯 算 法 建 立 分 类 模 型． 文 献 ［ ５ ］ 提 出 一 种基 于加 权 信 息 增 益 的特 征 选 择 方 法， 该 方 法 综 合 考 虑 特 征 频 率 和信 息 增 益 的作
用， 能够更加准确地选取有效特征， 从而提高检
测性能． 如上静态技术虽然对未知恶意代码识别 的误判率和漏报率都较低 ， 但其缺点是无法识别 被加壳的恶意代码 ； （ ２ ） 基于代码 的动态行为分
C4.5
该程序为C++写的C4.5算法，输入为类和属性文件（class_and_attribute.txt）与样本文件（sample.txt），输出决策树为从根节点到所有叶子节点的路径，输出如下图所示，图中每行代表一条路径即一个规则，最后的字符串代表类别，前面的字符串代表属性值，该决策树没有进行剪枝，只能处理离散属性，连续属性的处理以及剪枝以后会上传。
类和属性文件（class_and_attribute.txt）：YES NOOutLook1sunny overcast rain #Temperature1hot mild cool #Humidity1>75 <=75 #Wind1true false #样本文件（sample.txt）：sunny hot >75 false NOsunny hot >75 true NOovercast hot >75 false YESrain mild >75 false YESrain cool >75 false YESrain cool <=75 true NOovercast cool <=75 true YESsunny mild >75 false NOsunny cool <=75 false YESrain mild >75 false YESsunny mild <=75 true YESovercast mild >75 true YESovercast hot <=75 false YESrain mild >75 true NO类定义头文件（definitions.h）：信息读取头文件（io_functions.h）：#include "definitions.h"/********读入类和属性*********/void readClassesAndAttributes(Classes &classes,Attributes &attributes) {ifstream fin("class_and_attribute.txt");string temp;int i;for(i=0;i<MAX_CLASS;++i)//读入类信息{fin>>temp;classes.addClass(temp);}string att_name;bool is_dis;vector<string>value;Attribute temp_att;for(i=0;i<NUM_OF_ATTRI;++i){fin>>att_name;fin>>is_dis;if(is_dis==true){fin>>temp;while(temp!="#"){value.push_back(temp);fin>>temp;}}temp_att.AttriInit(att_name,i,is_dis,value);attributes.addAttri(temp_att);value.clear();}}/********读入样本*************/void readSample(Samples &samples,Classes &classes){ifstream fin("Sample.txt");string temp;short class_num;vector<string>temp_att;Sample temp_sample;for(int i=0;i<NUM_OF_SAMPLE;++i){for(int j=0;j<NUM_OF_ATTRI;++j) //读取样本的属性{fin>>temp;temp_att.push_back(temp);}fin>>temp; //读取样本的类别class_num=classes.getNum(temp); //计算类别编号temp_sample.setSample(temp_att,class_num);samples.addSample(temp_sample);temp_att.clear();}}函数体头文件（functions.h）:#include "io_functions.h"/*****************Classes*********************/void Classes::addClass(string _name){C.push_back(_name);}short Classes::getNum(string name)//返回名为name的类别的编号{for(short i=0;i<MAX_CLASS;++i){if(C[i]==name)return i;}}string Classes::getName(int k){return C[k];}/*************Attribute****************/void Attribute::setGainRatio(double _gain_ratio){gain_ratio=_gain_ratio;}double Attribute::getGainRatio(){return gain_ratio;}int Attribute::sizeOfValue()return value.size();}int Attribute::getNum() //返回该节点的属性编号{return num;}string Attribute::getValue(int k)//返回属性的第k个值{return value[k];}void Attribute::AttriInit(string _name,int _num,bool _is_dis,vector<string>_value) {name=_name;num=_num;is_discreted=_is_dis;if(is_discreted==true)value=_value;}/*************Attributes***************/void Attributes::deleteAttri(int k)//删除编号为k的属性{int K=sizeOfAttris();vector<Attribute>::iterator it;for(it=attris.begin();it!=attris.end();++it){if((*it).getNum()==k){attris.erase(it);break;}}}int Attributes::sizeOfAttris(){return attris.size();}void Attributes::addAttri(Attribute attri){attris.push_back(attri);}Attribute Attributes::getAttri(int att_num)for(int i=0;i<attris.size();++i){if(attris[i].getNum()==att_num)return attris[i];}}/*************Smaple****************/short Sample::getClass(){return class_num;}string Sample::getAttriValue(int k)//返回第k个属性值{return attri[k];}void Sample::setSample(vector<string>_attri,short _class_num){class_num=_class_num;attri=_attri;}void Sample::outPut(){cout<<class_num<<endl;for(int i=0;i<attri.size();++i){cout<<attri[i]<<' ';}cout<<endl;}/*************Samples******************/void Samples::addSample(Sample _sample)//{samps.push_back(_sample);}int Samples::getMostFrequent()//返回样本集中数量最大的类别的编号{int i,K=samps.size();int count[MAX_CLASS];memset(count,0,sizeof(count));for(i=0;i<K;++i){count[samps[i].getClass()]++;}int max_class;int max_count=-INF;for(i=0;i<MAX_CLASS;++i){if(count[i]>max_count){max_class=i;max_count=count[i];}}return max_class;}int Samples::sizeOfSamples(){return samps.size();}void Samples::outPut(){for(int i=0;i<samps.size();++i){samps[i].outPut();cout<<endl;}}//返回第attri个属性的属性值为value[k]的样本集，并将其在原样本集中删除Samples Samples::getSamps(int attri,string attri_value){Samples temp;vector<Sample>::iterator it;for(it=samps.begin();it!=samps.end();){if((*it).getAttriValue(attri)==attri_value){temp.samps.push_back((*it));samps.erase(it);}else ++it;}return temp;void Samples::clear(){samps.clear();}bool Samples::isPure(){int i,K=sizeOfSamples();for(i=1;i<K;++i){if(samps[i].getClass()!=samps[0].getClass())return false;}return true;}/*************DicisionTree************/void DicisionTree::addChild(DicisionTree child)//添加子树{children.push_back(child);}void DicisionTree::setLeaf(short _class) //设置叶子节点{is_leaf=true;class_num=_class;}void DicisionTree::setAttri(int k) //设定该节点的属性编号{is_leaf=false;attri_num=k;}bool DicisionTree::isEmpty(){if((is_leaf==false)&&(attri_num==-1))return true;else return false;}bool DicisionTree::isLeaf(){return is_leaf;}short DicisionTree::getClassNum(){return class_num;int DicisionTree::getAttriNum(){return attri_num;}void DicisionTree::output(string path,Attributes attributes,Classes classes) {if(isLeaf()==true){cout<<path<<" "<<classes.getName(getClassNum())<<endl;}else{path+=" ";string temp_path;for(int i=0;i<children.size();++i){temp_path=path;temp_path+=attributes.attris[getAttriNum()].getValue(i);children[i].output(temp_path,attributes,classes);}}}/****************C4.5*************************/DicisionTree C4_5::buildTree(Attributes attributes,Samples samples) {DicisionTree tree;if(samples.sizeOfSamples()==0)//样本集为空{return tree;}if(attributes.sizeOfAttris()==0)//属性集为空{tree.setLeaf(samples.getMostFrequent());}else if(samples.isPure())//样本集中样本为同一类{tree.setLeaf(samples.getMostFrequent());}else//建立子树{DicisionTree child;Samples temp_samples;int best_att;best_att=bestAttribute(attributes,samples);Attribute best_attribute=attributes.getAttri(best_att);//获得编号为best_att的属性if(best_attribute.getGainRatio()<THRESHOLD_VALUE)//熵小于阀值{tree.setLeaf(samples.getMostFrequent());return tree;}attributes.deleteAttri(best_att);//删除编号为best_att的属性tree.setAttri(best_attribute.getNum());//给该节点设置属性int K=best_attribute.sizeOfValue();//属性值的数量for(int i=0;i<K;++i){//返回samples中编号为best_attribute对应的属性且属性值为value[i]的Sample子集，//并将该子集在samples中删除temp_samples=samples.getSamps(best_att,best_attribute.getValue(i));child=buildTree(attributes,temp_samples);if(!tree.isEmpty())//子树不为空{tree.addChild(child);}}}return tree;}int C4_5::bestAttribute(Attributes attributes,Samples samples){int K=attributes.sizeOfAttris();if(K==0) return -1;//属性集为空int best_att;double max_gain_ratio=-INF;for(int i=0;i<K;++i)//枚举属性{double pri_entropy=entropy(samples);double now_entropy=entropy(attributes.attris[i],samples);double _splitI=splitI(attributes.attris[i],samples);double gain=pri_entropy-now_entropy;double _gain_ratio=gain/_splitI;if(_gain_ratio>max_gain_ratio){best_att=i;max_gain_ratio=_gain_ratio;}}attributes.attris[best_att].setGainRatio(max_gain_ratio);return attributes.attris[best_att].getNum();}double C4_5::entropy(Samples samples){int count[MAX_CLASS];memset(count,0,sizeof(count));int i,K=samples.sizeOfSamples();if(K==0)return 0;//样本集为空for(i=0;i<K;++i){count[samples.samps[i].getClass()]++;}double S=0;for(i=0;i<MAX_CLASS;++i){double p=(double)count[i]/K;if(p!=0)S-=p*(log(p)/log(2));}return S;}double C4_5::entropy(Attribute attribute,Samples samples){Samples temp;double S=0;int M=samples.sizeOfSamples();//样本数量if(M==0)return 0;int K=attribute.sizeOfValue();//属性值的数量int attri=attribute.getNum();for(int i=0;i<K;++i){temp=samples.getSamps(attri,attribute.getValue(i));S+=(temp.sizeOfSamples()/(double)M)*entropy(temp);temp.clear();}return S;}double C4_5::splitI(Attribute attribute,Samples samples){double SplitI=0;Samples temp;int M=samples.sizeOfSamples();int K=attribute.sizeOfValue();if(M==0)return 0;//样本集为空for(int i=0;i<K;++i){temp=samples.getSamps(attribute.getNum(),attribute.getValue(i));double p=temp.sizeOfSamples()/(double)M;if(p!=0)SplitI-=p*(log(p)/log(2));temp.clear();}return SplitI;}void C4_5::output(Attributes attributes,Classes classes){string path;tree.output(path,attributes,classes);}主函数（C4_5.cpp）：#include "functions.h"int main(){Classes classes;Attributes attributes;Samples samples;C4_5 c4_5;readClassesAndAttributes(classes,attributes);readSample(samples,classes);c4_5.getTree(attributes,samples);cout<<"决策树为："<<endl;c4_5.output(attributes,classes);system("pause");return 0;}该程序为本人第一次用面向对象思想写的程序，并且因为刚学习决策树，水平有限，请谅解。
C4.5算法概述
个最大的优点是它在学习过程中不需要 使用者了解很多背景知识，只要训练事例能够用属性即结论的方式表 达出来，就能使用该算法进行学习。
决策树算法在很多方面都有应用，如决策树算法在医学、制造和 生产、金融分析、天文学、遥感影像分类和分子生物学、机器学习和 知识发现等领域得到了广泛应用。
决策树技术是一种对海量数据集进行分类的非常有效的方法。通 过构造决策树模型，提取有价值的分类规则，帮助决策者做出准确的 预测已经应用在很多领域。决策树算法是一种逼近离散函数值的方 法。它是一种典型的分类方法，首先对数据进行处理，利用归纳算法 生成可读的规则和决策树，然后对新数据进行分析。本质上决策树是 通过一系列规则对数据进行分类的过程。
目录
1 决策树算法 ..................................... 2 1.1 具体应用场景和意义........................... 2 1.2 现状分析 .................................... 4
2 C4.5 算法对 ID3 算法的改进 ....................... 5 3 C4.5 算法描述................................... 9
3.1 C4.5 算法原理 ............................... 9 3.2 算法框架 .................................. 11 3.3 C4.5 算法伪代码 ............................ 11 4 实例分析 ...................................... 13 5 C4.5 算法的优势与不足 .......................... 15 5.1 C4.5 算法的优势 ............................ 15 5.2 C4.5 算法的不足： .......................... 16 参考文献 ......................................... 16
c4.5代码
== Uc(k)); == Uc(k));
tree.Nf = Nf; tree.split_loc
= split_loc(dim);
%If only one value remains for this pattern, one cannot split it. if (Nbins == 1) H = hist(targets, length(Uc)); [m, largest] = max(H); tree.Nf = []; tree.split_loc = []; tree.child = Uc(largest); return end if (discrete_dim(dim)), %Discrete pattern for i = 1:Nbins, indices = find(patterns(dim, :) == Nf(i)); tree.child(i) = make_tree(patterns(dims, indices), targets(indices), inc_node, discrete_dim(dims), maxNbin, base); end else %Continuous pattern indices1 = find(patterns(dim,:) <= split_loc(dim)); indices2 = find(patterns(dim,:) > split_loc(dim)); if ~(isempty(indices1) | isempty(indices2)) tree.child(1) = make_tree(patterns(dims, indices1), targets(indices1), inc_node, discrete_dim(dims), maxNbin, base+1); tree.child(2) = make_tree(patterns(dims, indices2), targets(indices2), inc_node, discrete_dim(dims), maxNbin, base+1); else H = hist(targets, length(Uc)); [m, largest] = max(H); tree.child = Uc(largest); tree.dim = 0; end end
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
）数据挖掘分类算法之决策树（zz Decision tree决策树（）以实例为基础的归纳学习算法。
决策树是它从一组无次序、无规则的元组中推理出决策树表示形式的分类规则。
它采并根据不同的用自顶向下的递归方式，在决策树的内部结点进行属性值的比较，该结点向下分支，叶结点是要学习划分的类。
从根到叶结点的一条路属性值从径就对应着一条合取规则，整个决策树就对应着一组析取表达式规则。
1986年又ID3算法的基础上，1993年QuinlanQuinlan提出了著名的ID3算法。
在提出了若干改提出了C4.5算法。
为了适应处理大规模数据集的需要，后来又SPRINT (scalable 进的算法，其中SLIQ(super-vised learning in quest)和是比较有代表性的两个算法。
parallelizableinduction of decision trees) (1) ID3算法算法的核心是：在决策树各级结点上选择属性时，用信息增益ID3）作为属性的选择标准，以使得在每一个非叶结点进行测（information gain 检测所有的属性，其具体方法是：试时，能获得关于被测试记录最大的类别信息。
再对由该属性的不同取值建立分支，选择信息增益最大的属性产生决策树结点，直到所有子集仅包含同一各分支的子集递归调用该方法建立决策树结点的分支，类别的数据为止。
最后得到一棵决策树，它可以用来对新的样本进行分类。
某属性的信息增益按下列方法计算。
通过计算每个属性的信息增益，并比较它们的大小，就不难获得具有最大信息增益的属性。
个m个不同值，定义mS 设是s个数据样本的集合。
假定类标号属性具有中的样本数。
对一个给定的样本分类所需si是类Ci不同类Ci(i=1,…,m)。
设的期望信息由下式给出：为底，其原2Ci 其中pi=si/s的概率。
注意，对数函数以是任意样本属于因是信息用二进制编码。
个划分为v可以用属性A将Sv 设属性A具有个不同值{a1,a2,……,av}。
aj上具有相同的值A，其中Sj中的样本在属性子集{S1,S2,……,Sv}（j=1,2,……,v）。
设sij是子集Sj中类Ci的样本数。
由A 划分成子集的熵或信息期望由下式给出：熵值越小，子集划分的纯度越高。
对于给定的子集Sj，其信息期望为其中pij=sij/sj 是Sj中样本属于Ci的概率。
在属性A上分枝将获得的信息增益是Gain(A)= I(s1, s2, …,sm)-E(A)ID3算法的优点是：算法的理论清晰，方法简单，学习能力较强。
其缺点是：决策树可当训练数据集加大时，且对噪声比较敏感，只对比较小的数据集有效，能会随之改变。
算法(2) C4.5 ID3 C4.5算法继承了算法的优点，并在以下几方面对ID3算法进行了改进：用信息增益率来选择属性，克服了用信息增益选择属性时偏向选择取值1)多的属性的不足；在树构造过程中进行剪枝；2)3) 能够完成对连续属性的离散化处理；4) 能够对不完整数据进行处理。
算法与其它分类算法如统计方法、神经网络等比较起来有如下优点：C4.5产生的分类规则易于理解，准确率较高。
其缺点是：在构造树的过程中，需要对只适合因而导致算法的低效。
数据集进行多次的顺序扫描和排序，此外，C4.5 于能够驻留于内存的数据集，当训练集大得无法在内存容纳时程序无法运行。
(3) SLIQ算法在决策树的构造SLIQ算法对C4.5决策树分类算法的实现方法进行了改进，预排序”和“广度优先策略”两种技术。
过程中采用了“预排序。
对于连续属性在每个内部结点寻找其最优分裂标准时，都需要对1)SLIQ训练集按照该属性的取值进行排序，而排序是很浪费时间的操作。
为此，采用了预排序技术。
所谓预排序，就是针对每个属性的取值，把所有的记算法以消除在决策树的每个结点对数据集进行的排录按照从小到大的顺序进行排序，现时，需要为训练数据集的每个属性创建一个属性列表，为类别属序。
具体实性创建一个类别列表。
算法中，树的构造是按照深度优先策略完成的，C4.5 2)广度优先策略。
在采需要对每个属性列表在每个结点处都进行一遍扫描，费时很多，为此，SLIQ广度优先策略构造决策树，即在决策树的每一层只需对每个属性列表扫描一用次，就可以为当前决策树中每个叶子结点找到最优分裂标准。
大得多的使得该算法能够处理比C4.5 SLIQ算法由于采用了上述两种技术，训练集，在一定范围内具有良好的随记录个数和属性个数增长的可伸缩性。
然而它仍然存在如下缺点：而类别列表的元组数与训练集的元组数由于需要将类别列表存放于内存,1) ,这就一定程度上限制了可以处理的数据集的大小。
是相同的由于采用了预排序技术，而排序算法的复杂度本身并不是与记录个数成线2)算法不可能达到随记录数目增长的线性可伸缩性。
性关系，因此，使得SLIQ 算法(4)SPRINT算法进一步改进了决策树算法的数SPRINT 为了减少驻留于内存的数据量，SLIQ中需要驻留于内存的类别列表，将它的类别列合并到每去掉了在据结构，个属性列表中。
这样，在遍历每个属性列表寻找当前结点的最优分裂标准时，不必参照其他信息，将对结点的分裂表现在对属性列表的分裂，即将每个属性列表分成两个，分别存放属于各个结点的记录。
SPRINT算法的优点是在寻找每个结点的最优分裂标准时变得更简单。
其缺点是对非分裂属性的属性列表进行分裂变得很困难。
解决的办法是对分裂属性进行分裂时用哈希表记录下每个记录属于哪个孩子结点，若内存能够容纳下整个哈希表，其他属性列表的分裂只需参照该哈希表即可。
由于哈希表的大小与训练集的大小成正比，当训练集很大时，哈希表可能无法在内存容纳，此时分裂只算法的可伸缩性仍然不是很好。
SPRINT能分批执行，这使得．算法C4.5 一．背景。
当前最有影响的决CLS1966年提出的最早的决策时算法是由Hunt等人于只。
ID3于Quinlan1986年提出的ID3和1993年提出的C4.5策树算法是其目的是进能处理离散型描述属性，它选择信息增益最大的属性划分训练样本，算法的主要缺从而提高算法的运算速度和精确度。
ID3行分枝时系统的熵最小，而在某偏向于取值较多的属性，陷是，用信息增益作为选择分枝属性的标准时，算法的改进ID3些情况下，这类属性可能不会提供太多有价值的信息。
C4.5是采用了C4.5算法，不仅可以处理离散型描述属性，还能处理连续性描述属性。
ID3信息增益比作为选择分枝属性的标准，弥补了算法的不足。
）对噪声决策树算法的优点如下：（1）分类精度高；（2）成的模式简单；（3在数据挖数据有很好的健壮性。
因而是目前应用最为广泛的归纳推理算法之一，掘中受到研究者的广泛关注。
二．改进的具体方面C4.5 算法存在的缺点1.ID3算法在选择根节点和各内部节点中的分支属性时，采用信息增益作ID3（1）为评价标准。
信息增益的缺点是倾向于选择取值较多的属性，在有些情况下这类属性可能不会提供太多有价值的信息。
ID3算法只能对描述属性为离散型属性的数据集构造决策树。
）（2 C4.5算法做出的改进2．(1)用信息增益率来选择属性克服了用信息增益来选择属性时偏向选择值多的属性的不足。
信息增益率定义为：代ID3算法中的信息增益相同，而分裂信息SplitInfo(S,A)其中Gain(S,A)与的广度和均匀性。
分裂样本集S表了按照属性A个样本子集。
而形成的c分割是S其中，到Scc个不同值的属性AS130个用例）分成了10个用例和集（含把如按照属性AS20个用例两个集合SplitInfo(S,A)=-1/3*log(1/3)-2/3*log(2/3)则．(2)可以处理连续数值型属性在选择某节点C4.5既可以处理离散型描述属性，也可以处理连续性描述属性。
相同，按照的处理方法与ID3上的分枝属性时，对于离散型描述属性，C4.5，假设在某个结该属性本身的取值个数进行计算；对于某个连续性描述属性Ac C4.5将作以下处理。
点上的数据集的样本数量为total，将该结点上的所有数据样本按照连续型描述属性的具体数值，由小到大进行l……Atotalc}。
排序，得到属性值的取值序列{A1c，A2c，）个分割点的取值（0<i<total个分割点。
第l 在取值序列中生成total-1i它可以将该节点上的数据集划分为两个子c）设置为Vi=（Aic+A/2,（i+1）集。
个分割点中选择最佳分割点。
对于每一个分割点划分数据集的方total-1l 从并且从中选择信息增益比最大的分割点来划分式，C4.5计算它的信息增益比，数据集。
(3)采用了一种后剪枝方法避免树的高度无节制的增长，避免过度拟合数据，方从而决定是否真正剪枝。
该方法使用训练样本集本身来估计剪枝前后的误差，法中使用的公式如下：个实例中分类错E为N（其中其中N是实例的数量，f=E/N为观察到的误差率算法的一个输入参数，默c为置信度（C4.5误的个数），q为真实的误差率，的设定值通过查cc的标准差，其值可根据认值为z0.25），为对应于置信度的一个置信度上限，用q正态分布表得到。
通过该公式即可计算出真实误差率做一个悲观的估计：此上限为该节点误差率e的大小，从而决定是否需要剪枝。
通过判断剪枝前后e(4)对于缺失值的处理在某些情况下，可供使用的数据可能缺少某些属性的值。
假如〈x，c(x)〉是样本集S中的一个训练实例，但是其属性A的值A(x)未知。
处理缺少属性值的一种策略是赋给它结点n所对应的训练实例中该属性的最常见值；另外一种更复杂的策略是为A的每个可能值赋予一个概率。
例如，给定一个布尔属性A，如果结点n包含6个已知A=1和4个A=0的实例，那么A(x)=1的概率是0.6，而A(x)=0的概率是0.4。
于是，实例x的60%被分配到A=1的分支，40%被分配到另一个分支。
这些片断样例（fractional examples）的目的是计算信息增益，另外，如果有第二个缺少值的属性必须被测试，这些样例可以在后继的就是使用这种方法处理缺少的属性值。
C4.5树分支中被进一步细分。
．算法的优缺点3. C4.5 优点：产生的分类规则易于理解，准确率较高。
因而导致需要对数据集进行多次的顺序扫描和排序，缺点：在构造树的过程中，C4.5只适合于能够驻留于内存的数据集，当训练集大得无算法的低效。
此外，法在内存容纳时程序无法运行。
retur0incheck_attribute_null(in*iAttributeink = 0whil(k < (i-1)i(-1 != iAttribute[k]retur0k++retur1voiget_attributes(in*iSamples,in*iAttributeValue,iniAttributeink = 0inl = 0whil((-1 != iSamples[k])&&(k < j)l = 0whil(-1 != iAttributeValue[l]i(iInput[iSamples[k]][iAttribute] == iAttributeValue[l]breakl++i(-1 == iAttributeValue[l]iAttributeValue[l] = iInput[iSamples[k]][iAttribute]k++}分:算。