K-Means聚类算法

更多数据挖掘算法：https://github.com/linyiqun/DataMiningAlgorithm

算法介绍

K-Means又名为K均值算法，他是一个聚类算法，这里的K就是聚簇中心的个数，代表数据中存在多少数据簇。K-Means在聚类算法中算是非常简单的一个算法了。有点类似于KNN算法，都用到了距离矢量度量，用欧式距离作为小分类的标准。

算法步骤

(1)、设定数字k，从n个初始数据中随机的设置k个点为聚类中心点。

(2)、针对n个点的每个数据点，遍历计算到k个聚类中心点的距离，最后按照离哪个中心点最近，就划分到那个类别中。

(3)、对每个已经划分好类别的n个点，对同个类别的点求均值，作为此类别新的中心点。

(4)、循环(2)，(3)直到最终中心点收敛。

以上的计算过程将会在下面我的程序实现中有所体现。

算法的代码实现

输入数据：

[java] view plain copy print ?

1. 33
2. 410
3. 96
4. 148
5. 1811
6. 217

主实现类：

[java] view plain copy print ?

1. packageDataMining_KMeans;
3. importjava.io.BufferedReader;
4. importjava.io.File;
5. importjava.io.FileReader;
6. importjava.io.IOException;
7. importjava.text.MessageFormat;
8. importjava.util.ArrayList;
9. importjava.util.Collections;
11. /**
12. *k均值算法工具类
13. *
14. *@authorlyq
15. *
16. */
17. publicclassKMeansTool{
18. //输入数据文件地址
19. privateStringfilePath;
20. //分类类别个数
21. privateintclassNum;
22. //类名称
23. privateArrayList<String>classNames;
24. //聚类坐标点
25. privateArrayList<Point>classPoints;
26. //所有的数据左边点
27. privateArrayList<Point>totalPoints;
29. publicKMeansTool(StringfilePath,intclassNum){
30. this.filePath=filePath;
31. this.classNum=classNum;
32. readDataFile();
33. }
35. /**
36. *从文件中读取数据
37. */
38. privatevoidreadDataFile(){
39. Filefile=newFile(filePath);
40. ArrayList<String[]>dataArray=newArrayList<String[]>();
42. try{
43. BufferedReaderin=newBufferedReader(newFileReader(file));
44. Stringstr;
45. String[]tempArray;
46. while((str=in.readLine())!=null){
47. tempArray=str.split("");
48. dataArray.add(tempArray);
49. }
50. in.close();
51. }catch(IOExceptione){
52. e.getStackTrace();
53. }
55. classPoints=newArrayList<>();
56. totalPoints=newArrayList<>();
57. classNames=newArrayList<>();
58. for(inti=0,j=1;i<dataArray.size();i++){
59. if(j<=classNum){
60. classPoints.add(newPoint(dataArray.get(i)[0],
61. dataArray.get(i)[1],j+""));
62. classNames.add(i+"");
63. j++;
64. }
65. totalPoints
66. .add(newPoint(dataArray.get(i)[0],dataArray.get(i)[1]));
67. }
68. }
70. /**
71. *K均值聚类算法实现
72. */
73. publicvoidkMeansClustering(){
74. doubletempX=0;
75. doubletempY=0;
76. intcount=0;
77. doubleerror=Integer.MAX_VALUE;
78. Pointtemp;
80. while(error>0.01*classNum){
81. for(Pointp1:totalPoints){
82. //将所有的测试坐标点就近分类
83. for(Pointp2:classPoints){
84. p2.computerDistance(p1);
85. }
86. Collections.sort(classPoints);
88. //取出p1离类坐标点最近的那个点
89. p1.setClassName(classPoints.get(0).getClassName());
90. }
92. error=0;
93. //按照均值重新划分聚类中心点
94. for(Pointp1:classPoints){
95. count=0;
96. tempX=0;
97. tempY=0;
98. for(Pointp:totalPoints){
99. if(p.getClassName().equals(p1.getClassName())){
100. count++;
101. tempX+=p.getX();
102. tempY+=p.getY();
103. }
104. }
105. tempX/=count;
106. tempY/=count;
108. error+=Math.abs((tempX-p1.getX()));
109. error+=Math.abs((tempY-p1.getY()));
110. //计算均值
111. p1.setX(tempX);
112. p1.setY(tempY);
114. }
116. for(inti=0;i<classPoints.size();i++){
117. temp=classPoints.get(i);
118. System.out.println(MessageFormat.format("聚类中心点{0}，x={1},y={2}",
119. (i+1),temp.getX(),temp.getY()));
120. }
121. System.out.println("----------");
122. }
124. System.out.println("结果值收敛");
125. for(inti=0;i<classPoints.size();i++){
126. temp=classPoints.get(i);
127. System.out.println(MessageFormat.format("聚类中心点{0}，x={1},y={2}",
128. (i+1),temp.getX(),temp.getY()));
129. }
131. }
133. }

