Weka开发［20］——IB1源代码分析

转自 Koala++'s blog

      首先先解释一下算法名字，很多人很奇怪为什么叫IB1,IBK，IB Instance-Based的缩写，但按Jiawei Han书上所写，KNN其实是Instance-based learning(也被称为Lazing learning)中一种，他还讲解了基于案例的推理(Case-based reasoning)。算法其实是KNN，但是作者论文的名字是Instance-based Learning Algorithms。

我先介绍一下IB1，IB1就是只找一个邻居。我们还是先看buildClassifier。

public void buildClassifier(Instances instances) throws Exception {

 

    if (instances.classAttribute().isNumeric()) {

       throw new Exception("IB1: Class is numeric!");

    }

    if (instances.checkForStringAttributes()) {

       throw new UnsupportedAttributeTypeException(

              "IB1: Cannot handle string attributes!");

    }

    // Throw away training instances with missing class

    m_Train = new Instances(instances, 0, instances.numInstances());

    m_Train.deleteWithMissingClass();

 

    m_MinArray = new double[m_Train.numAttributes()];

    m_MaxArray = new double[m_Train.numAttributes()];

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

       m_MinArray[i] = m_MaxArray[i] = Double.NaN;

    }

       

    Enumeration enu = m_Train.enumerateInstances();

    while (enu.hasMoreElements()) {

       updateMinMax((Instance) enu.nextElement());

    }

}

       是的，KNN也有buildClassifier，听起来蛮奇怪的。第二个if，IB1不能对字符串属性进行学习，因为这种属性不好定义距离，比如a和ab是0.5还是1呢？然类别缺失的样本抛弃。m_MinArray和m_MaxArray分别保存每一个属性的最小值和最大值。最下面是对样本进行循环，找出最大值，最小值，updataMinMax代码如下：

private void updateMinMax(Instance instance) {

 

    for (int j = 0; j < m_Train.numAttributes(); j++) {

       if ((m_Train.attribute(j).isNumeric()) && 

           (!instance.isMissing(j))) {

           if (Double.isNaN(m_MinArray[j])) {

              m_MinArray[j] = instance.value(j);

              m_MaxArray[j] = instance.value(j);

           } else {

               if (instance.value(j) < m_MinArray[j]) {

                  m_MinArray[j] = instance.value(j);

               } else {

                  if (instance.value(j) > m_MaxArray[j]) {

                      m_MaxArray[j] = instance.value(j);

                  }

               }

           }

       }

    }

}

Double.isNaN(m_MinArray[j])判断是不是m_MinArray和m_MaxArray已经赋值过了，else，如果可以更新min和max更新。

再看一下classifyInstance函数：

public double classifyInstance(Instance instance) throws Exception {

 

    if (m_Train.numInstances() == 0) {

       throw new Exception("No training instances!");

    }

 

    double distance, minDistance = Double.MAX_VALUE, classValue = 0;

    updateMinMax(instance);

    Enumeration enu = m_Train.enumerateInstances();

    while (enu.hasMoreElements()) {

       Instance trainInstance = (Instance) enu.nextElement();

       if (!trainInstance.classIsMissing()) {

           distance = distance(instance, trainInstance);

           if (distance < minDistance) {

              minDistance = distance;

              classValue = trainInstance.classValue();

           }

       }

    }

 

    return classValue;

}

因为要进化归范化，所以对这个分类的样本再次调用updateMinMax。然后对训练样本进行循环，用distance计算与每一个样本的距离，如果比前面的距离小，则记录，最后返回与测试样本距离最小的样本的类别值。因为要进化归范化，所以对这个分类的样本再次调用updateMinMax。然后对训练样本进行循环，用distance计算与每一个样本的距离，如果比前面的距离小，则记录，最后返回与测试样本距离最小的样本的类别值。

        因为要进化归范化，所以对这个分类的样本再次调用updateMinMax。然后对训练样本进行循环，用distance计算与每一个样本的距离，如果比前面的距离小，则记录，最后返回与测试样本距离最小的样本的类别值。

private double distance(Instance first, Instance second) {

    double diff, distance = 0;

 

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

       if (i == m_Train.classIndex()) {

           continue;

       }

       if (m_Train.attribute(i).isNominal()) {

              // If attribute is nominal

           if (first.isMissing(i) || second.isMissing(i)

                  || ((int) first.value(i) != (int) second.value(i))) {

              distance += 1;

           }

       } else {

           // If attribute is numeric

           if (first.isMissing(i) || second.isMissing(i)) {

              if (first.isMissing(i) && second.isMissing(i)) {

                  diff = 1;

              } else {

                  if (second.isMissing(i)) {

                     diff = norm(first.value(i), i);

                  } else {

                     diff = norm(second.value(i), i);

                  }

                  if (diff < 0.5) {

                     diff = 1.0 - diff;

                  }

              }

           } else {

              diff = norm(first.value(i), i) - norm(second.value(i), i);

           }

           distance += diff * diff;

       }

    }

 

    return distance;

}

        和Jiawei Han书里面说的一样，对离散属性来说，两个样本任一在对应属性上为缺失值，距离为1，不相等相然还是为1。对于连续属性，如果两个都是缺失值，距离为1，其中之一在对应属性上为缺失值，把另一个不为缺失值的属性值规范化，距离为1-diff，意思就是设到可能的最远(当然那个缺失值比m_MinArray，m_MaxArray还小还大，这就不对了)。如果两个都有值，就把距离相加，最后平方。

为了完整性，将norm列出来：

private double norm(double x, int i) {

 

    if (Double.isNaN(m_MinArray[i])

           || Utils.eq(m_MaxArray[i], m_MinArray[i])) {

       return 0;

    } else {

       return (x - m_MinArray[i]) / (m_MaxArray[i] - m_MinArray[i]);

    }

}