K-means算法

最新推荐文章于 2025-10-05 08:00:00 发布
原创 最新推荐文章于 2025-10-05 08:00:00 发布 · 2.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#k-means算法 #聚类算法 #鸢尾花数据集测试

K-means算法是一种广泛应用的聚类算法，基于划分方法，寻找数据中的自然聚类中心，通过迭代优化簇内对象的均方误差。尽管算法简单高效，但对初始中心点选择敏感，适用于凸形、密集的簇。鸢尾花数据集测试展示了其聚类效果。该算法在大数据集上表现可伸缩，但在非凸形状簇和噪声数据上效果不佳。
AI助手已提取文章相关产品：

      聚类是在给定的数据集合中寻找同类的数据子集合，每一个子集合形成一个类簇，同类簇中的数据具有更大的相似性。聚类算法大体上可分为基于划分的方法、基于层次的方法、基于密度的方法、基于网格的方法以及基于模型的方法。

      术语“k-means”最早是由James MacQueen在1967年提出的，这一观点可以追溯到1957年 Hugo Steinhaus所提出的想法。1957年，斯图亚特·劳埃德最先提出这一标准算法，当初是作为一门应用于脉码调制的技术,直到1982年，这一算法才在贝尔实验室被正式提出。1965年， E.W.Forgy发表了一个本质上是相同的方法，1975年和1979年，Hartigan和Wong分别提出了一个更高效的版本。

      目前k-means算法是一种得到最广泛使用的基于划分的聚类算法，把n个对象分为k个簇，以使簇内具有较高的相似度。相似度的计算根据一个簇中对象的平均值来进行。它与处理混合正态分布的最大期望算法很相似，因为他们都试图找到数据中自然聚类的中心。

      算法首先随机地选择k个对象，每个对象初始地代表了一个簇的平均值或中心。对剩余的每个对象根据其与各个簇中心的距离，将它赋给最近的簇，然后重新计算每个簇的平均值。这个过程不断重复，直到准则函数收敛。

      它假设对象属性来自于空间向量，并且目标是使各个群组内部的均方误差总和最小。假设有k个群组Si, i=1,2,…,k。μi是群组Si内所有元素xj的重心，或叫中心点。

       K值的选择应该在2和√n之间，n为数据个数。

算法的性能分析：

1）优点
      1、k-平均算法是解决聚类问题的一种经典算法，算法简单、快速。
      2、对处理大数据集，该算法是相对可伸缩的和高效率的，因为它的复杂度大约是O（nkt），其中n是所有对象的数目，k是簇的数目,t是迭代的次数。通常k远小于n。这个算法经常以局部最优结束。
      3、算法尝试找出使平方误差函数值最小的k个划分。当簇是密集的、球状或团状的，而簇与簇之间区别明显时，它的聚类效果很好。

2）缺点
      1、k-means只有在簇的平均值被定义的情况下才能使用，不适用于某些应用，如涉及有分类属性的数据不适用。
      2、要求用户必须事先给出要生成的簇的数目k。
      3、对初值敏感，对于不同的初始值，可能会导致不同的聚类结果。
      4、不适合于发现非凸面形状的簇，或者大小差别很大的簇。
      5、对于”噪声”和孤立点数据敏感，少量的该类数据能够对平均值产生极大影响。

k-means 算法基本步骤：
      （1）从 n个数据对象任意选择 k 个对象作为初始聚类中心；
      （2） 计算每个对象与这些中心对象的距离；并根据最小距离对相应对象进行划分；
      （3）重新计算每个中心对象；
      （4）重复（2）、（3）布直至满足准则收敛函数。

鸢尾花数据集测试实例：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<string.h>
#include<math.h>

//鸢尾花数据集的定义
typedef struct
{
    float x ;   //花萼长度
    float y ;   //花萼宽度
    float i ;   //花瓣长度
    float j ;   //花瓣宽度
    int type ;   //属种
    /**
        1--Iris-setosa          0---第一类
        2--Iris-versicolor      1---第二类
        3--Iris-virginica       2---第三类
    */
} Iris ;

Iris *iris ;   //保存数据
Iris *irisCopy ;  //数据副本


//文件操作，读取鸢尾花数据集，有3组数据，每组50个
void ReadData()
{
    FILE *fp ;  //文件指针
    char s[50],t[20] ;
    int i = 0 ;
    iris = (Iris *)malloc(150*sizeof(Iris)) ;
    fp = fopen("iris.data","r") ;
    //读取文件内容，保存进iris
    while(fgets(s,50,fp)!=NULL){
        iris[i].x = atof(s) ;
        iris[i].y = atof(&s[4]) ;
        iris[i].i = atof(&s[8]) ;
        iris[i].j = atof(&s[12]) ;
        if(i<50){
            iris[i].type = 1 ;
        }
        else if(i<100){
            iris[i].type = 2 ;
        }
        else{
            iris[i].type = 3 ;
        }
        //printf("%d,%f,%f,%f,%f,%d\n",i,iris[i].x,iris[i].y,iris[i].i,iris[i].j,iris[i].type) ;
        i++ ;
    }
}

