程序博客网 > sql重庆培训

k-means聚类算法

来源：互联网 发布：sql重庆培训 编辑：程序博客网 时间：2024/05/17 03:08
开始之前先介绍下什么是簇识别。
簇识别：簇识别给出聚类结果的含义。假定有一些数据，现在将相似数据归到一起，簇识别会告诉我们这些簇到底都是些什么。
k-均值是发现给定数据集的K个簇的算法。簇个数是用户给定的，每一个簇通过其质心，即簇中所有点的中心来描述。

k-means聚类算法的评价：
优点：容易实现
缺点：可能收敛到局部最小值，在大规模数据集上收敛较慢。
使用数据类型：数值型数据。

工作流程：
首先，随机确定K个初始点作为质心。然后将数据集中的每个点分配到一个簇中，具体来讲，为每个点找距其最近的质心。并将其分配给该质心所对应的簇。这一步完成之后，每个簇的质心更新为该簇所有点的平均值，然后使用心的质心迭代聚类过程，直到收敛为止。
（这里的收敛指质心的不在改变，如果迭代后的质心位置与上一次相比如果超过了设定的差，那么就说明还未收敛，需要继续迭代）

伪代码：
1.创建k个点作为起始质心（经常是随机选择）
2.当任意一个点的簇分配结果发生改变时
        对数据集中的每个数据点
                对每个质心
                        计算质心与数据点之间的距离
                将数据点分配到距其最近的簇
        对每一个簇，计算簇中所有点的均值并将均值作为质心
3.使用新的质心来迭代2，直到收敛为止。
一般流程：
收集数据：使用任意方法
准备数据：需要数值型数据来计算距离，也可以将标称型数据映射为二值型数据再用于距离计算。
分析数据：使用任意方法
训练算法：不适用于无监督学习，即无监督学习没有训练过程。
测试算法：应用聚类算法、观察结果。可以使用量化的错误指标如误差平方和来评价算法的结果
使用算法：可以用于所希望的任何应用。通常情况下，簇质心可以代表整个簇的数据来做出决定。

其他问题
离群点的处理
离群点可能过度影响簇的发现，导致簇的最终发布会与我们的预想有较大出入，所以提前发现并剔除离群点是有必要的。
利用方差来剔除离群点，结果显示效果非常好。下文java实现的算法并未剔除利群点，如果有需要，可以在自己的算法实现中加入这一步。
簇分裂和簇合并（代码下面会做具体的介绍）
使用较大的K，往往会使得聚类的结果看上去更加合理，但很多情况下，我们并不想增加簇的个数。
这时可以交替采用簇分裂和簇合并。这种方式可以避开局部极小，并且能够得到具有期望个数簇的结果。

