k-means聚类及C代码实现

最新推荐文章于 2024-04-29 18:16:07 发布
最新推荐文章于 2024-04-29 18:16:07 发布
阅读量4.9k 收藏 5
点赞数
分类专栏： Machine Learning 文章标签： k-means
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/einsdrw/article/details/37663099
版权

1 基本步骤

    k均值聚类算法是一种基于划分的聚类方法，即把数据样本划分成k个分区，每个分区代表一簇。这些簇的形成旨在优化优化一个客观的划分准则，如基于距离的相异性函数，使得在同一簇中，样本是“相似的”，不同簇的样本是“相异的”。

    目标：使得类内距离尽可能小，类间距离尽可能大。常用的是类内距离度量准则，即求下式最小：

 



    k均值的基本聚类过程如下：

    （1）选取k个样本作为初始聚类中心；

    （2）对每个待分类样本，计算它与每个聚类中心的距离，将其指派给距离最小的中心点所代表的那一类；

    （3）重新计算每类的类心；

    （4）若目标函数达到最优或达到最大迭代次数，则停止，否则跳到步骤（2）。

 

2 注意的问题：

（1）k的确定

    a. 按先验知识确定k。

    b. 让k从小到大逐步增加，每个k都用k-均值法分类，J随k的增加而单调减少，但速度在一定时候会减缓，曲率变化最大点对应最优类数。

（2）初始聚类中心的选取

    a. 凭经验。

    b. 将模式随机分成k类，计算每类中心，作为初始类心。

    c. 求以每个特征点为球心，某一正数d为半径的球型区域中的特征点个数（即该特征点的密度），选取密度最大的特征点为第一个初始聚类中心，然后，在与该中心大于某个距离d的那些特征点中选取另一个具有最大密度的特征点作为第二个初始聚类中心，直到选取k个初始类心。

    d. 用相距最远的k个特征点作为类心。

    e. 当Ｎ较大时，先随机地从N个模式中取出一部分模式用层次聚类法聚成k类，以每类的重心作为初始类心。

（3）距离的度量

最常用的是欧式距离。其它度量方法还有绝对值距离、马氏距离、余弦相似度等

欧式距离：

（4）算法停止条件

    一般是目标函数达到最优或者达到最大的迭代次数即终止。对于欧氏距离，一般使用误差平方和准则。即：

（5）收敛性

    可以证明，k均值聚类算法是一定会收敛的。

 

3 优缺点分析

   Kmeans算法试图找到使平方误差准则函数最小的簇，需要事先指定聚类数目。当潜在的簇形状是凸面的，簇与簇之间区别较明显，且簇大小相近时，其聚类结果较理想。时间复杂度与样本数量线性相关，所以，对于处理大数据集合，该算法非常高效，且伸缩性较好。

    其对初始聚类中心敏感比较敏感，经常以局部最优结束，不合适的初始值不能得到满意的聚类结果，可以进行多次聚类，选取最好的一次作为最后的聚类结果；同时对“噪声”和孤立点敏感，并且该方法不适于发现非凸面形状的簇或大小差别很大的簇。



 

4 实现

利用了opencv来做数据显示

#include "highgui.h"
#include <math.h> 
#include <time.h>
#include "cv.h"

void myKmeans(float* pSamples,int* pClusterResult,int clusterNum,
			int sampleNum,int featureNum,
			int AttempTimes=1,int* pInitCenter=NULL);

