k-means聚类JAVA实例

《mahout in action》第六章。

datafile/cluster/simple_k-means.txt数据集如下：

1 1
2 1
1 2
2 2
3 3
8 8
8 9
9 8
9 9

1. k-means聚类算法原理

1、从D中随机取k个元素，作为k个簇的各自的中心。

2、分别计算剩下的元素到k个簇中心的相异度，将这些元素分别划归到相异度最低的簇。

3、根据聚类结果，重新计算k个簇各自的中心，计算方法是取簇中所有元素各自维度的算术平均数。

4、将D中全部元素按照新的中心重新聚类。

5、重复第4步，直到聚类结果不再变化。

6、将结果输出。

2. 举例说明

2.1 从D中随机取k个元素，作为k个簇的各自的中心。

private final static Integer K=2; //选K=2，也就是估算有两个簇。

下面选1 1，2，1两个点。

C0:1 1

C1:2 1

2.2 分别计算剩下的元素到k个簇中心的相异度，将这些元素分别划归到相异度最低的簇。

结果为：

C0 : 1 1
C0:的点为：1.0,2.0
C1:  2 1
C1:的点为：2.0,2.0
C1:的点为：3.0,3.0
C1:的点为：8.0,8.0
C1:的点为：8.0,9.0
C1:的点为：9.0,8.0
C1:的点为：9.0,9.0

2.3 根据2.2的聚类结果，重新计算k个簇各自的中心，计算方法是取簇中所有元素各自维度的算术平均数。

采取欧区距离公式。

C0 新的簇心为：1.0,1.5

C1 新的簇心为：5.857142857142857,5.714285714285714

2.4 将D中全部元素按照新的中心重新聚类。

第2次迭代
C0:的点为：1.0,1.0
C0:的点为：2.0,1.0
C0:的点为：1.0,2.0
C0:的点为：2.0,2.0
C0:的点为：3.0,3.0
C1:的点为：8.0,8.0
C1:的点为：8.0,9.0
C1:的点为：9.0,8.0
C1:的点为：9.0,9.0

2.5  重复第4步，直到聚类结果不再变化。

当距离小于某个值的时候，就认为聚类已经聚类了，不需要再迭代，这里的值选0.001

private final static Double converge=0.001;

------------------------------------------------
C0的簇心为：1.6666666666666667,1.75
C1的簇心为：7.971428571428572,7.942857142857143
各个簇心移动中最小的距离为，move=0.7120003121097943
第3次迭代
C0:的点为：1.0,1.0
C0:的点为：2.0,1.0
C0:的点为：1.0,2.0
C0:的点为：2.0,2.0
C0:的点为：3.0,3.0
C1:的点为：8.0,8.0
C1:的点为：8.0,9.0
C1:的点为：9.0,8.0
C1:的点为：9.0,9.0
------------------------------------------------
C0的簇心为：1.777777777777778,1.7916666666666667
C1的簇心为：8.394285714285715,8.388571428571428
各个簇心移动中最小的距离为，move=0.11866671868496578
第4次迭代
C0:的点为：1.0,1.0
C0:的点为：2.0,1.0
C0:的点为：1.0,2.0
C0:的点为：2.0,2.0
C0:的点为：3.0,3.0
C1:的点为：8.0,8.0
C1:的点为：8.0,9.0
C1:的点为：9.0,8.0
C1:的点为：9.0,9.0
------------------------------------------------
C0的簇心为：1.7962962962962965,1.7986111111111114
C1的簇心为：8.478857142857143,8.477714285714285
各个簇心移动中最小的距离为，move=0.019777786447494432
第5次迭代
C0:的点为：1.0,1.0
C0:的点为：2.0,1.0
C0:的点为：1.0,2.0
C0:的点为：2.0,2.0
C0:的点为：3.0,3.0
C1:的点为：8.0,8.0
C1:的点为：8.0,9.0
C1:的点为：9.0,8.0
C1:的点为：9.0,9.0
------------------------------------------------
C0的簇心为：1.799382716049383,1.7997685185185184
C1的簇心为：8.495771428571429,8.495542857142857
各个簇心移动中最小的距离为，move=0.003296297741248916
第6次迭代
C0:的点为：1.0,1.0
C0:的点为：2.0,1.0
C0:的点为：1.0,2.0
C0:的点为：2.0,2.0
C0:的点为：3.0,3.0
C1:的点为：8.0,8.0
C1:的点为：8.0,9.0
C1:的点为：9.0,8.0
C1:的点为：9.0,9.0
------------------------------------------------
C0的簇心为：1.7998971193415638,1.7999614197530864
C1的簇心为：8.499154285714287,8.499108571428572
各个簇心移动中最小的距离为，move=5.49382956874724E-4

