码迷,mamicode.com
首页 > 其他好文 > 详细

Weka算法Clusterers-Xmeans源码分析

时间:2014-10-01 01:33:50      阅读:357      评论:0      收藏:0      [点我收藏+]

标签:源码   算法   机器学习   weka   kmeans   

</pre><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);
    //这两个是最小聚类数量和最大聚类数量
    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,如果是数值型,则替换为平均值,如果是枚举型,则替换为出现最多的那个值
    // 这里可以算预处理数据时的一个小技巧
    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();
    
    //测试相关,暂时忽略
    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. 达到最大迭代次数
     * 注意,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:");
      //进行内层迭代,内层迭代退出的条件也有两个,第一个是迭代次数达到最大,第二个是两次循环的聚类结果一样
      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);
      //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();
      //新的聚类中心,可以遇见到,每个原聚类中心都要进行分裂,因为容量是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;
        //通过某种方式分裂成两个中心,这个分裂过程还是挺有意思的,主流程之后会详细分析
	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;
    }    
  }


(未完待续)


Weka算法Clusterers-Xmeans源码分析

标签:源码   算法   机器学习   weka   kmeans   

原文地址:http://blog.csdn.net/roger__wong/article/details/39617309

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!