//k个随机质心的生成
Iris *Random(int k,int n)
{
    int i,j,a ;
    int r[k] ;  //保存随机数
    Iris *center ;  //保存质心数据
    center = (Iris *)malloc(k*sizeof(Iris)) ;
    srand( (unsigned)time( NULL ) );
    //随机生成整数，防止重复
    for(i=0;i<k;i++){
        a = rand()%n ;
        for(j=0;j<i;j++){
            if(r[j]==a){
                a = rand()%n ;
                j = 0 ;
            }
        }
        r[i] = a ;
    }
    //ReadData() ;
    //赋值给质心
    for(i=0;i<k;i++){
        center[i].x = iris[r[i]].x ;
        center[i].y = iris[r[i]].y ;
        center[i].i = iris[r[i]].i ;
        center[i].j = iris[r[i]].j ;
        center[i].type = iris[r[i]].type ;
        //printf("%d,",r[i]) ;
        //printf("%f,%f,%f,%f,%d\n",center[i].x,center[i].y,center[i].i,center[i].j,center[i].type) ;
    }
    return center ;
}


//创建数据集副本
void DataCopy()
{
    int i = 0;
    irisCopy = (Iris *)malloc(150*sizeof(Iris)) ;
    for(i;i<150;i++){
        irisCopy[i].x = iris[i].x ;
        irisCopy[i].y = iris[i].y ;
        irisCopy[i].i = iris[i].i ;
        irisCopy[i].j = iris[i].j ;
        irisCopy[i].type = iris[i].type ;
    }
}

//创建质心副本
Iris *centerCopy(Iris *center,int k)
{

    int i = 0 ;
    Iris *cenCopy ;   //质心副本
    cenCopy = (Iris *)malloc(k*sizeof(Iris)) ;
    for(i;i<k;i++){
        cenCopy[i].x = center[i].x ;
        cenCopy[i].y = center[i].y ;
        cenCopy[i].i = center[i].i ;
        cenCopy[i].j = center[i].j ;
        cenCopy[i].type = center[i].type ;
    }
    return cenCopy ;
}

//计算质心
Iris ComputingCenter(Iris *c,int top)
{
    Iris c_ir ;  //质点
    int m ;
    float i=0,j=0,x=0,y=0 ;
    //求和
    for(m=0;m<top;m++){
        x = x+c[m].x ;
        y = y+c[m].y ;
        i = i+c[m].i ;
        j = j+c[m].j ;
    }
    //给质点赋值
    c_ir.x = x/top ;
    c_ir.y = y/top ;
    c_ir.i = i/top ;
    c_ir.j = j/top ;
    return c_ir ;
}

/**********************************************************/
//比较原质心和生成的质心是否一致
int Compare(Iris *center,Iris *centerCopy,int k)
{
    int i ;
    for(i=0;i<k;i++){
        if((centerCopy[i].x!=center[i].x)||(centerCopy[i].y!=center[i].y)||(centerCopy[i].i!=center[i].i)||(centerCopy[i].j!=center[i].j)){
            //判断每对质心是不是变化
            return 0 ;  //变化返回0
        }
    }
    return 1 ;  //不变化返回1
}
/**********************************************************/
//比较与哪个质心相近，返回与第几个质心最近
int Belong(Iris *center,Iris ir,int k)
{
    double a[k] ;  //保存距离的平方
    int i ,min;
    for(i=0;i<k;i++){
        a[i] = (center[i].x - ir.x)*(center[i].x - ir.x) + (center[i].y - ir.y)*(center[i].y - ir.y) + (center[i].i - ir.i)*(center[i].i - ir.i) + (center[i].j - ir.j)*(center[i].j - ir.j) ;
        //计算距离的平方
        //printf("%f\n",a[i]) ;
    }
    min = 0 ;
    for(i=0;i<k;i++){
        if(a[min]>a[i])
            min = i ;
    }
    return min ;
}

