用java实现K-means算法，k-means聚类算法原理

最新推荐文章于 2024-06-27 08:27:04 发布
最新推荐文章于 2024-06-27 08:27:04 发布
阅读量1.7w 收藏 91
点赞数 15
分类专栏： java 文章标签： java java实现K-means算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keseliugeizuori/article/details/53162171
版权

1、从包含多个数据点的数据集D中随机取k个点，作为k个簇的各自的中心。

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

   两个点之间的相异度大小采用欧氏距离公式衡量，对于两个点T0(x1,y2)和T1(x2,y2)，

   T0和T1之间的欧氏距离为

       d = sqrt((x1-x2)^2+(y1-y2)^2)

  欧氏距离越小，说明相异度越小

 

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

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

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

6、将结果输出。

 

举例说明，假设包含9个点数据D如下(见simple_k-means.txt),从D中随机取k个元素，

作为k个簇的各自的中心, 假设选k=2, 即将如下的9个点聚类成两个类(cluster)。

1  1

2  1

1  2

2  2

3  3

8  8

8  9

9  8

9  9

 

1.      假设选C0(1  1)和C1(2  1)前两个点作为两个类的簇心。

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

 

3.     根据2的聚类结果，重新计算k个簇各自的中心，计算方法是取簇中所

有元素各自维度的算术平均数。

C0 新的簇心为：1.0,1.5

C1新的簇心为：5.857142857142857,  5.714285714285714

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

 

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

当每个簇心点前后移动的距离小于某个阈值t的时候，就认为聚类已经

结束了，不需要再迭代，这里的值选t=0.001，距离计算采用欧氏距离

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

C0的簇心为：1.6666666666666667,1.75

C1的簇心为：7.971428571428572, 7.942857142857143

各个簇心移动中最小的距离为，moveDistance=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

各个簇心移动中最小的距离为，moveDistance  = 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

各个簇心移动中最小的距离为，moveDistance=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

各个簇心移动中最小的距离为，moveDistance=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

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

*************************************************************************************

K_means类，代码如下：

package Kmeans;

import java.util.ArrayList;  
import java.util.Random;  
   
public class k_means {  
    private int k;// 分成多少簇  
    private int m;// 迭代次数  
    private int dataSetLength;// 数据集元素个数，即数据集的长度  
    private ArrayList<float[]> dataSet;// 数据集链表  
    private ArrayList<float[]> center;// 中心链表  
    private ArrayList<ArrayList<float[]>> cluster; // 簇  
    private ArrayList<Float> jc;// 误差平方和，k越接近dataSetLength，误差越小  
    private Random random;  
   
    public void setDataSet(ArrayList<float[]> dataSet) {  
    	//设置需分组的原始数据集
        this.dataSet = dataSet;  
    }  

    public ArrayList<ArrayList<float[]>> getCluster() {  
        return cluster;  
    }  
   
    public k_means(int k) {  
    	//传入需要分成的簇数量
        if (k <= 0) {  
            k = 1;  
        }  
        this.k = k;  
    }  
  
    private void init() { 
    	//初始化
        m = 0;  
        random = new Random();  
        if (dataSet == null || dataSet.size() == 0) {   
        	System.out.println("数据为空，请输入数据！！！！");
        } else{
        	dataSetLength = dataSet.size();  
        	if (k > dataSetLength) {  
        		k = dataSetLength;  
        	}  
        	center = initCenters();  
        	cluster = initCluster();  
        	jc = new ArrayList<Float>();  
        	}
    }  
  
    private ArrayList<float[]> initCenters() {  
    	//初始化中心数据链表，分成多少簇就有多少个中心点
        ArrayList<float[]> center = new ArrayList<float[]>();  
        int[] randoms = new int[k];  
        boolean flag;  
        int temp = random.nextInt(dataSetLength);  
        randoms[0] = temp;  
        for (int i = 1; i < k; i++) {  
            flag = true;  
            while (flag) {  
                temp = random.nextInt(dataSetLength);  
                int j = 0;  
                while (j < i) {  
                    if (temp == randoms[j]) {  
                        break;  
                    }  
                    j++;  
                }  
                if (j == i) {  
                    flag = false;  
                }  
            }  
            randoms[i] = temp;  
        }   
        for (int i = 0; i < k; i++) {  
            center.add(dataSet.get(randoms[i]));// 生成初始化中心链表  
        }  
        return center;  
    }  
  
 
    private ArrayList<ArrayList<float[]>> initCluster() {  
    	//初始化簇集合
        ArrayList<ArrayList<float[]>> cluster = new ArrayList<ArrayList<float[]>>();  
        for (int i = 0; i < k; i++) {  
            cluster.add(new ArrayList<float[]>());  
        }  
  
        return cluster;  
    }  
  