代码：
  1. import java.util.ArrayList;
  2. import java.util.EmptyStackException;
  3. import java.util.Random;
  4. import java.util.Scanner;
  6. /**
  7.  * Created by wubo on 2016/10/27.
  8.  */
  9. public class Kmeans {
  10.     private int k;//簇的个数
  11.     private int m;// 迭代次数
  12.     private int dataSetLength;// 数据集元素个数，即数据集的长度
  13.     private ArrayList<float[]> dataSet;// 数据集链表
  14.     private ArrayList<float[]> center;// 中心链表
  15.     private ArrayList<ArrayList<float[]>> cluster; // 簇
  16.     private ArrayList<Float> jc;// 误差平方和，k越接近dataSetLength，误差越小
  17.     private Random random;
  18.     /**
  19.      * 设置需分组的原始数据集
  20.      *
  21.      * @param dataSet
  22.      */
  23.     public void setDataSet(ArrayList<float[]> dataSet) {
  24.         this.dataSet = dataSet;
  25.     }
  27.     /**
  28.      * 获取结果分组
  29.      *
  30.      * @return 结果集
  31.      */
  32.     public ArrayList<ArrayList<float[]>> getCluster() {
  33.         return cluster;
  34.     }
  36.     /**
  37.      * 构造函数，传入需要分成的簇数量
  38.      *
  39.      * @param k
  40.      * 簇数量,若k<=0时，设置为1，若k大于数据源的长度时，置为数据源的长度
  41.      */
  42.     public Kmeans(int k) {
  43.         if (k <= 0) {
  44.             k = 1;
  45.         }
  46.         this.k = k;
  47.     }
  49.     /**
  50.      * 初始化
  51.      */
  52.     private void init() {
  53.         m = 0;//初始化迭代次数
  54.         random = new Random();
  55.         if (dataSet == null || dataSet.size() == 0) {
  56.             initDataSet();
  57.         }
  58.         dataSetLength = dataSet.size();//数据集长度
  59.         if (k > dataSetLength) {
  60.             k = dataSetLength;
  61.         }
  63.         center = initCenters();//初始化质心
  64.         System.out.print("error");
  65.         cluster = initCluster();//初始化簇集合
  67.         jc = new ArrayList<Float>();//误差平方和
  69.     }
  71.     /**
  72.      * 如果调用者未初始化数据集，则采用内部测试数据集
  73.      */
  74.     private void initDataSet() {
  75.         dataSet = new ArrayList<float[]>();
  76.         // 其中{6,3}是一样的，所以长度为15的数据集分成14簇和15簇的误差都为0
  77.         float[][] dataSetArray = new float[][] { { 8, 2 }, { 3, 4 }, { 2, 5 },
  78.                 { 4, 2 }, { 7, 3 }, { 6, 2 }, { 4, 7 }, { 6, 3 }, { 5, 3 },
  79.                 { 6, 3 }, { 6, 9 }, { 1, 6 }, { 3, 9 }, { 4, 1 }, { 8, 6 } };
  81.         for (int i = 0; i < dataSetArray.length; i++) {
  82.             dataSet.add(dataSetArray[i]);
  83.             System.out.print("["+dataSetArray[i][0]+","+dataSetArray[i][1]+"]");
  84.         }
  85.     }
  87.     /**
  88.      * 初始化中心数据链表，分成多少簇就有多少个中心点
  89.      *
  90.      * @return 中心点集
  91.      */
  92.     private ArrayList<float[]> initCenters() {
  93.         ArrayList<float[]> center = new ArrayList<float[]>();
  94.         int[] randoms = new int[k];//创建存放质心的数组
  95.         boolean flag;
  96.         int temp = random.nextInt(dataSetLength);//随机一个质点
  97.         randoms[0] = temp;//质点加入数组中
  98.         for (int i = 1; i < k; i++) {
  99.             flag=false;
  100.             while(!flag){
  101.                 temp=random.nextInt(dataSetLength);
  102.                 int j=0;
  103.                 for (j=0;j<i;j++){
  104.                     if (randoms[j]==temp){
  105.                         break;
  106.                     }
  107.                 }
  108.                 if(j==i){
  109.                     flag=true;
  110.                 }
  111.             }
  112.             randoms[i] = temp;
  113.         }
  115.          //测试随机数生成情况
  116.          for(int i=0;i<k;i++)
  117.          {
  118.             System.out.println("test1:randoms["+i+"]="+randoms[i]);
  119.          }
  121.         for (int i = 0; i < k; i++) {
  122.             center.add(dataSet.get(randoms[i]));// 生成初始化中心链表
  123.         }
  124.         return center;
  125.     }
  127.     /**
  128.      * 初始化簇集合
  129.      *
  130.      * @return 一个分为k个簇的空数据的簇集合
  131.      */
  132.     private ArrayList<ArrayList<float[]>> initCluster() {
  133.         ArrayList<ArrayList<float[]>> cluster = new ArrayList<ArrayList<float[]>>();
  134.         for (int i = 0; i < k; i++) {
  135.             cluster.add(new ArrayList<float[]>());
  136.         }
  137.         return cluster;
  138.     }
  140.     /**
  141.      * 计算两个点之间的距离
  142.      *
  143.      * @param element
  144.      *            点1
  145.      * @param center
  146.      *            点2
  147.      * @return 距离
  148.      */
  149.     private float distance(float[] element, float[] center) {
  150.         float distance = 0.0f;
  151.         float x = element[0] - center[0];
  152.         float y = element[1] - center[1];
  153.         float z = x * x + y * y;
  154.         distance = (float) Math.sqrt(z);
  155.         return distance;
  156.     }
  158.     /**
  159.      * 获取距离集合中最小距离的位置
  160.      *
  161.      * @param distance
  162.      *            距离数组
  163.      * @return 最小距离在距离数组中的位置
  164.      */
  165.     private int minDistance(float[] distance) {
  166.         float minDistance = distance[0];
  167.         int minLocation = 0;
  168.         for (int i = 1; i < distance.length; i++) {
  169.             if (distance[i] < minDistance) {
  170.                 minDistance = distance[i];
  171.                 minLocation = i;
  172.             } else if (distance[i] == minDistance) // 如果相等，随机返回一个位置
  173.             {
  174.                 if (random.nextInt(10) < 5) {
  175.                     minLocation = i;
  176.                 }
  177.             }
  178.         }
  179.         return minLocation;
  180.     }
  182.     /**
  183.      * 核心，将当前元素放到最小距离中心相关的簇中
  184.      */
  185.     private void clusterSet() {
  186.         float[] distance = new float[k];
  187.         for (int i = 0; i < dataSetLength; i++) {
  188.             for (int j = 0; j < k; j++) {
  189.                 distance[j] = distance(dataSet.get(i), center.get(j));//计算出当前点到每个簇质心的距离
  190.             }
  191.             int minLocation = minDistance(distance);//取得的最小距离的簇在数组中的编号
  192.             cluster.get(minLocation).add(dataSet.get(i));// 核心，将当前元素放到最小距离中心相关的簇中
  193.         }
  194.     }
  196.     /**
  197.      * 求两点误差平方的方法
  198.      *
  199.      * @param element
  200.      *            点1
  201.      * @param center
  202.      *            点2
  203.      * @return 误差平方
  204.      */
  205.     private float errorSquare(float[] element, float[] center) {
  206.         float x = element[0] - center[0];
  207.         float y = element[1] - center[1];
  208.         float errSquare = x * x + y * y;
  209.         return errSquare;
  210.     }
  212.     /**
  213.      * 计算误差平方和准则函数方法，所有点到质心的误差平方和之和
  214.      */
  215.     private void countRule() {
  216.         float jcF = 0;
  217.         for (int i = 0; i < cluster.size(); i++) {
  218.             for (int j = 0; j < cluster.get(i).size(); j++) {
  219.                 jcF += errorSquare(cluster.get(i).get(j), center.get(i));
  220.             }
  221.         }
  222.         jc.add(jcF);
  223.     }
  225.     /**
  226.      * 设置新的簇中心方法，平面的质心的求解算法，即求x,y的平均值
  227.      */
  228.     private void setNewCenter() {
  229.         for (int i = 0; i < k; i++) {
  230.             int n = cluster.get(i).size();
  231.             if (n != 0) {
  232.                 float[] newCenter = { 0, 0 };
  233.                 for (int j = 0; j < n; j++) {
  234.                     newCenter[0] += cluster.get(i).get(j)[0];
  235.                     newCenter[1] += cluster.get(i).get(j)[1];
  236.                 }
  237.                 // 设置一个平均值
  238.                 newCenter[0] = newCenter[0] / n;
  239.                 newCenter[1] = newCenter[1] / n;
  240.                 center.set(i, newCenter);
  241.             }
  242.         }
  243.     }
  245.     /**
  246.      * 打印数据，测试用
  247.      *
  248.      * @param dataArray
  249.      *            数据集
  250.      * @param dataArrayName
  251.      *            数据集名称
  252.      */
  253.     public void printDataArray(ArrayList<float[]> dataArray,
  254.                                String dataArrayName) {
  255.         for (int i = 0; i < dataArray.size(); i++) {
  256.             System.out.println("print:" + dataArrayName + "[" + i + "]={"
  257.                     + dataArray.get(i)[0] + "," + dataArray.get(i)[1] + "}");
  258.         }
  259.         System.out.println("===================================");
  260.     }
  262.     /**
  263.      * Kmeans算法核心过程方法
  264.      */
  265.     private void kmeans() {
  267.         init();
  268.         System.out.print("finish init");
  269.         //printDataArray(dataSet,"initDataSet");
  270.         // printDataArray(center,"initCenter");
  271.         // 循环分组，直到误差不变为止
  272.         while (true) {
  273.             clusterSet();
  274.             countRule();//计算误差平方和
  276.             // 误差不变了，分组完成
  277.             if (m != 0) {//m为迭代次数
  278.                 if (Math.abs(jc.get(m) - jc.get(m - 1)) <1E-10) {
  279.                     System.out.print(jc.get(m) - jc.get(m - 1));
  280.                     System.out.print("迭代完成\n");
  281.                     break;
  282.                 }
  283.             }
  284.             printDataArray(center,"newCenter");
  285.             setNewCenter();
  286.             m++;
  287.             cluster.clear();
  288.             cluster = initCluster();
  289.         }
  290.         printDataArray(center,"newCenter");
  291.         System.out.println("note:the times of repeat:m="+m);//输出迭代次数
  292.     }
  294.     /**
  295.      * 执行算法
  296.      */
  297.     public void execute() {
  298.         long startTime = System.currentTimeMillis();
  299.         System.out.println("kmeans begins");
  300.         kmeans();
  301.         long endTime = System.currentTimeMillis();
  302.         System.out.println("kmeans running time=" + (endTime - startTime)
  303.                 + "ms");
  304.         System.out.println("kmeans ends");
  305.         System.out.println();
  306.     }
  307. }
  1. import sun.security.jgss.krb5.Krb5NameElement;
  3. /**
  4.  * Created by wubo on 2016/10/28.
  5.  */
  6. public class KmeansTest {
  8.     public static void main(String[] args) {
  9.         Kmeans kmeans =new Kmeans(2);
  10.         kmeans.execute();
  12.     }
  13. }

