精华内容
下载资源
问答
  • Kmeans算法matlab实现

    2020-07-10 20:45:30
    k均值聚类算法(k-means clustering algorithm)是一种迭代求解的聚类分析算法,其步骤是,预将数据分为K组,则随机选取K个对象作为初始的聚类中心,然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配...
  • Kmeans算法python实现

    2017-08-10 15:21:10
    Kmeans算法的python3.5实现 带数据可以直接运行
  • 基于Hadoop的Kmeans算法实现:Kmeans算法是很典型的基于距离的聚类算法,采用距离作为相似性的评价指标。即认为两个对象的距离越近,其相似度就越大。该算法认为簇是由距离靠近的对象组成的,因此把得到紧凑且独立的...
  • 带有gpu支持的基本kmeans算法(带有Forgy初始化的劳埃德方法)的pytorch实现 用法: from kmeans_pytorch . kmeans import lloyd import numpy as np A = np . concatenate ([ np . random . randn ( 1000 , 2 ), p...
  • Kmeans 算法抠图

    2019-02-14 17:23:27
    3、 Kmeans 算法抠图 需要背景为纯色效果 查找效果速度块 环境VS2013 OPENCV2.4.13
  • php实现kmeans算法

    2019-04-23 23:23:58
    用php实现kmeans算法,在此基础上可以修改为数据库数据的聚类分析。
  • 模糊Kmeans算法

    2018-05-24 15:00:52
    模糊Kmeans算法,java语言编写,里面的py文件是对聚类结果可视化。
  • KMeans 算法

    2018-12-30 19:44:09
    kmeans算法代码 Kmeans算法基本思想是:首先给出聚类的个数K,然后初始随机给定K个待聚类中心(也叫簇中心),按照最邻近原则把待分类样本点分到各个类,也就是样本点到哪个簇中心的距离最近,这个样本点就属于哪一...
  • K-means, Matlab, 聚类算法,机器学习 有丰富的注释解释代码含义,并提供了修改思路
  • 基于Matlab模糊聚类Kmeans算法,有兴趣和需要的可以研究
  • 改进kmeans算法matlab代码介绍 这个Matlab软件包实现了伟大的教科书中描述的机器学习算法:C. Bishop()的模式识别和机器学习。 它是完全用Matlab语言编写的。 它是独立的。 没有外部依赖性。 注意:此软件包需要...
  • 改进的基于广度优先搜索的COP-Kmeans算法,朱煜,钱景辉,将广度优先搜索BFS应用于COP-Kmeans算法会对相同的约束对产生不同的搜索序列,导致算法的准确率降低。针对这种情况,提出了一种改进��
  • 主要介绍了python Kmeans算法深入解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Spark中机器学期(Machine Learning)之KMeans算法完整代码讲解
  • 利用KMeans算法对点云数据进行分类,例如可以提取出点云数据里的房屋、道路等。
  • 用MapReduce实现KMeans算法,数据的读写都是在HDFS上进行的,在伪分布下运行没有问题。文档中有具体说明。
  • matlab实现kmeans算法

    2013-12-26 11:22:25
    matlab实现kmeans算法,可直接运行,稍加改动可实现复杂需求。
  • kmeans算法配套数据

    2019-06-06 19:08:56
    kmeans算法及kmeans-dbscan算法的应用,所用的数据为啤酒数据
  • KMeans算法

    2019-09-26 10:35:09
    目录一、基本概念二、Centroid Initialization Methods三、Mini-Batch K-Means四、找寻最优的聚类数量4.1 拐点4.2 silhouette score 轮廓分数五、Kmeans的限制六、利用Kmeans做preprocessing 无监督问题,将相似的...

    无监督问题,将相似的样本分到一组,难点是如何评估和调参
    注意!!!!!!!:对输入数据进行标准化很重要!!!!
    it is important to scale the input features.虽然不能保证所有的cluster被聚类的很好,但是通常会改善一些。

    一、基本概念

    工作原理:

    1. 选取k个点作为初始的类中心点,这些点一开始都是从数据集中随机抽取的
    2. 将每个点分配到最近的类中心点,这样就形成了k个类,然后重新计算每个类的中心点
    3. 重复第二步,直到类不发生变化,或者设置最大迭代数,只要达到最大迭代次数就会结束聚类

    质心:centroid,均值,即向量各维取平均值,中心点
    距离的度量: 常用欧几里得距离和余弦相似度(要先标准化操作)
    优化目标:对所有的K簇进行优化(每个簇里要优化每个样本点x到中心点c的距离越小越好)
    在这里插入图片描述

    Kmeans算法做出来的分类结果很大程度上由起始centroid决定。如果起始中心点设置不好,最终的结果也只能是局部最优。

    二、Centroid Initialization Methods

    1. 可以试着将大概的各个cluster的中心点,输入到算法中。(比如说之前用了其他的聚类算法得到的中心点)
    2. 可以多跑几次,使用不同的随机起始中心点。然后选取最优的。在sklearn中由n_init控制
      如何衡量聚类结果是最优的呢?叫做inertia [ɪˈnɜːrʃə] :mean squared distance between each instance and its closest centroid
      通过Kmeans.inertia_ 调用或者Kmeans.score(x) 会得到负的inertia值(great is better)
    3. 通常初始中心点生成使用 K-Means++ 方法。不需要改成random。

    三、Mini-Batch K-Means

    K-Means算法在Sklearn中默认采用accelerated K-Means:避免不必要地距离计算

    如果要用最原始地K-Means算法可以将 algorithm参数调成'full'

    Mini-batch:
    不用所有的数据集进行迭代,而是使用小批量的数据。每轮使用小批量数据迭代后,centroid只移动一点点

    from sklearn.cluster import MiniBatchKMeans
    
    minibatch_kmeans = MiniBatchKMeans(n_clusters=5)
    minibatch_kmeans.fit(X)

    Mini-Batch 比原版的运算更快,但inertia(一种聚类的评估指标)会更差一些,尤其当clusters增多时
    在这里插入图片描述

    四、找寻最优的聚类数量

    4.1 拐点

    一般来说我们并不知道有多少个聚类K。如果只用inertia单纯的衡量聚类的好坏,是不够的!!
    因为随着K聚类的不断地增加,inertia必定减少
    The inertia is not a good performance metric when trying to choose k since it keeps getting lower as we increase k. Indeed, the more clusters there are, the closer each instance will be to its closest centroid, and therefore the lower the inertia will be.
    在这里插入图片描述
    可以看出k=4 是一个拐点,尽管k=5是最优解,但很靠近了。拐点左边的K值没必要在测试了,可以测拐点右边的K值。(这个方法来选择最优的K值是很粗糙的)

    4.2 silhouette score 轮廓分数

    [ˌsɪluˈet]
    silhouette score = (b – a) / max(a, b)
    ai:计算样本i到同簇其他样本的平均距离。ai越小,说明样本i越应该被聚类到该簇。将ai称为样本i的簇内不相似度
    bi: 计算样本i到其他簇的所有样本的平均距离,bi是这些平均距离中的最小值!!!bi =min{b1, b2, bik}
    在这里插入图片描述

    s值越接近1越好,取值是[-1,1] ,接近于0,说明此时的样本靠近聚类边界,-1说明很可能被分错了

    from sklearn.metrics import silhouette_score
    silhouette_score(X, kmeans.labels_)

    一种更具有信息的可视化方法是,将每个样本的silhouette 系数画出来,并按照所分配的cluster进行排序
    在这里插入图片描述

    红色的虚线代表所有cluster的silhouette score的平均值,当在一个cluster中的大部分样本的silhouette score低于这个红线值时,那么这个cluster聚类是相当差的,这意味着它的样本要更接近于其他的cluster。

    上图可以看出当k=3和k=6时,有坏的cluster。
    k=4,和k=5时的cluster看起来不错:大部分的样本silhouette score超过了红线。
    然而仔细看k=4时,index=1,那个橙色的cluster里有更多的样本,显得很粗,而k=5的各个簇的样本数量看上去更平均。所以尽管总体silhouette score,k=4要超过k=5,我们更愿意选择k=5.
    https://blog.csdn.net/sinat_29957455/article/details/80113972

    五、Kmeans的优缺点

    优点是:简单,运算速度快和可扩展,适合常规数据集,然而K-means并不是完美的。
    缺点:K值很难确定!它必须跑很多次来避免局部最优。复杂度与样本数量呈线性关系
    而且当clusters的形状很怪异时,各个cluster的大小不一时,密度不同时,K-Means的效果并不好。如果初始值中心点生成不好,结果会很差!

    六、利用Kmeans做preprocessing

    在特征工程时加入一列Kmeans聚类得来的聚类标签,利用GridSearchCV找到最优的K值,来看看通过Kmean聚类后是否会比原始的数据更好

    from sklearn.model_selection import GridSearchCV
    
    param_grid = dict(kmeans__n_clusters=range(2, 100))
    grid_clf = GridSearchCV(pipeline, param_grid, cv=3, verbose=2)
    grid_clf.fit(X_train, y_train)

    在这里插入图片描述

    七、利用K-Means进行图像压缩。

    对数据分析无用,可以省略,在网易云课堂里有教。

    八、代码

    8.1 聚类

    #标准化,要尝试min-max和zscore两种
    from sklearn.preprocessing import StandardScaler
    scaler = StandardScaler()
    data_zscore = scaler.fit_transform(data)
    #from sklearn.preprocessing import MinMaxScaler
    #minmax = MinMaxScaler()
    #data_minmax = minmax.fit_transform(data)
    
    from sklearn.cluster import KMeans
    kmeans = KMeans(n_clusters=3,random_state=0)
    kmeans.fit(data_zscore)
    cluster_labels = kmeans.predict(data_zscore)
    
    #将得到的聚类标签粘到原数据上
    data['Cluster'] = cluster_labels

    8.2 inertia拐点评估聚类的好坏

    #https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans
    #用来存放设置不同簇数时的SSE值
    distortions = []
    for i in range(1,8):
        km = KMeans(n_clusters=i,init="k-means++",n_init=10,max_iter=300,tol=1e-4,random_state=0)
        km.fit(data_zscore)
        #获取K-means算法的SSE
        distortions.append(km.inertia_)
    
    #绘制曲线
    plt.plot(range(1,8),distortions,marker="o")
    plt.xlabel("Number of Cluster")
    plt.ylabel("Inertia(SSE)")
    plt.show()

    在这里插入图片描述

    8.3 轮廓曲线判断聚类的好坏

    kmeans = KMeans(n_clusters=2,init="k-means++",n_init=10,max_iter=300,tol=1e-4,random_state=0)
    from sklearn.metrics import silhouette_samples
    cluster_label = kmeans.fit_predict(data_zscore) #获取每个样本的cluster标签
    from matplotlib import cm
    
    #获取簇的标号
    unique_label = np.unique(cluster_label)
    #获取簇的个数
    n_clusters = unique_label.shape[0]
    #基于欧式距离计算轮廓系数
    silhoutte_vals = silhouette_samples(data_zscore,cluster_label,metric="euclidean")
    
    y_ax_lower,y_ax_upper=0,0
    yticks=[]    
    for i,c in enumerate(unique_label):
        #获取不同簇的轮廓系数
        c_silhouette_vals = silhoutte_vals[cluster_label == c]
        #对簇中样本的轮廓系数由小到大进行排序
        c_silhouette_vals.sort()
        #获取到簇中轮廓系数的个数
        y_ax_upper += len(c_silhouette_vals)
        #获取不同颜色
        color = cm.jet(i / n_clusters)
        #绘制水平直方图
        plt.barh(range(y_ax_lower,y_ax_upper),c_silhouette_vals,height=1.0,edgecolor="none",color=color)
        #获取显示y轴刻度的位置
        yticks.append((y_ax_lower+y_ax_upper) / 2)
        #下一个y轴的起点位置
        y_ax_lower += len(c_silhouette_vals)
        
    #获取轮廓系数的平均值
    silhouette_avg = np.mean(silhoutte_vals)
    #绘制一条平行y轴的轮廓系数平均值的虚线
    plt.axvline(silhouette_avg,color="red",linestyle="--")
    #设置y轴显示的刻度
    plt.yticks(yticks,cluster_labels+1)
    plt.ylabel("Cluster")
    plt.xlabel("Silhouette Score")
    plt.show()

    在这里插入图片描述

    展开全文
  • 1. 写在前面如果想从事数据挖掘或者机器学习的工作,掌握常用的机器学习算法是非常有必要的,常见的机器学习算法:监督学习算法:逻辑回归,线性回归,决策树,朴素贝叶斯,K近邻,支持向量机,集成算法Adaboost等无...

    1. 写在前面

    如果想从事数据挖掘或者机器学习的工作,掌握常用的机器学习算法是非常有必要的,常见的机器学习算法:

    • 监督学习算法:逻辑回归,线性回归,决策树,朴素贝叶斯,K近邻,支持向量机,集成算法Adaboost等
    • 无监督算法:聚类,降维,关联规则, PageRank等

    为了详细的理解这些原理,曾经看过西瓜书,统计学习方法,机器学习实战等书,也听过一些机器学习的课程,但总感觉话语里比较深奥,读起来没有耐心,并且理论到处有,而实战最重要, 所以在这里想用最浅显易懂的语言写一个白话机器学习算法理论+实战系列

    个人认为,理解算法背后的idea和使用,要比看懂它的数学推导更加重要。idea会让你有一个直观的感受,从而明白算法的合理性,数学推导只是将这种合理性用更加严谨的语言表达出来而已,打个比方,一个梨很甜,用数学的语言可以表述为糖分含量90%,但只有亲自咬一口,你才能真正感觉到这个梨有多甜,也才能真正理解数学上的90%的糖分究竟是怎么样的。如果算法是个梨,本文的首要目的就是先带领大家咬一口。另外还有下面几个目的:

    • 检验自己对算法的理解程度,对算法理论做一个小总结
    • 能开心的学习这些算法的核心思想, 找到学习这些算法的兴趣,为深入的学习这些算法打一个基础。
    • 每一节课的理论都会放一个实战案例,能够真正的做到学以致用,既可以锻炼编程能力,又可以加深算法理论的把握程度。
    • 也想把之前所有的笔记和参考放在一块,方便以后查看时的方便。

    学习算法的过程,获得的不应该只有算法理论,还应该有乐趣和解决实际问题的能力!

    今天是白话机器学习算法理论+实战的第八篇 之KMeans聚类算法, 听到这个名字,你可别和第七篇K近邻算法搞混了,K-Means 是一种非监督学习,解决的是聚类问题,这里的K表示的是聚成K类。而之前的K近邻算法是监督学习算法,解决的是分类问题,这里的K表示的是K个邻居。相差十万八千里吧, 一条取经路呢。一定要区分开。这个算法也不是很难,前面说道,K近邻算法的原理可以用八个大字叫做“近朱者赤,近墨者黑”来总结,这里我依然放出八个大字:“人以类聚,物以群分”,形容KMeans最好不过了。

    通过今天的学习,掌握KMeans算法的工作原理,然后会使用sklearn实现KMeans聚类,最后我们来做一个实战项目:如何使用KMeans对图像进行分割? 下面我们开始吧。

    大纲如下:

    • KMeans聚类的工作原理(结合足球队等级划分谈一谈)
    • 20支亚洲足球队,你能划分出等级吗?(KMeans聚类应用)
    • KMeans聚类的实战:图像分割

    OK, let's go!

    2. K-Means的工作原理

    上面我们说过,K-Means 是一种非监督学习,解决的是聚类问题。K 代表的是 K 类,Means 代表的是中心,你可以理解这个算法的本质是确定 K 类的中心点,当你找到了这些中心点,也就完成了聚类。

    那么这里有两个问题:如何确定K类的中心点?如何把其他类划分到K个类中去?

    先别慌, 先和我考虑一个场景,假设我有 20 支亚洲足球队,想要将它们按照成绩划分成 3 个等级,可以怎样划分?

    元芳, 你怎么看?

    对亚洲足球队的水平,你可能也有自己的判断。比如一流的亚洲球队有谁?你可能会说伊朗或韩国。二流的亚洲球队呢?你可能说是中国。三流的亚洲球队呢?你可能会说越南。

    其实这些都是靠我们的经验来划分的,那么伊朗、中国、越南可以说是三个等级的典型代表,也就是我们每个类的中心点。

    所以回过头来,如何确定 K 类的中心点?一开始我们是可以随机指派的,当你确认了中心点后,就可以按照距离将其他足球队划分到不同的类别中。

    这也就是 K-Means 的中心思想,就是这么简单直接。

    你可能会问:如果一开始,选择一流球队是中国,二流球队是伊朗,三流球队是韩国,中心点选择错了怎么办?其实不用担心,K-Means 有自我纠正机制,在不断的迭代过程中,会纠正中心点。中心点在整个迭代过程中,并不是唯一的,只是你需要一个初始值,一般算法会随机设置初始的中心点。

    那下面就给出K-Means的工作原理,两步就搞定,就是那两个问题的解决:

    1. 选取 K 个点作为初始的类中心点,这些点一般都是从数据集中随机抽取的;
    2. 将每个点分配到最近的类中心点,这样就形成了 K 个类,然后重新计算每个类的中心点;(这个怎么算最近,一般是欧几里得距离公式, 那么怎么重新计算每个类的中心点, 每个维度的平均值就可以的)
    3. 重复第二步,直到类不发生变化,或者你也可以设置最大迭代次数,这样即使类中心点发生变化,但是只要达到最大迭代次数就会结束。

    什么?还不明白? 好吧,那直接看看亚洲球队聚类的例子吧

    3. 如何给亚洲球队做聚类

    对于机器来说需要数据才能判断类中心点,所以下面整理了 2015-2019 年亚洲球队的排名,如下表所示。

    我来说明一下数据概况。

    其中 2019 年国际足联的世界排名,2015 年亚洲杯排名均为实际排名。2018 年世界杯中,很多球队没有进入到决赛圈,所以只有进入到决赛圈的球队才有实际的排名。如果是亚洲区预选赛 12 强的球队,排名会设置为 40。如果没有进入亚洲区预选赛 12 强,球队排名会设置为 50。d467e4ae1f10104b893ec267311ede7a.png我们怎么做聚类呢?可以跟着我的思路走了:

    • 首先,针对上面的排名,我们需要做的就是数据规范化,你可以把这些值划分到[0,1]或者按照均值为 0,方差为 1 的正态分布进行规范化。我先把数值规范化到了[0,1]空间中,得到了下面的数值表:bbef88065ca22862cbec1bbad6782f5a.png如果我们随机选取中国、日本、韩国为三个类的中心点,我们就需要看下这些球队到中心点的距离。

    • 下面就是把其其他样本根据距离中心点的远近划分到这三个类中去,有关距离可以参考KNN那一篇博客。 常用的有欧氏距离,曼哈顿距离等。这里采用欧式距离。

    欧氏距离是最常用的距离计算方式,这里选择欧氏距离作为距离的标准,计算每个队伍分别到中国、日本、韩国的距离,然后根据距离远近来划分。我们看到大部分的队,会和中国队聚类到一起。这里我整理了距离的计算过程,比如中国和中国的欧氏距离为 0,中国和日本的欧式距离为 0.732003。如果按照中国、日本、韩国为 3 个分类的中心点,欧氏距离的计算结果如下表所示:94dda8c29d435432e74d30d7f5323319.png然后我们再重新计算这三个类的中心点,如何计算呢?最简单的方式就是取平均值,然后根据新的中心点按照距离远近重新分配球队的分类,再根据球队的分类更新中心点的位置。计算过程这里不展开,最后一直迭代(重复上述的计算过程:计算中心点和划分分类)到分类不再发生变化,可以得到以下的分类结果:5e4d683cc62eece24e292f838bd20179.png所以我们能看出来第一梯队有日本、韩国、伊朗、沙特、澳洲;第二梯队有中国、伊拉克、阿联酋、乌兹别克斯坦;第三梯队有卡塔尔、泰国、越南、阿曼、巴林、朝鲜、印尼、叙利亚、约旦、科威特和巴勒斯坦。

    这个就是KMeans进行聚类的过程了。简单点,就是反复两个过程:

    • 确定中心点
    • 把其他的点按照距中心点的远近归到相应的中心点

    上面这个也可以使用sklearn中的K-Means进行实战一下子,作为图像分割图像的准备期。

    4. KMeans聚类实战:如何使用KMeans对图像进行分割?

    还是老规矩,我们在实战之前,先看一下如何调用sklearn实现KMeans。

    4.1 如何使用sklearn中的KMeans算法

    sklearn 是 Python 的机器学习工具库,如果从功能上来划分,sklearn 可以实现分类、聚类、回归、降维、模型选择和预处理等功能。这里我们使用的是 sklearn 的聚类函数库,因此需要引用工具包,具体代码如下:

    from sklearn.cluster import KMeans

    当然 K-Means 只是 sklearn.cluster 中的一个聚类库,实际上包括 K-Means 在内,sklearn.cluster 一共提供了 9 种聚类方法,比如 Mean-shift,DBSCAN,Spectral clustering(谱聚类)等。这些聚类方法的原理和 K-Means 不同,这里不做介绍。

    我们看下 K-Means 如何创建:

    KMeans(n_clusters=8, init='k-means++', n_init=10, max_iter=300, tol=0.0001, precompute_distances='auto', verbose=0, random_state=None, copy_x=True, n_jobs=1, algorithm='auto')

    这些参数解释一下:

    • n_clusters: 即 K 值,一般需要多试一些 K 值来保证更好的聚类效果。你可以随机设置一些 K 值,然后选择聚类效果最好的作为最终的 K 值;max_iter:最大迭代次数,如果聚类很难收敛的话,设置最大迭代次数可以让我们及时得到反馈结果,否则程序运行时间会非常长;
    • n_init:初始化中心点的运算次数,默认是 10。程序是否能快速收敛和中心点的选择关系非常大,所以在中心点选择上多花一些时间,来争取整体时间上的快速收敛还是非常值得的。由于每一次中心点都是随机生成的,这样得到的结果就有好有坏,非常不确定,所以要运行 n_init 次, 取其中最好的作为初始的中心点。如果 K 值比较大的时候,你可以适当增大 n_init 这个值;
    • init:即初始值选择的方式,默认是采用优化过的 k-means++ 方式,你也可以自己指定中心点,或者采用 random 完全随机的方式。自己设置中心点一般是对于个性化的数据进行设置,很少采用。random 的方式则是完全随机的方式,一般推荐采用优化过的 k-means++ 方式;
    • algorithm:k-means 的实现算法,有“auto” “full”“elkan”三种。一般来说建议直接用默认的"auto"。简单说下这三个取值的区别,如果你选择"full"采用的是传统的 K-Means 算法,“auto”会根据数据的特点自动选择是选择“full”还是“elkan”。我们一般选择默认的取值,即“auto” 。

    在创建好 K-Means 类之后,就可以使用它的方法,最常用的是 fit 和 predict 这个两个函数。你可以单独使用 fit 函数和 predict 函数,也可以合并使用 fit_predict 函数。其中 fit(data) 可以对 data 数据进行 k-Means 聚类。predict(data) 可以针对 data 中的每个样本,计算最近的类。

    下面我们先跑一遍20支亚洲球队的聚类问题:数据集在这下载


    # coding: utf-8
    from sklearn.cluster import KMeans
    from sklearn import preprocessing
    import pandas as pd
    import numpy as np
    # 输入数据
    data = pd.read_csv('data.csv', encoding='gbk')
    train_x = data[["2019年国际排名","2018世界杯","2015亚洲杯"]]
    df = pd.DataFrame(train_x)
    kmeans = KMeans(n_clusters=3)
    # 规范化到[0,1]空间
    min_max_scaler=preprocessing.MinMaxScaler()
    train_x=min_max_scaler.fit_transform(train_x)
    # kmeans算法
    kmeans.fit(train_x)
    predict_y = kmeans.predict(train_x)
    # 合并聚类结果,插入到原数据中
    result = pd.concat((data,pd.DataFrame(predict_y)),axis=1)
    result.rename({0:u'聚类'},axis=1,inplace=True)
    print(result)

    运行结果如下:


    国家 2019年国际排名 2018世界杯 2015亚洲杯 聚类
    0 中国 73 40 7 2
    1 日本 60 15 5 0
    2 韩国 61 19 2 0
    3 伊朗 34 18 6 0
    4 沙特 67 26 10 0
    5 伊拉克 91 40 4 2
    6 卡塔尔 101 40 13 1
    7 阿联酋 81 40 6 2
    8 乌兹别克斯坦 88 40 8 2
    9 泰国 122 40 17 1
    10 越南 102 50 17 1
    11 阿曼 87 50 12 1
    12 巴林 116 50 11 1
    13 朝鲜 110 50 14 1
    14 印尼 164 50 17 1
    15 澳洲 40 30 1 0
    16 叙利亚 76 40 17 1
    17 约旦 118 50 9 1
    18 科威特 160 50 15 1
    19 巴勒斯坦 96 50 16 1

    4.2 如何用KMeans对图像进行分割?

    图像分割就是利用图像自身的信息,比如颜色、纹理、形状等特征进行划分,将图像分割成不同的区域,划分出来的每个区域就相当于是对图像中的像素进行了聚类。单个区域内的像素之间的相似度大,不同区域间的像素差异性大。这个特性正好符合聚类的特性,所以你可以把图像分割看成是将图像中的信息进行聚类。当然聚类只是分割图像的一种方式,除了聚类,我们还可以基于图像颜色的阈值进行分割,或者基于图像边缘的信息进行分割等。

    将微信开屏封面进行分割。

    我们现在用 K-Means 算法对微信页面进行分割。微信开屏图如下所示:b6c780b7fc59a7262ba6720215ad7827.png我们先设定下聚类的流程,聚类的流程和分类差不多,如图所示:17c74c71f7d143ab713f37631bc1f414.png在准备阶段里,我们需要对数据进行加载。因为处理的是图像信息,我们除了要获取图像数据以外,还需要获取图像的尺寸和通道数,然后基于图像中每个通道的数值进行数据规范化。这里我们需要定义个函数 load_data,来帮我们进行图像加载和数据规范化。代码如下:

    # 加载图像,并对数据进行规范化
    def load_data(filePath):
    # 读文件
    f = open(filePath,'rb')
    data = []
    # 得到图像的像素值
    img = image.open(f)
    # 得到图像尺寸
    width, height = img.size
    for x in range(width):
    for y in range(height):
    # 得到点(x,y)的三个通道值
    c1, c2, c3 = img.getpixel((x, y))
    data.append([c1, c2, c3])
    f.close()
    # 采用Min-Max规范化
    mm = preprocessing.MinMaxScaler()
    data = mm.fit_transform(data)
    return np.mat(data), width, height

    因为 jpg 格式的图像是三个通道 (R,G,B),也就是一个像素点具有 3 个特征值。这里我们用 c1、c2、c3 来获取平面坐标点 (x,y) 的三个特征值,特征值是在 0-255 之间。

    为了加快聚类的收敛,我们需要采用 Min-Max 规范化对数据进行规范化。我们定义的 load_data 函数返回的结果包括了针对 (R,G,B) 三个通道规范化的数据,以及图像的尺寸信息。在定义好 load_data 函数后,我们直接调用就可以得到相关信息,代码如下:

    # 加载图像,得到规范化的结果img,以及图像尺寸
    img, width, height = load_data('./weixin.jpg')

    假设我们想要对图像分割成 2 部分,在聚类阶段,我们可以将聚类数设置为 2,这样图像就自动聚成 2 类。代码如下:

    # 用K-Means对图像进行2聚类
    kmeans =KMeans(n_clusters=2)
    kmeans.fit(img)
    label = kmeans.predict(img)
    # 将图像聚类结果,转化成图像尺寸的矩阵
    label = label.reshape([width, height])
    # 创建个新图像pic_mark,用来保存图像聚类的结果,并设置不同的灰度值
    pic_mark = image.new("L", (width, height))
    for x in range(width):
    for y in range(height):
    # 根据类别设置图像灰度, 类别0 灰度值为255, 类别1 灰度值为127
    pic_mark.putpixel((x, y), int(256/(label[x][y]+1))-1)
    pic_mark.save("weixin_mark.jpg", "JPEG")

    代码中有一些参数,下面说一下这些参数的作用和设置方法:

    我们使用了 fit 和 predict 这两个函数来做数据的训练拟合和预测,因为传入的参数是一样的,我们可以同时进行 fit 和 predict 操作,这样我们可以直接使用 fit_predict(data) 得到聚类的结果。得到聚类的结果 label 后,实际上是一个一维的向量,我们需要把它转化成图像尺寸的矩阵。label 的聚类结果是从 0 开始统计的,当聚类数为 2 的时候,聚类的标识 label=0 或者 1。
    如果你想对图像聚类的结果进行可视化,直接看 0 和 1 是看不出来的,还需要将 0 和 1 转化为灰度值。灰度值一般是在 0-255 的范围内,我们可以将 label=0 设定为灰度值 255,label=1 设定为灰度值 127。具体方法是用 int(256/(label[x][y]+1))-1。可视化的时候,主要是通过设置图像的灰度值进行显示。所以我们把聚类 label=0 的像素点都统一设置灰度值为 255,把聚类 label=1 的像素点都统一设置灰度值为 127。原来图像的灰度值是在 0-255 之间,现在就只有 2 种颜色(也就是灰度为 255,和灰度 127)。

    有了这些灰度信息,我们就可以用 image.new 创建一个新的图像,用 putpixel 函数对新图像的点进行灰度值的设置,最后用 save 函数保存聚类的灰度图像。这样你就可以看到聚类的可视化结果了,如下图所示:47590d7f2b7fb02b67d8c3d5a8b750fe.png如果我们想要分割成 16 个部分,该如何对不同分类设置不同的颜色值呢?这里需要用到 skimage 工具包,它是图像处理工具包。你需要使用 pip install scikit-image 来进行安装。这段代码可以将聚类标识矩阵转化为不同颜色的矩阵:

    from skimage import color
    # 将聚类标识矩阵转化为不同颜色的矩阵
    label_color = (color.label2rgb(label)*255).astype(np.uint8)
    label_color = label_color.transpose(1,0,2)
    images = image.fromarray(label_color)
    images.save('weixin_mark_color.jpg')

    代码中,我使用 skimage 中的 label2rgb 函数来将 label 分类标识转化为颜色数值,因为我们的颜色值范围是[0,255],所以还需要乘以 255 进行转化,最后再转化为 np.uint8 类型。unit8 类型代表无符号整数,范围是 0-255 之间。

    得到颜色矩阵后,你可以把它输出出来,这时你发现输出的图像是颠倒的,原因可能是图像源拍摄的时候本身是倒置的。我们需要设置三维矩阵的转置,让第一维和第二维颠倒过来,也就是使用 transpose(1,0,2),将原来的 (0,1,2)顺序转化为 (1,0,2) 顺序,即第一维和第二维互换。

    最后我们使用 fromarray 函数,它可以通过矩阵来生成图片,并使用 save 进行保存。最后得到的分类标识颜色化图像是这样的:ebd73041e09db2c9d90cb83c97b10524.png刚才我们做的是聚类的可视化。如果我们想要看到对应的原图,可以将每个簇(即每个类别)的点的 RGB 值设置为该簇质心点的 RGB 值,也就是簇内的点的特征均为质心点的特征。

    我给出了完整的代码,代码中,我可以把范围为 0-255 的数值投射到 1-256 数值之间,方法是对每个数值进行加 1,你可以自己来运行下:

    # -*- coding: utf-8 -*-
    # 使用K-means对图像进行聚类,并显示聚类压缩后的图像
    import numpy as np
    import PIL.Image as image
    from sklearn.cluster import KMeans
    from sklearn import preprocessing
    import matplotlib.image as mpimg
    # 加载图像,并对数据进行规范化
    def load_data(filePath):
    # 读文件
    f = open(filePath,'rb')
    data = []
    # 得到图像的像素值
    img = image.open(f)
    # 得到图像尺寸
    width, height = img.size
    for x in range(width):
    for y in range(height):
    # 得到点(x,y)的三个通道值
    c1, c2, c3 = img.getpixel((x, y))
    data.append([(c1+1)/256.0, (c2+1)/256.0, (c3+1)/256.0])
    f.close()
    return np.mat(data), width, height
    # 加载图像,得到规范化的结果imgData,以及图像尺寸
    img, width, height = load_data('./weixin.jpg')
    # 用K-Means对图像进行16聚类
    kmeans =KMeans(n_clusters=16)
    label = kmeans.fit_predict(img)
    # 将图像聚类结果,转化成图像尺寸的矩阵
    label = label.reshape([width, height])
    # 创建个新图像img,用来保存图像聚类压缩后的结果
    img=image.new('RGB', (width, height))
    for x in range(width):
    for y in range(height):
    c1 = kmeans.cluster_centers_[label[x, y], 0]
    c2 = kmeans.cluster_centers_[label[x, y], 1]
    c3 = kmeans.cluster_centers_[label[x, y], 2]
    img.putpixel((x, y), (int(c1*256)-1, int(c2*256)-1, int(c3*256)-1))
    img.save('weixin_new.jpg')

    结果如下:51172397bfabd8bff9d4600762f83c9d.png你可以看到我没有用到 sklearn 自带的 MinMaxScaler,而是自己写了 Min-Max 规范化的公式。这样做的原因是我们知道 RGB 每个通道的数值在[0,255]之间,所以我们可以用每个通道的数值 +1/256,这样数值就会在[0,1]之间。

    对图像做了 Min-Max 空间变换之后,还可以对其进行反变换,还原出对应原图的通道值。对于点 (x,y),我们找到它们所属的簇 label[x,y],然后得到这个簇的质心特征,用 c1,c2,c3 表示:

    c1 = kmeans.cluster_centers_[label[x, y], 0]
    c2 = kmeans.cluster_centers_[label[x, y], 1]
    c3 = kmeans.cluster_centers_[label[x, y], 2]

    因为 c1, c2, c3 对应的是数据规范化的数值,因此我们还需要进行反变换,即:

    c1=int(c1*256)-1
    c2=int(c2*256)-1
    c3=int(c3*256)-1

    然后用 img.putpixel 设置点 (x,y) 反变换后得到的特征值。最后用 img.save 保存图像。

    5. 总结

    好了,写到这关于KMeans,就要结束了。下面快速的回顾一下:

    首先,通过足球队聚类的例子引出了KMeans聚类的工作原理,简单来说两步,你可以回忆回忆。

    然后,通过KMeans实现了对图像分割的实战,另外我们还学习了如何在 Python 中如何对图像进行读写,具体的代码如下,上文中也有相应代码,你也可以自己对应下:

    import PIL.Image as image
    # 得到图像的像素值
    img = image.open(f)
    # 得到图像尺寸
    width, height = img.size

    这里会使用 PIL 这个工具包,它的英文全称叫 Python Imaging Library,顾名思义,它是 Python 图像处理标准库。同时我们也使用到了 skimage 工具包(scikit-image),它也是图像处理工具包。用过 Matlab 的同学知道,Matlab 处理起图像来非常方便。skimage 可以和它相媲美,集成了很多图像处理函数,其中对不同分类标识显示不同的颜色。在 Python 中图像处理工具包,我们用的是 skimage 工具包。

    好了,KMeans的故事就到这里吧。

    参考:

    • http://note.youdao.com/noteshare?id=10dac8bb5d83358ffe73c792e1490a7b&sub=C7A3E74A1088435ABBE11AB91AC37194
    • https://time.geekbang.org/
    • 91bf50388acc47157a80bab0c9cef08f.png

    点个在看,么么哒!

    4b2e4f7ad525c7c821046d29a9a1c916.gif
    展开全文
  • KMeans算法流程

    2021-05-20 22:31:43
    一、KMeans算法原理 KMeans算法作为聚类算法的典型代表,那它是怎么完成聚类的呢? 在 KMeans 算法中, 簇的个数用k表示,k是一个超参数,需要我们人为输入来确定。 Kmeans 的核心任务就是根据我们设定好的 k ,找...

    一、什么是簇?

    我们知道聚类就是让机器把数据集中的样本按照特征的性质分组,直观上来看,簇是一组一组聚集在一起的数据,在 一个簇 中的数据就认为是 同一类 ,簇就是聚类的结果表现。实际上簇并没有明确的定义,并且簇的划分没有客观标准,我们可以利用下图来理解什么是簇。该图显示了20个点和将它们划分成簇的3种不同方法,标记的形状(口、△、☆等)表示簇的隶属关系。

    图中分别将数据划分成两个簇、四个簇和六个簇。直观地看,将图b的2个较大的簇再划分成4个簇好像也不无道理,这可能是人的视觉系统造成的假象。

    该图表明簇的定义是不精确的,而最好的定义依赖于数据的特性和期望的结果。

    二、什么是质心?

    簇中所有 数据的均值 通常被称为这个 簇的“质心”( centroids) 。在一个二维平面中,一簇数据点的质心的横坐标就是这一簇数据点的横坐标的均值,质心的纵坐标就是这一簇数据点的纵坐标的均值。同理可推广至高维空间。
    一、KMeans算法原理

    KMeans算法作为聚类算法的典型代表,那它是怎么完成聚类的呢?
    在 KMeans 算法中, 簇的个数用k表示,k是一个超参数,需要我们人为输入来确定。 Kmeans 的核心任务就是根据我们设定好的 k ,找出 k个最优的质心,并将离这些质心最近的数据分别分配到这些质心代表的簇中去。

    二、KMeans算法流程

    (1)首先设置参数k, k的含义为将数据聚合成几类(这里取k=3);
    (2)从数据当中,随机的选择三(k)个点,成为聚类初始中心点;(图中初始三个中心点用蓝色、红色和黄色标记)

    在这里插入图片描述
    (3)计算所有其他点到这三(k)个点的距离, 然后找出离每个数据点最近的中心点, 将该点划分到这个中心点所代表的的簇当中去。那么所有点都会被划分到三(k)个簇当中去。

    在这里插入图片描述
    (4)重新计算三个簇的质心,作为下一次聚类的中心点;
    在这里插入图片描述
    (5)重复上面的3-4步的过程,重新进行聚类,不断迭代重复这个过程。
    (6)停止条件:
    第一种:当重新聚类后,所有样本点归属类别都没有发生变化的时候。
    第二种:当迭代次数达到规定的最大次数时,也会停止。

    在什么情况下,质心的位置会不再变化呢?

    引言: 在上节介绍KMeans算法流程中,我们简单介绍了聚类停止的条件,其中簇不再发生变化的条件,本质上是指簇的质心位置不再发生改变。为什么呢?

    因为:在我们找质心的过程中,当每次迭代中被分配到这个质心上的样本都是一致时,也就是说:每次新生成的簇都是一致的,所有的样本点都不会再从一个簇转移到另一个簇,质心就不会变化了。
    接下来,我们以可视化的形式详细讨论质心的位置的变化情况。
    质心位置变化的可视化展示过程

    上面论述的过程,我们可以由下图来显示:我们规定,将数据分为 4 簇(k=4),其中白色 X 代表质心的位置,每个颜色块代表着围绕着质心所形成的簇。在这里插入图片描述
    在这里插入图片描述
    注:灰色箭头表示质心的变化情况
    在数据集下多次迭代(iteration),就会有:
    在这里插入图片描述
    第六次迭代之后,基本上质心的位置就不再改变了,生成的簇也变得稳定。此时我们的聚类就完成了。

    展开全文
  • 用matlab实现kmeans算法,非常完整例子一维和二维
  • 1K-means Clusteringalgorithm2K-means Clustering K-means clustering is a sort of clustering algorithm and it is a method of vector quantization, originally from signal processing, that is popular for c
  • kmeans算法

    2019-04-22 15:23:31
    基本版本的kmeans算法的实现,附带wine数据集,并做了可视化
  • K-means聚类算法c语言实现。样本数据从文件读入,支持任意维数数据和任意k值(k当然要小于样本数).原创原创!
  • 1. Kmeans算法原理1.1 Kmeans算法介绍聚类算法是一种无监督学习方法,将相似的对象归到同一个簇中。在K-Means算法中,我们将所有的数据划分到K个不同的簇中并且每一个簇的中心是该簇中所有的节点的均值计算得到,...

    #1. Kmeans算法原理
    ##1.1 Kmeans算法介绍
    聚类算法是一种无监督学习方法,将相似的对象归到同一个簇中。在K-Means算法中,我们将所有的数据划分到K个不同的簇中并且每一个簇的中心是该簇中所有的节点的均值计算得到,因此称为K—均值算法。

    在机器学习中聚类和分类算法最大的不同在于,分类的目标事先是已知的,而聚类则不同,聚类的目标是未知的。分类产生的结果是分类前已经知晓的结果,而聚类产生的结果是未知的,因此聚类别称为无监督的学习方式。
    ##1.2 Kmeans算法原理
    K-Means算法是发现给定数据集中的K个簇而簇的个数K是用户给定的数据信息,每一个簇通过簇的质心来描述,质心是通过该类中的所有点求平均值得到。
    在K-Means算法中,算法的流程如下:

    (1)随机选择K个点作为初始质心

    (2)对所有的点计算寻找最近的质心为该点所属的质心,并计算到该质心的距离。

    (3)对各个节点划分好的点通过求该簇所有节点的均值计算该簇新的质心。

    (4)重复步骤(2)对所有的节点重新进行划分,直到所有的簇的质心不再改变。

    在计算节点与质心之间的距离时,我们通常采用欧式距离进行计算计算公式如下:
    d i s t = s q r t ( ( x 1 − y 1 ) 2 + ( x 2 − y 2 ) 2 + . . . + ( x i − y i ) 2 ) dist=sqrt((x_1-y_1)^2+(x_2-y_2)^2+...+(x_i-y_i)^2) dist=sqrt((x1y1)2+(x2y2)2+...+(xiyi)2)
    根据上述描述的过程Kmeans算法执行的过程主要为:计算质心——划分节点——重新计算的过程,接下来我们考虑如何实现K-Means算法
    #2. Kmeans算法Python实现

    ##2.1 初始化质心

    def Random_initCentroids(dataSet, k):
        numSamples, dim = dataSet.shape
        centroids = zeros((k, dim))
        #随机生成聚类中心
        for i in range(k):
            index = int(random.uniform(0, numSamples))
            centroids[i, :] = dataSet[index, :]
        return centroids
    

    在上述代码中,在所有的数据节点中随机选择一个节点作为聚类中心,在Random_initCentroids()中通过随机的选择所有的点中的任意K个作为聚类中心。其中Random_initCentroids()传入的参数分别为:
    dataSet和k值,在随机选择时同样同样的可以在每一个特征的最小值和最大值之间随机选取一个值作为初始的质心。

    ##2.2 计算节点距离

    def euclDistance(vector1, vector2):
        return sqrt(sum(power(vector2 - vector1, 2)))
    

    上述代码用于计算两个向量之间的距离,也就是节点vector1和节点vector2之间的距离在这里的距离表示的欧式距离。

    ##2.3 Kmeans聚类

    def kmeans(dataSet, k,medthod):
        numSamples = dataSet.shape[0]
        # first column stores which cluster this sample belongs to,
        # second column stores the error between this sample and its centroid
        clusterAssment = mat(zeros((numSamples, 2)))
        clusterChanged = True
        ## 初始化聚类中心
        if medthod == 0:
            centroids = Random_initCentroids(dataSet, k)
        else:
            centroids = maxDis_initCentroids(dataSet, k)
        while clusterChanged:
            clusterChanged = False
            ## 对每一个点计算聚类中心
            for i in range(numSamples):
                minDist = 100000.0
                minIndex = 0
                ## 寻找最近的聚类中心
                for j in range(k):
                    distance = euclDistance(centroids[j, :], dataSet[i, :])
                    if distance < minDist:
                        minDist = distance
                        minIndex = j
                ##更新节点所属的簇判断迭代是否继续
                if clusterAssment[i, 0] != minIndex:
                    clusterChanged = True
                clusterAssment[i, :] = minIndex, minDist ** 2
            ## 更新聚类中心
            for j in range(k):
                pointsInCluster = dataSet[nonzero(clusterAssment[:, 0].A == j)[0]]
                centroids[j, :] = mean(pointsInCluster, axis=0)
        print('Congratulations, cluster complete!')
        return centroids, clusterAssment
    

    在上述的Kmeans聚类算法中主要的执行过程如下:

    (1)初始化聚类中心

    根据下面的代码可知,在我们这里定义了两种初始化聚类中心的方式一种为上面讲述的Random_initCentroids()随机选取聚类中心的方式,另外一种为maxDis_initCentroids()方式,第二种聚类方式我们在下面做详细的介绍。

    clusterAssment = mat(zeros((numSamples, 2)))
    clusterChanged = True
    ## 初始化聚类中心
    if medthod == 0:
        centroids = Random_initCentroids(dataSet, k)
    else:
        centroids = maxDis_initCentroids(dataSet, k)
    

    (2)计算每一个结点所有的簇

    对数据集中的所有节点计算出距离最小的质心,并将该节点划分到质心所属的簇。

    while clusterChanged:
        clusterChanged = False
        ## 对每一个点计算聚类中心
        for i in range(numSamples):
            minDist = 100000.0
            minIndex = 0
            ## 寻找最近的聚类中心
            for j in range(k):
                distance = euclDistance(centroids[j, :], dataSet[i, :])
                if distance < minDist:
                    minDist = distance
                    minIndex = j
            ##更新节点所属的簇判断迭代是否继续
            if clusterAssment[i, 0] != minIndex:
                clusterChanged = True
            clusterAssment[i, :] = minIndex, minDist ** 2
    

    (3)更新质心

    对统计簇中每一个点的每一维特征的均值作为新的质心,并重复上述步骤(2)直到所有簇的质心都不再发生改变为止。

    for j in range(k):
        pointsInCluster = dataSet[nonzero(clusterAssment[:, 0].A == j)[0]]
        centroids[j, :] = mean(pointsInCluster, axis=0)
    

    ##2.4 数据可视化
    在Python中我们可以通过matplotlib对二维的数据进行可视化。

    def showCluster(dataSet, k, centroids, clusterAssment):
        numSamples, dim = dataSet.shape
        printCluster(dataSet, centroids, clusterAssment)
        if dim != 2:
            print("Sorry! I can not draw because the dimension of your data is not 2!")
            return 1
    
        mark = ['or', 'ob', 'og', 'ok', '^r', '+r', 'sr', 'dr', '<r', 'pr']
        if k > len(mark):
            print
            "Sorry! Your k is too large! please contact Zouxy"
            return 1
    
            # draw all samples
        for i in range(numSamples):
            markIndex = int(clusterAssment[i, 0])
            plt.plot(dataSet[i, 0], dataSet[i, 1], mark[markIndex])
    
        mark = ['Dr', 'Db', 'Dg', 'Dk', '^b', '+b', 'sb', 'db', '<b', 'pb']
        # draw the centroids
        for i in range(k):
            plt.plot(centroids[i, 0], centroids[i, 1], mark[i], markersize=12)
        plt.show()
    

    ##2.5 数据输出
    输出整个数据集的所有簇的质心以及每一个每一个数据项对应的簇和该簇的质心。

    def printCluster(dataSet, centroids, clusterAssment):
        numSample,dim = dataSet.shape
        i = 0;
        for a in centroids:
            print("Cluster ",i,"centroids is ",a);
            i = i + 1
        for i in range(numSample):
            print("the node ",dataSet[i]," belong to the cluster",clusterAssment[i],"the centroids is ",centroids[int(clusterAssment[i,0])]);
    

    ##2.6 测试代码

    from numpy import *
    import time
    import matplotlib.pyplot as plt
    ## step 1: load data
    from src.Kmeans import kmeans, showCluster
    print("step 1: load data...")
    dataSet = []
    fileIn = open('../data/Iris.txt')
    #read each line in the file
    for line in fileIn.readlines():
        linedata = []
        lineArr = line.strip().split(',')
        for data in lineArr:
            linedata.append(float(data));
        dataSet.append(linedata)
    
    print("step 2: clustering...")
    dataSet = mat(dataSet)
    k = 3
    centroids, clusterAssment = kmeans(dataSet,k,1)
    ## step 3: show the result  
    print("step 3: show the result...")
    showCluster(dataSet, k, centroids, clusterAssment) 
    

    #3. 运行结果
    在测试算法的聚类效果时,我们分别选取了两个数据集进行聚类,一个是在参考的博客中给出的数据集,是一个二维的数据集,一个失鸢尾花数据集。
    ##3.1 二维数据集
    下面如下图1为matplotlib绘制出的二维图像,我们将所有的数据一共聚成4个类,根据下述图中的显示的结果可知,Kmean算法具有较好的聚类效果。

    这里写图片描述

    对于聚类后的输出数据如下图2所示

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hgCTyw9f-1595748821806)(Image/2.png)]这里写图片描述

    ##3.2鸢尾花数据集
    对于鸢尾花数据集聚类的结果输出如下所示,我们将数据结果一共聚类成3个类。
    这里写图片描述

    #4. Kmeans算法的优缺点及改进方法
    ##4.1 Kmens算法的优点
    (1)实现简单,易于理解
    ##4.2 Kmeans算法的缺点
    (1)可能收敛到局部最小值,在大规模数据集上收敛较慢

    (2)只适用于数值型的数据

    (3)对初始质心的比较敏感。

    (4)无法聚类非球状数据

    (5)在较大数据集上收敛速度慢
    ##4.3 Kmeans聚类性能提高
    为了解决聚类算法对处置敏感性的问题,防止Kmeans算法收敛到最小值的可能收敛到局部的最小值,我们通过改变质心的初始化方式来解决这一问题,根据上述描述的方式,我们在初始化聚类中心时采用随机初始化聚类中心的方式。为了减小聚类中心对初始值的敏感性,我们对聚类中心的初始化方式有以下两种:

    (1)通过最大距离的方式初始化聚类中心。

    根据下述的代码可知,通过maxDistance初始化聚类中心时,第一个质心通过随机选取,在此之后所有质心的选择都选择与当前已经选择作为质心的点最远的点作为新的质心。

    def maxDistance(dataSet,centroids,numCentroids):
        numSamples,dim = dataSet.shape;
        maxDis = 0;
        maxindex = 0;
        for i in range(numSamples):
            distance = 0;
            for j in range(numCentroids):
                distance = euclDistance(dataSet[i,:],centroids[j,:]) + distance;
            if distance > maxDis:
                maxDis = distance;
                maxindex = i;
        centroids[numCentroids,:] = dataSet[maxindex,:]
    

    (2)通过分层聚类初始化聚类中心
    通过Canopy进行分层聚类,在每一个Canopy中选择一个点作为质心进行聚类,得到最终的聚类结果。

    此外还有一些聚类的后处理方式以及二分K-均值聚类算法在之后进行描述
    博客源代码下载地址

    展开全文
  • Kmeans算法

    2019-04-29 19:28:07
    基本的K-means算法模拟,使用C++代码实现。 打开一个文件,将文件中的所有点根据K个初始点进行多次迭代后划分。
  • 肘部法则对于K-means算法的K值确定起到指导作用,很多人在用K-means算法的时候可能不知道如何确定K取多少比较好,在面试也会遇到K值确定的问题。肘部算法可以有效解决这个问题 简单叙述一下肘部法则,由左下图,y轴...
  • KMeans算法动画演示

    2020-10-13 19:55:28
    KMeans算法动画演示,供大家学习和交流。如果发现有代码上的优化可以私聊我scdn账号。 并没有其他的特殊含义。
  • 数据挖掘--基于KMeans算法的客户价值分析-附件资源

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,092
精华内容 9,636
关键字:

kmeans算法