3. JAVA实现

package mysequence.machineleaning.clustering.kmeans;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import mysequence.machineleaning.clustering.canopy.Point;

public class MyKmeans {

	static Vector<Point>  li=new Vector<Point>();
	//static List<Point>  li=new ArrayList<Point>();
	static List<Vector<Point>> list=new ArrayList<Vector<Point>>(); //每次迭代保存结果，一个vector代表一个簇
	private final static Integer K=2; //选K=2，也就是估算有两个簇。
	private final static Double converge=0.001; //当距离小于某个值的时候，就认为聚类已经聚类了，不需要再迭代，这里的值选0.001	

	//读取数据
	public static final void readF1() throws IOException {
		String filePath="datafile/cluster/simple_k-means.txt";
		BufferedReader br = new BufferedReader(new InputStreamReader(
        new FileInputStream(filePath)));
        for (String line = br.readLine(); line != null; line = br.readLine()) {
            if(line.length()==0||"".equals(line))continue;
        	String[] str=line.split(" ");
            Point p0=new Point();
    		p0.setX(Double.valueOf(str[0]));
    		p0.setY(Double.valueOf(str[1]));
    		li.add(p0);
            //System.out.println(line);
        }
        br.close();
    }
	  //math.sqrt(double n)
    //扩展下，如果要给m开n次方就用java.lang.StrictMath.pow(m,1.0/n);
	//采用欧氏距离
	public static  Double DistanceMeasure(Point p1,Point p2){

		Double tmp=StrictMath.pow(p2.getX()-p1.getX(), 2)+StrictMath.pow(p2.getY()-p1.getY(), 2);
		return Math.sqrt(tmp);
	}

	//计算新的簇心
	public static Double CalCentroid(){
		System.out.println("------------------------------------------------");
		Double movedist=Double.MAX_VALUE;
		for(int i=0;i<list.size();i++){
			Vector<Point> subli=list.get(i);
			Point po=new Point();
			Double sumX=0.0;
			Double sumY=0.0;
			Double Clusterlen=Double.valueOf(subli.size());
			for(int j=0;j<Clusterlen;j++){
				Point nextp=subli.get(j);
				sumX=sumX+nextp.getX();
				sumY=sumY+nextp.getY();
			}
			po.setX(sumX/Clusterlen);
			po.setY(sumY/Clusterlen);
			//新的点与旧点之间的距离
			Double dist=DistanceMeasure(subli.get(0),po);
			//在多个簇心移动的过程中，返回移动距离最小的值
			if(dist<movedist)movedist=dist;
			list.get(i).clear();
			list.get(i).add(po);
			System.out.println("C"+i+"的簇心为："+po.getX()+","+po.getY());
		}
		String test="ll";
		return movedist;
	}
	//本次的簇心
	//下一次移动的簇心

	private static Double move=Double.MAX_VALUE;//移动距离
	//不断地迭代，直到收敛
	public static void RecursionKluster(){
		for(int times=2;move>converge;times++){
			System.out.println("第"+times+"次迭代");
			//默认每一个list里的Vector第0个元素是质心
			for(int i=0;i<li.size();i++){
				Point p=new Point();
				 p=li.get(i);
				int index = -1;

	            double neardist = Double.MAX_VALUE;
				for(int k=0;k<K;k++){
					Point centre=list.get(k).get(0);
					double currentdist=DistanceMeasure(p,centre);
					if(currentdist<neardist){
						neardist=currentdist;
						index=k;
					}
				}

				System.out.println("C"+index+":的点为："+p.getX()+","+p.getY());
				list.get(index).add(p);

			}
			//重新计算簇心,并返回移动的距离，最小的那个距离

			move=CalCentroid();
			System.out.println("各个簇心移动中最小的距离为，move="+move);
		}
	}

	public static void Kluster(){

		for(int k=0;k<K;k++){
			Vector<Point> vect=new Vector<Point>();
			Point p=new Point();
			p=li.get(k);
			vect.add(p);
			list.add(vect);
		}
		System.out.println("第1次迭代");
		//默认每一个list里的Vector第0个元素是质心
		for(int i=K;i<li.size();i++){
			Point p=new Point();
			 p=li.get(i);
			int index = -1;

            double neardist = Double.MAX_VALUE;
			for(int k=0;k<K;k++){
				Point centre=list.get(k).get(0);
				double currentdist=DistanceMeasure(p,centre);
				if(currentdist<neardist){
					neardist=currentdist;
					index=k;
				}
			}

			System.out.println("C"+index+":的点为："+p.getX()+","+p.getY());
			list.get(index).add(p);

		}

	}

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		//读取数据
		readF1();
		//第一次迭代
		Kluster();
		//第一次迭代后计算簇心
		CalCentroid();
		//不断迭代，直到收敛
		RecursionKluster();
	}

}

