kmean算法理解

先放一段其他大神的理解，讲的已经很清楚了，后面结合代码说说我的理解

在数据挖掘中，K-Means算法是一种cluster analysis的算法，其主要是来计算数据聚集的算法，主要通过不断地取离种子点最近均值的算法。

问题

K-Means算法主要解决的问题如下图所示。我们可以看到，在图的左边有一些点，我们用肉眼可以看出来有四个点群，但是我们怎么通过计算机程序找出这几个点群来呢？于是就出现了我们的K-Means算法（Wikipedia链接）



K-Means要解决的问题

算法概要

这个算法其实很简单，如下图所示： 



从上图中，我们可以看到，A，B，C，D，E是五个在图中点。而灰色的点是我们的种子点，也就是我们用来找点群的点。有两个种子点，所以K=2。

然后，K-Means的算法如下：
随机在图中取K（这里K=2）个种子点。
然后对图中的所有点求到这K个种子点的距离，假如点Pi离种子点Si最近，那么Pi属于Si点群。（上图中，我们可以看到A，B属于上面的种子点，C，D，E属于下面中部的种子点）
接下来，我们要移动种子点到属于他的“点群”的中心。（见图上的第三步）
然后重复第2）和第3）步，直到，种子点没有移动（我们可以看到图中的第四步上面的种子点聚合了A，B，C，下面的种子点聚合了D，E）。

这个算法很简单，但是有些细节我要提一下，求距离的公式我不说了，大家有初中毕业水平的人都应该知道怎么算的。我重点想说一下“求点群中心的算法”。

求点群中心的算法

一般来说，求点群中心点的算法你可以很简的使用各个点的X/Y坐标的平均值。不过，我这里想告诉大家另三个求中心点的的公式：

1）Minkowski Distance公式——λ可以随意取值，可以是负数，也可以是正数，或是无穷大。



2）Euclidean Distance公式——也就是第一个公式λ=2的情况



3）CityBlock Distance公式——也就是第一个公式λ=1的情况



这三个公式的求中心点有一些不一样的地方，我们看下图（对于第一个λ在0-1之间）。







（1）Minkowski Distance     （2）[b]Euclidean Distance    （3） [b]CityBlock Distance[/b][/b]

上面这几个图的大意是他们是怎么个逼近中心的，第一个图以星形的方式，第二个图以同心圆的方式，第三个图以菱形的方式。

K-Means的演示

如果你以”K Means Demo“为关键字到Google里查你可以查到很多演示。这里推荐一个演示：http://home.dei.polimi.it/matteucc/Clustering/tutorial_html/AppletKM.html

操作是，鼠标左键是初始化点，右键初始化“种子点”，然后勾选“Show History”可以看到一步一步的迭代。

注：这个演示的链接也有一个不错的K Means Tutorial。
下面是代码：

#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <math.h>
#include <stdlib.h>
#define k 3//簇的数目
using namespace std;
//存放元组的属性信息
typedef vector<double> Tuple;//存储每条数据记录

int dataNum;//数据集中数据记录数目
int dimNum;//每条记录的维数

//计算两个元组间的欧几里距离
double getDistXY(const Tuple& t1, const Tuple& t2)
{
double sum = 0;
for(int i=1; i<=dimNum; ++i)
{
sum += (t1[i]-t2[i]) * (t1[i]-t2[i]);
}
return sqrt(sum);
}

//根据质心，决定当前元组属于哪个簇
int clusterOfTuple(Tuple means[],const Tuple& tuple){
double dist=getDistXY(means[0],tuple);
double tmp;
int label=0;//标示属于哪一个簇
for(int i=1;i<k;i++){
tmp=getDistXY(means[i],tuple);
if(tmp<dist) {dist=tmp;label=i;}
}
return label;
}
//获得给定簇集的平方误差
double getVar(vector<Tuple> clusters[],Tuple means[]){
double var = 0;
for (int i = 0; i < k; i++)
{
vector<Tuple> t = clusters[i];
for (int j = 0; j< t.size(); j++)
{
var += getDistXY(t[j],means[i]);
}
}
//cout<<"sum:"<<sum<<endl;
return var;

}
//获得当前簇的均值（质心）
Tuple getMeans(const vector<Tuple>& cluster){

int num = cluster.size();
Tuple t(dimNum+1, 0);
for (int i = 0; i < num; i++)
{
for(int j=1; j<=dimNum; ++j)
{
t[j] += cluster[i][j];
}
}
for(int j=1; j<=dimNum; ++j)
t[j] /= num;
return t;
//cout<<"sum:"<<sum<<endl;
}

void print(const vector<Tuple> clusters[])
{
for(int lable=0; lable<k; lable++)
{
cout<<"第"<<lable+1<<"个簇："<<endl;
vector<Tuple> t = clusters[lable];
for(int i=0; i<t.size(); i++)
{
cout<<i+1<<".(";
for(int j=0; j<=dimNum; ++j)
{
cout<<t[i][j]<<", ";
}
cout<<")\n";
}
}
}

