数据挖掘经典算法——K-means算法

算法描述

　　K-means算法是一种被广泛使用的基于划分的聚类算法，目的是将n个对象会分成k个簇。算法的具体描述如下：

随机选取k个对象作为簇中心；

Do

          计算所有对象到这k个簇中心的距离，将距离最近的归入相应的簇；

          重新计算每个簇的中心；

          计算准则函数V；

While 准则函数的值稳定（或变化小于某个阈值）

　　其中准则函数V的定义如下：

　　　　　　　　 

　　其中，u_i表示第i个簇S_i的中心。最终经过T次迭代获取到最终的分类结果，对于第t+1次迭代之后得到的中心，有如下定义：

　　　　　　　　　　

算法的优缺点

　　优点：

　　　　1)         算法描述简单，高效；

　　　　2)         适合用于处理大数据，得到的算法的复杂度大约为O(nkt)，n表示对象的数量，k是划分的簇数量，t为迭代次数。通常情况下能够保证k<<n，算法的效率有一定的保障；

　　　　3)         算法比较适合处理簇之间划分明确的对象集合；

　　缺点：

　　　　1)         k值必须手动的给出，选取k值就显得特别重要了；

　　　　2)         不同的初始对象会带来不同的划分结果；

　　　　3)         如果对象集合内部包含一些小范围孤立对象，这种基于局部最优的聚类划分算法可能会产生一些错误的划分；

　　　　4)         通常判断对象之间远近的依据是欧拉距离，可以尽快得到结果，但同时也带来了一些缺点，比如采用K-means算法处理一下非凸面的簇时。