void main()
{
    #define MAX_CLUSTERS 5
    CvScalar color_tab[MAX_CLUSTERS];
    IplImage* img = cvCreateImage( cvSize( 500, 500 ), IPL_DEPTH_8U, 3 );
    CvRNG rng = cvRNG(cvGetTickCount());
    CvPoint ipt;
	
    color_tab[0] = CV_RGB(255,0,0);
    color_tab[1] = CV_RGB(0,255,0);
    color_tab[2] = CV_RGB(100,100,255);
    color_tab[3] = CV_RGB(255,0,255);
    color_tab[4] = CV_RGB(255,255,0);
	

    int i,k;
    int clusterNum = cvRandInt(&rng)%MAX_CLUSTERS + 2;	//至少有两类
    int sampleNum = cvRandInt(&rng)%1000 + 100;			//至少100个点
    int feaNum=2;
    CvMat* sampleMat = cvCreateMat( sampleNum, 1, CV_32FC2 );
	
    /* generate random sample from multigaussian distribution */
    //产生高斯随机数
    for( k = 0; k < clusterNum; k++ )
    {
        CvPoint center;
	int topIndex=k*sampleNum/clusterNum;
	int bottomIndex=(k == clusterNum - 1 ? sampleNum : (k+1)*sampleNum/clusterNum);

        CvMat* localMat=cvCreateMatHeader(bottomIndex-topIndex,1,CV_32FC2);
        center.x = cvRandInt(&rng)%img->width;
        center.y = cvRandInt(&rng)%img->height;
        cvGetRows( sampleMat, localMat, topIndex,bottomIndex, 1 );
	/*此函数不会给localMat分配空间*/	
	
        cvRandArr( &rng, localMat, CV_RAND_NORMAL,
		cvScalar(center.x,center.y,0,0),
		cvScalar(img->width*0.1,img->height*0.1,0,0));
    }
	
   // shuffle samples 混乱数据
	for( i = 0; i < sampleNum/2; i++ )
	{
		CvPoint2D32f* pt1 = (CvPoint2D32f*)sampleMat->data.fl + cvRandInt(&rng)%sampleNum;
		CvPoint2D32f* pt2 = (CvPoint2D32f*)sampleMat->data.fl + cvRandInt(&rng)%sampleNum;
		CvPoint2D32f temp;
		CV_SWAP( *pt1, *pt2, temp );
	}

	float* pSamples=new float[sampleNum*feaNum];
	int* pClusters=new int[sampleNum];
	for (i=0;i<sampleNum;i++)
	{
		//feaNum=2
		pSamples[i*feaNum]=(cvGet2D(sampleMat,i,0)).val[0];
		pSamples[i*feaNum+1]=(cvGet2D(sampleMat,i,0)).val[1];
	}
	cvReleaseMat( &sampleMat );

	cvZero( img );
    for( i = 0; i < sampleNum; i++ )
    {
		//feaNum=2
        ipt.x = (int)(pSamples[i*feaNum]);
        ipt.y = (int)(pSamples[i*feaNum+1]);
        cvCircle( img, ipt, 1, cvScalar(255,255,255), CV_FILLED, CV_AA, 0 );
    }
	cvSaveImage("origin.jpg",img);

	myKmeans(pSamples,pClusters,clusterNum,sampleNum,feaNum,1,NULL);

    cvZero( img );
    for( i = 0; i < sampleNum; i++ )
    {
		//feaNum=2
        int cluster_idx = pClusters[i];
        ipt.x = (int)(pSamples[i*feaNum]);
        ipt.y = (int)(pSamples[i*feaNum+1]);
        cvCircle( img, ipt, 1, color_tab[cluster_idx], CV_FILLED, CV_AA, 0 );
    }
	delete[] pClusters;
	pClusters=NULL;
	delete[] pSamples;
	pSamples=NULL;
	
	
	cvNamedWindow( "clusters");
    cvShowImage( "clusters", img );	
	cvWaitKey(0);
    cvDestroyWindow( "clusters" );
	cvSaveImage("clusters.jpg",img);

	cvReleaseImage(&img);
}

