k-means聚类及C代码实现

最新推荐文章于 2024-12-13 19:08:03 发布
最新推荐文章于 2024-12-13 19:08:03 发布
阅读量5k 收藏 5
点赞数
分类专栏： Machine Learning 文章标签： k-means
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/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.youkuaiyun.com/qll125596718/article/details/8243404

《数据挖掘 概念与技术》

k-均值聚类算法c语言版
阿伟
04-06 4379
k-均值聚类算法c语言版#include stdio.h> #include math.h>#define TRUE            1#define FALSE           0 int N;//数据个数int K;//集合个数int * CenterIndex;//初始化质心数组的索引double * Center;//质心集合double * CenterCopy;//质
k-means聚类算法c语言实现
09-26
用c语言实现的k-means算法 本例子是用k-means算法来处理一些有关基因的数据，对上千个八维向量进行聚类分组
k-均值聚类算法C语言源码
技术成就梦想，知识改变命运 !
09-23 1434
#include #include #define TRUE 1 #define FALSE 0 int N;//数据个数 int K;//集合个数 int * CenterIndex;//初始化质心数组的索引 double *
K-Mean聚类算法+C语言代码
Try_再努力一点
07-23 2000
K-Mean聚类算法+C语言代码： 实现步骤： 1. 确定分的簇数K； 2. 随机选择K个簇作为数据的计算中心，即随机选取质心； 3. 用欧式距离计算每组数据到中心的距离，将距离最短的对应纳入对应簇 Crowd[lable]； 4. 计算各组簇到该簇中心的欧式距离和 Var； 5. oldVar 与 newVar 进行比较，若abs(oldVar - newVar) 6. 更新质心，
计算智能——K-means聚类算法C语言代码
qq_42678341的博客
09-07 3961
K-means聚类算法 也称K均值聚类算法 是一种迭代求解的聚类分析算法，其步骤是随机选取K个对象作为初始的聚类中心，然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。 1. K-Means原理 上图a表示最初的对象点的样本，在图b中我们首先假定k=2，即在样本空间区域随机选取两个坐标点，然后通过计算每个点与两个之间的距离大小分为两个类别，如图...
K-Means聚类分析算法C语言实现
04-08
模式识别课程中，动态聚类算法中比较容易的K-Means聚类分析的C语言实现。
Python用K-means聚类算法进行客户分群的实现
09-16
### Python运用K-means聚类算法进行客户分群的实现详解 #### 一、背景与问题陈述 在当今商业环境中，了解客户群体特征对于制定有效的市场策略至关重要。本篇文章将探讨如何利用Python中的K-means聚类算法对超市...
【AI知识】无监督学习之K-means 聚类算法+代码+过程可视化
最新发布
想买很多漂亮衣服但是买不起的博客
12-13 802
【AI知识】无监督学习之K-means 聚类算法+代码+过程可视化
聚类分析|k-means聚类方法及其Python实现
皖山文武
03-25 3404
k-means算法由MacQueen在1967年提出。是一种经典的基于划分的聚类方法。划分方法（Partitioning Method）是基于距离判断样本相似度，通过不断迭代将含有多个样本的数据集划分成若干个簇，使每个样本都属于且只属于一个簇，同时聚类簇的总数小于样本总数目。该方法需要事先给定聚类数以及初始聚类中心，通过迭代的方式使得样本与各自所属类别的簇中心的距离平方和最小，聚类效果很大程度取决于初始簇中心的选择。
KMEANS 聚类算法实现程序（c实现）
05-03
KMEANS 聚类算法实现程序（c实现）
K-means聚类算法c语言实现（支持任意维数数据和任意k值）
12-01
K-means聚类算法c语言实现。样本数据从文件读入，支持任意维数数据和任意k值（k当然要小于样本数），同时可以防止分出空类。 为做作业原创
K-means聚类算法的实现 源码+详细步骤
03-14
该文档为数据挖掘中常用的分类算法K-means均值聚类算法，包含源码+详细步骤
k-means算法C语言实现
03-09
使用C语言对传统K-means聚类算法进行了实现，内含较多注释。
K-means聚类模型
与时俱进，一专多能。
05-24 1893
K-means 聚类模型是一种无监督学习算法，用于将数据划分为不同的组或簇，使得组内的数据点具有较高的相似性，而组间的数据点具有较低的相似性。接着，更新聚类中心为每个簇内数据点的平均值；例如，某电商企业可以使用 K-means 聚类模型对客户进行细分，将客户分为高价值客户、中价值客户和低价值客户等不同的组，然后针对不同的客户群体进行精准营销，提高客户的满意度和忠诚度。1. 对初始聚类中心敏感：K-means 聚类模型的结果对初始聚类中心的选择非常敏感，如果初始聚类中心选择不当，可能会导致聚类结果不准确。
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语言）
Aesthetic92的专栏
11-14 2万+
最近做了聚类实验——K-means算法
C语言实现K-means聚类算法
TechGlide的博客
09-09 590
K-means聚类算法是一种常用的无监督学习算法，用于将数据集中的样本划分为K个不同的簇。每个簇内的样本具有相似的特征，而不同簇之间的样本具有差异性。本文将演示如何使用C语言实现K-means聚类算法，并提供相应的源代码。在该函数中，我们首先初始化聚类中心，然后通过迭代的方式进行样本的分配和聚类中心的更新。这就是使用C语言实现K-means聚类算法的方法。通过该算法，我们可以根据样本的特征将其划分为不同的簇，从而实现数据的聚类分析。运行以上代码，将会输出每个样本点所属的簇的信息。结构体来表示样本点的坐标。
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
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值