数据挖掘之KMEANS算法

KMeans算法的代码实现。

这是我学习数据挖掘KMEans算法的一个简明版本。

这个代码比较简单。

package cluster;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Cluster {
	private double ClusterCenter;
	private double[] ClusterData;
	private List<Double> listData;
	public Cluster(double ClusterCenter){
		this.ClusterCenter=ClusterCenter;
		init();
	}
	private void init(){
		double[] data=new double[1];
		//data[0]=1e308;
		ClusterData=data;
		listData=new ArrayList<Double>();
	}
	/**
	 * 分配数据给该数据中心函数
	 * */
	public void AssDPToCCenter(double datapoint){
		listData.add(datapoint);
		double datas[]=new double[listData.size()];
		for(int i=0;i<datas.length;i++){
			datas[i]=listData.get(i);
		}
		this.ClusterData=datas;
	}	
	/**
	 * 获得当前聚类的聚类中心与每个数值之间的方差和
	 * */
	public double getVAR(){
		return MathUtil.getVARIANCE(this.ClusterData,this.ClusterCenter);
	}
	/**
	 * 以下方法用来重新计算聚类中心
	 * */
	public double reGetCenter(double eps){
		double center=1e308;
		double d;
		System.out.println("this clusterData="+Arrays.toString(ClusterData));
		d=MathUtil.getMeans(ClusterData);
		double[] data=MathUtil.getDistanceArray(ClusterData, d);
		System.out.println("data="+Arrays.toString(data));
		Integer[] intmarks=MathUtil.getMinValueMarks(data, eps);
		double[] dataArrs=new double[intmarks.length];
		if(intmarks.length==1){
			center=ClusterData[intmarks[0]];
		}
		if(intmarks.length>1){	
			for(int i=0;i<dataArrs.length;i++){
				dataArrs[i]=ClusterData[intmarks[i]];
			}
			if(MathUtil.isDuplicateExist(dataArrs)){
				System.out.println("-------------------------------------------------------------");
				center=MathUtil.getMinValue(dataArrs);
			}else{
				center=dataArrs[0];
			}
			
		}
		System.out.println("intmarks="+Arrays.toString(intmarks));
package K_MEANS;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import Matrix.Matrix;
import cluster.Cluster;
import cluster.MathUtil;

/**
 * @param K为聚类的个数
 * @param data为聚类的数据
 * @param cluster聚类数
 * @param MaxIterateStep最大迭代数
 * */
public class K_MEANS {
	public int K;
	public double[] data;
	public Cluster[] clusters;
	public K_MEANS(int K,double[] data){
		this.K=K;
		if(K>data.length){
			this.K=data.length;
		}
		this.data=data;
		init();
	}
	/***
	 * 初始化
	 * */
	private void init(){
		this.clusters=new Cluster[K];
		int[] intArrs=getTempArrays();
		for(int i=0;i<K;i++){
			clusters[i]=new Cluster(intArrs[i]);
		}
	}
	/**
	 * 以下方法用来获得一个随机数组生成随机中心数据点
	 * */
	private int[] getTempArrays(){
		return genRandom.genRandom.getRandom(data, K);
	}
	/**
	 * 以下方法为地磁分配数据给各个聚类中心
	 * */
	public Cluster[] AssignDataToCenter(double[] datas){
		Cluster[] clusters=this.clusters;
		Matrix DistanceMatrix=getDistance(datas);
		System.out.println("DistanceMatrix"+DistanceMatrix.toString());
		for(int i=0;i<datas.length;i++){
			Integer[] min=DistanceMatrix.getMinValueColsMarks(i+1);
			
				clusters[min[0]].AssDPToCCenter(datas[i]);
			
		}
		return clusters;
	}
	/**
	 * 以下方法用来获得每个中心聚点与每个数据区域的距离
	 * */
	public Matrix getDistance(double[] data){
		double[] centers=getClusterCenter();
		Matrix DistanceMatrix=new Matrix(data.length,K);
		for(int i=1;i<=DistanceMatrix.getRownums();i++){
			for(int j=1;j<=DistanceMatrix.getColnums();j++){
				DistanceMatrix.setMatrixValue(i, j, MathUtil.getDistance(centers[j-1], data[i-1]));
			}
		}
		return DistanceMatrix;
	}
	
	/**
	 * 以下方法用来重新计算聚类中心方法
	 * */
	public Cluster[] reGetCenter(double eps){
		for(int i=0;i<this.clusters.length;i++){
			clusters[i].reGetCenter(eps);
		}
		return clusters;
	}
	
	/**
	 * 以下方法用来获得聚类中心值，返回数组
	 * */
	public double[] getClusterCenter(){
		double[] tmp=new double[K];
		for(int i=0;i<tmp.length;i++){
			tmp[i]=clusters[i].getClusterCenter();
		}
		return tmp;
	}
	/**
	 * 用来处理文本分类的主程序
	 * 将分类完成后的数据写入到硬盘当中
	 * */
	public void ProcessFiles(double eps){
		int i=0;
		List<Double> listVar=new ArrayList<Double>();
		while(true){
			AssignDataToCenter(data);
			double VAR=getTotalVAR();
			listVar.add(VAR);
			if(listVar.size()>2){	
				if(Math.abs(listVar.get(listVar.size()-2)-(listVar.get(listVar.size()-1)))<eps){
					break;
				}
//				if(i>this.MaxIterateSteps){
//					break;
//				}
			}
			reGetCenter(eps);
			clearData();
			i++;
		}
	}
	/**
	 * 获得所有聚类区域的方差和
	 * */
	public double getTotalVAR(){
		double VAR=0;
		for(int i=0;i<this.clusters.length;i++){
			VAR=clusters[i].getVAR()+VAR;
		}
		return VAR;
	}
	private void clearData(){
		for(int i=0;i<this.clusters.length;i++){
			clusters[i].clearData();
		}
	}
	public int getK() {
		return K;
	}
	public void setK(int k) {
		K = k;
	}
	public double[] getData() {
		return data;
	}
	public void setData(double[] data) {
		this.data = data;
	}
	public Cluster[] getClusters() {
		return clusters;
	}
	public void setClusters(Cluster[] clusters) {
		this.clusters = clusters;
	}
	public String toString(){
		return Arrays.toString(clusters)+this.getClusterCenter();
	}
	public static void main(String[] args){
		double[] data={2,3,4,5,20,30,40,50,100,200,300,400,500,600,700,800,900};
		K_MEANS k=new K_MEANS(2,data);
		
		k.ProcessFiles(0.0000005);
		System.out.println(Arrays.toString(k.clusters));
	}
}


package Single_Regression;


public class Regression {
	public static double getArraySUM(double[] data){
		double sum=0;
		for(int i=0;i<data.length;i++){
			sum+=data[i];
		}
		return sum;
	}
	public static double getMeanX(double[] data){
		double d=0;
		double mean=0;
		for(int i=0;i<data.length;i++){
			d+=data[i];
			
		}
		mean=d/(data.length);
		return mean;
	}
	public static double getMeanY(double[] data){
		double d=0;
		double mean=0;
		for(int i=0;i<data.length;i++){
			d+=data[i];
			
		}
		mean=d/(data.length);
		return mean;
	}
	public static double[] getXS(double[] data){
		 double dataSquare[]=new double[data.length];
		 for(int i=0;i<data.length;i++){
			 dataSquare[i]=Math.pow(data[i],2);
		 }
		 return dataSquare;
	}
	public static double[] getYS(double[] data){
		 double dataSquare[]=new double[data.length];
		 for(int i=0;i<data.length;i++){
			 dataSquare[i]=Math.pow(data[i],2);
		 }
		 return dataSquare;
	}
	public static double[] getXY(double[] datax,double[] datay){
		if(initSuccess(datax,datay)==false){
			try{
				throw new Exception("不好意思出现了错误，请检查下数据");
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		double[] dataXY=new double[datax.length];
		for(int i=0;i<datax.length;i++){
			dataXY[i]=datax[i]*datay[i];
		}
		return dataXY;
	}
	private static boolean initSuccess(double[] datax,double[] datay){
		boolean status=true;
		if(datax.length!=datay.length){
			status=false;
		}
		return status;
	}

	public static double getLXX(double[] datax){
		int n=datax.length;
		double LXX;
		LXX=getArraySUM(getXS(datax))-n*(Math.pow(getMeanX(datax), 2));
		return LXX;
	}
	public static double getLXY(double[] datax,double[] datay){
		int n=datax.length;
		double[] data=getXY(datax,datay);
		double LXY;
		LXY=getArraySUM(data)-n*(getMeanX(datax)*getMeanY(datay));
		return LXY;
	}
	public static double getLYY(double[] datay){
		int n=datay.length;
		double LYY;
		LYY=getArraySUM(getXS(datay))-n*(Math.pow(getMeanX(datay), 2));
		return LYY;
	}
	/**
	 * 获得两个数组之间的线性相关性
	 * */
	public static double getR(double[] datax,double[] datay){
		double LXY=getLXY(datax,datay);
		double LXX=getLXX(datax);
		double LYY=getLYY(datay);
		double r;
		r=LXY/((Math.sqrt(LXX))*(Math.sqrt(LYY)));
		return r;
	}
	/**
	 * 获得SSR
	 * */
	public static double getSSR(){
		return 0;
	} 

}    


System.out.println("center="+center);if(center==1e308){try{throw new Exception("不好意思，出了差错");}catch(Exception e){e.printStackTrace();}}this.ClusterCenter=center;return this.ClusterCenter;}public void setClusterData(double[] clusterData) {ClusterData = clusterData;}/**
 * 获得当前聚类的大小 * */public int getSize(){return this.ClusterData.length;}public double getClusterCenter() {return ClusterCenter;}public void setClusterCenter(double clusterCenter) {ClusterCenter = clusterCenter;}/** * toString方法 * */public String toString(){return
 "ClusterCenter="+this.ClusterCenter+","+Arrays.toString(ClusterData);}public double[] getClusterData() {return ClusterData;}/** * 清空cluster数据区域 * */public void clearData(){this.listData.clear();}}