算法 - k-means++
Kmeans++算法
Kmeans++算法，主要可以解决初始中心的选择问题，不可解决k的个数问题。
Kmeans++主要思想是选择的初始聚类中心要尽量的远。
做法：
1. 在输入的数据点中随机选一个作为第一个聚类中心。
2. 对于所有数据点，计算它与已有的聚类中心的最小距离D(x)
3. 选择一个数据点作为新增的聚类中心，选择原则：D(x)较大的点被选为聚类中心的概率较大。
4. 重复2~3步骤直到选出k个聚类中心。
5. 运行Kmeans算法。
package com.lfy.main; import java.util.ArrayList; import java.util.List; import java.util.Random; /** * K均值聚类算法 */ public class Kmeans { private int numOfCluster;// 分成多少簇 private int timeOfIteration;// 迭代次数 private int dataSetLength;// 数据集元素个数，即数据集的长度 private ArrayList<float[]> dataSet;// 数据集 private ArrayList<float[]> center;// 质心 private ArrayList<ArrayList<float[]>> cluster; //簇 private ArrayList<Float> sumOfErrorSquare;// 误差平方和 private Random random; /** * 设置需分组的原始数据集 * * @param dataSet */ public void setDataSet(ArrayList<float[]> dataSet) { this.dataSet = dataSet; } /** * 获取结果分组 * * @return 结果集 */ public ArrayList<ArrayList<float[]>> getCluster() { return cluster; } /** * 构造函数，传入需要分成的簇数量 * * @param numOfCluster * 簇数量,若numOfCluster<=0时，设置为1，若numOfCluster大于数据源的长度时，置为数据源的长度 */ public Kmeans(int numOfCluster) { if (numOfCluster <= 0) { numOfCluster = 1; } this.numOfCluster = numOfCluster; } /** * 初始化 */ private void init() { timeOfIteration = 0; random = new Random(); //如果调用者未初始化数据集，则采用内部测试数据集 if (dataSet == null || dataSet.size() == 0) { initDataSet(); } dataSetLength = dataSet.size(); //若numOfCluster大于数据源的长度时，置为数据源的长度 if (numOfCluster > dataSetLength) { numOfCluster = dataSetLength; } center = initCenters(); cluster = initCluster(); sumOfErrorSquare = new ArrayList<Float>(); //查看init质心的选取情况 printDataArray(center,"initCenter"); } /** * 如果调用者未初始化数据集，则采用内部测试数据集 */ private void initDataSet() { dataSet = new ArrayList<float[]>(); // 其中{6,3}是一样的，所以长度为15的数据集分成14簇和15簇的误差都为0 float[][] dataSetArray = new float[][] { { 8, 2 }, { 3, 4 }, { 2, 5 }, { 4, 2 }, { 7, 3 }, { 6, 2 }, { 4, 7 }, { 6, 3 }, { 5, 3 }, { 6, 3 }, { 6, 9 }, { 1, 6 }, { 3, 9 }, { 4, 1 }, { 8, 6 } }; for (int i = 0; i < dataSetArray.length; i++) { dataSet.add(dataSetArray[i]); } } /** * 随机选取k个质点 * 初始化中心点，分成多少簇就有多少个中心点 * * @return 中心点集 */ private ArrayList<float[]> initCenters() { ArrayList<float[]> center = new ArrayList<float[]>(); int[] randoms = new int[numOfCluster]; int temp = random.nextInt(dataSetLength); randoms[0] = temp; //---------------------- List<Integer> list=new ArrayList<Integer>(); list.add(temp); //randoms数组中存放dataSet数据集的不同的下标 for (int i = 1; i < numOfCluster; i++) { // while (true) { // temp = random.nextInt(dataSetLength); // // int j=0; // for(; j<i; j++){ // if(randoms[j] == temp){ // break; // } // } // //没有与任何一个已经选定的质心重复 // //跳出外层循环，设定一个随机质心 // if (j == i) { // break; // } // } //---------------------- ArrayList<float[]> ltemp=new ArrayList<float[]>(); //从剩下的点中继续找质点 for (int k = 0; k < dataSetLength; k++) { //如果该点还没有被选择为质点，则计算它与已有的所有质点的最小距离 if(!list.contains(k)) { float[] distance = new float[numOfCluster]; for (int j = 0; j < list.size(); j++) { //某点k到已有中心点的距离 distance[j] = distance(dataSet.get(k), dataSet.get(list.get(j))); } int j = minDistance(distance); float[] f={0,0}; f[0]=k; f[1]=distance[j]; ltemp.add(f); } } int m=maxDistance(ltemp); temp=(int) ltemp.get(m)[0]; list.add(temp); //---------------------- randoms[i] = temp; } for (int i = 0; i < numOfCluster; i++) { center.add(dataSet.get(randoms[i]));// 生成初始化中心点集 } return center; } /** * 初始化簇集合 * * @return 一个分为k簇的空数据的簇集合 */ private ArrayList<ArrayList<float[]>> initCluster() { ArrayList<ArrayList<float[]>> cluster = new ArrayList<ArrayList<float[]>>(); for (int i = 0; i < numOfCluster; i++) { cluster.add(new ArrayList<float[]>()); } return cluster; } /** * 计算两个点之间的距离 * * @param element * 点1 * @param center * 点2 * @return 距离 */ 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; } /** * 获取距离集合中最小距离的位置 * * @param distance * 距离数组 * @return 最小距离在距离数组中的位置 */ 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; } } return minLocation; } /** * 获取距离集合中最小距离的最大的位置 * * @param distance * 各点最小距离数组 * @return 各点最小距离在距离数组中的位置 */ private int maxDistance(ArrayList<float[]> distance) { float[] maxDistance = distance.get(0); int maxLocation = 0; for (int i = 1; i < distance.size(); i++) { if (distance.get(i)[1] >= maxDistance[1]) { maxDistance = distance.get(i); maxLocation = i; } } return maxLocation; } /** * 核心，将当前元素放到最小距离的簇中 */ private void clusterSet() { float[] distance = new float[numOfCluster]; for (int i = 0; i < dataSetLength; i++) { for (int j = 0; j < numOfCluster; j++) { //计算数据集点与所有中心点的距离 distance[j] = distance(dataSet.get(i), center.get(j)); } int j = minDistance(distance); // 核心，将当前元素放到最小距离中心相关的簇中 cluster.get(j).add(dataSet.get(i)); } } /** * 求族中各点到其中心点距离的平方，即误差平方 * * @param element * 点1 * @param center * 点2 * @return 误差平方 */ 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)); } } sumOfErrorSquare.add(jcF); } /** * 设置新的簇中心方法 */ private void setNewCenter() { for (int i = 0; i < numOfCluster; 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); } } printDataArray(center,"newCenter"); } /** * 打印数据，测试用 * * @param dataArray * 数据集 * @param dataArrayName * 数据集名称 */ public void printDataArray(ArrayList<float[]> dataArray, String dataArrayName) { for (int i = 0; i < dataArray.size(); i++) { System.out.println("print:" + dataArrayName + "[" + i + "]={" + dataArray.get(i)[0] + "," + dataArray.get(i)[1] + "}"); } System.out.println("==================================="); } /** * Kmeans算法核心过程方法 */ private void kmeans() { init(); // 循环分组，直到误差不变为止 while (true) { clusterSet(); countRule(); // 误差不变了，分组完成 if (timeOfIteration != 0) { if (sumOfErrorSquare.get(timeOfIteration) - sumOfErrorSquare.get(timeOfIteration - 1) == 0) { break; } } //设置各簇新的质心，继续迭代 setNewCenter(); timeOfIteration++; cluster.clear(); cluster = initCluster(); } System.out.println("note:the times of repeat:timeOfIteration="+timeOfIteration);//输出迭代次数 } /** * 执行算法 */ public void execute() { long startTime = System.currentTimeMillis(); System.out.println("kmeans begins"); kmeans(); long endTime = System.currentTimeMillis(); System.out.println("kmeans running time=" + (endTime - startTime) + "ms"); System.out.println("kmeans ends"); System.out.println(); } }
package com.lfy.main; import java.util.ArrayList; public class KmeansTest { public static void main(String[] args) { //初始化一个Kmean对象，设置k值 Kmeans k=new Kmeans(3); ArrayList<float[]> dataSet=new ArrayList<float[]>(); dataSet.add(new float[]{3,4}); dataSet.add(new float[]{4,4}); dataSet.add(new float[]{3,3}); dataSet.add(new float[]{4,3}); // dataSet.add(new float[]{0,2}); dataSet.add(new float[]{1,2}); dataSet.add(new float[]{0,1}); dataSet.add(new float[]{1,1}); // dataSet.add(new float[]{3,1}); dataSet.add(new float[]{3,0}); dataSet.add(new float[]{5,0}); dataSet.add(new float[]{4,0}); dataSet.add(new float[]{4,1}); //设置原始数据集 k.setDataSet(dataSet); //执行算法 k.execute(); //得到聚类结果 ArrayList<ArrayList<float[]>> cluster=k.getCluster(); //查看结果 for(int i=0;i<cluster.size();i++) { k.printDataArray(cluster.get(i), "cluster["+i+"]"); } } }