坐标点类：

[java] view plain copy print ?

1. packageDataMining_KMeans;
3. /**
4. *坐标点类
5. *
6. *@authorlyq
7. *
8. */
9. publicclassPointimplementsComparable<Point>{
10. //坐标点横坐标
11. privatedoublex;
12. //坐标点纵坐标
13. privatedoubley;
14. //以此点作为聚类中心的类的类名称
15. privateStringclassName;
16. //坐标点之间的欧式距离
17. privateDoubledistance;
19. publicPoint(doublex,doubley){
20. this.x=x;
21. this.y=y;
22. }
24. publicPoint(Stringx,Stringy){
25. this.x=Double.parseDouble(x);
26. this.y=Double.parseDouble(y);
27. }
29. publicPoint(Stringx,Stringy,StringclassName){
30. this.x=Double.parseDouble(x);
31. this.y=Double.parseDouble(y);
32. this.className=className;
33. }
35. /**
36. *距离目标点p的欧几里得距离
37. *
38. *@paramp
39. */
40. publicvoidcomputerDistance(Pointp){
41. if(p==null){
42. return;
43. }
45. this.distance=(this.x-p.x)*(this.x-p.x)+(this.y-p.y)
46. *(this.y-p.y);
47. }
49. publicdoublegetX(){
50. returnx;
51. }
53. publicvoidsetX(doublex){
54. this.x=x;
55. }
57. publicdoublegetY(){
58. returny;
59. }
61. publicvoidsetY(doubley){
62. this.y=y;
63. }
65. publicStringgetClassName(){
66. returnclassName;
67. }
69. publicvoidsetClassName(StringclassName){
70. this.className=className;
71. }
73. publicdoublegetDistance(){
74. returndistance;
75. }
77. publicvoidsetDistance(doubledistance){
78. this.distance=distance;
79. }
81. @Override
82. publicintcompareTo(Pointo){
83. //TODOAuto-generatedmethodstub
84. returnthis.distance.compareTo(o.distance);
85. }
87. }

调用类：

[java] view plain copy print ?

1. /**
2. *K-means（K均值）算法调用类
3. *@authorlyq
4. *
5. */
6. publicclassClient{
7. publicstaticvoidmain(String[]args){
8. StringfilePath="C:\\Users\\lyq\\Desktop\\icon\\input.txt";
9. //聚类中心数量设定
10. intclassNum=3;
12. KMeansTooltool=newKMeansTool(filePath,classNum);
13. tool.kMeansClustering();
14. }
15. }

测试输出结果：

[java] view plain copy print ?

1. 聚类中心点1，x=15.5,y=8
2. 聚类中心点2，x=4,y=10
3. 聚类中心点3，x=3,y=3
4. ----------
5. 聚类中心点1，x=17.667,y=8.667
6. 聚类中心点2，x=6.5,y=8
7. 聚类中心点3，x=3,y=3
8. ----------
9. 聚类中心点1，x=17.667,y=8.667
10. 聚类中心点2，x=6.5,y=8
11. 聚类中心点3，x=3,y=3
12. ----------
13. 结果值收敛
14. 聚类中心点1，x=17.667,y=8.667
15. 聚类中心点2，x=6.5,y=8
16. 聚类中心点3，x=3,y=3

K-Means算法的优缺点

1、首先优点当然是算法简单，快速，易懂，没有涉及到特别复杂的数据结构。

2、缺点1是最开始K的数量值以及K个聚类中心点的设置不好定，往往开始时不同的k个中心点的设置对后面迭代计算的走势会有比较大的影响，这时候可以考虑根据类的自动合并和分裂来确定这个k。

3、缺点2由于计算是迭代式的，而且计算距离的时候需要完全遍历一遍中心点，当数据规模比较大的时候，开销就显得比较大了。