C45算法代码实现及其详解

1.概述

C45算法在weka已经有具体的实现，即weka中的J48.java。不过J48.java中的具体代码牵扯到较多的类和其他东西，直接看源代码比较容易混乱，且需要了解的东西较多，有比较多和C45算法本身没有太大关系而是为了方便代码实现的类、变量和方法等。
本文是基于C45算法思想和对J48源代码的详细解读，自己写了一个C45算法的代码（之后均称为MyC45）。该代码只含有两个类（99%的代码只在一个类中实现），需要了解的结构相对简单，算法的实现过程相对清晰，算法的效果和J48.java相差无几，写在这里权作参考。
weka中的每个分类器的类文件都实现了buildClassifier和distributionForInstance两个算法，前者是构建分类器，后者是根据构建的分类器对每个实例进行类标记预测。所以，MyC45算法中主要分为建树（buildClassifier）和预测（distributionForInstance）两部分，其中建树（buildClassifier）是主体部分，预测（distributionForInstance）只是简单的利用前面构建好的树对每个实例进行预测。
特别说明，本文所使用的实例集均已进行数据预处理，所以在MyC45中没有J48中对缺失值的处理、判断J48能否处理该实例集等等对实例集的处理。

2.类及其变量说明

MyC45包括两个类，一个是MyC45，另一个是MyClassifierTree，它们的具体功能和变量说明如下：
1.MyC45：实现C45算法的类。
变量：
m_Root:C45决策树的根节点。
2.MyClassifierTree：具体实现C45算法中的建树和预测实例类标记两大部分的功能。
变量：
int[] m_AttributeList： 当前节点的可选分裂属性集合，以整数形式保存.-1表示当前节点不能选择该属性作为分裂属性。
int m_SplitAttribute：当前节点的分裂属性，以整数的形式表示。
int m_NumAttributes：训练实例集中属性的个数（包括类属性）。
MyCLassifierTree[] m_Sons：当前节点的儿子节点。
Instances m_Instances：当前节点对应的实例集。
int m_MinInstances：最小实例数，若当前节点对应的实例集的实例数小于该值，则当前节点只能作为叶节点。

注：以上是关键变量说明，类中其他变量并不是很重要就没有特别说明，在后面的代码中出现时会有说明。

3.伪代码

输入：训练实例集D，可选属性列表m_AttributeList，最小实例数m_MinInstances。
1.创建根节点m_root，m_AttributeList初始化为全0.
2.if D中的所有实例类标记都一样，则将m_root标记为叶节点并返回m_root。
3.if m_AttributeList为空，则将m_root标记为叶节点并返回m_root。
4.if m_Instances的实例数小于m_MinInstances，则将m_root标记为叶节点并返回m_root。
5.根据getBestSplitAttribute方法，在m_AttributeList中找出增益率最大的属性作为当前节点的分裂属性m_SplitAttribute。
6.根据m_SplitAttribute的属性值将当前节点的实例集m_Instances划分成多个子集，也就是当前节点的儿子节点 m_Sons。
7.对m_Sons中的每个节点递归地循环2-6的步骤以构建子树。
8.决策树构建好后，需要对其进行collapse处理和prune处理。前者是折叠子树过程，后者是后剪枝过程，具体说明在后面。

4.函数调用流程图

以下是各个部分的主要函数调用流程图，后面将对这些主要函数进行详细说明。

图1. buildClassifier部分的主要函数调用流程图

在MyC45类中的buildClassifier函数中，先初始化可选属性列表m_AttributeList和最小实例数m_MinInstances，然后用这两个参数初始化m_Root，之后再用m_Root调用MyClassifierTree类中的buildeClassifier函数即可。

图2. distributionForInstance部分的主要函数调用流程图

在MyC45类中的distributionForInstance函数中，直接用m_Root调用MyClassifierTree类中的distributionForInstance函数即可。

图3. 建树（buildTree）的主要函数调用流程图