    private float distance(float[] element, float[] center) {  
    	//计算两个点之间的距离
        float distance = 0.0f;  
        float x = element[0] - center[0];  
        float y = element[1] - center[1];  
        float z = x * x + y * y;  
        distance = (float) Math.sqrt(z);  
  
        return distance;  
    }  
  
  
    private int minDistance(float[] distance) {  
    	 //获取距离集合中最小距离的位置
        float minDistance = distance[0];  
        int minLocation = 0;  
        for (int i = 1; i < distance.length; i++) {  
            if (distance[i] < minDistance) {  
                minDistance = distance[i];  
                minLocation = i;  
            } else if (distance[i] == minDistance) // 如果相等，随机返回一个位置  
            {  
                if (random.nextInt(10) < 5) {  
                    minLocation = i;  
                }  
            }  
        }  
  
        return minLocation;  
    }  
  
 
    private void clusterSet() {  
    	//将当前元素放到最小距离中心相关的簇中
        float[] distance = new float[k];  
        for (int i = 0; i < dataSetLength; i++) {  
            for (int j = 0; j < k; j++) {  
                distance[j] = distance(dataSet.get(i), center.get(j));  
            }  
            int minLocation = minDistance(distance);  
            cluster.get(minLocation).add(dataSet.get(i));  
  
        }  
    }  
  

    private float errorSquare(float[] element, float[] center) {
    	//求两点误差平方的方法 
        float x = element[0] - center[0];  
        float y = element[1] - center[1];  
  
        float errSquare = x * x + y * y;  
  
        return errSquare;  
    }  
  
  
    private void countRule() {  
    	//计算误差平方和准则函数方法
        float jcF = 0;  
        for (int i = 0; i < cluster.size(); i++) {  
            for (int j = 0; j < cluster.get(i).size(); j++) {  
                jcF += errorSquare(cluster.get(i).get(j), center.get(i));  
  
            }  
        }  
        jc.add(jcF);  
    }  
    private void setNewCenter() { 
    	//设置新的簇中心方法
        for (int i = 0; i < k; i++) {  
            int n = cluster.get(i).size();  
            if (n != 0) {  
                float[] newCenter = { 0, 0 };  
                for (int j = 0; j < n; j++) {  
                    newCenter[0] += cluster.get(i).get(j)[0];  
                    newCenter[1] += cluster.get(i).get(j)[1];  
                }  
                // 设置一个平均值  
                newCenter[0] = newCenter[0] / n;  
                newCenter[1] = newCenter[1] / n;  
                center.set(i, newCenter);  
            }  
        }  
    }  
    
    public void printDataArray(ArrayList<float[]> dataArray,  
            String dataArrayName) { 
    	//打印数据
        for (int i = 0; i < dataArray.size(); i++) {  
            System.out.println("print:(" + dataArray.get(i)[0] + "," + dataArray.get(i)[1]+")");  
        }  
        System.out.println("===================================");  
    }  
   
    void kmeans() {  
        init();  
        // 循环分组，直到误差不变为止  
        while (true) {  
            clusterSet();  
            countRule();   
            // 误差不变了，分组完成  
            if (m != 0) {  
                if (jc.get(m) - jc.get(m - 1) == 0) {  
                    break;  
                }  
            }  
  
            setNewCenter();   
            m++;  
            cluster.clear();  
            cluster = initCluster();  
        }  
    }  
}
ReadData类，代码如下： 

package Kmeans;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class ReadData {
	//从文件中读取数据
public ArrayList<float[]> read(String fileName){
	ArrayList<float[]> arr=new ArrayList<float[]>();
	try {
		BufferedReader reader = new BufferedReader(new FileReader(fileName));
		String line = null;
        while((line=reader.readLine())!=null){
        	String str[] = line.split("\\s+");
        	float[][] point1 = new float[1][2];
        	point1[0][0]=Float.parseFloat(str[0].trim());
        	point1[0][1]=Float.parseFloat(str[1].trim());
        	arr.add(point1[0]);
        }
	}catch (FileNotFoundException e) {
		e.printStackTrace();
	}catch (IOException e) {
		e.printStackTrace();
	}
    	
	return arr;
    	
    }
}
main类，代码如下： 

package Kmeans;

import java.util.ArrayList;
import java.util.Scanner;