使用后处理来提高聚类性能：
       k-means算法中簇的数目k是一个用户预先定义的参数，那么用户如何知道K的选择是否正确？如何才能知道簇的选择比较好？
上文中未做介绍，下文来细说下。
       K-均值算法收敛但聚类效果较差的原因是，k-均值算法收敛到了局部最小值而非全局最小值。（局部最小值指结果还可以但并非最好结果，全局最小值是最好的结果）。
       一种用于度量聚类效果的指标是SSE(Sum of Squard Error，误差平方和)。SSE值越小表示数据点越接近与它们的质心，聚类效果也越好。因为对误差去了平方，因此更加重视那些远离中心的点。一种肯定可以降低SSE值的方法是增加簇的个数，但是这违背了聚类的目标。聚类的目标是在保持簇数目不变的情况下提高簇的质量。
       另一种方法就是将具有最大的SSE值的簇划分为两个簇。具体实现时可以将最大簇包含的点过滤出来，并在这些点上运行K-均值算法，其中的k设为2。同时为了保证簇总数不变，可以将某两个簇合并。
       那么如何选择要合并的两个簇，有两种可以量化的办法：合并最近的质心，或者合并两个使得SSE增幅最小的质心。第一种思路是计算所有质心之间的距离，第二种需要合并两个簇然后计算总SSE值，必需在所有可能的两个簇上重复上述处理过程，直到找出合并最佳的两个簇为止。 
        为此，在k-均值算法的基础上有实现了该技术的 二分 k-均值算法

