Weka算法Classifier-trees-RandomTree源码分析

一、RandomTree算法

在网上搜了一下，并没有找到RandomTree的严格意义上的算法描述，因此我觉得RandomTree充其量只是一种构建树的思路，和普通决策树相比，RandomTree会随机的选择若干属性来进行构建而不是选取所有的属性。

Weka在实现上，对于随机属性的选取、生成分裂点的过程是这样的：

1、设置一个要选取的属性的数量K

2、在全域属性中无放回的对属性进行抽样

3、算出该属性的信息增益（注意不是信息增益率）

4、重复K次，选出信息增益最大的当分裂节点。

5、构建该节点的孩子子树。

二、具体代码实现

（1）buildClassifier

 public void buildClassifier(Instances data) throws Exception {    // 如果传入的K不合理，把K放到一个合理的范围里    if (m_KValue > data.numAttributes() - 1)      m_KValue = data.numAttributes() - 1;    if (m_KValue < 1)      m_KValue = (int) Utils.log2(data.numAttributes()) + 1;//这个是K的默认值    // 判断一下该分类器是否有能力处理这个数据集，如果没能力直接就在testWithFail里抛异常退出了    getCapabilities().testWithFail(data);    // 删除掉missClass    data = new Instances(data);    data.deleteWithMissingClass();    // 如果只有一列，就build一个ZeroR模型，之后就结束了。ZeroR模型分类是这样的：如果是连续型，总是返回期望，如果离散型，总是返回训练集中出现最多的那个    if (data.numAttributes() == 1) {      System.err          .println("Cannot build model (only class attribute present in data!), "              + "using ZeroR model instead!");      m_zeroR = new weka.classifiers.rules.ZeroR();      m_zeroR.buildClassifier(data);      return;    } else {      m_zeroR = null;    }    // 如果m_NumFlods大于0，则会把数据集分为两部分，一部分用于train，一部分用于test，也就是backfit

    //分的方式和多折交叉验证是一样的，例如m_NumFlods是10的话，则train占90%，backfit占10%    Instances train = null;    Instances backfit = null;    Random rand = data.getRandomNumberGenerator(m_randomSeed);    if (m_NumFolds <= 0) {      train = data;    } else {      data.randomize(rand);      data.stratify(m_NumFolds);      train = data.trainCV(m_NumFolds, 1, rand);      backfit = data.testCV(m_NumFolds, 1);    }    // 生成所有的可选属性    int[] attIndicesWindow = new int[data.numAttributes() - 1];    int j = 0;    for (int i = 0; i < attIndicesWindow.length; i++) {      if (j == data.classIndex())        j++; // 忽略掉classIndex      attIndicesWindow[i] = j++;//这段代码有点奇怪，i和j是相等的，为啥不用attIndicesWindow=i?    }    // 算出每个class的频率，也就是每个分类出现的次数（更正确的说法应该是权重，但权重默认都是1）    double[] classProbs = new double[train.numClasses()];    for (int i = 0; i < train.numInstances(); i++) {      Instance inst = train.instance(i);      classProbs[(int) inst.classValue()] += inst.weight();    }    // Build tree    m_Tree = new Tree();    m_Info = new Instances(data, 0);    m_Tree.buildTree(train, classProbs, attIndicesWindow, rand, 0);//调用tree的build方法,在后面单独分析    // Backfit if required    if (backfit != null) {      m_Tree.backfitData(backfit);//在后面单独分析    }  }

这个Tree对象是RandomTree的一个子类，之前我还以为会复用其余的决策树模型（比如J48），但weka没这么做，很惊奇的是RandomTree和J48的作者还是同一个，不知道为啥这么设计。

（2）tree.buildTree

 protected void buildTree(Instances data, double[] classProbs,        int[] attIndicesWindow, Random random, int depth) throws Exception {      //首先判断一下是否有instance，如果没有的话直接就返回      if (data.numInstances() == 0) {        m_Attribute = -1;        m_ClassDistribution = null;        m_Prop = null;        return;      }      m_ClassDistribution = classProbs.clone();      if (Utils.sum(m_ClassDistribution) < 2 * m_MinNum          || Utils.eq(m_ClassDistribution[Utils.maxIndex(m_ClassDistribution)],              Utils.sum(m_ClassDistribution))          || ((getMaxDepth() > 0) && (depth >= getMaxDepth()))) {        // 递归结束的条件有3个 1、instance数量小于2*m_Minnum  2、instance都已经在同一个类中 3、达到最大的深度

       //前两个条件和j48的递归结束条件很相似，相关内容可参考我之前的几篇博客。        m_Attribute = -1;        m_Prop = null;        return;      }      double val = -Double.MAX_VALUE;      double split = -Double.MAX_VALUE;      double[][] bestDists = null;      double[] bestProps = null;      int bestIndex = 0;      double[][] props = new double[1][0];      double[][][] dists = new double[1][0][0];//这个数组第一列只有下标为0的被用到，不知道为啥这么设计      int attIndex = 0;//存储被选择到的属性      int windowSize = attIndicesWindow.length;//存储目前可选择的属性的数量      int k = m_KValue;//k代表还能选择的属性的数量      boolean gainFound = false;//是否发现了一个有信息增益的节点      while ((windowSize > 0) && (k-- > 0 || !gainFound)) {//此循环退出条件有2个 1、没有节点可以选了 2、已经选了k个属性了并且找到了一个有用的属性 换句话说，如果K次迭代没有找到可以分裂的随机节点，循环也会继续下去

        int chosenIndex = random.nextInt(windowSize);//随机选一个，生成下标        attIndex = attIndicesWindow[chosenIndex];//得到该属性的index       //下面三行把选择的属性放到attIndicesWindow的末尾，然后把windowSize-1这样下个循环就不会选到了，也就是实现了无放回的抽取        attIndicesWindow[chosenIndex] = attIndicesWindow[windowSize - 1];        attIndicesWindow[windowSize - 1] = attIndex;        windowSize--;        double currSplit = distribution(props, dists, attIndex, data);//这个函数计算了在使用attIndex进行分裂所产生的分布，如果classIndex是连续值的话，还计算了分裂点，原理和J48的split一样，不在赘述。        double currVal = gain(dists[0], priorVal(dists[0]));//这个计算了信息增益        if (Utils.gr(currVal, 0))          gainFound = true;//如果信息增益大于0的话，说明节点有效，设置gainFound        if ((currVal > val) || ((currVal == val) && (attIndex < bestIndex))) {          val = currVal; //如果信息增益大的话，则更新把attIndex更新为bestIndex，这是为了选取最优的节点（ID3）的方法          bestIndex = attIndex;          split = currSplit;          bestProps = props[0];          bestDists = dists[0];        }      }      m_Attribute = bestIndex;      // Any useful split found?      if (Utils.gr(val, 0)) { <span style="white-space:pre"></span>//如果找到了一个分裂点，则在该分裂点的基础上构建子树

        m_SplitPoint = split;        m_Prop = bestProps;        Instances[] subsets = splitData(data);        m_Successors = new Tree[bestDists.length];        for (int i = 0; i < bestDists.length; i++) {          m_Successors[i] = new Tree();          m_Successors[i].buildTree(subsets[i], bestDists[i], attIndicesWindow,              random, depth + 1);//注意这里传入的attIndicesWindow没有变，换句话说，每次迭代传入的可选属性集合是一样的，因此子节点在进行属性的random选择时，很有可能会选择到父节点已经选过的节点，但因为不产生信息增益，因此不会再次作为bestIndex，但会产生额外的计算量（我感觉还不少），这里还有一定的优化空间，同理j48也是这么实现的。        }        boolean emptySuccessor = false;        for (int i = 0; i < subsets.length; i++) {          if (m_Successors[i].m_ClassDistribution == null) {            emptySuccessor = true;            break;          }        }        if (!emptySuccessor) {          m_ClassDistribution = null;        }      } else {       //这个else是<span style="font-family: Arial, Helvetica, sans-serif;">Utils.gr(currVal, 0)这个条件的，代表没有选择到合适的分裂节点</span>        m_Attribute = -1;      }    }

（3）tree.backfit

什么是Backfit?Backfit将改变已有tree节点及其子节点的class分布，而class分布将直接被用于实例的预测。

直接使用RandomTree有时会出现过拟合的现象（通过代码可以看到，和J48相比没有剪枝过程），因此通过传入一个新的数据集来backfit已有节点是一个解决过拟合的方法。

  protected void backfitData(Instances data, double[] classProbs)        throws Exception {

<span style="white-space:pre"></span>//判断一下是否有数据      if (data.numInstances() == 0) {        m_Attribute = -1;        m_ClassDistribution = null;        m_Prop = null;        return;      }      m_ClassDistribution = classProbs.clone();      if (m_Attribute > -1) {        // m_Attribut>-1代表不是leaf，可以看上面的buildTree得出这个结论        m_Prop = new double[m_Successors.length];//子节点数组的length也就是分类的类的数量

<span style="white-space:pre"></span>//把传入的data用此节点算各类的频率        for (int i = 0; i < data.numInstances(); i++) {          Instance inst = data.instance(i);          if (!inst.isMissing(m_Attribute)) {            if (data.attribute(m_Attribute).isNominal()) {              m_Prop[(int) inst.value(m_Attribute)] += inst.weight();            } else {              m_Prop[(inst.value(m_Attribute) < m_SplitPoint) ? 0 : 1] += inst                  .weight();//连续型只会分两类，小于splitPoint一类，大于是一类，和J48采用的策略相同            }          }        }        if (Utils.sum(m_Prop) <= 0) {          m_Attribute = -1;//如果data全部都是missingValue，则把此节点变成leaf节点          m_Prop = null;          return;        }        // 归一化        Utils.normalize(m_Prop);        // 根据本节点算出在data上进行分类的subset        Instances[] subsets = splitData(data);        for (int i = 0; i < subsets.length; i++) {          // 递归的对孩子节点进行backfit          double[] dist = new double[data.numClasses()];          for (int j = 0; j < subsets[i].numInstances(); j++) {            dist[(int) subsets[i].instance(j).classValue()] += subsets[i]                .instance(j).weight();          }          m_Successors[i].backfitData(subsets[i], dist);        }<span style="white-space:pre"></span>        if (getAllowUnclassifiedInstances()) {          m_ClassDistribution = null;          return;        }<span style="white-space:pre"></span>//如果某个子节点的分布为空的话，则父节点要保存分布，否则不需要持有分布。

 <span style="white-space:pre"></span>//为什么呢？因为使用RandomTree进行预测时会遍历节点的分布并进行累加，得到分布最大的class作为预测class，在J48的那篇博客中有分析        boolean emptySuccessor = false;        for (int i = 0; i < subsets.length; i++) {          if (m_Successors[i].m_ClassDistribution == null) {            emptySuccessor = true;            return;          }        }        m_ClassDistribution = null;      }    }

三、总结

对RandomForest的分析到这里就结束了，首先分析了RandomForest，接着分析了Bagging，最后分析了RandomTree。