public class main {
	public  static void main(String[] args)  
    {  
        //初始化一个Kmean对象，将k置为3
		int num;
		System.out.println("输入要分为的类数：");			
		num=(new Scanner(System.in)).nextInt();
        k_means k=new k_means(num);  
        ArrayList<float[]> dataSet=new ArrayList<float[]>();  
        ReadData rd=new ReadData();
        String fileName="data/11.txt";
		dataSet=rd.read(fileName);
        //设置原始数据集  
        k.setDataSet(dataSet);  
        //执行算法  
        k.kmeans();
        //得到聚类结果  
        ArrayList<ArrayList<float[]>> cluster=k.getCluster();  
        //查看结果  
        for(int i=0;i<cluster.size();i++)  
        {  
            k.printDataArray(cluster.get(i), "cluster["+i+"]");  
        }    
    }  
}

以上代码可能存在一些冗余的部分，没有进行修改，如果需要可以自行拷贝和修改。

-lim-
关注
  • 15
    点赞
  • 踩
  • 91
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
【JAVA实现】K-means聚类算法
C_son的专栏
02-22 5259
上一篇博文介绍了层次聚类算法的实现http://blog.csdn.net/c_son/article/details/43900503 ，可以发现其效率比较低下，因为每次迭代都要计算每两个聚簇之间的距离。这次的k-means算法在效率上要优于层次聚类算法。               算法实现：        1）从样本D中随机选取K个元素，作为K个簇的中心        2）分别计算剩下
K-Means聚类算法java实现
追梦恋影的博客
07-28 2148
对于K-Means算法想必做机器学习和数据挖掘的广大同胞们已经不再陌生，做为数据挖据的十大经典算法之一，k-Means做聚类分析上有得天独厚的优势。对于其原理进行简单的描述： k-Means算法是典型的基于距离的聚类算法，采用的是距离作为相似性指标。经过n次迭代后，当中心的位置不在发生变换的时候即是收敛完成。 算法：            1. 从n个文档中随机的选择出k个文档作为质心  
k-means kmeans k均值 算法 java
06-08
k-means kmeans k均值 算法 用java实现的k均值算法 200行左右 可以通过文件读取空间二维点坐标，聚类结果将格式化输出到文本，利用excel就可以实现可视化
Java实现K-Means算法
虚言假面的博客
12-07 4962
K-means算法基本思想 在数据集中根据一定策略选择K个点作为每个簇的初始中心，将数据划分到距离这K个点最近的簇中，共分成K个类。也就是说将数据划分成K个簇完成一次划分，但形成的新簇并不一定是最好的划分，因此生成的新簇中，重新计算每个簇的中心点，然后再重新进行划分，直到每次划分的结果保持不变。 算法步骤 随机选择K个中心点 把每个数据点分配到离它最近的中心点（此处的距离采用欧氏距离） 重新计算...
【机器学习】K-means++: 一种改进的聚类算法详解
最新发布
鑫宝的博客
06-27 3288
从数据集中随机选择第一个质心。对于每个数据点x，计算其到已选择的所有质心的最短距离D(x)。选择一个新的数据点作为下一个质心，选择的概率与D(x)成正比，即概率P(x)D(x)/ ΣD(x)。重复步骤2和3，直到选择了K个质心。这种选择策略确保了质心之间的分散性，从而提高了聚类效果。K-means++算法通过一种更加智能的初始化策略，显著改善了经典K-means算法的性能，尤其在解决初始质心选择的随机性和局部最优问题上表现出色。
K-Means聚类算法JAVA实现
x_8efengfan的博客
12-18 3023
使用java实现K-Means聚类算法
java运用kmeans算法进行聚类
m0_46527751的博客
11-08 4886
java运用kmeans算法进行聚类 kmeans算法进行聚类大概步骤如下 选出k值,随机出k个簇的中心点。 分别计算每个点和k个中心点之间的欧式距离,就近归类。 欧式距离计算方法如下： 最终中心点集可以划分为k类,分别重新计算每类中新的中心点。 重新计算的中心点坐标即把当前簇内所有点的x,y坐标分别加起来取平均值 重复2,3步骤对所有点进行归类,如果当所有分类的质心点不再改变,则最终收敛。 接下来以一个例子来进行说明： java代码参考这篇文章为了满足老师作业的要求进行了一定程度
kmeans聚类算法的java实现
04-27
java实现的kmeans聚类算法, 对某张表的某个字段进行kmeans聚类算法,并写到新创建的表中
详解Java实现的k-means聚类算法
08-28
在Java中实现k-means聚类算法需要使用到以下几个重要的概念： 1. ArrayList：ArrayList是Java中的一种集合类型，用于存储数据点。 2. Map：Map是Java中的一种集合类型，用于存储质心和簇的对应关系。 3. SQL：SQL是...
python基于K-means聚类算法的图像分割
09-18
在本文中，我们将深入探讨如何使用Python中的K-means聚类算法进行图像分割。K-means是一种经典的无监督机器学习算法，它通过迭代过程将数据点分配到最近的聚类中心，最终达到聚类的目的。在图像处理领域，图像可以被...
K均值聚类即K-Means算法详解PPT
04-13
在这里，我们将详细介绍K-Means聚类算法的原理、步骤和应用。 一、聚类算法概述 聚类是一种无监督学习方法，旨在将数据点分组成不同的簇，以便发现数据中的模式和结构。聚类算法有很多种，常见的有K-Means聚类、...
java实现k-means算法
01-13
Java 实现 K-Means 算法是一个在数据挖掘领域常见的任务，它主要用于聚类分析，即将数据分组成不同的类别或簇。K-Means 是一种迭代算法，旨在找到数据点的最佳分配，使得每个簇内的数据点尽可能相似，而不同簇之间的...
K-means.rar_K._k-means聚类算法
07-14
总的来说，"K-means.rar_K._k-means聚类算法"提供了一个学习和实践K-means算法的MATLAB平台，通过对代码的理解和修改，你可以深入掌握聚类分析的基本原理，并为后续的机器学习项目打下坚实的基础。
K-means
yanglee0
06-20 265
主要缺点：对于高维度数据，用kmeans方法可能会受到数据形态的影响，其假设高维数据呈球形分布。
【火炉炼AI】机器学习020-使用K-means算法对数据进行聚类分析
weixin_33815613的博客
09-03 538
【火炉炼AI】机器学习020-使用K-means算法对数据进行聚类分析 (本文所使用的Python库和版本号: Python 3.6, Numpy 1.14, scikit-learn 0.19, matplotlib 2.2 ) 前面的机器学习类文章（编号从010-019）都是关于监督学习，但是从本篇文章开始，炼丹老顽童要开始讲解无监督学习方面，无监督学习是指处理的数据没有任何形式的标记，我们没...
算法 聚类（划分）K-means
u012842247的专栏
12-11 825
什么是k-means 算法？ 是聚类算法的一种，聚类算法中的划分聚类算法，属于无监督学习方法。 算法思想？ 1、首先确定划分群体的个数k 2、随机从数据集中选取k个中心点，这里使用欧几里德距离公式计算数据集任意一点到中心点的距离，把距离中心点近的划分一类。 3、重复步骤2.从第一次的群体中找到相应的中心点，在进行群体划分。 4、重复步骤2、3 直到 数据收敛或满足迭代次数。 ---...
kmeans聚类算法java_K-Means聚类算法
weixin_42474220的博客
02-13 688
一、聚类思想所谓聚类算法是指将一堆没有标签的数据自动划分成几类的方法，属于无监督学习方法，这个方法要保证同一类的数据有相似的特征，如下图所示：根据样本之间的距离或者说是相似性(亲疏性)，把越相似、差异越小的样本聚成一类(簇)，最后形成多个簇，使同一个簇内部的样本相似度高，不同簇之间差异性高。二、k-means聚类分析算法相关概念：K值：要得到的簇的个数质心：每个簇的均值向量，即向量各维取平均即可距...
Java实现的k-means聚类算法
maibaodexiaoerlang的博客
03-20 366
需求对MySQL数据库中某个表的某个字段执行k-means算法,将处理后的数据写入新表中。 源码及驱动http://download.csdn.net/download/xiaobuding007/10203673 源码import java.sql.*; import java.util.*; /** * @author tianshl * @version 2018/1/13 上午1...
聚类算法之KMeans(Java实现)
wangtao6791842的专栏
09-17 1148
聚类算法之KMeans(Java实现) KMeans算法的基本思想是初始随机给定K个簇中心，按照最邻近原则把待分类样本点分到各个簇。然后按平均法重新计算各个簇的质心，从而确定新的簇心。一直迭代，直到簇心的移动距离小于某个给定的值。 当初始簇心选行不好时，KMeans的结果会很差，所以一般是多运行几次，按照一定标准（比如簇内的方差最小化）选择一个比较好的结果。 下图给出对坐标点的聚类结
Python实现K-Means聚类算法详解
"这篇资源详细介绍了K-Means算法，包括其原理和Python实现，并提到了使用scikit-learn库进行聚类的方法。" K-Means算法是一种经典的无监督机器学习方法，主要用于数据的聚类，即将相似的数据对象归为一类。聚类是一...
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值