int main()
{
    Iris cla[3][150] ;
    int ncla[3][150] = {-1} ;
    Iris *center,*cenCopy ;
    int top[3] ;
    int i,j,h=0 ;
    ReadData() ;
    center = Random(3,150) ;
    DataCopy() ;
    cenCopy = centerCopy(center,3) ;
    cenCopy[0].x  = 0.0 ;
    for(i=0;i<3;i++){
        top[i] = 0 ;
    }
    while(!Compare(cenCopy,center,3)){  //类中心不再变化停止循环
        cenCopy = centerCopy(center,3) ;
        for(i=0;i<3;i++){
            top[i] = 0 ;
        }
        for(i=0;i<150;i++){
            j = Belong(center,iris[i],3) ;
            ncla[j][top[j]] = i ;  //源数据所在位置
            cla[j][top[j]].x = iris[i].x ;
            cla[j][top[j]].y = iris[i].y ;
            cla[j][top[j]].i = iris[i].i ;
            cla[j][top[j]].j = iris[i].j ;
            cla[j][top[j]].type = j ;
            top[j]++ ;
        }
        for(i=0;i<3;i++){
            center[i] = ComputingCenter(cla[i],top[i]) ;  //重新计算类中心
            //printf("%d,%f,%f,%f,%f\n",i,center[i].x,center[i].y,center[i].i,center[i].j) ;
        }
        h++ ;  //统计循环次数
    }
    for(i=0;i<3;i++){
        printf("\n第%d类数据(%d个)：\n",i,top[i]) ;
        for(j=0;j<top[i];j++){
            printf("%d\t",ncla[i][j]) ;
        }
    }
    printf("\n迭代次数：%d\n",h) ;
    return 0 ;
}

输出结果：

参考：
1、Jiawei Han等著，《数据挖掘概念与技术》，2008
2、吴夙慧等，k-means算法研究综述，2011

您可能感兴趣的与本文相关内容