//Kmeans聚类，得到的结果从0开始计数
void myKmeans(float* pSamples,int* pClusterResult,int clusterNum,int sampleNum,int featureNum,int AttempTimes,int* pInitCenter)
{
	int i,j,k,t;
	int IterationTimes;	//当前迭代次数
	double MinDistance;	//与聚类中心的最小距离
	int currentCategory;	//当前点的类别
	double VarSum;	//平方误差和
	double LastVarSum;	//上一次的平方误差和
	double minVarSum;	//最小平方误差和
	int clusterEmpty;		//是否有空类
	int bestCluster;

	int MaxIterationTimes=100;	//最大迭代次数
	double Epslion=0.001;			//聚类停止误差

	float *pCenters=new float[clusterNum*featureNum];	//聚类中心
	float *pBestCenters=new float[clusterNum*featureNum];	//聚类中心
	int* pEveryTimesResult=new int[sampleNum*AttempTimes];	//每一次尝试的聚类结果
	double* pSum=new double[clusterNum*featureNum];		//用于计算聚类中心
	int* pNum=new int[clusterNum];						//每类的数目

	memset(pClusterResult,0,sampleNum*sizeof(int));

	//初始化聚类中心
	if (NULL==pInitCenter)
	{
		srand((unsigned int)time(NULL));  
		int index_temp=rand()%sampleNum;

		for (i=0;i<clusterNum;i++)
		{
			for (j=0;j<featureNum;j++)
			{
				pCenters[i*featureNum+j]=pSamples[index_temp*featureNum+j];
			}

			index_temp+=(sampleNum/clusterNum);
			if (index_temp>=sampleNum)
			{
				index_temp%=sampleNum;
			}
		}
	}
	else
	{
		for (i=0;i<clusterNum;i++)
		{
			for (j=0;j<featureNum;j++)
			{
				pCenters[i*featureNum+j]=pSamples[pInitCenter[i]*featureNum+j];
			}
		}
	}
	

	//开始聚类
	for (t=0;t<AttempTimes;t++)
	{
		//初始化聚类中心
		if (0!=t)
		{
			srand((unsigned int)time(NULL));  
			int index_temp=rand()%sampleNum;
			
			for (i=0;i<clusterNum;i++)
			{
				for (j=0;j<featureNum;j++)
				{
					pCenters[i*featureNum+j]=pSamples[index_temp*featureNum+j];
				}
				
				index_temp+=(sampleNum/clusterNum);
				if (index_temp>=sampleNum)
				{
					index_temp%=sampleNum;
				}
			}
		}

		//聚类
		IterationTimes=0;
		VarSum=0;
		LastVarSum=0;
		clusterEmpty=0;
		while(1)
		{
			bool hasEmpty=false;
			IterationTimes++;
			for (i=0;i<clusterNum;i++)
			{
				for (j=0;j<featureNum;j++)
				{
					pSum[i*featureNum+j]=0;
				}
				pNum[i]=0;
			}
			VarSum=0;
			
			for (i=0;i<sampleNum;i++)
			{
				//计算当前点属于哪一类
				for (k=0;k<clusterNum;k++)
				{
					double distance_temp=0;
					for (j=0;j<featureNum;j++)
					{
						distance_temp+=(double)((double)(pCenters[k*featureNum+j]-pSamples[i*featureNum+j])*(pCenters[k*featureNum+j]-pSamples[i*featureNum+j]));
					}
					
					if (0==k || MinDistance>distance_temp)
					{
						MinDistance=distance_temp;
						currentCategory=k;
					}
				}
				pClusterResult[i]=currentCategory;
				pEveryTimesResult[i*AttempTimes+t]=currentCategory;
				
				//计算平方误差
				VarSum+=sqrtl(MinDistance);		//开方防止超出存储长度
				
				//用于计算新的聚类中心
				pNum[currentCategory]++;
				for (j=0;j<featureNum;j++)
				{
					pSum[currentCategory*featureNum+j]+=pSamples[i*featureNum+j];
				}
			}
			
			//重新计算聚类中心，注意可能会有空类
			for (i=0;i<clusterNum;i++)
			{
				for(j=0;j<featureNum;j++)
				{
					if (pNum[i]!=0)
					{
						pCenters[i*featureNum+j]=pSum[i*featureNum+j]/(float)(pNum[i]);
					}
					else		//直接使用原来的类心，是否会有形成死循环的可能，表示不清楚
					{
						hasEmpty=true;
					}
				}
			}
			
			//如果有空类，就至少还要循环两次
			if (true==hasEmpty)
			{
				clusterEmpty=2;
			}
			else
			{
				clusterEmpty=clusterEmpty-1>=0 ? clusterEmpty-1 : 0;
			}
			
			if ((IterationTimes>=MaxIterationTimes 
				|| fabsl(VarSum-LastVarSum)<=Epslion) 
				&& (0==clusterEmpty))
			{
				break;
			}
			LastVarSum=VarSum;
		}

		if (0==t || minVarSum>VarSum)
		{
			minVarSum=VarSum;
			bestCluster=t;
			for (i=0;i<clusterNum;i++)
			{
				for(j=0;j<featureNum;j++)
				{
					pBestCenters[i*featureNum+j]=pCenters[i*featureNum+j];					
				}
			}
		}
	}

	delete[] pCenters;
	pCenters=NULL;
	delete[] pSum;
	pSum=NULL;
	delete[] pNum;
	pNum=NULL;
	delete[] pBestCenters;
	pBestCenters=NULL;

	if (bestCluster!=AttempTimes-1)
	{
		for (i=0;i<sampleNum;i++)
		{
			pClusterResult[i]=pEveryTimesResult[i*AttempTimes+bestCluster];
		}
	}

	delete[] pEveryTimesResult;
	pEveryTimesResult=NULL;
}
</span>


 

