精华内容
下载资源
问答
  • 本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类算法,数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。关于聚类聚类算法是这样的一种算法:给定样本数据Sample...

    本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类算法,数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。

    关于聚类

    聚类算法是这样的一种算法:给定样本数据Sample,要求将样本Sample中相似的数据聚到一类。有了这个认识之后,就应该了解了聚类算法要干什么了吧。说白了,就是归类。

    首先,我们需要考虑的是,如何衡量数据之间的相似程度?比如说,有一群说不同语言的人,我们一般是根据他们的方言来聚类的(当然,你也可以指定以身高来聚类)。这里,语言的相似性(或者身高)就成了我们衡量相似的量度了。在考虑存在海量数据,如微博上各种用户的关系网,如何根据用户的关注和被关注来聚类,给用户推荐他们感兴趣的用户?这就是聚类算法研究的内容之一了。

    Kmeans就是这样的聚类算法中比较简单的算法,给定数据样本集Sample和应该划分的类数K,对样本数据Sample进行聚类,最终形成K个cluster,其相似的度量是某条数据i与中心点的”距离”(这里所说的距离,不止于二维)。

    基本思想

    KMeans算法的基本思想是初始随机给定K个簇中心,按照最邻近原则把待分类样本点分到各个簇。然后按平均法重新计算各个簇的质心,从而确定新的簇心。一直迭代,直到簇心的移动距离小于某个给定的值。

    基本步骤

    K-Means聚类算法主要分为三个步骤:

    1,初始化k个聚类中心。

    2,计算出每个对象跟这k个中心的距离(相似度计算,这个下面会提到),假如x这个对象跟y这个中心的距离最小(相似度最大),那么x属于y这个中心。这一步就可以得到初步的k个聚类 。

    3,在第二步得到的每个聚类分别计算出新的聚类中心,和旧的中心比对,假如不相同,则继续第2步,直到新旧两个中心相同,说明聚类不可变,已经成功 。

    复杂度分析

    时间复杂度:O(tKmn),其中,t为迭代次数,K为簇的数目,m为记录数,n为维数

    空间复杂度:O((m+K)n),其中,K为簇的数目,m为记录数,n为维数

    初始质心的选择

    选择适当的初始质心是基本kmeans算法的关键步骤。常见的方法是随机的选取初始质心,但是这样簇的质量常常很差。处理选取初始质心问题的一种常用技术是:多次运行,每次使用一组不同的随机初始质心,然后选取具有最小SSE(误差的平方和)的簇集。这种策略简单,但是效果可能不好,这取决于数据集和寻找的簇的个数。

    第二种有效的方法是,取一个样本,并使用层次聚类技术对它聚类。从层次聚类中提取K个簇,并用这些簇的质心作为初始质心。该方法通常很有效,但仅对下列情况有效:

    (1)样本相对较小,例如数百到数千(层次聚类开销较大);

    (2)K相对于样本大小较小

    第三种选择初始质心的方法,随机地选择第一个点,或取所有点的质心作为第一个点。然后,对于每个后继初始质心,选择离已经选取过的初始质心最远的点。使用这种方法,确保了选择的初始质心不仅是随机的,而且是散开的。但是,这种方法可能选中离群点。此外,求离当前初始质心集最远的点开销也非常大。为了克服这个问题,通常该方法用于点样本。由于离群点很少(多了就不是离群点了),它们多半不会在随机样本中出现。计算量也大幅减少。

    第四种方法是使用canopy算法进行初始划分。基于Canopy Method的聚类算法将聚类过程分为两个阶段:

    Stage1:聚类最耗费计算的地方是计算对象相似性的时候,Canopy Method在第一阶段选择简单、计算代价较低的方法计算对象相似性,将相似的对象放在一个子集中,这个子集被叫做Canopy ,通过一系列计算得到若干Canopy,Canopy之间可以是重叠的,但不会存在某个对象不属于任何Canopy的情况,可以把这一阶段看做数据预处理。

    Stage2:在各个Canopy 内使用传统的聚类方法(如K-means),不属于同一Canopy 的对象之间不进行相似性计算。从这个方法起码可以看出两点好处:首先,Canopy 不要太大且Canopy 之间重叠的不要太多的话会大大减少后续需要计算相似性的对象的个数;其次,类似于K-means这样的聚类方法是需要人为指出K的值的,通过Stage1得到的Canopy 个数完全可以作为这个K值,一定程度上减少了选择K的盲目性。

    算法实验

    任务

    在给定的Iris.txt样本文件中,用K-means聚类算法将150个4维样本数据分成3类

    数据集(Iris.txt)

    5.1 3.5 1.4 0.2

    4.9 3.0 1.4 0.2

    4.7 3.2 1.3 0.2

    4.6 3.1 1.5 0.2

    5.0 3.6 1.4 0.2

    5.4 3.9 1.7 0.4

    4.6 3.4 1.4 0.3

    5.0 3.4 1.5 0.2

    4.4 2.9 1.4 0.2

    4.9 3.1 1.5 0.1

    5.4 3.7 1.5 0.2

    4.8 3.4 1.6 0.2

    4.8 3.0 1.4 0.1

    4.3 3.0 1.1 0.1

    5.8 4.0 1.2 0.2

    5.7 4.4 1.5 0.4

    5.4 3.9 1.3 0.4

    5.1 3.5 1.4 0.3

    5.7 3.8 1.7 0.3

    5.1 3.8 1.5 0.3

    5.4 3.4 1.7 0.2

    5.1 3.7 1.5 0.4

    4.6 3.6 1.0 0.2

    5.1 3.3 1.7 0.5

    4.8 3.4 1.9 0.2

    5.0 3.0 1.6 0.2

    5.0 3.4 1.6 0.4

    5.2 3.5 1.5 0.2

    5.2 3.4 1.4 0.2

    4.7 3.2 1.6 0.2

    4.8 3.1 1.6 0.2

    5.4 3.4 1.5 0.4

    5.2 4.1 1.5 0.1

    5.5 4.2 1.4 0.2

    4.9 3.1 1.5 0.2

    5.0 3.2 1.2 0.2

    5.5 3.5 1.3 0.2

    4.9 3.6 1.4 0.1

    4.4 3.0 1.3 0.2

    5.1 3.4 1.5 0.2

    5.0 3.5 1.3 0.3

    4.5 2.3 1.3 0.3

    4.4 3.2 1.3 0.2

    5.0 3.5 1.6 0.6

    5.1 3.8 1.9 0.4

    4.8 3.0 1.4 0.3

    5.1 3.8 1.6 0.2

    4.6 3.2 1.4 0.2

    5.3 3.7 1.5 0.2

    5.0 3.3 1.4 0.2

    7.0 3.2 4.7 1.4

    6.4 3.2 4.5 1.5

    6.9 3.1 4.9 1.5

    5.5 2.3 4.0 1.3

    6.5 2.8 4.6 1.5

    5.7 2.8 4.5 1.3

    6.3 3.3 4.7 1.6

    4.9 2.4 3.3 1.0

    6.6 2.9 4.6 1.3

    5.2 2.7 3.9 1.4

    5.0 2.0 3.5 1.0

    5.9 3.0 4.2 1.5

    6.0 2.2 4.0 1.0

    6.1 2.9 4.7 1.4

    5.6 2.9 3.9 1.3

    6.7 3.1 4.4 1.4

    5.6 3.0 4.5 1.5

    5.8 2.7 4.1 1.0

    6.2 2.2 4.5 1.5

    5.6 2.5 3.9 1.1

    5.9 3.2 4.8 1.8

    6.1 2.8 4.0 1.3

    6.3 2.5 4.9 1.5

    6.1 2.8 4.7 1.2

    6.4 2.9 4.3 1.3

    6.6 3.0 4.4 1.4

    6.8 2.8 4.8 1.4

    6.7 3.0 5.0 1.7

    6.0 2.9 4.5 1.5

    5.7 2.6 3.5 1.0

    5.5 2.4 3.8 1.1

    5.5 2.4 3.7 1.0

    5.8 2.7 3.9 1.2

    6.0 2.7 5.1 1.6

    5.4 3.0 4.5 1.5

    6.0 3.4 4.5 1.6

    6.7 3.1 4.7 1.5

    6.3 2.3 4.4 1.3

    5.6 3.0 4.1 1.3

    5.5 2.5 5.0 1.3

    5.5 2.6 4.4 1.2

    6.1 3.0 4.6 1.4

    5.8 2.6 4.0 1.2

    5.0 2.3 3.3 1.0

    5.6 2.7 4.2 1.3

    5.7 3.0 4.2 1.2

    5.7 2.9 4.2 1.3

    6.2 2.9 4.3 1.3

    5.1 2.5 3.0 1.1

    5.7 2.8 4.1 1.3

    6.3 3.3 6.0 2.5

    5.8 2.7 5.1 1.9

    7.1 3.0 5.9 2.1

    6.3 2.9 5.6 1.8

    6.5 3.0 5.8 2.2

    7.6 3.0 6.6 2.1

    4.9 2.5 4.5 1.7

    7.3 2.9 6.3 1.8

    6.7 2.5 5.8 1.8

    7.2 3.6 6.1 2.5

    6.5 3.2 5.1 2.0

    6.4 2.7 5.3 1.9

    6.8 3.0 5.5 2.1

    5.7 2.5 5.0 2.0

    5.8 2.8 5.1 2.4

    6.4 3.2 5.3 2.3

    6.5 3.0 5.5 1.8

    7.7 3.8 6.7 2.2

    7.7 2.6 6.9 2.3

    6.0 2.2 5.0 1.5

    6.9 3.2 5.7 2.3

    5.6 2.8 4.9 2.0

    7.7 2.8 6.7 2.0

    6.3 2.7 4.9 1.8

    6.7 3.3 5.7 2.1

    7.2 3.2 6.0 1.8

    6.2 2.8 4.8 1.8

    6.1 3.0 4.9 1.8

    6.4 2.8 5.6 2.1

    7.2 3.0 5.8 1.6

    7.4 2.8 6.1 1.9

    7.9 3.8 6.4 2.0

    6.4 2.8 5.6 2.2

    6.3 2.8 5.1 1.5

    6.1 2.6 5.6 1.4

    7.7 3.0 6.1 2.3

    6.3 3.4 5.6 2.4

    6.4 3.1 5.5 1.8

    6.0 3.0 4.8 1.8

    6.9 3.1 5.4 2.1

    6.7 3.1 5.6 2.4

    6.9 3.1 5.1 2.3

    5.8 2.7 5.1 1.9

    6.8 3.2 5.9 2.3

    6.7 3.3 5.7 2.5

    6.7 3.0 5.2 2.3

    6.3 2.5 5.0 1.9

    6.5 3.0 5.2 2.0

    6.2 3.4 5.4 2.3

    5.9 3.0 5.1 1.8

    Python实现

    算法流程

    第一步,将文件中的数据读入到dataset列表中,通过len(dataset[0])来获取数据维数,在测试样例中是四维

    第二步,产生聚类的初始位置。首先扫描数据,获取每一维数据分量中的最大值和最小值,然后在这个区间上随机产生一个值,循环k次(k为所分的类别),这样就产生了聚类初始中心(k个)

    第三步,按照最短距离(欧式距离)原则将所有样本分配到k个聚类中心中的某一个,这步操作的结果是产生列表assigments,可以通过Python中的zip函数整合成字典。注意到原始聚类中心可能不在样本中,因此可能出现分配的结果出现某一个聚类中心点集合为空,此时需要结束,提示“随机数产生错误,需要重新运行”,以产生合适的初始中心。

    第四步,计算各个聚类中心的新向量,更新距离,即每一类中每一维均值向量。然后再进行分配,比较前后两个聚类中心向量是否相等,若不相等则进行循环,否则终止循环,进入下一步。

    最后,将结果输出到文件和屏幕中

    代码如下

    # coding=gbk

    #python edition: Python3.4.1,2014,9,24

    from collections import defaultdict

    from random import uniform

    from math import sqrt

    def read_points():

    dataset=[]

    with open('Iris.txt','r') as file:

    for line in file:

    if line =='\n':

    continue

    dataset.append(list(map(float,line.split(' '))))

    file.close()

    return dataset

    def write_results(listResult,dataset,k):

    with open('result.txt','a') as file:

    for kind in range(k):

    file.write( "CLASSINFO:%d\n"%(kind+1) )

    for j in listResult[kind]:

    file.write('%d\n'%j)

    file.write('\n')

    file.write('\n\n')

    file.close()

    def point_avg(points):

    dimensions=len(points[0])

    new_center=[]

    for dimension in range(dimensions):

    sum=0

    for p in points:

    sum+=p[dimension]

    new_center.append(float("%.8f"%(sum/float(len(points)))))

    return new_center

    def update_centers(data_set ,assignments,k):

    new_means = defaultdict(list)

    centers = []

    for assignment ,point in zip(assignments , data_set):

    new_means[assignment].append(point)

    for i in range(k):

    points=new_means[i]

    centers.append(point_avg(points))

    return centers

    def assign_points(data_points,centers):

    assignments=[]

    for point in data_points:

    shortest=float('inf')

    shortest_index = 0

    for i in range(len(centers)):

    value=distance(point,centers[i])

    if value

    shortest=value

    shortest_index=i

    assignments.append(shortest_index)

    if len(set(assignments))

    print("\n--!!!产生随机数错误,请重新运行程序!!!!--\n")

    exit()

    return assignments

    def distance(a,b):

    dimention=len(a)

    sum=0

    for i in range(dimention):

    sq=(a[i]-b[i])**2

    sum+=sq

    return sqrt(sum)

    def generate_k(data_set,k):

    centers=[]

    dimentions=len(data_set[0])

    min_max=defaultdict(int)

    for point in data_set:

    for i in range(dimentions):

    value=point[i]

    min_key='min_%d'%i

    max_key='max_%d'%i

    if min_key not in min_max or value

    min_max[min_key]=value

    if max_key not in min_max or value>min_max[max_key]:

    min_max[max_key]=value

    for j in range(k):

    rand_point=[]

    for i in range(dimentions):

    min_val=min_max['min_%d'%i]

    max_val=min_max['max_%d'%i]

    tmp=float("%.8f"%(uniform(min_val,max_val)))

    rand_point.append(tmp)

    centers.append(rand_point)

    return centers

    def k_means(dataset,k):

    k_points=generate_k(dataset,k)

    assignments=assign_points(dataset,k_points)

    old_assignments=None

    while assignments !=old_assignments:

    new_centers=update_centers(dataset,assignments,k)

    old_assignments=assignments

    assignments=assign_points(dataset,new_centers)

    result=list(zip(assignments,dataset))

    print('\n\n---------------------------------分类结果---------------------------------------\n\n')

    for out in result :

    print(out,end='\n')

    print('\n\n---------------------------------标号简记---------------------------------------\n\n')

    listResult=[[] for i in range(k)]

    count=0

    for i in assignments:

    listResult[i].append(count)

    count=count+1

    write_results(listResult,dataset,k)

    for kind in range(k):

    print("第%d类数据有:"%(kind+1))

    count=0

    for j in listResult[kind]:

    print(j,end=' ')

    count=count+1

    if count%25==0:

    print('\n')

    print('\n')

    print('\n\n--------------------------------------------------------------------------------\n\n')

    def main():

    dataset=read_points()

    k_means(dataset,3)

    if __name__ == "__main__":

    main()

    分类结果

    a. 通过多次运行程序发现,所得结果与初始值的选定有着密切的关系,并且由于在我的程序中采用随机数的方式产生初值,因此经过观察发现有多种结果。

    b. 其中两种常见的结果之一如下:

    第1类数据有:(50)

    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

    第2类数据有:(38)

    52 77 100 102 103 104 105 107 108 109 110 111 112 115 116 117 118 120 122 124 125 128 129 130 131 132 134 135 136 137 139 140 141 143 144 145 147 148

    第3类数据有:(62)

    50 51 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

    76 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 101 106

    113 114 119 121 123 126 127 133 138 142 146 149

    c. 结果之二:

    第1类数据有:(50)

    0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

    25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

    第2类数据有:(61)

    51 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

    78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 101 106 113

    114 119 121 123 126 127 133 138 142 146 149

    第3类数据有:(39)

    50 52 77 100 102 103 104 105 107 108 109 110 111 112 115 116 117 118 120 122 124 125 128 129 130 131 132 134 135 136 137 139 140 141 143 144 145 147 148

    以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

    展开全文
  • Kmeans聚类算法详解

    万次阅读 多人点赞 2018-05-16 18:41:40
    摘要:本文通过图文详细介绍Kmeans聚类算法的原理和程序实现,以及如何选取类簇中心点。本文首先介绍利用该算法的原理及理解,详细介绍基于MATLAB设计一个自定义的Kmeans函数过程,然后利用该函数对UCI的数据集进行...

    摘要:本文详细介绍Kmeans聚类算法的原理和程序实现。首先介绍利用该算法的原理及理解,详细介绍基于MATLAB设计一个自定义的Kmeans函数过程,然后利用该函数对UCI的数据集进行聚类以测试聚类结果。后续章节将介绍的主要部分有:

    • Kmeans算法的原理及理解
    • 编程实现
    • 聚类结果评价
    • 类簇中心点的选取

    点击下载:本文Kmeans算法M函数及测试完整文件


    1. 前言

    作为无监督聚类算法中的代表——K均值聚类(Kmeans)算法,该算法的主要作用是将相似的样本自动归到一个类别中。所谓的监督算法,就是输入样本没有对应的输出或标签。聚类(clustering)试图将数据集中的样本划分为若干个通常是不相交的子集,每个子集称为一个“簇(cluster)”,聚类既能作为一个单独过程,用于找寻数据内在的分布结构,也可作为分类等其他学习任务的前去过程。——《Machine Learning》

    聚类算法也许是机器学习中“新算法”出现最多、最快的领域,一个重要的原因是聚类不存在客观标准,给定数据集总能从某个角度找到以往算法未覆盖的某种标准从而设计出新算法。Kmeans算法十分简单易懂而且非常有效,但是合理的确定K值和K个初始类簇中心点对于聚类效果的好坏有很大的影响。众多的论文基于此都提出了各自行之有效的解决方案,新的改进算法仍然不断被提出,此类文章大家可以在Web Of Science中搜索。

    尽管Kmeans算法在MATLAB、Python等语言的工具箱函数中都有自带的函数可供调用,但作为机器学习的研究者新来说要设计出新的算法,有时就得“定制”自己的Kmeans函数了。自己动手编写无疑也更加能理解算法的具体过程,接下来就让我们进入正题吧


    2. Kmeans算法的原理与理解

    Kmeans算法是最常用的聚类算法,主要思想是:在给定K值和K个初始类簇中心点的情况下,把每个点(亦即数据记录)分到离其最近的类簇中心点所代表的类簇中,所有点分配完毕之后,根据一个类簇内的所有点重新计算该类簇的中心点(取平均值),然后再迭代的进行分配点和更新类簇中心点的步骤,直至类簇中心点的变化很小,或者达到指定的迭代次数。

    2.1 基本原理

    假定给定数据样本X,包含了n个对象X={X1,X2,X3,...,Xn}X=\left \{ X_{1} ,X_{2},X_{3},...,X_{n}\right \},其中每个对象都具有m个维度的属性。Kmeans算法的目标是将n个对象依据对象间的相似性聚集到指定的k个类簇中,每个对象属于且仅属于一个其到类簇中心距离最小的类簇中。对于Kmeans,首先需要初始化k个聚类中心{C1,C2,C3,...,Ck},1<kn\left \{ C_{1} ,C_{2},C_{3},...,C_{k}\right \},1<k\leq n,然后通过计算每一个对象到每一个聚类中心的欧式距离,如下式所示dis(Xi,Cj)=t=1m(XitCjt)2dis(X_{i},C_{j})=\sqrt{\sum_{t=1}^{m}(X_{it}-C_{jt})^{2}}
    上式中,XiX_{i}表示第i个对象1in1\leq i\leq n,CjC_{j}表示第j个聚类中心的1jk1\leq j\leq kXitX_{it}表示第i个对象的第t个属性,1tm1\leq t\leq mCjtC_{jt}表示第j个聚类中心的第t个属性。

    依次比较每一个对象到每一个聚类中心的距离,将对象分配到距离最近的聚类中心的类簇中,得到k个类簇{S1,S2,S3,...,Sk}\left \{ S_{1},S_{2},S_{3},...,S_{k} \right \}

    Kmeans算法用中心定义了类簇的原型,类簇中心就是类簇内所有对象在各个维度的均值,其计算公式如下Ct=XiSlXiSlC_{t}=\frac{\sum_{X_{i}\in S_{l}}X_{i}}{\left | S_{l} \right |}
    式中,ClC_{l}表示第l个聚类的中心,1lk1\leq l\leq kSl\left | S_{l} \right |表示第l个类簇中对象的个数,XiX_{i}表示第l个类簇中第i个对象,1iSl1\leq i\leq\left | S_{l} \right |

    2.2 算法流程

    输入:样本集D={x1,x2,x3,...,xm}D=\left \{ x_{1},x_{2},x_{3},...,x_{m} \right \};聚类簇数k.
    过程:
    1:从D中随机选择k个样本作为初始均值向量{μ1,μ2,μ3,...,μk}\left \{ \mu _{1},\mu _{2},\mu _{3},...,\mu _{k} \right \}

    2:repeat
    3: 令Ci=(1ik)C_{i}=\varnothing (1\leqslant i\leqslant k)
    4: for j=1,2,…,m do
    5: 计算样本xjx_{j}与各均值向量μi(1ik)\mu_{i}(1\leqslant i\leqslant k)的距离:dji=xjμi2d_{ji}=\left \| x_{j}-\mu_{i} \right \|_{2};
    6: 根据距离最近的均值向量确定xjx_{j}的簇标记:λj=argmini{1,2,3,...,k}dji\lambda _{j}=arg min_{i\in \left \{ 1,2,3,...,k \right \}}d_{ji}
    7: 将样本xjx_{j}划入相应的簇:Cλj=Cλj{xj}C_{\lambda_{j}}=C_{\lambda_{j}}\cup \left \{ x_{j} \right \};
    8: end for

    9: for i=1,2,…,k do
    10: 计算新均值向量:μi=1CixCix\mu_{i}^{'}=\frac{1}{\left | C_{i} \right |}\sum _{x\in C_{i}}x;
    11: if μiμi\mu_{i}^{'}\neq \mu_{i} then
    12: 将当前均值向量 μi\mu_{i}更新为μi\mu_{i}^{'}
    13: else
    14: 保持当前均值不变
    15: end if

    16: end for
    17:until 当前均值向量均未更新
    输出:簇划分C={C1,C2,...,Ck}C=\left \{ C_{1} ,C_{2},...,C_{k} \right \}

    以上算法流程引自周志华《机器学习》,从流程来看K-means算法计算步骤基本上可以概括为两个部分:(1)计算每一个对象到类簇中心的距离;(2)根据类簇内的对象计算新的簇类中心。


    3. 编程实现

    为了方便应用我们将其编写为一个M函数KMeans(),首先需要确定函数的输入输出。这里输入参数为:data,K,iniCentriods,iterations(其中data为输入的不带标号的数据集数据矩阵,大小为numOfDatanumOfAttributes,K为数据分的类簇数目,iniCentriods为自行指定的初始聚类中心矩阵,大小为KnumOfAttributes,iterations为算法迭代次数。)
    输出参数为:Idx,centroids,DistanceIdx为返回的分类标号, centroids为每一类的中心,Distance为类内总距离)

    根据前面2.2节中的算法流程编写Kmeans算法的MATLAB程序如下

    %% Kmeans算法
    % 输入:
    % data 输入的不带分类标号的数据
    % K 数据一共分多少类
    % iniCentriods 自行指定初始聚类中心
    % iterations 迭代次数
    
    % 输出:
    % Idx 返回的分类标号
    % centroids 每一类的中心
    % Distance 类内总距离
    
     
    function [Idx,centroids,Distance]=KMeans(data,K,iniCentriods,iterations)
    [numOfData,numOfAttr]=size(data); % numOfData是数据个数,numOfAttr是数据维数
    centroids=iniCentriods;
    %% 迭代
    for iter=1:iterations
        pre_centroids=centroids;% 上一次求得的中心位置
        
        tags=zeros(numOfData,K);
        %% 寻找最近中心,更新中心
        for i=1:numOfData
            D=zeros(1,K);% 每个数据点与每个聚类中心的标准差
            Dist=D;
            
            % 计算每个点到每个中心点的标准差
            for j=1:K
                Dist(j)=norm(data(i,:)-centroids(j,:),2);
            end
            
            [minDistance,index]=min(Dist);% 寻找距离最小的类别索引
            tags(i,index)=1;% 标记最小距离所处的位置(类别)
        end
        
        
        %% 取均值更新聚类中心点
        for i=1:K
            if sum(tags(:,i))~=0
                % 未出现空类,计算均值作为下一聚类中心
                for j=1:numOfAttr
                    centroids(i,j)=sum(tags(:,i).*data(:,j))/sum(tags(:,i));
                end
            else % 如果出现空类,从数据集中随机选中一个点作为中心
                randidx = randperm(size(data, 1));
                centroids(i,:) = data(randidx(1),:);
                tags(randidx,:)=0;
                tags(randidx,i)=1;
            end
        end
        
       
        if sum(norm(pre_centroids-centroids,2))<0.001  % 不断迭代直到位置不再变化
            break;
        end
        
        
    end
    
    %% 计算输出结果
    Distance=zeros(numOfData,1);
    Idx=zeros(numOfData,1);
    for i=1:numOfData
        D=zeros(1,K);% 每个数据点与每个聚类中心的标准差
        Dist=D;
        % 计算每个点到每个中心点的标准差
        for j=1:K
            Dist(j)=norm(data(i,:)-centroids(j,:),2);
        end
        
        [distance,idx]=min(Dist);% 寻找距离最小的类别索引
        distance=Dist(idx);
        
        Distance(i)=distance;
        Idx(i)=idx;
    end
    Distance=sum(Distance,1);% 计算类内总距离
    end
    

    在以上代码中其最主要部分在于第18至58行,进行寻找最近中心和求取均值更新聚类中心点。值得注意的是,在聚类过程中可能会出现空类即代码第44行那样,为保证算法的继续运行,从数据集中随机选取一个点作为中心。

    4. 聚类结果评价

    为了验证编写的Kmeans函数的性能,这里对想用的UCI数据集Iris数据集进行聚类并计算聚类的准确率,Iris数据集可以在http://archive.ics.uci.edu/ml/index.php上下载得到。首先读取Iris数据集,自行指定初始聚类中心调用前面编写的KMeans函数进行聚类,然后计算聚类的准确率,其代码如下

    clear 
    data=load('Iris.txt');
    data=data(:,2:end);
    
    matrix=[5.9016,2.7484,4.3935,1.4339;6.8500,3.0737,5.7421,2.0711;5.0060,3.4280,1.4620,0.2460];
    [Idx,C,distance]=KMeans(data,3,matrix,500);
    Distance=sum(distance)
    
    c1=Idx(1:50,1);c2=Idx(51:100,1);c3=Idx(101:150,1);
    accuracy=(sum(c1==mode(Idx(1:50,1)))+sum(c2==mode(Idx(51:100,1)))+sum(c3==mode(Idx(101:150,1))))/150
    

    为方便使用Iris数据集经过了一些整理,这里将最后一列的带字符串的标签Iris-setosa,Iris-versicolor,Iris-virginica分别用数字1,2,3代替并移到了第一列,所以第三行选取的是从第二列至最后一列的数据。第5行中的matrix是查阅论文得到的一个初始聚类中心,正好用来比对聚类结果。第6行则调用KMeans()函数进行聚类,得到聚类标号和类内距离。对每类的类内距离求和即得到总的距离Distance,如第7行。准确率的计算有点麻烦,因为不能直接用KMeans计算后得到的标号跟原数据集中的标号对比计算准确率,KMeans只需要也只能将那些“相似”的数据点聚集到一类中,而给这一类数据的标号却是可能跟原数据集不同的。

    这里采用一个简单的方法,从原数据集的标签可以看出第1-50个数据点为一类(Iris-setosa),第51-100为一类(Iris-versicolor),第101-150为一类(Iris-virginica),因此只需确定每50个数据点中的聚类标号是不是一致。取它们之中数目最多的标号作为正确的个数,最终比上数据集的总数即为准确率。以上代码运行结果如下所示。

    5. 类簇中心点的选取

    KMeans算法本身思想比较简单,但是合理的确定K值和K个初始类簇中心点对于聚类效果的好坏有很大的影响。最简单的确定初始类簇中心点的方法是随机产生数据大小范围内的K个点作为初始的簇类中心点。随机产生初始点并进行测试的程序代码如下

    clear
    data=load('Iris.txt');
    data=data(:,2:end);
    K=3;
    
    
    %% 产生随机初始点
    [numOfData,numOfAttr]=size(data);   % numOfData是数据个数,numOfAttr是数据维数
    
    centroids=zeros(K,numOfAttr);       % 随机初始化,最终迭代到每一类的中心位置
    maxAttr=zeros(numOfAttr);        % 每一维最大的数
    minAttr=zeros(numOfAttr);        % 每一维最小的数
    for i=1:numOfAttr
        maxAttr(i)=max(data(:,i));    % 每一维最大的数
        minAttr(i)=min(data(:,i));    % 每一维最小的数
        for j=1:K
            centroids(j,i)=maxAttr(i)+(minAttr(i)-maxAttr(i))*rand();  % 随机初始化,选取每一维[min max]中初始化
        end
    end
    
    [Idx,C,distance]=KMeans(data,K,centroids,500);% 调用KMeans
    Distance=sum(distance)% 计算类内距离之和
    
    %% 计算准确率
    c1=Idx(1:50,1);c2=Idx(51:100,1);c3=Idx(101:150,1);
    Accuracy=(sum(c1==mode(Idx(1:50,1)))+sum(c2==mode(Idx(51:100,1)))+sum(c3==mode(Idx(101:150,1))))/numOfData
    

    可以多运行几次以上代码,可以看出由于初始点事随机选取的每次运行得到的结果有所差异。这也是基本Kmeans算法的一个缺点,随着众多改进算法的提出Kmeans算法的这一问题也得到改善,深入了解的朋友可以查阅相关论文。

    6. 结束语

    本博文的完整MATLAB程序文件与整理好的数据集文件已经上传,下载即可运行。下载地址如下

    点击下载:本文Kmeans算法M函数及测试完整文件

    公众号获取
        本人微信公众号已创建,扫描以下二维码并关注公众号“AI技术研究与分享”,后台回复“KM20180516”即可获取全部资源文件信息。

    由于编者能力有限,代码即使经过了多次校对,也难免会有疏漏之处。希望您能热心指出其中的错误,以便下次修改时能以一个更完美更严谨的样子,呈现在大家面前。同时如果有更好的实现方法也请您不吝赐教。

    展开全文
  • Python biKmeans 二分聚类算法
  • 1、基本概念;聚类分析简称聚类(clustering),是一个把数据集划分成子集的过程,每一个子集是一个簇(cluster),使得簇中的样本彼此相似,但与其他簇中的...在工作中遇到用户画像、群组划分问题,而kmeans聚类这一...

    1、基本概念;

    聚类分析简称聚类(clustering),是一个把数据集划分成子集的过程,每一个子集是一个簇(cluster),使得簇中的样本彼此相似,但与其他簇中的样本不相似。

    聚类分析不需要事先知道样本的类别,甚至不用知道类别个数,因此它是一种典型的无监督学习算法,一般用于数据探索,比如群组发现和离群点检测,还可以作为其他算法的预处理步骤。

    在工作中遇到用户画像、群组划分问题,而kmeans聚类这一无监督学习算法,可以在无数据标注训练情况下,基于距离按将群组划分不同的簇。

    主要的聚类算法一般可以划分为以下几类:

    方法

    一般特点

    划分方法

    1.发现球形互斥的簇 2.基于距离 3.可用均值或中心点代表簇中心 4.对中小规模数据有效

    层次方法

    1.聚类是一个层次分解 2.不能纠正错误的合并或划分 3.可以集成其他技术

    基于密度的方法

    1.可以发现任意形状的簇 2.簇是对象空间中被低密度区域分隔的稠密区域 3.簇密度 4.可能过滤离群点

    基于网格的方法

    1.使用一种多分辨率网格数据结构 2.快速处理

    2、Kmeans算法

    Kmeans属于划分方法的经典聚类方法。

    算法步骤如下:

    选择K个点作为初始质心(随机产生或者从D中选取)

    repeat

    将每个点分配到最近的质心,形成K个簇

    重新计算每个簇的质心

    until 簇不发生变化或达到最大迭代次数

    2.1 k值选取

    k的值是用户指定的,表示需要得到的簇的数目。在运用Kmeans算法时,我们一般不知道数据的分布情况,不可能知道数据的集群数目,所以一般通过枚举来确定k的值。另外,在实际应用中,由于Kmean一般作为数据预处理,或者用于辅助分类贴标签,所以k一般不会设置很大。

    2.2 初始质心的选取

    Kmeans算法对初始质心的选取比较敏感,选取不同的质心,往往会得到不同的结果。初始质心的选取方法,常用以下两种的简单方法:一种是随机选取,一种是用户指定。

    需要注意的是,无论是随机选取还是用户指定,质心都尽量不要超过原始数据的边界,即质心每一维度上的值要落在原始数据集每一维度的最小与最大值之间。

    2.3 距离度量方法

    距离度量方法(或者说相似性度量方法)有很多种,常用的有欧氏距离,余弦相似度,街区距离,汉明距离等等。在Kmeans算法中,一般采用欧氏距离计算两个点的距离,欧氏距离如下:

    distEclud(X,Y)=∑i=1n(Xi−Yi)2‾‾‾‾‾‾‾‾‾‾‾‾⎷

    举个例子,X=(1000,0.1),Y=(900,0.2),那么它们的欧氏距离就是:

    (1000−900)2+(0.1−0.2)2‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾√≈100(1000−900)2+(0.1−0.2)2≈100

    举这个例子是为了说明,当原始数据中各个维度的数量级不同时,它们对结果的影响也随之不同,那些数量级太小的维度,对于结果几乎没产生任何影响。比如所举的例子中的第二个维度的0.1,0.2,与第一个维度1000的数量级相差了一万倍。

    为了赋予数据每个维度同等的重要性,我们在运用欧氏距离时,必须先对数据进行规范化,比如将每个维度都缩放到[0,1]之间。

    2.4 质心的计算

    在Kmeans算法中,将簇中所有样本的均值作为该簇的质心。这也是Kmeans名字的由来吧。

    2.5 算法停止条件

    在两种情况下算法应该停止:一种是达到了指定的最大迭代次数,一种是算法已经收敛,即各个簇的质心不再发生变化。关于算法的收敛,在2.5部分讨论。

    2.6 代价函数与算法收敛

    Kmeans算法的代价函数比较简单,就是每个样本点与其所属质心的距离的平方和(误差平方和,Sum of Squared Error,简称SSE):

    J(c,u)=∑i=1k||X(i)−uc(i)||2

    与其他机器学习算法一样,我们要最小化这个代价函数,但这个函数没有解析解,所以只能通过迭代求解的方法来逼近最优解(这一点也和众多机器学习算法一样吧)。所以你再看看算法步骤,其实就是一个迭代过程。

    由于代价函数(SSE)是非凸函数,所以在运用Kmeans算法时,不能保证收敛到一个全局的最优解,我们得到的一般是一个局部的最优解。

    因此,为了取得比较好的效果,一般会多跑几次算法(用不同的初始质心),得到多个局部最优解,比较它们的SSE,选取SSE最小的那个。

    方法优点:

    k-平均算法是解决聚类问题的一种经典算法,算法简单、快速。

    对处理大数据集,该算法是相对可伸缩的和高效率的,因为它的复杂度大约是O(nkt),其中n是所有对象的数目,k是簇的数目,t是迭代的次数。通常k<

    算法尝试找出使平方误差函数值最小的k个划分。当簇是密集的、球状或团状的,而簇与簇之间区别明显时,它的聚类效果很好。

    缺点:

    K 是事先给定的,这个 K 值的选定是非常难以估计的;

    对初值敏感,对于不同的初始值,可能会导致不同的聚类结果。一旦初始值选择的不好,可能无法得到有效的聚类结果;

    该算法需要不断地进行样本分类调整,不断地计算调整后的新的聚类中心,因此当数据量非常大时,算法的时间开销是非常大的。

    不适合于发现非凸面形状的簇,或者大小差别很大的簇;

    对于”噪声”和孤立点数据敏感,少量的该类数据能够对平均值产生极大影响。

    3、Kmeans算法实现

    采用python实现,基于numpy、sklearn库,其中从sklearn.cluster中import KMeans。为了可视化聚类效果,对二维数据进行聚类并用matplot画出数据不同簇的划分。

    #!/usr/bin/env python2

    # -*- coding: utf-8 -*-

    """

    @author: liuweima

    """

    from sklearn.cluster import KMeans

    from sklearn.externals import joblib

    import numpy

    import time

    import matplotlib.pyplot as plt

    import sys

    reload(sys)

    sys.setdefaultencoding('utf8')

    if __name__ == '__main__':

    ## step 1: 加载数据

    print "step 1: load data..."

    dataSet = []

    loss = []

    fileIn = open('path')

    for line in fileIn.readlines():

    lineArr = line.strip('\xef\xbb\xbf') # '\xef\xbb\xbf'是BOM,标识读入的文件是UTF-8编码,需strip()切掉

    lineArr = lineArr.strip().split('\t') #注意自己文件中每行数据中是用什么对列数据做分割 建议先用Word 规范一下要打开的文件

    dataSet.append([float(lineArr[0])/1.99759326,(float(lineArr[1])-100)/192230]) #数据规范化【0,1】

    print dataSet

    #设定不同k值以运算

    for k in range(2,10):

    clf = KMeans(n_clusters=k) #设定k !!!!!!!!!!这里就是调用KMeans算法

    s = clf.fit(dataSet) #加载数据集合

    numSamples = len(dataSet)

    centroids = clf.labels_

    print centroids,type(centroids) #显示中心点

    print clf.inertia_ #显示聚类效果

    mark1 = ['or', 'ob', 'og', 'ok', '^r', '+r', 'sr', 'dr', '

    #画出所有样例点 属于同一分类的绘制同样的颜色

    for i in xrange(numSamples):

    #markIndex = int(clusterAssment[i, 0])

    plt.plot(dataSet[i][0], dataSet[i][1], mark1[clf.labels_[i]]) #mark[markIndex])

    mark2 = ['Dr', 'Db', 'Dg', 'Dk', '^b', '+b', 'sb', 'db', '

    # 画出质点,用特殊图型

    centroids = clf.cluster_centers_

    for i in range(k):

    plt.plot(centroids[i][0], centroids[i][1], mark2[i], markersize = 12)

    #print centroids[i, 0], centroids[i, 1]

    plt.show()

    loss.append(clf.inertia_)

    for m in range(8): #因为k 取值是2-9 (!不包括10) m取值是0-7

    plt.plot(m,loss[m],'bo')

    plt.show()

    质心的初始化、最大迭代次数都为默认值。

    其中读取文件一些坑已经做了备注。整个kmeans算法不是很耗时,主要在画图上花费时间。以我跑十万级别的数据来看,画图很费时间。

    聚类结果图 ,涉及业务,就不贴出了。

    贴出,k取range(2,30)时,kmeans的误差平方和(SSE)曲线图。

    为了弥补经典kmeans聚类算法的不足,出现了一些改进型kmeans

    比如二分Kmeans算法(bisectingKmeans)是为了克服Kmeans算法收敛于局部最小值的问题而提出的。

    该算法首先将所有点作为一个簇,然后将该簇一分为二。之后选择其中一个簇继续划分,选择哪一个簇进行划分

    取决于对其划分是否可以最大程度降低SSE的值,上述过程不断迭代,直到得到用户指定的簇数目为止。

    或者先使用MeanShift算法自动生成k值删除游离点。

    展开全文
  • 1、kmeanskmeans, k-均值聚类算法,能够实现发现数据集的 k 个簇的算法,每个簇通过其质心来描述。kmeans步骤:(1)随机找 k 个点作为质心(种子);(2)计算其他点到这 k 个种子的距离,选择最近的那个作为该点的类别;...

    1、kmeans

    kmeans, k-均值聚类算法,能够实现发现数据集的 k 个簇的算法,每个簇通过其质心来描述。

    kmeans步骤:

    (1)随机找 k 个点作为质心(种子);

    (2)计算其他点到这 k 个种子的距离,选择最近的那个作为该点的类别;

    (3)更新各类的质心,迭代到质心的不变为止。

    Q:如何选择 k 值?

    A: 根据 k 取不同的值时,模型性能曲线图。

    横坐标是聚类数目k,纵坐标是各点到距离中心的距离和。在拐点处的K(距离和下降速率变慢)作为选择的值。

    d1d57967-0a13-4618-8c2b-c7fbb6eda3b8.png?UCloudPublicKey=TOKEN_8d8b72be-579a-4e83-bfd0-5f6ce1546f13&Signature=y2mX9XUmIwMeGy1lS%252B00wOhfNS8%253D&Expires=1602251436

    2、kmeans++

    因为,kmeans的初始种子的随机找的,这样,算法的收敛快慢与初始值关系非常大,于是,kmeans++ 主要针对初始值的选取进行改进。

    初始值选取,如下:

    1、也是随机选取一个种子;

    2、计算其他点到这个种子的距离;

    3、选择这些较大的距离的那个点,替代随机选取的那个种子,作为新的种子点(这里的较大的距离,可以理解为maxDistance*随机数,随机数可以选取0.5-1;);

    4、迭代1-3步,直到选取k个种子为止。

    3. 评估聚类效果

    轮廓系数法SC

    轮廓系数(Silhouette Coefficient))结合了聚类的凝聚度(Cohesion)和分离度(Separation),用于评估聚类的效果。该值处于-1~1之间,值越大,表示聚类效果越好。

    计算步骤:

    (1)选择一个点 6556c3789b8a035795f4b0e3e8b563b9.png,计算该点 到同一簇内所有其他元素距离的平均值,记为 e7dda1f4282e4346f4c887d4c4eda531.png, 量化簇内的凝聚度;

    (2)选择一个其他簇,计算该点到簇内的平均距离。选择该点与其他簇平均距离最小的值,记为 974e4e6df39d42f382622b0c61e7a274.png, 用于量化簇间的分离度。

    (3)对于样本点e969f509b1dc82203a5e7be3f553f1bb.png,轮廓系数为:

    equation?tex=s(i)%20=%20%5Cfrac%7B(b(i)%20-%20a(i))%20%7D%20%7Bmax%5C%7B%20a(i),%20b(i)%5C%7D%7D%0A

    a(i) :i向量到同一簇内其他点不相似程度的平均值

    b(i) :i向量到其他簇的平均不相似程度的最小值

    73eda4902bdc37a04d282f2d83ddbeb5.png

    当轮廓系数<0, 该点可能误分; 值 = 0, 该点在两簇边缘; 值=1, 离其他簇很远。

    计算所有点的轮廓系数,求平均值, 即为当前聚类的整体轮廓系数。

    因此,轮廓系数可以用来确定Kmean的K值,选取轮廓系数最大的K作为最终的类数目。

    (2)误差平方和

    equation?tex=SSE%20=%20%5Csum_i%5EK%20%5Csum_%7Bp%5Cin%20c_i%7D%20%7Cp%20-%20m_i%7C%5E2%0A

    4. 其他问题

    (1)kmeans一定会收敛吗

    kmeans的目标函数:

    b2aa5402ec607531a7932563b24146f0.png

    E步:评估隐变量,每类样本属于的类别

    1a83e1d56d47fa0b1537a926c6a8bc57.png

    M步:固定数据点的分配,更新参数

    cdc5bc4d4d6cd11f5f25b19ac6a4725b.png

    由于EM算法具有收敛性,kmeans也会最终收敛。

    (2) Kmeans 和KNN的区别

    KNN:

    分类算法;

    监督学习;

    数据集是带Label的数据;

    没有明显的训练过程,基于Memory-based learning;

    K值含义 - 对于一个样本X,要给它分类,首先从数据集中,在X附近找离它最近的K个数据点,将它划分为归属于类别最多的一类

    K-means:

    聚类算法;

    非监督学习;

    数据集是无Label,杂乱无章的数据;

    有明显的训练过程;

    K值含义- K是事先设定的数字,将数据集分为K个簇,需要依靠人的先验知识

    不同点:

    两种算法之间的根本区别是,K-means本质上是无监督学习,而KNN是监督学习;K-means是聚类算法,KNN是分类(或回归)算法。

    K-means算法把一个数据集分割成簇,使得形成的簇是同构的,每个簇里的点相互靠近。该算法试图维持这些簇之间有足够的可分离性。由于无监督的性质,这些簇没有任何标签。KNN算法尝试基于其k(可以是任何数目)个周围邻居来对未标记的观察进行分类。它也被称为懒惰学习法,因为它涉及最小的模型训练。因此,它不用训练数据对未看见的数据集进行泛化。

    5. 实践

    Kmeans python 代码:

    import numpy as np

    class KMeans(object):

    def __init__(self, n_cluster, epochs=10):

    self.n_cluster = n_cluster

    self.epochs = epochs

    pass

    def init_centers(self, X):

    idx = np.random.randint(len(X), size=(self.n_cluster,))

    centers = X[idx,:]

    return centers

    def calculate_distance(self,arr1,arr2):

    # L2 distance.

    distance = np.mean(np.sqrt((arr1-arr2)**2))

    return distance

    def update_centers(self, X):

    predict_class = self.predict(X)

    # update centers

    centers = self.centers

    for ct in range(len(centers)):

    idx, = np.where(predict_class == ct)

    samples = X[idx, :]

    assert len(samples)>0

    centers[ct] = np.mean(samples,axis=0)

    self.centers = centers

    return self.centers

    def fit(self, X, y=None):

    self.centers = self.init_centers(X)

    for epoch in range(self.epochs):

    self.centers = self.update_centers(X)

    return self.centers

    def predict(self,X):

    predict_class = np.zeros(shape=(len(X),))

    centers = self.centers

    for n_sample,arr in enumerate(X):

    min_distance = float("inf")

    p_class = 0

    for ct in range(len(centers)):

    distance = self.calculate_distance(arr,centers[ct])

    if distance < min_distance:

    min_distance = distance

    p_class = ct

    predict_class[n_sample] = p_class

    return predict_class

    def score(self, X):

    pass复制代码

    示例:

    定义3个高斯分布。

    np.random.seed(1)

    data1 = np.random.normal(1, 0.5, size=(100, 2))

    np.random.seed(1)

    data2 = np.random.normal(4, 0.8, size=(100, 2))

    np.random.seed(1)

    data3 = np.random.normal(7, 0.8, size=(100, 2))

    X = np.concatenate((data1, data2, data3),axis=0)#np.random.randint(10,size=(100,2))

    print(X.shape)

    kmeans = KMeans(3)

    centers = kmeans.fit(X)

    print(centers)复制代码

    可视化聚类的结果:

    # Generate scatter plot for training data

    import matplotlib.pyplot as plt

    plt.scatter(X[:,0], X[:,1], marker="o", picker=True)

    plt.title('Clusters of data')

    plt.xlabel('x1')

    plt.ylabel('x2')

    plt.scatter(centers[:,0], centers[:,1], marker="v", picker=True)

    plt.show()复制代码

    6a56967a672fa754f869a4577799400d.png在这里插入图片描述

    参考:

    本文使用 mdnice 排版

    展开全文
  • k-means算法是一种聚类算法,所谓聚类,即根据相似性原则,将具有较高相似度的数据对象划分至同一类簇,将具有较高相异度的数据对象划分至不同类簇。聚类与分类最大的区别在于,聚类过程为无监督过程,即待处理数据...
  • distance self.iterations = iterators self.loss = None def fit(self, data): """ 进行k-means算法迭代,划分簇 :param Y: Y是对应X正确的种类 :param iterators: 算法迭代次数 :param data: 数据集(X, Y) X是测试...
  • return centroids #def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent): def kMeans(dataSet, k): m = shape(dataSet)[0] #等价于dataSet.shape[0] 第一维的长度,即行数 clusterAssment = mat...
  • 算法优缺点:优点:容易实现缺点:可能收敛到局部最小值,在大规模数据集上收敛较慢使用数据类型:数值型数据算法思想k-means算法实际上就是通过计算不同样本间的距离来判断他们的相近关系的,相近的就会放到同一个...
  • Python版本:Python3.6.2一、K-Means算法K-Means算法是聚类算法中最简单的,python中可以直接调用Kmeans()函数,其中参数n_clusters,指定要聚成几类。代码:# -*- coding: utf-8 -*-"""@Time : 2018/1/22 21:53@...
  • 这里,用一个《Programming Collective Intelligence》中的聚类例子,写几个经典聚类算法的实现,分别是hierachiclaCluster、kmeans、kmedoids。另外,最近一直在看数据挖掘、自然语言处理相关的东西,通过看资料...
  • Kmeans聚类算法 python sklearn 用户画像

    千次阅读 2017-08-17 20:54:12
    聚类分析不需要事先知道样本的类别,甚至不用知道类别个数,因此它是一种典型的无监督学习算法,一般用于数据探索,比如群组发现和离群点检测,还可以作为其他算法的预处理步骤。 在工作中遇到用户画像、群组划分...
  • 标签:在进去聚类情况分析前,我们需要为我们的IDLE安装sklearn库,scikit-learn是Python的一个开源机器学习模块,它建立在NumPy,SciPy和matplotlib模块之上能够为用户提供各种机器学习算法接口,可以让用户简单、...
  • 主要为大家详细介绍了Python实现Kmeans聚类算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Python实实现现Kmeans聚聚类类算算法法 这篇文章主要为大家详细介绍了Python实现Kmeans聚类算法文中示例代码介绍的非常详细具有一定的参考价 值感兴趣的小伙 们可以参考一下 本本节内内容容 本节内容是根据上学期所...
  • 主要介绍了Python实现的KMeans聚类算法,结合实例形式较为详细的分析了KMeans聚类算法概念、原理、定义及使用相关操作技巧,需要的朋友可以参考下
  • Python实现-Kmeans聚类算法

    千次阅读 2019-08-13 08:37:19
    Python实现-Kmeans聚类算法 1.Kmeans聚类定义 2.问题描述 3.实现过程 1. Kmeans聚类算法 Kmeans聚类算法: k均值聚类算法(k-means clustering algorithm)是一种迭代求解的聚类分析算法,其步骤是随机选取K个对象...
  • Kmeans聚类算法及其Python实现

    万次阅读 2015-04-12 12:51:03
    Kmeans聚类算法及其 Python实现Kmeans聚类算法及其 Python实现 关于聚类 基本思想 初始质心的选择 算法实验 Python实现 本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类...
  • 中科大2019春AI 实验二,包括Kmeans算法,PCA算法和层次聚类算法
  • Kmeans聚类算法python下的实现--附测试数据
  • Kmeans聚类算法及应用

    千次阅读 2019-11-06 16:55:17
    文章目录Kmeans聚类算法及应用1. Kmeans聚类算法原理1.2 算法图示1.3 算法要点1.3.1 核心思想1.3.2 算法步骤图解1.3.3 算法实现步骤2. Kmeans分类算法Python实战2.1 需求2.2 python代码实现2.2.1 利用numpy手动实现...
  • python Kmeans聚类之后如何给数据贴上聚类的标签? 用了二分Kmeans 来聚类 质心和聚类的簇都得到了,不知道如何给每一条数据贴上具体的标签? 这个链接下的代码,可以作为参考: ...
  • 本文实例讲述了Python实现的KMeans聚类算法。分享给大家供大家参考,具体如下:菜鸟一枚,编程初学者,最近想使用Python3实现几个简单的机器学习分析方法,记录一下自己的学习过程。关于KMeans算法本身就不做介绍了...
  • Python学习—利用Kmeans聚类算法进行主颜色提取 目录 Python学习—利用Kmeans聚类算法进行主颜色提取 1、导入pyrhon需要的相关库 2、原图像 3、读取图像并进行数据类型转换 4、构造Kmeans聚类器 5、获取聚类...
  • Kmeans聚类算法详解与实现,Kmeans算法的MATLAB实现、python实现源代码都有。附有算法原理的解析。 对应的博客地址:http://blog.csdn.net/zengxiantao1994/article/details/73441922
  • 0引言我做过一段时间车联网大数据分析,当然实际上是跟着一位大姐打杂学习。...不过聚类算法的奇妙一直印在我的脑子里:不需要标签就能把样本分成若干有内在关联的小组。正是因为聚类算法的这种...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 732
精华内容 292
关键字:

kmeans聚类算法python

python 订阅