Kmeans算法的Java实现

 import java.awt.BorderLayout;
 import java.awt.Canvas;
 import java.awt.Color;
 import java.awt.Dimension;
 import java.awt.Frame;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Paint;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Random;
 import java.util.Set;

 import ocr.algorithm.KMeans.Cluster;
 import ocr.algorithm.KMeans.KMeansNode;

 /**
  * 这是一个简单的Kmeans算法实现
  * 假设前提包括：
  * 1.集合中每个对象都是一个位于二维平面的点
  * 2.对象之间的距离判定以欧氏距离为标准
  * 3.这只是一个样例程序，主要用于叙述K-means算法的主干部分，一些特殊的情况未曾考虑（数据溢出，性能优化）
  * @author yahokuma
  * @email Hazin.lu@gmail.com
  */
 public class KMeans {

     private List<KMeansNode> datas = new ArrayList<KMeans.KMeansNode>();

     public static class KMeansNode {
         private double x;
         private double y;

         public double getX() {
             return x;
         }

         public double getY() {
             return y;
         }

         public KMeansNode(double x,double y){
             this.x = x;
             this.y = y;
         }

         public double distance(KMeansNode n){
             return
                 Math.pow( x - n.x , 2 ) + Math.pow( y - n.y , 2 );
         }

     }

     public static class Cluster{
         private List<KMeansNode> nodes = new ArrayList<KMeans.KMeansNode>();
         private KMeansNode center = null;
         public KMeansNode getCenter() {
             return center;
         }
         public void addNode(KMeansNode n){
             this.nodes.add(n);
         }
         public Cluster(KMeansNode c){
             this.center = c;
         }
         public void calculateCenter(){
             double x = 0,y = 0;
             for (KMeansNode n : nodes) {
                 x += n.x;
                 y += n.y;
             }
             this.center = new KMeansNode( x / nodes.size(), y / nodes.size());
         }

         public double criterion(){
             double criterion = 0;
             calculateCenter();
             for (KMeansNode n : nodes) {
                 criterion += center.distance(n);
             }

             return criterion;
         }

         public void clear(){
             this.nodes.clear();
         }

         public List<KMeansNode> getNodes(){
             return this.nodes;
         }

         public void print(){
             System.out.println("Contains "+ nodes.size() + " Nodes !");
             System.out.println("Center Node is ( "+ getCenter().x + "," + getCenter().y + " )");
         }
     }

     public KMeans(List<KMeansNode> datas){
         this.datas = datas;
     }

     private List<KMeansNode> findRandNodes(int k){
         List<KMeansNode> rNodes = new ArrayList<KMeans.KMeansNode>();
         Set<Integer> rIndexes = new HashSet<Integer>();
         Random r = new Random();
         Integer rInt = null;
         for (int i = 0; i < k; i++) {
             rInt = r.nextInt(datas.size());
             while(rIndexes.contains(rInt))
                 rInt = r.nextInt(datas.size());

             rIndexes.add(rInt);
             rNodes.add( datas.get(rInt));
         }

         return rNodes;
     }

     private double calculateCriterion(List<Cluster> clusters){
         double res = 0;
         for (Cluster c : clusters) {
             res += c.criterion();
         }
         return res;
     }

     public List<Cluster> partition(int k){
         List<KMeansNode> centerNodes = findRandNodes(k);
         List<Cluster> clusters = new ArrayList<KMeans.Cluster>();
         for (KMeansNode c : centerNodes) {
             clusters.add(new Cluster(c));
         }

         double minDistance = Double.MAX_VALUE , distance;
         Cluster minCluster = null;
         double lastCriterion , criterion= Double.MAX_VALUE;

         do{
             for (Cluster c : clusters) {
                 c.clear();
             }
             lastCriterion = criterion;

             for (KMeansNode n : datas) {
                 minDistance = Double.MAX_VALUE;
                 for (Cluster c : clusters) {
                     distance = c.getCenter().distance(n);
                     if( distance < minDistance ){
                         minDistance = distance;
                         minCluster = c;
                     }
                 }
                 minCluster.addNode(n);
             }
             criterion = calculateCriterion(clusters);

         }while( criterion != lastCriterion);

         return clusters;

     }

     /**
     *随机生成了1000个平面点，将其划分为4个簇（k=4）
     *由于点的坐标都是随机生成的，在空间上分布均匀；
     *从结果中可以看出K-means对于处理这种边界不分明的对象集合时并不能很好的进行区分；
     *但是一般情况，经过处理还是会将整个平面均匀得划分成四个部分
     **/
     public static void main(String args[]){
         Random r = new Random();
         List<KMeansNode> nodes = new ArrayList<KMeans.KMeansNode>();
         for (int i = 0; i < 1000; i++) {
             nodes.add(new KMeansNode(r.nextDouble() * 1000, r.nextDouble() * 1000));
         }

         KMeans kmeans = new KMeans(nodes);
         List<Cluster> clusters = kmeans.partition(4);
         for( Cluster c :  clusters){
             c.print();
         }

          Frame frame = new Frame("K-means Test!");
          frame.addWindowListener(new WindowAdapter(){
              public void windowClosing(WindowEvent e) {
                  System.exit(0);
              }
          });
          frame.add(new KMeansCanvas(clusters),BorderLayout.CENTER);
          frame.pack();
          frame.setVisible(true);
     }

 }

 /**
  *
  * @author yahokuma
  * @email Hazin.lu@gmail.com
  */
 class KMeansCanvas extends Canvas {
     public final static Paint[] PAINT_COLOR = {Color.BLUE,Color.RED, Color.ORANGE, Color.BLACK};

     private List<Cluster> clusters = null;
     public KMeansCanvas(List<Cluster> clusters) {
         this.setBackground(Color.WHITE);
         this.clusters = clusters;
     }
     @Override
     public void paint(Graphics g) {
         drawKarel(g);
     }
     @Override
     public Dimension getPreferredSize() {
         return new Dimension(1000,1000);
     }  

     private void drawKarel(Graphics g) {  

         Random r = new Random();
         int i = 0 ;
         for (Cluster c : clusters) {
             Graphics2D g2d= (Graphics2D) g;
             g2d.setPaint(PAINT_COLOR[i++]);
             for (KMeansNode n : c.getNodes()) {
                 g2d.drawRect((int)n.getX(), (int)n.getY() , 2, 2);
                 g2d.fillRect((int)n.getX(), (int)n.getY() , 2, 2);
             }
         }
     }
     private static final long serialVersionUID = 1L;
 }  

参考资料

http://en.wikipedia.org/wiki/K-means_clustering

http://blog.csdn.net/aladdina/article/details/4141177

http://www.cnblogs.com/jerrylead/archive/2011/04/06/2006910.html

http://zh.wikipedia.org/wiki/K%E5%B9%B3%E5%9D%87%E7%AE%97%E6%B3%95