结果图：

 

 参考资料：

http://blog.csdn.net/qll125596718/article/details/8243404

《数据挖掘 概念与技术》

einsdrw
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于k-means聚类算法实现三维数据分类含Matlab源码
07-09
在数据分析和机器学习...总之，k-means聚类算法是数据分析的基础工具，掌握其在Matlab中的实现对于学术研究和实际应用都非常有益。通过分析和实践提供的源代码，不仅可以学习算法本身，还能提升编程和数据可视化技能。
K-means算法的c++代码实现
waitingforone的博客
04-14 975
简单实现K-means算法的c++代码实现
K-Means聚类算法的实现（C语言）
Aesthetic92的专栏
11-14 2万+
最近做了聚类实验——K-means算法
K-Means聚类算法（含Python代码）
qq_56891068的博客
04-29 2047
K-Means算法是典型的基于距离的非层次聚类算法，在最小化误差函数的基础上将数据划分为预定的类数K，采用距离作为相似性的评价指标，即认为两个对象的距离越近其相似度就越大。
k-means聚类算法——c语言
yanxiaopan的博客
12-17 1万+
程序代码：#include"stdio.h" #include"stdlib.h" #include<iostream> using namespace std;#define N 11 #define k 3typedef struct{ float x; float y; }Point;Point point[N] = { { 2.0, 10.0 }, { 2.0
K-Means算法的C语言实现
u010480899的博客
04-17 1万+
聚类，就是将数据对象划分成若干个类，在同一个类中的对象具有较高的相似度，而不同的类相似度较小。聚类算法将数据集合进行划分，分成彼此相互联系的若干类，以此实现对数据的深入分析和数据价值挖掘的初步处理阶段。例如在现代商业领域，聚类分析算法可以从庞大的数据集合中对消费者的消费习惯、消费倾向，以方便决策者制订消费策略。总之，作为数据挖掘中的一个模块，聚类分析算法可以作为一个单独的工具已发现数据库中分布的一些深层信息，并概括出每一类的特点。聚类分析算法也可作为数据挖掘算法中其他分析算法的一个预处理步骤。
计算智能——K-means聚类算法C语言代码
qq_42678341的博客
09-07 3833
K-means聚类算法 也称K均值聚类算法 是一种迭代求解的聚类分析算法，其步骤是随机选取K个对象作为初始的聚类中心，然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。 1. K-Means原理 上图a表示最初的对象点的样本，在图b中我们首先假定k=2，即在样本空间区域随机选取两个坐标点，然后通过计算每个点与两个之间的距离大小分为两个类别，如图...
K-Means 聚类算法C语言代码实现
乌哩哇啦的技术学习记录
06-28 4161
1.具体代码实现如下 #include include include include include include include include using namespace std; typedef struct //点结构体 { double x; //属性1 double y; //属性2 }Point...
多维k-means聚类算法java实现，导入直接运行
02-17
多维k-means聚类算法是一种在数据挖掘和机器学习领域广泛应用的无监督学习方法，主要用于将高维数据集划分为不同的簇或类别。在Java编程语言中实现这个算法，可以方便地处理各种数据集，尤其适用于那些需要进行分类...
python Calinski-Harabasz指数评价K-means聚类模型
12-20
总结起来，本示例展示了如何使用Python进行图像数据的预处理、降维和K-means聚类，并通过Calinski-Harabasz指数来评估聚类效果。这种方法可以帮助数据科学家和机器学习工程师更好地理解数据结构，优化模型，并做出更...
k-means聚类算法c语言实现
09-26
用c语言实现的k-means算法 本例子是用k-means算法来处理一些有关基因的数据，对上千个八维向量进行聚类分组
K-Means算法介绍并用C语言实现
格子衫双肩包的专栏
04-14 596
a.原始样本集文件；b.K值，也就是期望的目标簇（cluster）c.最多迭代次数；d.保存聚类结果的文件；
C语言实现k-means算法
monetvan的博客
09-08 2011
k-means算法 算法思想 K-means主要思想是在给定K值和若干样本（点）的情况下，把每个样本（点）分到离其最近的类簇中心点所代表的类簇中，所有点分配完毕之后，根据一个类簇内的所有点重新计算该类簇的中心点(取平均值)，然后再迭代的进行分配点和更新类簇中心点的步骤，直至类簇中心点的变化很小，或者达到指定的迭代次数。 用C语言实现 自定义的数据集共有15个： (2, 7) (2, 5) ...
K-Mean聚类算法+C语言代码
Try_再努力一点
07-23 1920
K-Mean聚类算法+C语言代码： 实现步骤： 1. 确定分的簇数K； 2. 随机选择K个簇作为数据的计算中心，即随机选取质心； 3. 用欧式距离计算每组数据到中心的距离，将距离最短的对应纳入对应簇 Crowd[lable]； 4. 计算各组簇到该簇中心的欧式距离和 Var； 5. oldVar 与 newVar 进行比较，若abs(oldVar - newVar) 6. 更新质心，
K-Means聚类算法--步骤+代码
weixin_45788069的博客
09-29 3万+
0.介绍 聚类和分类算法的最大区别在于，分类的目标类别为已知（监督学习），而聚类的目标类别是未知的（非监督）。K_Means算法（K_均值算法）就是无监督算法之一 1.原理 对于给定的样本集，按照样本之间的距离大小，将样本集划分为K个簇。让簇内的点尽量紧密的连在一起，而让簇间的距离尽量的大。 数据表达式： 假设簇划分为(C1,C2，...Ck)(C_1 ,C_2，...C_k)(C1​,C2​，...Ck​)，则我们的目标是最小化平方误差E： E=∑i=1K∑x∈Ci∣∣x−μi∣∣22 E={\sum
C均值分析与例子
Cai_Xu_Kun的博客
04-15 1527
C均值 算法思想 采用距离作为相似性指标，从而发现给定数据集中的K个类，且每个类的中心是根据类中所有值的均值得到，每个类用聚类中心来描述。对于给定的一个包含n个d维数据点的数据集X以及要分得的类别K,选取欧式距离作为相似度指标，聚类目标是使得各类的聚类平方和最小，聚类中心为对应类别中各数据点的平均值，同时为了使得算法收敛，在迭代过程中，应使最终的聚类中心尽可能的不变 。 算法基本步骤 1在样本集合中选择C个点作为初始类中心； 2在剩下的样本点中选择一个，计算其到各个中心点的距离，选取距离最短者将其归为那个类
【机器学习实战之三】：C++实现K-均值（K-Means）聚类算法
热门推荐
懂幸福，爱生活
01-08 3万+
聚类是一种无监督的学习，它将相似的对象归到同一个簇中。它有点像全自动分类（类别体系是自动构建的）。聚类方法几乎可以应用于所有对象，簇内的对象越相似，聚类的效果越好。本文要介绍一种称为K-均值（K-means）聚类的算法。之所以称之为K-均值是因为它可以发现k个不同的簇，且每个簇的中心采用簇中所含值的均值计算而成。
k-means聚类算法伪代码
最新发布
06-28
K-means聚类算法是一种常用的无监督机器学习方法，用于将数据集划分为预设数量的类别（或簇）。下面是K-means算法的简单伪代码： ``` 1. 初始化（K步骤）： - 随机选择K个点作为初始质心（中心点）C1, C2, ..., CK...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值