weka分类器-C4.5决策树

最新推荐文章于 2023-01-08 10:17:09 发布

豹先生_MR-BAO

最新推荐文章于 2023-01-08 10:17:09 发布

阅读量2.5k

点赞数

分类专栏：数据挖掘文章标签：大数据海量数据数据挖掘

数据挖掘专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1. 算法概述

C4.5，是机器学习算法中的另一个分类决策树算法，它是决策树(决策树也就是做决策的节点间的组织方式像一棵树，其实是一个倒树)核心算法，是相对于ID3算法的改进，主要改进点有：

1. 用信息增益率来选择属性。C4.5克服了ID3用信息增益选择属性时偏向选择取值多的属性的不足。

2. 在树构造过程中进行剪枝。

3. 对非离散数据也能处理。

4. 能够对不完整数据进行处理。

2. 算法过程

统计好样本集S，属性集A，分别求出属性集中每个属性的信息增益率，选中增益率最大的属性P，假设P总有n种情况的取值（连续变量要离散化），那么分别统计好第i种情况时样本集Si和除去P的属性集Pi，递归生成相对应的子树。

2.1 主要步骤

1）读取文件信息，统计数目

2）建立决策树

如果样本集为空，则生成一个信息数目都为0的树节点返回

如果样本均为同一类别，则生成一个叶子节点返回

计算节点正负样本的数目

如果属性值只有那个类别的属性，则生成一个叶子节点，并赋值类型索引

如果以上都不是，则选择一个增益率最大的属性（连续属性要用增益率离散化），按那个属性的取值情况从新定义样本集和属性集，建造相关子树

3）事后剪枝（采用悲观错误率估算）

4）输出决策树

5）移除决策时

3. 算法实现分析

3.1 训练分类器

public voidbuildClassifier(Instances instances) throws Exception {

ModelSelectionmodSelection;

if (m_binarySplits)

modSelection= newBinC45ModelSelection(m_minNumObj, instances,m_useMDLcorrection);

else

modSelection= newC45ModelSelection(m_minNumObj, instances,m_useMDLcorrection);

if (!m_reducedErrorPruning)

m_root = newC45PruneableClassifierTree(modSelection, !m_unpruned,

m_CF, m_subtreeRaising, !m_noCleanup, m_collapseTree);

else

m_root = newPruneableClassifierTree(modSelection, !m_unpruned,

m_numFolds, !m_noCleanup,m_Seed);

m_root.buildClassifier(instances);

}

第一个if判断是否对nominal属性进行二分裂，第二个if是判断是否对tree进行剪枝。

modSelection后面会被用于选择足有的分裂模型。

m_root是该树的根节点。

上面比较重要的是最后一句m_root.buildClassifier(instances);用于在各节点中构建分类器。下面我们看看其代码：

(C45PruneableClassifierTree.java)