void KMeans(vector<Tuple>& tuples){
vector<Tuple> clusters[k];//k个簇
Tuple means[k];//k个中心点
int i=0;
//一开始随机选取k条记录的值作为k个簇的质心（均值）
srand((unsigned int)time(NULL));
for(i=0;i<k;){
int iToSelect = rand()%tuples.size();
if(means[iToSelect].size() == 0)
{
for(int j=0; j<=dimNum; ++j)
{
means[i].push_back(tuples[iToSelect][j]);
}
++i;
}
}
int lable=0;
//根据默认的质心给簇赋值
for(i=0;i!=tuples.size();++i){
lable=clusterOfTuple(means,tuples[i]);
clusters[lable].push_back(tuples[i]);
}
double oldVar=-1;
double newVar=getVar(clusters,means);
cout<<"初始的的整体误差平方和为："<<newVar<<endl;
int t = 0;
while(abs(newVar - oldVar) >= 1) //当新旧函数值相差不到1即准则函数值不发生明显变化时，算法终止
{
cout<<"第 "<<++t<<" 次迭代开始："<<endl;
for (i = 0; i < k; i++) //更新每个簇的中心点
{
means[i] = getMeans(clusters[i]);
}
oldVar = newVar;
newVar = getVar(clusters,means); //计算新的准则函数值
for (i = 0; i < k; i++) //清空每个簇
{
clusters[i].clear();
}
//根据新的质心获得新的簇
for(i=0; i!=tuples.size(); ++i){
lable=clusterOfTuple(means,tuples[i]);
clusters[lable].push_back(tuples[i]);
}
cout<<"此次迭代之后的整体误差平方和为："<<newVar<<endl;
}

cout<<"The result is:\n";
print(clusters);
}
int main(){

char fname[256];
cout<<"请输入存放数据的文件名： ";
cin>>fname;
cout<<endl<<" 请依次输入: 维数 样本数目"<<endl;
cout<<endl<<" 维数dimNum: ";
cin>>dimNum;
cout<<endl<<" 样本数目dataNum: ";
cin>>dataNum;
ifstream infile(fname);
if(!infile){
cout<<"不能打开输入的文件"<<fname<<endl;
return 0;
}
vector<Tuple> tuples;
//从文件流中读入数据
for(int i=0; i<dataNum && !infile.eof(); ++i)
{
string str;
getline(infile, str);
istringstream istr(str);
Tuple tuple(dimNum+1, 0);//第一个位置存放记录编号，第2到dimNum+1个位置存放实际元素
tuple[0] = i+1;
for(int j=1; j<=dimNum; ++j)
{
istr>>tuple[j];
}
tuples.push_back(tuple);
}

cout<<endl<<"开始聚类"<<endl;
KMeans(tuples);
return 0;
}

这段代码也是很容易理解的了：

1.先在所有向量中随机取K个向量作为初始质心，并给一个初始误差。

2.然后遍历所有向量，那个向量离那个质心（k个）近，就把这个向量归于到那个质心

3.接着计算误差。（其实就是每个类内部的每个向量到各自所属类质心的的距离的和，然后把K个类的都算出来，全加起来得到那个var）

4.用得到误差减去上一个误差，如果小于1，就说明质心到个各类的真正质心变化不大了，就退出，否则继续往下。

5.然后每个类重新计算质心（程序里就是类里面所有向量对应元素求平均）

6.再次计算误差。

7.根据质心重新归类。

8.回到第4步。

总结：说白了，就是计算各个质心到各自类的距离和，距离和变化大：重新归类重新计算质心，变化小：退出。

Matlab中的使用：

使用方法：
Idx=Kmeans(X,K)
[Idx,C]=Kmeans(X,K) 
[Idx,C,sumD]=Kmeans(X,K) 
[Idx,C,sumD,D]=Kmeans(X,K) 
[…]=Kmeans(…,’Param1’,Val1,’Param2’,Val2,…)

各输入输出参数介绍：

X N*P的数据矩阵
K 表示将X划分为几类，为整数
Idx N*1的向量，存储的是每个点的聚类标号
C K*P的矩阵，存储的是K个聚类质心位置
sumD 1*K的和向量，存储的是类间所有点与该类质心点距离之和
D N*K的矩阵，存储的是每个点与所有质心的距离

[…]=Kmeans(…,'Param1',Val1,'Param2',Val2,…)
这其中的参数Param1、Param2等，主要可以设置为如下：

1. ‘Distance’(距离测度)
‘sqEuclidean’ 欧式距离（默认时，采用此距离方式）
‘cityblock’ 绝度误差和，又称：L1
‘cosine’ 针对向量
‘correlation’  针对有时序关系的值
‘Hamming’ 只针对二进制数据

2. ‘Start’（初始质心位置选择方法）
‘sample’ 从X中随机选取K个质心点
‘uniform’ 根据X的分布范围均匀的随机生成K个质心
‘cluster’ 初始聚类阶段随机选择10%的X的子样本（此方法初始使用’sample’方法）
matrix 提供一K*P的矩阵，作为初始质心位置集合

3. ‘Replicates’（聚类重复次数）  整数
                   
使用案例：

data= 
5.0 3.5 1.3 0.3 -1
5.5 2.6 4.4 1.2 0
6.7 3.1 5.6 2.4 1
5.0 3.3 1.4 0.2 -1
5.9 3.0 5.1 1.8 1
5.8 2.6 4.0 1.2 0

[Idx,C,sumD,D]=Kmeans(data,3,'dist','sqEuclidean','rep',4)

运行结果：
Idx =
     1
     2
     3
     1
     3
     2

C =
    5.0000    3.4000    1.3500    0.2500   -1.0000
    5.6500    2.6000    4.2000    1.2000         0
6.3000    3.0500    5.3500    2.1000    1.0000

sumD =
    0.0300
    0.1250
    0.6300

D =
    0.0150   11.4525   25.5350
   12.0950    0.0625    3.5550
   29.6650    5.7525    0.3150
    0.0150   10.7525   24.9650
   21.4350    2.3925    0.3150
   10.2050    0.0625    4.0850