（学习笔记）十大经典算法——K-means聚类算法
weixin_42985978的博客
03-21 3614
聚类算法是在无监督的情况下将对象自动分组的一种分析方法，典型的聚类算法分为三个阶段：特征选择和特征提取，数据对象间相似度计算，根据相似度将数据对象分组。聚类算法的目标是将数据集合分成若干簇，使得同一簇内的数据点相似度尽可能大，而不同簇间的数据点相似度尽可能小。可分为层次聚类算法和划分聚类算法。
Spark聚类模型K-Means----来源Spark机器学习
小猪猪and小马马的博客
03-14 1181
import breeze.linalg.DenseVector import breeze.numerics.pow import org.apache.spark.mllib.clustering.KMeans import org.apache.spark.mllib.linalg.Vectors import org.apache.spark.mllib.linalg.distribute
Kemans算法详解
最新发布
onlymscn的博客
10-05 1054
K-means是一种经典无监督聚类算法，通过迭代优化将数据分成K个簇。其核心步骤包括：随机初始化K个质心，计算样本到质心距离并分配簇，更新质心位置，重复至收敛。算法简单高效但需预设K值，对初始质心敏感。优化方法包括K-means++初始化、肘部法则选择K值等。适用于客户分群、图像分割等场景，Python/scikit-learn和Spark/MLlib均提供实现。实际应用中需注意特征标准化、异常值处理和多轮运行取最优解。
聚类发展历史、现状、未来趋势
席八
12-19 1万+
1、发展历史 聚类算法的历史与有监督学习一样悠久。层次聚类算法出现于1963年[26]，这是非常符合人的直观思维的算法，现在还在使用。它的一些实现方式，包括SLINK[27]，CLINK[28]则诞生于1970年代。 k均值算法[25]可谓所有聚类算法中知名度最高的，其历史可以追溯到1967年，此后出现了大量的改进算法，也有大量成功的应用，是所有聚类算法中变种和改进型最多的。 大名鼎鼎的EM算法[29]诞生于1977年，它不光被用于聚类问题，还被用于求解机器学习中带有缺数数据的各种极大似然估计问题。 Mea
【机器学习】十大算法之一 “K-means”
Code_and516的博客
06-15 2598
k-means算法早在1957年就被发明了，最早由J. MacQueen提出。后来，Lloyd（1982年）、Hartigan（1975年）、Forgy（1965年）等学者对此算法进行了修正和改进。这个算法已被广泛应用于数据挖掘、模式识别、图像处理等领域，它可以用来识别数据集之间的模式，因此是一种十分实用的机器学习算法。本篇文章介绍了k-means算法，一种常见的聚类算法。我们详细讲解了该算法的发展史、原理、功能以及示例代码。
K-means聚类 来源博主ModestYjx大佬
laixiangwei的博客
01-07 316
KKK-means聚类中，K的值代表聚类的个数，means代表平均的意思 步骤: 确定KKK值的大小。如何确定KKK值大小，可以按照个人经验，也可以参考其他方法，比如肘部法权衡分类的准确率和"能耗" 进行数据清洗，比如一些异常数据的清除，偏离中心点的数据 随机化选择kkk个聚类中心(可以随机选择一个点，也可以随机定义kkk个中心）。 通过欧氏距离计算训练数据集到各个聚类中心的距离，并且通过比较大小进行归类。 归类结束后，求每一个类中的质心(这里需要注意，每一个类的中心不一定是类中固定的某个点)。质心所有类
进化聚类算法——k-means
个人记录使用
03-14 2040
本文介绍如何将传统的k-means算法套进进化聚类框架中。 将待聚类对象归一化为欧几里德空间中的单位向量。即在时间t上的对象由给出，其中每一个，并且距离矩阵 我们首先介绍一下传统的k-means算法。令t为固定的时间步长，令。这个算法首先需要设置k个聚类质心。，其中；质心的初始化可以随机指定或者使用前一个聚类集中的结果（增量k-means）。令closest(t)为所有接近质心的点集。即： ...
k-means算法课件ppt
09-28
k-means算法是一种广泛应用的无监督学习方法，主要用于数据聚类。它的主要目标是将数据集分割成k个不同的簇，使得每个数据点都尽可能接近其所在簇的中心，而不同簇之间的数据点尽可能远离。在讲解k-means算法时，...
关于k-means的一篇好的总结论文
07-12
k-means总结汇总 介绍基于k-means50年来的发展历程，系统的介绍了各种基于k-means的算法。非常好的数据挖掘入门读物。
精选资源
K均值聚类即K-Means算法详解PPT
04-13
K均值聚类，也称为K-Means算法，是一种在数据挖掘和机器学习领域中应用广泛的无监督学习方法。通过聚类算法，我们可以将数据点分组成具有相似特性的簇，以揭示数据内在的结构和模式。K-Means因其简单高效而被广泛...
K-means算法研究综述
热门推荐
u013473512的博客
03-18 5万+
K-means算法研究综述 聚类被认为是机器学习中最常使用的技术之一, 它历史悠久、应用广泛，几乎应用于环境学、医学、生物学、天文学、经济学等各个领域。其中K-means是最为常用的聚类算法。现在我们来详细介绍一下K-means算法。 1 K-means算法简介 K-means算法(Lloyod,1982)是简单而又有效的统计聚类算法，使机器能够将具有相同属性的样本归置到一块儿。与分类
机器学习算法之k-means
u010230273的博客
08-05 2023
K-means算法在1967年由J．B．MacQueen提出，是一种基于划分的动态聚类算法，同时也是一种具有较大影响力的无监督学习算法。该算法的优点是思想简单易行，时间复杂性接近线性，对大规模数据的挖掘具有高效性和可伸缩性，在工况分类等领域中有着广泛的应用。 K-means算法的基本思想是：对一个包含样本数据的样本集进行分类，确定聚类数目K值后，随机选取K个样本作为初始聚类中心，根据相似性度量
K-means
Sunflower_grh的博客
08-13 491
kmeans函数的基本用法Kmeans算法聚类方法 该方法的 具体工作流程如下 1）首先从数据中选取k个对象作为初始聚类的中心点 2）对于剩下的数根据与质心的距离进行比较进行归类 3）再重新计算各个类的质心(从新计算一下不同类之间的距离如果不同的类之间距离较近则说明分的类比较合理，若距离较近说明选择的聚类中心不合理) 4）重复进行2）3）直到重新计算的质心与原来的质心一致 kmeans
浅谈K-means聚类算法
qq_41181765的博客
12-23 2345
K-means算法的起源 1967年，James MacQueen在他的论文《用于多变量观测分类和分析的一些方法》中首次提出 “K-means”这一术语。1957年，贝尔实验室也将标准算法用于脉冲编码调制技术。1965年，E.W. Forgy发表了本质上相同的算法——Lloyd-Forgy算法，所以这一算法有时也被称为Lloyd-Forgy算法。更高效的版本则被Hartigan and Wong提...
K-means算法的介绍
红豆和绿豆的博客
01-18 990
1、介绍一下聚类 聚类就是类的内部相似，类间不相似 聚类的算法一般包括：划分聚类算法，层次聚类算法，基于密度聚类，基于网格聚类算法。 每一中算法中都包含狠多的具体算法。 基于划分聚类算法包括：k-均值，k-众数，PAM （k中心点），CLARA，CLARANS算法等等 现在主要就是看一下整个算法的流程： 该算法是有缺点的 1、K是很难确定的 2、容易受噪声点的干扰 整个算
[概念]图像分割的历史 + UNet-Family
程序客栈
02-22 1万+
2000年之前，数字图像处理时我们采用方法基于几类：阈值分割、区域分割、边缘分割、纹理特征、聚类等。 2000年到2010年期间， 主要方法有四类：基于图论、聚类、分类以及聚类和分类结合。 2010年至今，神经网络模型的崛起和深度学习的发展，主要涉及到几种模型： 截至到2017年底，我们已经分化出了数以百计的模型结构。当然，经过从技术和原理上考究，我们发现了一个特点，那就是当前最成功的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值