k-means

K-means聚类的java实现
      今天把自己写的一个机器学习算法库中的K-means算法整理了一下，因为这个算法较其他的相比相对独立，可以单独贴出来，不会引用太多的其他类（不过还是有点引用，不过引用些简单的功能，看类名就知道什么意思了）。
基本功能和规则为：
1.当然是进行k-means算法，对数据集（这里使用二维数组来表示数据集，行数为数据总数，列数为数据维度）进行N维聚类
2.可以指定收敛的阀值（convergenceDis默认为0.0001）
3.为避免局部最小，可以指定重复运行次数，通过设定replicates的数值来指定，默认为0，即只重复一次聚类过程
4.测试数据格式为每一行代表一个输入，用空格分隔输入的各个维度，为了计算结果不出太大意外，建议对原始数据进行归一化
首先上骨架代码：
View Code

 Matrix
package org.tadoo.ml;

import java.io.PrintStream;

import org.tadoo.ml.exception.MatrixComputeException;

/**
 * 矩阵结构
 *
 * <p>time:2011-3-23</p>
 * @author T. QIN
 */
public class Matrix
{
    private int rowNum;

    private int colNum;

    private double value[][];

    /**
     * 构造器方法
     * 
     * @param rows 行数
     * @param cols 列数
     * @see: 
     * @author: T. QIN
     */
    public Matrix(int rows, int cols)
    {
        this.rowNum = rows;
        this.colNum = cols;
        this.value = new double[rows][cols];
    }

    /**
     * 构造器方法
     * 
     * @param rows 行数
     * @param cols 列数
     * @param isInitialMemory 是否初始化权值矩阵
     * @see: 
     * @author: T. QIN
     */
    public Matrix(int rows, int cols, boolean isInitialMemory)
    {
        this.rowNum = rows;
        this.colNum = cols;
        if (isInitialMemory)
        {
            this.value = new double[rows][cols];
        }
    }

    /**
     * 替换矩阵值
     *
     * @param v
     * @throws MatrixComputeException 
     * @see: 
     */
    public void changeWholeValue(double v[][]) throws MatrixComputeException
    {
        if (v.length != this.rowNum && v[0].length != this.colNum)
        {
            throw new MatrixComputeException("矩阵大小不拟合");
        }
        this.value = v;
    }

    public void print(PrintStream ps)
    {
        if (ps == null)
        {
            ps = System.out;
        }
        for (int i = 0; i < rowNum; i++)
        {
            for (int j = 0; j < colNum; j++)
            {
                ps.print(value[i][j] + "\t");
            }
            ps.println();
        }
    }

    /**
     * overwrite
     * 
     * @return
     * @see: 
     */
    public String toString()
    {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < rowNum; i++)
        {
            for (int j = 0; j < colNum; j++)
            {
                sb.append(value[i][j] + "\t");
            }
            sb.append("\n");
        }
        return sb.toString();
    }

    /**
     * rowNum的 get() 方法
     * @return int rowNum.
     */
    public int getRowNum()
    {
        return rowNum;
    }

    /**
     * rowNum的 set() 方法
     * @param rowNum The rowNum to set.
     */
    public void setRowNum(int rowNum)
    {
        this.rowNum = rowNum;
    }

    /**
     * colNum的 get() 方法
     * @return int colNum.
     */
    public int getColNum()
    {
        return colNum;
    }

    /**
     * colNum的 set() 方法
     * @param colNum The colNum to set.
     */
    public void setColNum(int colNum)
    {
        this.colNum = colNum;
    }

    /**
     * value的 get() 方法
     * @return double[][] value.
     */
    public double[][] getValue()
    {
        return value;
    }

    /**
     * value的 set() 方法
     * @param value The value to set.
     */
    public void setValue(double[][] value)
    {
        this.value = value;
    }

}
复制代码
 MatrixComputeException

按 Ctrl+C 复制代码
 DataUtil

按 Ctrl+C 复制代码
然后是测试：
View Code
package org.tadoo.ml.test;

import junit.framework.TestCase;

import org.tadoo.ml.Matrix;
import org.tadoo.ml.cluster.kmeans.KmeansCluster;
import org.tadoo.ml.util.DataUtil;
import org.tadoo.ml.util.Utils;

/**
 * 测试K-means聚类器
 *
 * <p>time:2011-6-2</p>
 * @author T. QIN
 */
public class TestKmeansCluster extends TestCase
{
    Matrix dataSet = null;

    double[][] ds = null;

    protected void setUp()
    {
        dataSet = Utils.uniformFileInputIntoFeatures("D:\\test.s.txt");
        ds = DataUtil.load("D:\\data1.txt");
    }

    /**
     * 测试用K-means选取中心节点
     *
     * @see: 
     */
    public void testKmeansCenters()
    {
        KmeansCluster kmc = new KmeansCluster(dataSet.getValue(), 2);
        kmc.train();
        System.out.println(kmc.getTotalSumOfdistances());
        System.out.println(kmc.getIter());
        double[][] centers = kmc.getCenters();
        for (int i = 0; i < centers.length; i++)
        {
            for (int j = 0; j < centers[i].length; j++)
            {
                System.out.print(centers[i][j] + "\t");
            }
            System.out.println();
        }
    }
    
    public void testKmeansReplicate(){
        KmeansCluster kmc = new KmeansCluster(dataSet.getValue(), 11);
        kmc.setReplicates(12);
        kmc.train();
        KmeansCluster.KMCResult[] kmcr =  kmc.getKmcresults();
        for (int i = 0; i < kmcr.length; i++)
        {
            System.out.println("iters:"+kmcr[i].iters+"\tSum:"+kmcr[i].sum);
        }
    }
}

http://www.cnblogs.com/tadoo/archive/2011/06/02/2068591.html
因为是初学者，写的很冗长，不过多少能算出结果来了。