建树首先根据isAllTheSame和canSplit两个函数和其他条件判断当前节点是否为叶节点；若可以分裂则调用getBestSplitAttribute函数求出最佳的分裂属性（也就是增益率最大的属性），getBestSplitAttribute函数中对每个可选属性分别调用beforeSplit、afterSplit和computeSplitInfo函数以求出该可选属性的增益率；随后将当前节点对应的实例集根据最佳分裂属性（即当前节点的分裂属性）分裂出多个子集，这些子集即为当前节点的子节点的实例集；然后对每个子集调用getNewTree函数以构建相应的子树，getNewTree函数中即调用buildTree函数，从而递归地构建决策树。

图4. 折叠子树（collapse）的主要函数调用流程图

collapse是对非叶节点进行操作，对于非叶节点，调用getCurrentTraningErrors求出当前节点的实例集上误分实例数，再调用getSubTraningErrors求出所有子树上实例集上误分实例数；如果后者大于前者，说明这些子树并不能提高这颗树的准确度，则把这些子树删除。否则在每个子树上递归的collapse。

图5. 后剪枝（prune）的主要函数调用流程图

prune是后剪枝操作，所以需要先递归找到叶节点的上一层的第一个子树开始剪枝。首先，调用getLargetBranch求出当前节点的最大树枝；随后，调用getEstimatedErrorsForBranch求出当前结点实例集在最大树枝上的误分实例数，标记为a；调用getEstimatedErrorsForDistribution求出当前节点的实例集在当前节点上的误分实例数，标记为b；调用getEstimatedErrors求出当前节点的所有子树上的误分实例数，标记为c。接着，判断是否应该把当前结点设置为叶节点，即第一个if语句。若不成立，则判断是否用最大树枝代替当前结点，即第二个if语句。若是，则将最大树枝上的变量信息覆盖当前结点的变量信息，并调用restInstances根据更改后的当前节点对当前实例集进行调整树的结构，并递归地对更改后的当前节点进行prune操作。

5.buildTree

isAllTheSame和canSplit函数比较简单，split就是根据属性值对实例集进行划分，getNewTree只是简单的初始化节点并调用buildTree形成递归，这些都比较简单，略过。