0 0
sql重庆培训 sql重庆培训
原创粉丝点击
热门IT博客
php 为什么可以跨平台php 为什么可以跨平台
ossim for linux下载ossim for linux下载
网络远程教育报名
数据库运行管理规范
郑州淘宝运营
java plug in是什么
effect java 第三版
linux查看swap大小
于海文基督教网络歌曲
2030中国人工智能
js监听css3动画结束
ubuntu 安装maven3
炫浪网络社区电脑版
淘宝直播id
手机离线同声翻译软件
傲风和迪锐克斯 知乎
淘宝德邦快递单打印
淘宝客店铺推广佣金
数据库设计五大原则
下面对云计算基础设施
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 重生过去，我在人世间 全球游戏：开局百亿灵能币 无敌从忽悠老人修仙开始 斗罗之九剑封天 诸天世界里的剑客 灵能复苏：我获得了不死之身 重生之时代先锋 我得到了地府礼包 柯南之助人为乐 偶像失格之日，巨星崛起之时 唐奇谭 从武侠世界开始种道 开局遭遇异兽，反手召唤九霄神明 木叶之任务达人 学霸的无限 从空间之力至诸天 从龙族开始打穿世界 全职高手：一剑风雷变 从双城开始的幕后法师 曹操喊我去盗墓 太古龙象诀 大唐第一世家 表白校花被拒，奖励五雷正法 四合院之大佬人生 LOL：OMG为什么是神 诸天从让子弹飞开始 无尽物语：起始于型月 教官从我是特种兵开始 神话从童子功开始 四合院之赤脚医生 哈利波特之最强学长 亮剑之开局一个团 反清：我其实真的是老实人 企鹅系玩家 身处东京的我只想咸鱼 洛丹伦的黎明 摄政王的小反派嚣张且善变 诡秘：最后的神之途径 松下紗栄子 乔依领 景甜

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里