Weka算法Clusterers-Xmeans源码分析_x-means聚类过程-优快云博客

转自：http://blog.youkuaiyun.com/roger__wong/article/details/39755615

http://blog.youkuaiyun.com/roger__wong/article/details/39617309

[java]view plaincopy 
   
 <p></p><p><span style="font-size:18px">上几篇博客都是分析的分类器算法（有监督学习），这次就分析一个聚类算法（无监督学习）。</span></p><p><span style="font-size:18px"></span></p><p><span style="font-size:18px">一、算法</span></p><p><span style="font-size:18px">Xmeans算法基本就是大名鼎鼎的K-means算法，然后Weka做了一点“小”改进，使之能自动确定聚类数量，那么首先就说一下K-means算法。顺便说一下Weka原生的Kmeans算法是SimpleKMeans聚类器。</span></p><p><span style="font-size:18px">K-means算法是属于典型的简单但有有效的算法，具有非常直观的美感，其过程如下：</span></p><p><span style="font-size:18px">输入：聚类数量K，以及数据集data</span></p><p><span style="font-size:18px">1、随机选取K个点作为聚类中心</span></p><p><span style="font-size:18px">2、对于数据集中每个用例，找出离其最近的聚类中心i，将这个用例归到第i类。</span></p><p><span style="font-size:18px">3、对于每个分类，重新计算聚类中心</span></p><p><span style="font-size:18px">4、重复2和3，直到达到迭代退出的条件。</span></p><p><span style="font-size:18px">K-means的时间复杂度是O(snk)，其中s是迭代次数，和退出迭代的条件选取有关，n是数据集数量，k是聚类的数量，可以看出，在聚类数量要求不多的情况下，算法还是比较高效的。</span></p><p><span style="font-size:18px">但K-means的缺点以下两个：</span></p><p><span style="font-size:18px">1、不稳定，最后聚类结果和初始的聚类中心之间有很大关系。</span></p><p><span style="font-size:18px">2、只能处理连续值，无法处理离散值。</span></p><p><span style="font-size:18px">针对1，产生了K-means的扩展K-means++算法，针对2，则有K-modes算法以及K-prototype算法，有兴趣的读者可以去搜一下，这里不展开说了。</span></p><p><span style="font-size:18px">K-means算法的关键有以下几点：</span></p><p><span style="font-size:18px">1、如何计算各用例之间的“距离”</span></p><p><span style="font-size:18px">2、所谓的“迭代退出条件”是什么</span></p><p><span style="font-size:18px">3、如何确定聚类中心</span></p><p><span style="font-size:18px">4、在实现过程中有没有一些用来提高效率的trick</span></p><p><span style="font-size:18px">本篇博客在分析源码时将着重去解决以上4个问题。</span></p><p><span style="font-size:18px"></span></p><p><span style="font-size:18px">二、源码</span></p><p><span style="font-size:18px">weka.clusterers.Xmeans继承自RandomizableClusterer类（从名字来猜测是不稳定的聚类器，其可以传入一个随机数种子），而后者又继承自AbstractClusterer（含有两个关键的虚方法buildClusterer和clusterInstance），因此我们着重分析Xmeans对buildClusterer和clusterInstance的实现</span></p><p><span style="font-size:18px">Xmeans方法只能处理连续型数值、日期、以及MissingValue，可以从getCapabilities中看到。</span></p><p><span style="font-size:18px"></span></p><p><span style="font-size:18px">1、buildCLusterer</span></p><p><span style="font-size:18px">该方法接受Instances作为参数，作用是训练聚类模型。</span></p><p><span style="font-size:18px"></span></p><pre name="code" class="java"> public void buildClusterer(Instances data) throws Exception {  
   
     // 先测一下这个data的属性是否能处理。  
     getCapabilities().testWithFail(data);  
     //这两个是最小聚类数量和最大聚类数量  

[java]view plaincopy 
   
 if (m_MinNumClusters > m_MaxNumClusters) {  
   throw new Exception("XMeans: min number of clusters "  
       + "can't be greater than max number of clusters!");  
 }  
   
 m_NumSplits = 0;  
 m_NumSplitsDone = 0;  
 m_NumSplitsStillDone = 0;  
   
 // 替换掉MissingValue，如果是数值型，则替换为平均值，如果是枚举型，则替换为出现最多的那个值  

[java]view plaincopy 
   
 // 这里可以算预处理数据时的一个小技巧  
 m_ReplaceMissingFilter = new ReplaceMissingValues();  
 m_ReplaceMissingFilter.setInputFormat(data);  
 m_Instances = Filter.useFilter(data, m_ReplaceMissingFilter);  
   
 // 设定一个随机种子  
 Random random0 = new Random(m_Seed);  
   
 // 聚类数量从最小聚类数量开始，这个值默认是2  
 m_NumClusters =  m_MinNumClusters;  
   
 //这里是默认的算距离的方法,可以传入自定义的函数，默认使用欧式距离。  
 if (m_DistanceF == null) {  
   m_DistanceF = new EuclideanDistance();  
 }  
 //这两个函数都没实现，不知道放这里的用意是什么  
 m_DistanceF.setInstances(m_Instances);  
 checkInstances();  
 nbsp;  

[java]view plaincopy 
   
 //测试相关，暂时忽略  
 if (m_DebugVectorsFile.exists() && m_DebugVectorsFile.isFile())  
   initDebugVectorsInput();  
   
 // allInstList存放所有Instances的下标  
 int[] allInstList = new int[m_Instances.numInstances()];   
 for (int i = 0; i < m_Instances.numInstances(); i++) {  
   allInstList[i] = i;  
 }  
   
 // 只是拷贝一个表头  
 m_Model = new Instances(m_Instances, 0);  
   
 // 确定聚类中心  
 if (m_CenterInput != null) {  
   //聚类中心可以从文件读取，注意m_ClusterCenters本身是一个Instances对象，但这里似乎没有判断这个m_ClusterCenters和m_Model（也就是传入的训练集）是否同构  
   m_ClusterCenters = new Instances(m_CenterInput);  
   m_NumClusters = m_ClusterCenters.numInstances();//如果传入了聚类中心文件，那么就更新一下聚类中心数量  
 }  
 else  
   // 随机选取聚类中心，有放回的随机抽样。  
   m_ClusterCenters = makeCentersRandomly(random0,  
          m_Instances, m_NumClusters);  
 PFD(D_FOLLOWSPLIT, "\n*** Starting centers ");//这个是debug函数，忽略  
 for (int k = 0; k < m_ClusterCenters.numInstances(); k++) {  
   PFD(D_FOLLOWSPLIT, "Center " + k + ": " + m_ClusterCenters.instance(k));  
 }  
   
 PrCentersFD(D_PRINTCENTERS);//打日志的函数，忽略  
   
 boolean finished = false;  
 Instances children;   
   
 // 是否使用KDTree，简单说一下KDTree，如果给定一堆点X，又给定一个点A，A离X中最近的那个点，传统的做法遍历整个X集合，找出最近的，时间复杂度为O（n）,构建KDTree之后（本质是在空间上建立索引），时间复杂度可以将为O（logn）  
 if (m_UseKDTree)  
   m_KDTree.setInstances(m_Instances);  
   
 // 迭代次数  
 m_IterationCount = 0;  
   
 /**  
  * 训练过程由两次迭代组成，外层迭代进行聚类中心的分裂，内层迭代对每个实例进行划分并算出新的聚类中心，外层迭代的退出条件有两个  
  * 1. finished为true(finished为true的条件后面会说到）  
  * 2. 达到最大迭代次数  

[java]view plaincopy 
   
  * 注意，m_ClusterCenters有可能已经比m_MaxClusters大了，因为可能是从文件读入的聚类中心，这种情况下迭代也会进行一次，因为finish是在循环结束时判断的  
  */  
 while (!finished &&  
        !stopIteration(m_IterationCount, m_MaxIterations)) {  
   PFD(D_FOLLOWSPLIT, "\nBeginning of main loop - centers:");  
   PrCentersFD(D_FOLLOWSPLIT);  
   PFD(D_ITERCOUNT, "\n*** 1. Improve-Params " + m_IterationCount +   
 . time");  
   m_IterationCount++;  
   
   // converged代表两次内层迭代，所产生的聚类结果是否一样  
   boolean converged = false;  
   
   // 这是一个一维数组，记录每个实例被分到了哪个聚类中心  
   m_ClusterAssignments = initAssignments(m_Instances.numInstances());  
   // 这个二维数组存放每个聚类中心都有那些实例，很奇怪的是weka全都是用数组，而没用list这样的数据结构，估计是从效率方面进行考虑。  
   int[][] instOfCent = new int[m_ClusterCenters.numInstances()][];  
   
   // 内层迭代的计数器  
   int kMeansIteration = 0;  
   
   // 打日志忽略  
   PFD(D_FOLLOWSPLIT, "\nConverge in K-Means:");  

[java]view plaincopy 
   
      //进行内层迭代，内层迭代退出的条件也有两个，第一个是迭代次数达到最大，第二个是两次循环的聚类结果一样  
      while (!converged &&   
      !stopKMeansIteration(kMeansIteration, m_MaxKMeans)) {  
   
 kMeansIteration++;  
 converged = true;  
   
        // 把实例分给相应的聚类中心，这里对converged进行了赋值，但后面有覆盖了所以这个赋值没有意义。这个函数比较麻烦但没有什么算法思想，就不展开分析了，KDTree结构或许会在后面的博客去分析其实现。  
        converged = assignToCenters(m_UseKDTree ? m_KDTree : null,  
                 m_ClusterCenters,   
                 instOfCent,  
                 allInstList,   
                 m_ClusterAssignments,  
                 kMeansIteration);  
   
 PFD(D_FOLLOWSPLIT, "\nMain loop - Assign - centers:");//打日志忽略  
 PrCentersFD(D_FOLLOWSPLIT);//打日志忽略  
 // 重新算聚类中心，如果两次聚类中心一样，就返回true，两次聚类中心一样，和两次的聚类结果一样是完全等价的。聚类中心的计算方法是算数平均值。  
        converged = recomputeCenters(m_ClusterCenters, // 聚类中心  
                  instOfCent,       // 这些聚类中心的实例  
                  m_Model);         // 表头  
      PFD(D_FOLLOWSPLIT, "\nMain loop - Recompute - centers:");  
      PrCentersFD(D_FOLLOWSPLIT);  
      }  
      PFD(D_FOLLOWSPLIT, "");  
      PFD(D_FOLLOWSPLIT, "End of Part: 1. Improve-Params - conventional K-means");  
   
   
      //计算每个聚类中心的偏差，m_Mle是个数组，存储各聚类中实例到聚类中心的距离之和  
      m_Mle = distortion(instOfCent, m_ClusterCenters);  

[java]view plaincopy 
   
 //bic是“贝叶斯失真规则”，越小说明模型对数据拟合越好，百度百科连接http://baike.baidu.com/view/1425589.htm?fr=aladdin#2。反正越小越好  
 m_Bic = calculateBIC(instOfCent, m_ClusterCenters, m_Mle);  
 PFD(D_FOLLOWSPLIT, "m_Bic " + m_Bic);  
   
 int currNumCent = m_ClusterCenters.numInstances();  

[java]view plaincopy 
   
      //新的聚类中心，可以遇见到，每个原聚类中心都要进行分裂，因为容量是currNumCent*2  
      Instances splitCenters = new Instances(m_ClusterCenters,   
                      currNumCent * 2);  
        
      //   
      double[] pbic = new double [currNumCent];  
      double[] cbic = new double [currNumCent];  
              
      // 对中心进行分裂  
      for (int i = 0; i < currNumCent   
    // 原备注说加了下一行可以提高速度，我也不是很懂  
    //        && currNumCent + numSplits <= m_MaxNumClusters  
           ;   
    i++) {  
   
 PFD(D_FOLLOWSPLIT, "\nsplit center " + i +  
           " " + m_ClusterCenters.instance(i));  
 Instance currCenter = m_ClusterCenters.instance(i);  
 int[] currInstList = instOfCent[i];  
 int currNumInst = instOfCent[i].length;//代表这个聚类中有几个实例  
   
 // 如果目前的实例小于等于2，就直接复制自己一份，每个聚类中心必须分裂，当然如果两个instance，每个点都当做聚类中心也可以，但直接dummy自己也不影响最后结果。  
 if (currNumInst <= 2) {  
   pbic[i] = Double.MAX_VALUE;  
   cbic[i] = 0.0;  
   // add center itself as dummy  
   splitCenters.add(currCenter);  
   splitCenters.add(currCenter);  
   continue;  
 }  
   
 //m_Mle[i]代表聚类i上的距离误差和，除以分类数得到平均误差，但这个误差并不是方差，这个变量的名字有点误导性。。。。  
 double variance = m_Mle[i] / (double)currNumInst;  

[java]view plaincopy 
   
        //通过某种方式分裂成两个中心，这个分裂过程还是挺有意思的，主流程之后会详细分析  
 children = splitCenter(random0, currCenter, variance, m_Model);  
   
 // 准备用这个聚类上的所有数据，根据这两个新的聚类中心，再做一次聚类  
 int[] oneCentAssignments = initAssignments(currNumInst);  
 int[][] instOfChCent = new int [2][]; // todo maybe split didn't work  
   
 // 标志记录两次迭代是否一样，下面循环逻辑和之前的聚类过程基本一样  
 converged = false;  
 int kMeansForChildrenIteration = 0;  
 PFD(D_FOLLOWSPLIT, "\nConverge, K-Means for children: " + i);  
 while (!converged &&   
          !stopKMeansIteration(kMeansForChildrenIteration,   
                m_MaxKMeansForChildren)) {  
   kMeansForChildrenIteration++;  
     
   converged =  
     assignToCenters(children, instOfChCent,  
             currInstList, oneCentAssignments);  
   
   if (!converged) {         
     recomputeCentersFast(children, instOfChCent, m_Model);//这个和recomputeCenters唯一的区别就是不算converged  
   }  
 }   
   
   
 splitCenters.add(children.instance(0));  
 splitCenters.add(children.instance(1));  
   
 PFD(D_FOLLOWSPLIT, "\nconverged cildren ");  
 PFD(D_FOLLOWSPLIT, " " + children.instance(0));  
 PFD(D_FOLLOWSPLIT, " " + children.instance(1));  
   
 // 分别计算父聚类中心和子聚类中心（2个）的BIC  
 pbic[i] = calculateBIC(currInstList, currCenter,  m_Mle[i], m_Model);  
 double[] chMLE = distortion(instOfChCent, children);  
 cbic[i] = calculateBIC(instOfChCent, children, chMLE);  
   
      } //对于每个聚类中心都做上述操作，循环结束  
   
      // 这个函数根据之前算出的BIC，计算出新的聚类中心，具体怎么选的后面会再跟进去详细说。  
      Instances newClusterCenters = null;  
      newClusterCenters = newCentersAfterSplit(pbic, cbic, m_CutOffFactor,  
                                                 splitCenters);  
   
      int newNumClusters = newClusterCenters.numInstances();  
      if (newNumClusters != m_NumClusters) {  
 //如果新的聚类中心数量和老的不相等，进入这个if。  
 PFD(D_FOLLOWSPLIT, "Compare with non-split");  
   
 int[] newClusterAssignments =   
   initAssignments(m_Instances.numInstances());  
   
 int[][] newInstOfCent = new int[newClusterCenters.numInstances()][];  
 //把所有instance放到新的聚类中心上。  
 converged = assignToCenters(m_UseKDTree ? m_KDTree : null,  
                 newClusterCenters,   
                 newInstOfCent,  
                 allInstList,   
                 newClusterAssignments,  
                 m_IterationCount);  
   
 double[] newMle = distortion(newInstOfCent, newClusterCenters);  
 double newBic = calculateBIC(newInstOfCent, newClusterCenters, newMle);//算一算新的bic  
 PFD(D_FOLLOWSPLIT, "newBic " + newBic);  
 if (newBic > m_Bic) {//如果新的bic比旧的大，说明新的聚类效果好，则用新的替换老的  
          PFD(D_FOLLOWSPLIT, "*** decide for new clusters");  
   m_Bic = newBic;  
   m_ClusterCenters = newClusterCenters;  
   m_ClusterAssignments = newClusterAssignments;  
 } else {  
          PFD(D_FOLLOWSPLIT, "*** keep old clusters");  
        }  
      }  
   
      newNumClusters = m_ClusterCenters.numInstances();  
      if ((newNumClusters >= m_MaxNumClusters)   
   || (newNumClusters == m_NumClusters)) {  
 finished = true;//置finish条件，当达到最大分类数量，或者没有任何分裂的时候，就置为true  
      }  
      m_NumClusters = newNumClusters;  
    }  
      
    if (m_ClusterCenters.numInstances() > 0 && m_CenterOutput != null) {  
      m_CenterOutput.println(m_ClusterCenters.toString());//输出模型用的，忽略  
      m_CenterOutput.close();  
      m_CenterOutput = null;  
    }      
  }  

首先处理两个问题，第一个是splitCenter用于对已有中心进行分裂，第二个是newCentersAfterSplit，根据分裂后的BIC计算出新的聚类中心，这个分裂机制可以算是XMeans区别于KMeans的最大不同点。

一、splitCenter

[java]view plaincopy 
   
 protected Instances splitCenter(Random random,  
                 Instance center,  
                 double variance,  
                 Instances model) throws Exception {  
    m_NumSplits++;  
    AlgVector r = null;  
    Instances children = new Instances(model, 2);  
   
    if (m_DebugVectorsFile.exists() && m_DebugVectorsFile.isFile()) {  
      Instance nextVector = getNextDebugVectorsInstance(model);  
      PFD(D_RANDOMVECTOR, "Random Vector from File " + nextVector);  
      r = new AlgVector(nextVector);  
    }  
    else {  
      //这个model是表头，r是生成一个随机向量，每一维都是0到1之间  
      r = new AlgVector(model, random);  
    }  
    r.changeLength(Math.pow(variance, 0.5));//改变向量的长度为sqrt(variance)这个variance就是聚类点到聚类中心的平均偏差  
    PFD(D_RANDOMVECTOR, "random vector *variance "+ r);  
      
    // 首先生成两个聚类中心的向量  
    AlgVector c = new AlgVector(center);  
    AlgVector c2 = (AlgVector) c.clone();  
    c = c.add(r);//c+r  
    Instance newCenter = c.getAsInstance(model, random);  
    children.add(newCenter);  
    PFD(D_FOLLOWSPLIT, "first child "+ newCenter);  
      
    // c2-r  
    c2 = c2.substract(r);  
    newCenter = c2.getAsInstance(model, random);  
    children.add(newCenter);  
    PFD(D_FOLLOWSPLIT, "second child "+ newCenter);  
   
    return children;  
  }  

执行过后的结果如图所示：

二、newCentersAfterSplit

[java]view plaincopy 
   
 protected Instances newCentersAfterSplit(double[] pbic,   
                      double[] cbic,  
                      double cutoffFactor,  
                      Instances splitCenters) {  
   
     //   
     boolean splitPerCutoff = false;  
     boolean takeSomeAway = false;  
     boolean[] splitWon = initBoolArray(m_ClusterCenters.numInstances());//这个数组存放每个聚类中心是否分裂的决定  
     int numToSplit = 0;  
     Instances newCenters = null;  
       
     for (int i = 0; i < cbic.length; i++) {  
       if (cbic[i] > pbic[i]) {  
     // 如果child的BIC比较大，就分裂，为什么是BIC越大越好而不是越小越好？Weka的BIC公式貌似没取负。  
     splitWon[i] = true; numToSplit++;  
     PFD(D_FOLLOWSPLIT, "Center " + i + " decide for children");  
       }  
       else {  
     // 默认是false，不用重新赋值。  
     PFD(D_FOLLOWSPLIT, "Center " + i + " decide for parent");  
       }  
     }  
   
     if ((numToSplit == 0) && (cutoffFactor > 0)) {  
       splitPerCutoff = true;  
         
       // 如果没有节点需要分裂，则使用cutoffFactor来决定要分裂的数量，这么做的原因是为了防止陷入局部最优点。  
       numToSplit = (int)   
         ((double) m_ClusterCenters.numInstances() * m_CutOffFactor);   
     }  
   
     // 把pbic和cbic进行相减，并排序，以便找出差最大的，优先分裂。  
     double[] diff = new double [m_NumClusters];  
     for (int j = 0; j < diff.length; j++) {  
       diff[j] = pbic[j] - cbic[j];  
     }      
     int[] sortOrder = Utils.sort(diff);  
       
     //检查一下最多的可分裂数量  
     int possibleToSplit = m_MaxNumClusters - m_NumClusters;   
   
     if (possibleToSplit > numToSplit) {  
       // 如果可分裂数量多于numToSplit，就按照numToSplit去分裂  
       possibleToSplit = numToSplit;  
     }  
     else  
       takeSomeAway = true;  
   
     // 如果有splitPerCuteoff标，说明使用了cutoffFactor来决定分裂多少，这时候splitWon里面肯定都是false，需要设置一定数量的为true  
     if (splitPerCutoff) {  
       for (int j = 0; (j < possibleToSplit) && (cbic[sortOrder[j]] > 0.0);  
        j++) {  
     splitWon[sortOrder[j]] = true;  
       }  
       m_NumSplitsStillDone += possibleToSplit;  
     }   
     else {  
       // take some splits away if max number of clusters would be exceeded  
       if (takeSomeAway) {  
     int count = 0;  
     int j = 0;//如果有这个标，说明能分裂的数量小于了splitWon中的数量，需要将一定数量得true设置为false  
     for (;j < splitWon.length && count < possibleToSplit; j++){  
       if (splitWon[sortOrder[j]] == true) count++;  
     }  
       
     while (j < splitWon.length) {  
       splitWon[sortOrder[j]] = false;  
       j++;  
     }  
       }  
     }  
      
     // 进行分裂操作，即若splitWon==true就分裂，否则保持原样  
     if (possibleToSplit > 0)   
       newCenters = newCentersAfterSplit(splitWon, splitCenters);  
     else  
       newCenters = m_ClusterCenters;  
     return newCenters;  
   }  