4.运行结果：

C0:1 1

C1:2 1

第1次迭代

C0:的点为：1.0,2.0

C1:的点为：2.0,2.0

C1:的点为：3.0,3.0

C1:的点为：8.0,8.0

C1:的点为：8.0,9.0

C1:的点为：9.0,8.0

C1:的点为：9.0,9.0

------------------------------------------------

C0的簇心为：1.0,1.5

C1的簇心为：5.857142857142857,5.714285714285714

第2次迭代

C0:的点为：1.0,1.0

C0:的点为：2.0,1.0

C0:的点为：1.0,2.0

C0:的点为：2.0,2.0

C0:的点为：3.0,3.0

C1:的点为：8.0,8.0

C1:的点为：8.0,9.0

C1:的点为：9.0,8.0

C1:的点为：9.0,9.0

------------------------------------------------

C0的簇心为：1.6666666666666667,1.75

C1的簇心为：7.971428571428572,7.942857142857143

各个簇心移动中最小的距离为，move=0.7120003121097943

第3次迭代

C0:的点为：1.0,1.0

C0:的点为：2.0,1.0

C0:的点为：1.0,2.0

C0:的点为：2.0,2.0

C0:的点为：3.0,3.0

C1:的点为：8.0,8.0

C1:的点为：8.0,9.0

C1:的点为：9.0,8.0

C1:的点为：9.0,9.0

------------------------------------------------

C0的簇心为：1.777777777777778,1.7916666666666667

C1的簇心为：8.394285714285715,8.388571428571428

各个簇心移动中最小的距离为，move=0.11866671868496578

第4次迭代

C0:的点为：1.0,1.0

C0:的点为：2.0,1.0

C0:的点为：1.0,2.0

C0:的点为：2.0,2.0

C0:的点为：3.0,3.0

C1:的点为：8.0,8.0

C1:的点为：8.0,9.0

C1:的点为：9.0,8.0

C1:的点为：9.0,9.0

------------------------------------------------

C0的簇心为：1.7962962962962965,1.7986111111111114

C1的簇心为：8.478857142857143,8.477714285714285

各个簇心移动中最小的距离为，move=0.019777786447494432

第5次迭代

C0:的点为：1.0,1.0

C0:的点为：2.0,1.0

C0:的点为：1.0,2.0

C0:的点为：2.0,2.0

C0:的点为：3.0,3.0

C1:的点为：8.0,8.0

C1:的点为：8.0,9.0

C1:的点为：9.0,8.0

C1:的点为：9.0,9.0

------------------------------------------------

C0的簇心为：1.799382716049383,1.7997685185185184

C1的簇心为：8.495771428571429,8.495542857142857

各个簇心移动中最小的距离为，move=0.003296297741248916

第6次迭代

C0:的点为：1.0,1.0

C0:的点为：2.0,1.0

C0:的点为：1.0,2.0

C0:的点为：2.0,2.0

C0:的点为：3.0,3.0

C1:的点为：8.0,8.0

C1:的点为：8.0,9.0

C1:的点为：9.0,8.0

C1:的点为：9.0,9.0

------------------------------------------------

C0的簇心为：1.7998971193415638,1.7999614197530864

C1的簇心为：8.499154285714287,8.499108571428572

各个簇心移动中最小的距离为，move=5.49382956874724E-4

k-means聚类JAVA实例

时间： 2024-10-11 06:49:09

k-means聚类JAVA实例的相关文章

k means聚类过程

k-means是一种非监督 (从下图0 当中我们可以看到训练数据并没有标签标注类别)的聚类算法 0.initial 1.select centroids randomly 2.assign points 3.update centroids 4.reassign points 5.update centroids 6.reassign points 7.iteration reference: https://www.naftaliharris.com/blog/visualizing-k-me

机器学习实战5：k-means聚类：二分k均值聚类+地理位置聚簇实例

k-均值聚类是非监督学习的一种,输入必须指定聚簇中心个数k.k均值是基于相似度的聚类,为没有标签的一簇实例分为一类. 一 经典的k-均值聚类 思路: 1 随机创建k个质心(k必须指定,二维的很容易确定,可视化数据分布,直观确定即可): 2 遍历数据集的每个实例,计算其到每个质心的相似度,这里也就是欧氏距离:把每个实例都分配到距离最近的质心的那一类,用一个二维数组数据结构保存,第一列是最近质心序号,第二列是距离: 3 根据二维数组保存的数据,重新计算每个聚簇新的质心: 4 迭代2 和 3,直到收敛

