数据挖掘经典算法——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