1.buildTree代码

    public void buildTree(Instances instances) throws Exception    {        initializePara(instances);//初始化一些变量        if (instances.numInstances()  <= m_MinInstances|| isAllTheSame(instances))         //小于m_MinInstances的实例集只能做叶节点，或当前实例集的类标记都一样也做叶节点,        {            m_IsLeaf = true;                   // 是则该节点为叶节点            m_Instances = instances;// 叶节点对应的实例集为instances            return;        }        if (!canSplit(m_AttributeList)) // 若可选属性集为空,则实例集不能继续分裂，所以当前节点是叶节点        {            m_IsLeaf = true;            m_Instances = instances;            return;        } else        {            int[] sonAttributeList = new int[m_NumAttributes];  //子节点的可选属性列表            for (int i = 0; i < sonAttributeList.length; i++)            {                if (i == m_ClassIndex)                    sonAttributeList[i] = -1;                else                    sonAttributeList[i] = m_AttributeList[i];            }            m_SplitAttribute = getBestSplitAttribute(instances, m_AttributeList); // 从当前可选的分裂属性集合中获取最佳的分裂属性            m_NameOfCurrentNode = instances.attribute(m_SplitAttribute).name(); // 获取当前分裂属性的名称            if (m_SplitAttribute != -1) // 当前实例集可以划分，且求得最佳分裂属性时            {                sonAttributeList[m_SplitAttribute] = -1; // 当前分裂属性在所有子节点上是不可选的，所以这里进行标记一下                int numOfSubTree = m_NumAttsValues[m_SplitAttribute];// 该节点对应的子节点数量，等于当前分裂属性的属性值个数                Instances[] localInstances;                localInstances = split(instances, numOfSubTree, m_SplitAttribute);// 根据分裂属性的属性值个数将实例集进行划分                m_NameOfLineToSon = new String[numOfSubTree];//每个子节点对应的属性值                for (int i = 0; i < numOfSubTree; i++)                    m_NameOfLineToSon[i] = m_Instances.attribute(m_SplitAttribute).value(i);                m_Sons = new MyCLassifierTree[numOfSubTree];                for (int i = 0; i < m_Sons.length; i++)                {// 接着为每一个localInstances构建子树                    m_Sons[i] = getNewTree(localInstances[i], sonAttributeList,m_MinInstances);                    localInstances[i] = null;                    if (m_Sons[i].m_IsLeaf)  //统计当前结点叶节点数                        m_NumLeaf ++;                }            } else// 当前实例集不可以划分，说明该节点是叶节点            {                m_IsLeaf = true;                m_Instances = instances;                return;            }        }    }

2.getBestSplitAttribute

    /**     * 从当前可选属性列表中求出最佳分裂属性，即增益率最大的属性     * @param instances     * @param attributesList     * @return     */    public int getBestSplitAttribute(Instances instances, int[] attributesList)    {        int bestSplitAttribute = 0; //标记最佳分裂属性        boolean canSplit = false; //判断该实例集是否可以继续划分        double[] gainRatio = new double[m_NumAttributes ]; //增益率，        double[] infoGain =  new double[m_NumAttributes ]; //信息增益，        double[] splitInfo =  new double[m_NumAttributes ]; //分裂信息，        for (int i = 0; i < m_NumAttributes ; i++) //遍历属性，计算每个属性增益率        {            if (i != m_ClassIndex && attributesList[i] != -1)//对可选的非类属性进行计算增益率            {                infoGain[i] = beforeSplit(instances) - afterSplit(instances,i);                splitInfo[i] = computeSplitInfo(instances,i);                gainRatio[i] = infoGain[i] / splitInfo[i];                canSplit = true; //当进入增益率计算时，说明该实例集可以进行划分            }            else             {                gainRatio[i] = 0;                infoGain[i] = 0;                splitInfo[i] = 0;            }        }        if (canSplit)        {  //若可以分裂，则找出gainRatio数组中最大且attributesList数组中不等于-1的下标，即为最佳分裂属性            bestSplitAttribute = getMaxIndex(gainRatio,attributesList);        }        else {//若当前实例集无法继续分裂，则返回-1作为没有找到最佳分裂属性的标记            bestSplitAttribute = -1;        }        return bestSplitAttribute;    }

getBestSplitAttribute是通过计算增益率求出的，以下下是计算增益率的一些公式：
（1）GainRito（A） = Gain（A）/SplitInfo（A）
GainRito（A）：属性A的增益率。
Gain（A）：属性A 的信息增益。
SplitInfo（A）：属性A的分裂信息量。

（2）Gain（A） = Info（Insts） - Info（Insts，A）
Info（Insts）：实例集Insts分裂前的信息量。
Info（Insts，A）：实例集Insts根据属性A分裂后的信息量。

（3）
C：实例集Insts中的类标记个数。
Pi：第i种类标记对应的实例数与实例总数的比值。

（4）
nA：属性A的属性值个数。
n：实例集的实例总数。
ni：属性A的第i种属性值对应的实例数。
Instsi：属性A的第i种属性值对应的实例集。
Info(Instsi):根据公式（3）计算属性A的第i种属性值对应的实例集的信息量。

（5）

3.beforeSplit

    /**     * 计算分裂前实例集的信息值     * @param instances     * @return     */    public double beforeSplit(Instances instances)    {        double infoBeforeSplit = 0;        int numClasses = instances.numClasses();        int numInstances = instances.numInstances(); //实例总数        double allWeight = 0;                                                 //实例集instances中的实例数（权重之和）        double[] numInstancesInClass = new double[numClasses];//每个类标记对应的实例数（权重）        for (int i = 0; i < numInstances; i++) //遍历每个实例，统计出每个类标记对应的实例数（权重）        {            int classLable = (int)instances.instance(i).classValue();            numInstancesInClass[classLable] += instances.instance(i).weight();             allWeight += instances.instance(i).weight();        }        if (onlyOneNotZero(numInstancesInClass,allWeight))//1.如果只有一个类标记的实例数（权重）不为0（其他类标记的实例数（权重）为0），则信息值为0            return 0.0;        if (eachEqualAve(numInstancesInClass))//2.如果所有类标记对应的实例数（权重）相等，则信息值最大，这里设置为1            return 1.0;        for (int i = 0; i < numClasses; i++) //3.根据公式（3）求出实例集的信息值        {            double pi = numInstancesInClass[i] / allWeight;            if (pi != 0.0) //注意pi为0时不要纳入计算，因为log0是一个无效值，这会导致整个infoBeforeSplit值无效（NaN）。反正pi等于0时 pi * log2(pi)即为0，所以不纳入计算即可                infoBeforeSplit = infoBeforeSplit + pi * log2(pi) ;        }        return - infoBeforeSplit; //注意加个负号    }

4.afterSplit

    /**     * 计算实例集根据属性attribute进行分裂后的信息量     * @param instances     * @param attribute     * @return     */    public double afterSplit(Instances instances, int attribute)    {        double infoAfterSplit = 0;        int numAttributeValue = instances.attribute(attribute).numValues(); //属性attribute的属性值个数        int numInstances = instances.numInstances(); // 实例总数        double allWeight = 0; ////实例集instances中的实例数权重之和        double[] weightInAttValue = new double[numAttributeValue];//每个属性值对应的实例数（权重之和）        Instances[] instsOfValue = new Instances[numAttributeValue];//每个属性值对应的实例子集        for (int i = 0; i < instsOfValue.length; i++)//初始化            instsOfValue[i] = new Instances(instances, 0);        for (int i = 0; i < numInstances; i++)//遍历实例集，将实例集instances根据属性值划分实例集，统计每个实例集的实例数（权重）        {            int attValue = (int)instances.instance(i).value(attribute); //获取第i个实例在属性attribute中的属性值            weightInAttValue[attValue] += instances.instance(i).weight(); //计算每个属性值对应的实例数（权重之和）            allWeight +=  instances.instance(i).weight();  //计算实例集instances中的实例权重之和            instsOfValue[attValue].add(instances.instance(i)); //将实例i放入对应的实例子集之中        }        for (int i = 0; i < numAttributeValue; i++)//根据公式（4）计算根据属性i分裂后的实例集的信息值        {            double value = weightInAttValue[i]/allWeight * beforeSplit(instsOfValue[i]);            infoAfterSplit = infoAfterSplit + value;        }        return infoAfterSplit;    }}

5.computeSplitInfo

    /**     * 计算分裂信息量     * @param instances     * @param attribute     * @return     */    public double computeSplitInfo(Instances instances, int attribute)    {        double splitInfo = 0;        double allWeight = 0; ////实例集instances中的实例数（权重之和）        int numAttributeValue = instances.attribute(attribute).numValues(); //属性attribute的属性值个数        double[] weightInEachValue = new double[numAttributeValue]; //每个属性值对应的实例数（权重之和）        for (int i = 0; i < instances.numInstances(); i++)        {            int  attValue = (int)instances.instance(i).value(attribute); //获取第i个实例在属性attribute中的属性值            weightInEachValue[attValue] += instances.instance(i).weight(); //计算每个属性值对应的实例数（权重之和）            allWeight += instances.instance(i).weight(); //计算实例集instances中的实例数（权重之和）        }        for (int i = 0; i < numAttributeValue; i++) //根据公式（5）计算分裂信息值        {            double pi = weightInEachValue[i] / allWeight;            if (pi != 0)//注意pi为0时不要纳入计算，因为log0是一个无效值，这会导致整个splitInfo值无效。                splitInfo = splitInfo +pi* log2(pi);        }        return  - splitInfo; //注意加个负号    }

6.collapse

1.collapse

    /**     * Collapses a tree to a node if training error doesn't increase.     * 如果当前节点存在很多子节点，但这些子节点并不能提高这颗分类树的准确度，则把这些孩子节点删除。否则在每个孩子上递归的collapse。     * 通过collapse方法可以在不减少精度的前提下减少决策树的深度，进而提高效率。     */    public final void collapse( )    {        double errorsOfTree;       // 当前节点上训练实例集误分的实例数（权重）        double errorsOfSubtree; // 当前节点的所有子树上训练实例集误分的实例数（权重）        int i;        if (!m_IsLeaf)//只有对非叶节点才进行折叠子树操作        {               errorsOfTree = getCurrentTrainingErrors();              errorsOfSubtree = getSubTrainingErrors();            if (errorsOfSubtree >= errorsOfTree - 1E-3)                //所有子树上误分实例数（权重）大于当前节点误分实例数（权重）时，说明这些孩子节点不好，将他们删除。                //删除的方式是将当前节点 的子树变量设置为空并将该节点设置为叶节点。1E-3是10的-3次方，即0.001             {                m_Sons = null;                m_IsLeaf = true;            }            else                for (i = 0; i < m_Sons.length; i++) // 在每个孩子上递归地进行折叠子树操作                    m_Sons[i].collapse();        }    }

2.getCurrentTrainingErrors

    /**     * 计算当前结点的误分实例数     * @return     */    private double getCurrentTrainingErrors()    {        double wrongWeight = 0;        int majorityClassLable = majorityClassLable(m_Instances); //获取当前实例集中的多数类        for (int i = 0; i < m_Instances.numInstances(); i++)  //遍历当前实例集，求出总误分实例数（权重）        {            int classValue = (int)m_Instances.instance(i).classValue();            if (classValue != majorityClassLable)            {                m_Predictions[i] = -1;                wrongWeight += m_Instances.instance(i).weight();            }        }        return wrongWeight;    }

3.getSubTrainingErrors

    /**     * 计算当前结点的所有子节点中误分的实例数（权重）     * @return     */    private double getSubTrainingErrors()    {        double errors = 0;        if (m_IsLeaf)   //对叶节点，直接调用getCurrentTrainingErrors函数求出该叶节点上的误分实例数（权重）            return getCurrentTrainingErrors();        else //对非叶节点，递归调用getSubTrainingErrors以求出所有子节点上的误分实例数（权重）        {            for (int i = 0; i < m_Sons.length; i++)                errors = errors + m_Sons[i].getSubTrainingErrors();            return errors;        }    }

7.prune

1.prune

    /**     * 后剪枝操作     * @throws Exception     */    public final void prune( ) throws Exception    {        double errorsLargestBranch; //当前节点实例集在最大树枝上的误分实例数        double errorsLeaf;                     //假设当前节点是叶节点时，该节点对应的实例集在该节点上的误分实例数        double errorsTree;                     //计算当前节点的所有子树上的误分实例数        int indexOfLargestBranch;     //最大树枝的下标        MyCLassifierTree largestBranch;  //临时保存最大树枝        int i;        if (!m_IsLeaf) //对非叶节点均进行剪枝        {            for (i = 0; i < m_Sons.length; i++)// 对当前节点的子节点递归地进行剪枝，由于是后剪枝，所以从树的最底层开始往上                m_Sons[i].prune();            // 求出当前树上的最大树枝，即当前节点的所有子集中实例数最大的子集下标，            indexOfLargestBranch = getLargetBranch();            // 计算当前节点实例集在最大树枝上的误分实例数            errorsLargestBranch = m_Sons[indexOfLargestBranch].getEstimatedErrorsForBranch(m_Instances);            //计算当前节点对应的实例集在当前节点上的误分实例数            errorsLeaf = getEstimatedErrorsForDistribution(m_Instances);            // 计算当前节点的所有子树上的误分实例数            errorsTree = getEstimatedErrors();            // 判断将该节点设置为叶节点是不是最好的选择，            if (Utils.smOrEq(errorsLeaf, errorsTree + 0.1) && Utils.smOrEq(errorsLeaf, errorsLargestBranch + 0.1))            {                m_Sons = null;                m_IsLeaf = true;                return;            }            // 判断用最大树枝代替当前节点是不是最好的选择            if (Utils.smOrEq(errorsLargestBranch, errorsTree + 0.1))            {                largestBranch = m_Sons[indexOfLargestBranch];  //获取最大树枝                m_Sons = largestBranch.m_Sons;                   m_AttributeList = largestBranch.m_AttributeList;   //将最大树枝的可选分裂属性列表覆盖当前节点的可选分裂属性列表                m_AttributeList[m_SplitAttribute] = 0;                        //由于会用最大树枝的分裂属性代替了原先节点的分裂属性，所以原先节点的分裂属性处于可选状态                m_SplitAttribute = largestBranch.m_SplitAttribute;  //用最大树枝的分裂属性代替了原先节点的分裂属性                m_IsLeaf = largestBranch.m_IsLeaf;                resetInstances(m_Instances);  //将当前实例集根据修改后的分裂属性进行划分                prune(); //递归地对修改后的节点进行剪枝            }        }    }

2.getEstimatedErrorsForDistribution

    /**     * 求出testInstances实例集在以m_Instances为根据的分类器中的误分实例数（权重）     * @param theDistribution     *            the distribution to use     * @return the estimated errors     */    private double getEstimatedErrorsForDistribution(Instances testInstances)    {        if (Utils.eq(testInstances.numInstances(), 0)) //若testInstances实例数为0，则误分实例数只能为0            return 0;        else        {            double inCorrectWeight = 0;            double allWeight = 0.0;            int majorityClassLable ;            majorityClassLable = majorityClassLable(m_Instances);//求出当前实例集m_Instances中的多数类            for (int i = 0; i < testInstances.numInstances(); i++)            {                allWeight += testInstances.instance(i).weight(); //统计测试实例集testInstances中的实例总数（权重）                int classVlaue = (int)testInstances.instance(i).classValue();                if (classVlaue != majorityClassLable)                    inCorrectWeight += testInstances.instance(i).weight(); //统计测试实例集testInstances中误分实例的实例总数（权重）            }            return inCorrectWeight +  Stats.addErrs(allWeight,inCorrectWeight, 0.25f);         }    }

3.getEstimatedErrorsForBranch

    /**     *  求出testInstances实例集在以m_Instances为根据的分类器中的误分实例数（权重）     * @param data     *            the data to work with     * @return the estimated errors     * @throws Exception     *             if something goes wrong     */    private double getEstimatedErrorsForBranch(Instances testInstances) throws Exception    {        double errors = 0;        int i;        if (m_IsLeaf) //若当前节点是叶节点，则调用getEstimatedErrorsForDistribution求出当前节点上的误分实例数            return getEstimatedErrorsForDistribution(testInstances);        else //若当前节点不是叶节点，则计算testInstances在其所有子节点上的误分实例数之和        {            //将testInstances根据当前节点的分裂属性的属性值，划分成不同的测试实例集            int numSubset = testInstances.attribute(m_SplitAttribute).numValues();            Instances[] localInstances = split(testInstances, numSubset, m_SplitAttribute);//测试实例子集            for (i = 0; i < m_Sons.length; i++) //计算每个测试实例子集在对应子节点上的误分实例数（权重）                errors = errors + m_Sons[i].getEstimatedErrorsForBranch(localInstances[i]);            return errors;        }    }

4.getEstimatedErrors

    /**     *计算当前结点的所有子树上的误分实例数（权重）     * @return the estimated errors     */    private double getEstimatedErrors()    {        double errors = 0;        int i;        if (m_IsLeaf)  //若当前结点是叶节点，则直接计算误分实例树（权重）            return getEstimatedErrorsForDistribution(m_Instances);        else        {            for (i = 0; i < m_Sons.length; i++)  //若当前节点不是叶节点，则递归地计算其所有子树上的误分实数（权重）                errors = errors + m_Sons[i].getEstimatedErrors();            return errors;        }    }

5.resetInstances

    /**     * 将当前实例集根据修改后的分裂属性进行划分，并修改预测结果数组m_Prediction[]     * @param instances     * @throws Exception      */    private void resetInstances(Instances instances) throws Exception    {        m_Instances = instances;        if (!m_IsLeaf) //若当前节点不是叶子节点，则递归地对其及其子树进行重新划分实例集        {            int numSubset = (int)instances.attribute(m_SplitAttribute).numValues();            Instances[] localInstances = split(instances, numSubset, m_SplitAttribute);            for (int i = 0; i < m_Sons.length; i++)//递归地对其子树进行重新划分实例集            {                m_Sons[i].m_Instances = localInstances[i];                   m_Sons[i].resetInstances(localInstances[i]);            }        }        else        {//由于实例集发生了变化，所以需要根据新实例集和新的可选分裂属性列表构建树            m_AttributeList[m_SplitAttribute] = -1;  //在当前节点上建树，则当前分裂属性在其子树的构建过程中不可选            m_IsLeaf = false;            int numSubset = (int)instances.attribute(m_SplitAttribute).numValues();   //此时是在各个子节点上建树            Instances[] localInstances = split(instances, numSubset, m_SplitAttribute);            m_Sons = new MyCLassifierTree[numSubset];            for (int i = 0; i < localInstances.length; i++)            {                m_Sons[i] = getNewTree(localInstances[i], m_AttributeList, m_MinInstances);            }        }    }