k均值聚类

目录 一.k均值简介 二.应用简介 三.算法 四.选择合适的K 五.具体实例 一.k均值简介 K均值聚类是一种无监督学习,对未标记的数据(即没有定义类别或组的数据)进行分类. 该算法的目标是在数据中找到由变量K标记的组.该算法迭代地工作基于所提供的特征,将每个数据点分配给K个组中的一个. 基于特征相似性对数据点进行聚类. K均值聚类算法的结果是: 1.K簇的质心,可用于标记新数据 2.训练数据的标签(每个数据点分配给一个集群) 二.应用简介 K均值聚类算法用于查找未在数据中明确标记的组.这可用于

第十篇：K均值聚类(KMeans)

前言 本文讲解如何使用R语言进行 KMeans 均值聚类分析,并以一个关于人口出生率死亡率的实例演示具体分析步骤. 聚类分析总体流程 1. 载入并了解数据集:2. 调用聚类函数进行聚类:3. 查看聚类结果描述:4. 将聚类结果图形化展示:5. 选择最优center并最终确定聚类方案:6. 图形化展示不同方案效果并提交分析报表. 人口出生/死亡率聚类分析 - K均值聚类 1. 载入并了解数据集 1.1 从网上下载一份txt格式的关于人口出生率统计的数据(countries.txt).其内容大致如下

机器学习--k均值聚类(k-means)算法

一.基本原理 分类是指分类器根据已标注类别的训练集,通过训练可以对未知类别的样本进行分类.分类被称为监督学习.如果训练集的样本没有标注类别,那么就需要用到聚类.聚类是把相似的样本聚成一类,这种相似性通常以距离来度量.聚类被称为无监督学习. 聚类是指根据"物以类聚"的原理,将本身没有类别的样本聚集成不同的组,这样的一组数据对象的集合叫做簇,并且对每一个这样的簇进行描述的过程.它的目的是使得属于同一个簇的样本之间应该彼此相似,而不同簇的样本应该足够不相似.与分类规则不同,进行聚类前并不知道

Sklearn K均值聚类

## 版权所有,转帖注明出处 章节 SciKit-Learn 加载数据集 SciKit-Learn 数据集基本信息 SciKit-Learn 使用matplotlib可视化数据 SciKit-Learn 可视化数据:主成分分析(PCA) SciKit-Learn 预处理数据 SciKit-Learn K均值聚类 SciKit-Learn 支持向量机 SciKit-Learn 速查 到目前为止,我们已经非常深入地了解了数据集,并且把它分成了训练子集与测试子集. 接下来,我们将使用聚类方法训练一个模

微信公众平台接入Java实例，结合BAE

关于注册公众账号这块不详细介绍 注册完成,审核认证完,就可以开始玩了 1.如何成为开发者? 需要填写接口配置信息,需要自己的服务器资源,一般自己没有服务器,所以可以采用云服务器,例如BAE,SAE,阿里云服务器.这里用BAE 2.打开百度开放云平台官网,注册,登陆,点击开发者服务管理 2.1.点击"创建工程" 填写工程相关信息,应用名称自定义,类型选择java-tomcat,域名唯一,代码管理工具选择svn     到这里,bae应用创建完了. 3.现在来实现TOKEN验证的代码部分

相似算法 ，Java实例9 - 汉明距离 Hamming Distance

Java实例9 - 汉明距离 Hamming Distance http://blog.csdn.net/kindterry/article/details/6581344 /**在信息理论中,两个等长字符串之间的汉明距离 * 是两个字符串对应位置上不同字符的个数, * 换句话说,汉明距离就是将一个字符串替换成另外一个字符串所需要替换的字符长度. *例如,1011101和1001001之间的汉明距离是2, *toned和roses之间的汉明距离是3. *汉明重量是字符串相对于同样长度的零字符串的

R与数据分析旧笔记（十五） 基于有代表性的点的技术：K中心聚类法

基于有代表性的点的技术:K中心聚类法 基于有代表性的点的技术:K中心聚类法 算法步骤 随机选择k个点作为"中心点" 计算剩余的点到这个k中心点的距离,每个点被分配到最近的中心点组成聚簇 随机选择一个非中心点,用它代替某个现有的中心点,计算这个代换的总代价S 如果S<0,则用代替,形成新的k个中心点集合 重复2,直至中心点集合不发生变化 K中心法的实现:PAM PAM使用离差平方和来计算成本S(类似于ward距离的计算) R语言的cluster包实现了PAM K中心法的优点:对于&