public voidbuildClassifier(Instances data) throws Exception {

……

buildTree(data,m_subtreeRaising);

if (m_collapseTheTree){

collapse();

}

if (m_pruneTheTree) {

prune();

}

if (m_cleanup) {

cleanup(new Instances(data, 0));

}

过程为:首选见创建树然后根据需要对数进行节点折叠、剪枝、清理内存空间等。下面我们依次分析：

3.1.1 创建树buildTree (ClassifierTree.java)

public voidbuildTree(Instances data, boolean keepData)throwsException {

Instances [] localInstances;

if(keepData) {

m_train= data;

}

m_test= null;

m_isLeaf= false;

m_isEmpty= false;

m_sons= null;

m_localModel = m_toSelectModel.selectModel(data); //选择最优的分裂模型

if(m_localModel.numSubsets()> 1) {

localInstances = m_localModel.split(data); //对训练数据进行分组

data = null;

m_sons= newClassifierTree [m_localModel.numSubsets()]; //分配子树

for(inti = 0; i <m_sons.length; i++) {

m_sons[i] = getNewTree(localInstances[i]); //在子树对应的训练数据中构建树

localInstances[i]= null;

}

}else{

m_isLeaf= true;

if(Utils.eq(data.sumOfWeights(), 0))

m_isEmpty = true;

data = null;

}

从上述代码中可以看出tree的构建过程为：首先根据instances选择最优的分裂模型，然后根据选择的分裂属性将训练集进行分组，最后在子树中构建树。

在该过程中最重要也是最复杂的是选择分裂模型的过程，即m_toSelectModel.selectModel(data);下面我们分析该过程：

public finalClassifierSplitModel selectModel(Instances data) {

try {

checkDistribution= newDistribution(data);

noSplitModel= newNoSplit(checkDistribution);

//这个if语句是判断是否有足够的样本进行分裂，因为分裂至少要生成2个新的节点所以判断checkDistribution.total()是否小于2*m_minNoObj，第二个条件是判断是否所有的instance都属于同一个类，若是则checkDistribution.total()会与最大类的instance数量相等。

if (Utils.sm(checkDistribution.total(),2 *m_minNoObj)

|| Utils.eq(checkDistribution.total(),checkDistribution

.perClass(checkDistribution.maxClass())))

return noSplitModel;

//这里判断是否所有的属性都是nominal，第二个条件是是判断该属性是否有足够多的值

if (m_allData !=null) {

Enumerationenu = data.enumerateAttributes();

while (enu.hasMoreElements()){

attribute= (Attribute) enu.nextElement();

if((attribute.isNumeric())

||(Utils.sm((double) attribute.numValues(),

(0.3* (double)m_allData.numInstances())))){

multiVal= false;

break;

}

currentModel= new C45Split[data.numAttributes()];//currentModel存储了在每个属性上构建出的分裂模型，以便后面挑选最优的一个。

sumOfWeights= data.sumOfWeights();

// For each attribute.

for (i = 0; i <data.numAttributes(); i++) {

// Apart from class attribute.

if (i !=(data).classIndex()) {

// Get models for current attribute.

currentModel[i]= newC45Split(i,m_minNoObj,sumOfWeights,

m_useMDLcorrection);

currentModel[i].buildClassifier(data); //这里是在第i个属性上构建分裂模型，这也是最重要的一个过程。

// Check if useful split for current attribute

// exists and check for enumerated attributes with

// a lot of values.

if(currentModel[i].checkModel())

if (m_allData !=null) {

if((data.attribute(i).isNumeric())

||(multiVal || Utils.sm((double) data.attribute(i).numValues(),

(0.3* (double)m_allData.numInstances())))){

averageInfoGain= averageInfoGain+ currentModel[i].infoGain();

validModels++;

}

}else{

averageInfoGain= averageInfoGain

+currentModel[i].infoGain();

validModels++;

}

}else

currentModel[i]= null;

}

// Check if any useful split was found.

if (validModels == 0)

return noSplitModel; //如果没有有效的分裂过程则返回为分裂模型

averageInfoGain= averageInfoGain / (double) validModels;

// Find "best" attribute to split on.

minResult= 0;

for (i = 0; i <data.numAttributes(); i++) {

if ((i !=(data).classIndex())

&&(currentModel[i].checkModel()))

// Use 1E-3 here to get a closer approximation to the

// original

// implementation.

//对所有的属性都构建完分裂模型后，根据其信息增益率选择一个最大的即为最优模型

if ((currentModel[i].infoGain() >= (averageInfoGain - 1E-3))

&&Utils.gr(currentModel[i].gainRatio(), minResult)) {

bestModel= currentModel[i];

minResult= currentModel[i].gainRatio();

}

// Check if useful split was found.

if (Utils.eq(minResult,0))

return noSplitModel;

// Add all Instances with unknown values for thecorresponding

// attribute to the distribution for the model, so that

// the complete distribution is stored with the model.

bestModel.distribution().addInstWithUnknown(data,bestModel.attIndex());

// Set the split point analogue to C45 ifattribute numeric.

if (m_allData !=null)

bestModel.setSplitPoint(m_allData);

return bestModel;

}catch(Exception e) {

e.printStackTrace();

}

return null;

}

上述过程中最重要的是对一个属性创建分裂模型的过程，即currentModel[i].buildClassifier(data);该过程代码如下：

public voidbuildClassifier(Instances trainInstances) throws Exception {

// Initialize the remaining instance variables.

m_numSubsets = 0;

m_splitPoint = Double.MAX_VALUE;

m_infoGain = 0;

m_gainRatio = 0;

// Different treatment for enumerated and numeric

// attributes.

//分别处理不同类型的属性

if(trainInstances.attribute(m_attIndex).isNominal()) {

m_complexityIndex= trainInstances.attribute(m_attIndex).numValues();

m_index = m_complexityIndex;

handleEnumeratedAttribute(trainInstances);

}else{

m_complexityIndex= 2;

m_index = 0;

trainInstances.sort(trainInstances.attribute(m_attIndex));

handleNumericAttribute(trainInstances);

}

这里handleEnumerateAttribute和handleNumericAttribute是决定到底是哪一个属性分裂(m_attIndex)和分裂出几个子结点的函数(m_numSubsets)。这里的m_ complexityIndex就是指分可以分裂出多少子结点。Nominal类型属性根据其类中值的个数决定，如果是连续属性就是2。

我们首先看一下handleEnumeratedAttribute(trainInstances);

private voidhandleEnumeratedAttribute(InstancestrainInstances)

throws Exception {

Instanceinstance;

// m_complexityIndex指定应该分裂成几个分支，该值由该类中的值的个数决定

m_distribution = new Distribution(m_complexityIndex,trainInstances.numClasses());

// Only Instances with known values are relevant.

//只考虑无缺失值的样例

Enumerationenu = trainInstances.enumerateInstances();

while (enu.hasMoreElements()){

instance= (Instance) enu.nextElement();

if (!instance.isMissing(m_attIndex))

m_distribution.add((int) instance.value(m_attIndex), instance);

}

// Check if minimum number of Instances in at least two

// subsets.

if (m_distribution.check(m_minNoObj)) {

m_numSubsets = m_complexityIndex;

//计算信息增益

m_infoGain = infoGainCrit.splitCritValue(m_distribution, m_sumOfWeights);

//计算信息增益率

m_gainRatio = gainRatioCrit.splitCritValue(m_distribution, m_sumOfWeights,m_infoGain);

}

再来看一下handleNumericAttribute(trainInstances);

private voidhandleNumericAttribute(Instances trainInstances)

throws Exception {

// Current attribute is a numeric attribute.

m_distribution = new Distribution(2, trainInstances.numClasses());

// Only Instances with known values are relevant.

Enumerationenu = trainInstances.enumerateInstances();

i= 0;

while (enu.hasMoreElements()){

instance= (Instance) enu.nextElement();

if (instance.isMissing(m_attIndex))

break;

m_distribution.add(1,instance);

i++;

}

//由于前面已经将instances对属性m_attIndex进行排序，所以有缺失值的instance都在后面，也就是firstMiss是在m_attIndex上有确定值的样本个数＋1

firstMiss= i;

// Compute minimum number of Instances required in each

// subset.

minSplit= 0.1 * (m_distribution.total()) / ((double) trainInstances.numClasses());

if (Utils.smOrEq(minSplit,m_minNoObj))

minSplit= m_minNoObj;

else if (Utils.gr(minSplit,25))

minSplit= 25;

// Enough Instances with known values?

if (Utils.sm((double) firstMiss, 2 *minSplit))

return;

// Compute values of criteria for all possible split

// indices.

//计算分裂前的信息增益

defaultEnt= infoGainCrit.oldEnt(m_distribution);

while(next < firstMiss) {

//这里if语句是判断两个属性值是否太接近，若是那么选择的分裂点不会有太大的区别，就不进行处理。

if(trainInstances.instance(next - 1).value(m_attIndex) + 1e-5 < trainInstances

.instance(next).value(m_attIndex)) {

// Move class values for all Instances up to next

// possible split point.

//是把第一个bag中下标从last到next-1的样本移到第0个bag

m_distribution.shiftRange(1, 0,trainInstances, last, next);

// Check if enough Instances in each subset and compute

// values forcriteria.

//如果在2个bag中都满足最小分裂条件，则计算在当前分裂节点下的信息增益。

if (Utils.grOrEq(m_distribution.perBag(0),minSplit) && Utils.grOrEq(m_distribution.perBag(1), minSplit)) {

currentInfoGain= infoGainCrit.splitCritValue(m_distribution,m_sumOfWeights, defaultEnt);

if (Utils.gr(currentInfoGain,m_infoGain)) {

//记录下所有尝试过分裂节点的最大增益及分裂的节点

m_infoGain = currentInfoGain;

splitIndex= next - 1;

}

m_index++;

}

last= next;

}

next++;

}

// Was there any useful split?

if (m_index == 0)

return;

// Compute modified information gain for best split.

if (m_useMDLcorrection){

m_infoGain =m_infoGain - (Utils.log2(m_index) /m_sumOfWeights);

}

if (Utils.smOrEq(m_infoGain, 0))

return;

// Set instance variables' values to values for

// best split.

m_numSubsets = 2;

//分裂节点取为当前分裂点与下一属性值的中间值

m_splitPoint =(trainInstances.instance(splitIndex + 1).value(m_attIndex) +trainInstances.instance(splitIndex).value(m_attIndex)) / 2;

// In case wehave a numerical precision problem we need to choose the

// smaller value

if (m_splitPoint ==trainInstances.instance(splitIndex + 1).value(m_attIndex)) {

m_splitPoint =trainInstances.instance(splitIndex).value(m_attIndex);

}

// Restore distributioN for best split.

//将instances按照分裂点分组到2个bag中去

m_distribution = new Distribution(2,trainInstances.numClasses());

m_distribution.addRange(0,trainInstances, 0, splitIndex + 1);

m_distribution.addRange(1,trainInstances, splitIndex + 1, firstMiss);

// Compute modified gain ratio for best split.

//计算信息增益率

m_gainRatio = gainRatioCrit.splitCritValue(m_distribution, m_sumOfWeights,m_infoGain);

}

3.1.2树节点折叠Collapse

创建完树结构之后我们可以根据需要对树中节点进行分裂：

public finalvoidcollapse() {

double errorsOfSubtree;

double errorsOfTree;

int i;

if (!m_isLeaf) {

errorsOfSubtree= getTrainingErrors(); //计算以该节点为根的子树的训练误差

errorsOfTree= localModel().distribution().numIncorrect(); //计算以该节点为根的树的训练误差

//如果分裂后子树的训练误差更大，则取消对该节点的分裂，将该节点恢复为叶节点。

if (errorsOfSubtree >=errorsOfTree - 1E-3) {

// Free adjacent trees

m_sons = null;

m_isLeaf = true;

// Get NoSplit Model for tree.

m_localModel = newNoSplit(localModel().distribution());

}else

for (i = 0; i <m_sons.length; i++)

son(i).collapse(); //递归的处理子树

}

3.1.3树剪枝Prune：

剪枝过程为从叶节点向根节点进行，采用减少训练误差的方法进行剪枝。

该算法过程为：对任一个非叶节点计算3个误差值：将该节点作为叶节点的训练误差errorsLeaf，取该节点中具有最多样例个数的子树并计算其训练误差errorsLargestBranch，一概节点为根的整棵树的误差errorsTree。如果errorsLeaf最小则将该树剪枝并将该节点设为叶子节点；如果errorsLargestBranch最小则将该子树分支替换该节点；否则不进行剪枝。

下面结合代码分析：

public voidprune() throwsException {

double errorsLargestBranch;

double errorsLeaf;

double errorsTree;

int indexOfLargestBranch;

C45PruneableClassifierTreelargestBranch;

int i;

if (!m_isLeaf) {

// Prune all subtrees.

//递归剪枝子节点，这里可以保证从叶节点向上依次进行

for (i = 0; i <m_sons.length; i++)

son(i).prune();

// Compute error for largest branch

//计算包含最多instance的子树分支的训练误差

indexOfLargestBranch= localModel().distribution().maxBag();

if (m_subtreeRaising) {

errorsLargestBranch= son(indexOfLargestBranch).getEstimatedErrorsForBranch((Instances)m_train);

}else{

errorsLargestBranch= Double.MAX_VALUE;

}

// Compute error if this Tree would be leaf

//计算作为叶节点的训练误差

errorsLeaf= getEstimatedErrorsForDistribution(localModel().distribution());

// Compute error for the whole subtree

//计算以以该节点为根的树的训练误差

errorsTree= getEstimatedErrors();

// Decide if leaf is best choice.

//判断是否作为叶节点具有更小的误差

if (Utils.smOrEq(errorsLeaf,errorsTree + 0.1)

&&Utils.smOrEq(errorsLeaf, errorsLargestBranch + 0.1)) {

// Free son Trees

m_sons = null;

m_isLeaf = true;

// Get NoSplit Model for node.

m_localModel = newNoSplit(localModel().distribution());

return;

}

// Decide if largest branch is better choice

// than whole subtree.

//判断是否以子树取代具有更小的训练误差

if (Utils.smOrEq(errorsLargestBranch,errorsTree + 0.1)) {

largestBranch= son(indexOfLargestBranch);

m_sons = largestBranch.m_sons;

m_localModel =largestBranch.localModel();

m_isLeaf = largestBranch.m_isLeaf;

newDistribution(m_train);

prune();//递归的对该节点进行剪枝过程

}

3.2 样本分类

对样本分类主要调用方法distributionForInstance(Instance instance)进行，

public finaldouble[]distributionForInstance(Instance instance)

throws Exception {

returnm_root.distributionForInstance(instance,m_useLaplace);

}

这里从根节点开始递归的查找并计算该样例属于每个类的概率，概率最大的类即为该样例所属的类。

过程如下：

public finaldouble[]distributionForInstance(Instanceinstance,

boolean useLaplace)throws Exception {

double[] doubles =new double[instance.numClasses()];

//对每个类都要计算概率

for (int i = 0; i < doubles.length; i++) {

if (!useLaplace) {

doubles[i]= getProbs(i, instance, 1);

}else{

doubles[i]= getProbsLaplace(i, instance, 1);

}

return doubles;

}

getProbs主要代码如下：

private doublegetProbs(intclassIndex, Instance instance,double weight)

throws Exception {

double prob = 0;

//如该节点为叶节点的话直接计算其概率

if (m_isLeaf) {

return weight *localModel().classProb(classIndex, instance, -1);

}else{

//判断该instance属于哪一个子树

int treeIndex = localModel().whichSubset(instance);

if (treeIndex == -1) {

//这里表示该阳历属于多个子树，则计算其在所有子树中的概率和

double[] weights =localModel().weights(instance);

for (int i = 0; i <m_sons.length; i++) {

if (!son(i).m_isEmpty) {

prob+= son(i).getProbs(classIndex, instance, weights[i] * weight);

}

return prob;

}else{

//找到其对应的子树首先判断节点是否为空，然后计算概率

if (son(treeIndex).m_isEmpty) {

return weight * localModel().classProb(classIndex, instance,treeIndex);

}else{

return son(treeIndex).getProbs(classIndex,instance, weight);

}