精华内容
下载资源
问答
  • R 实现Kmeans聚类算法教程
    千次阅读
    2022-03-14 19:16:18

    本文和你一起学习无监督机器学习算法 ———— kmeans算法,并在R中给详细的实现示例和步骤。

    什么是k-means聚类算法

    聚类是从数据集中对观测值进行聚类的机器学习方法。它的目标是聚类相似观测值,不同类别之间差异较大。聚类是一种无监督学习方法,因为它仅尝试从数据集中发现结构,而不是预测应变量的值。

    下面是一个市场营销中对客户分类的场景,通过下面客户信息:

    • 家庭收入
    • 住房面积
    • 户主职业
    • 据城区距离

    我们利用这些信息进行聚类,可识别相似家庭,从而能够识别某类型家庭可能购买某种产品或对某种类型的广告反应更好。

    最常用的聚类算法就是k-means聚类算法,下面我们介绍k-means算法并通过示例进行说明。

    k-means聚类算法把数据集中每个观测值分为K个类别。每个分类中的观测值相当类似,K类之间彼此差异较大。实际应用中执行下列几步实现k-means聚类算法:

    1. 确定K值

    首先确定把数据集分为几类。通常我们简单测试几个不同值K,然后分析结果,确定那个值更有现实意义。

    1. 将每个观察结果随机分配到一个初始簇中,从1到K。

    2. 执行以下步骤,直到集群分配停止变化。

    • 对于K个集群中的每一个,计算集群的质心。这仅仅是第k个簇中观测的p特征的向量。
    • 将每个观测值分配到质心最近的星系团。在这里最接近的是用欧氏距离来定义的。

    下面通过示例展示R的实现过程。

    R 实现kmeans聚类算法

    加载包

    首先加载两个包,包括kmeans算法的一些辅助函数。

    library(factoextra)
    library(cluster)
    

    加载示例数据

    对于本例我们将使用R中内置的usarrest数据集,该数据集包含1973年美国每个州每10万居民因谋杀、袭击和强奸而被捕的人数,以及每个州居住在城市地区的人口百分比(UrbanPop)。

    #load data
    df <- USArrests
    
    #remove rows with missing values
    df <- na.omit(df)
    
    #scale each variable to have a mean of 0 and sd of 1
    df <- scale(df)
    
    #view first six rows of dataset
    head(df)
    
    #                Murder   Assault   UrbanPop         Rape
    # Alabama    1.24256408 0.7828393 -0.5209066 -0.003416473
    # Alaska     0.50786248 1.1068225 -1.2117642  2.484202941
    # Arizona    0.07163341 1.4788032  0.9989801  1.042878388
    # Arkansas   0.23234938 0.2308680 -1.0735927 -0.184916602
    # California 0.27826823 1.2628144  1.7589234  2.067820292
    # Colorado   0.02571456 0.3988593  0.8608085  1.864967207
    

    上面代码首先加载USArrests数据集,删除缺失值,对数据值进行标准化。

    寻找最佳聚类数量

    执行kmeans聚类算法,我们可以使用内置包stat中的kmeans()函数,语法如下:

    kmeans(data, centers, nstart)

    • data : 数据集名称
    • centers: 聚类数量,即选择k的值
    • nstart: 初始配置个数。因为不同的初始启动集合可能会导致不同的结果,所以建议使用几种不同的初始配置。k-means算法将找到导致簇内变异最小的初始配置。

    既然在使用kmeans函数之前并不确定最优聚类数量,下面通过两个图来辅助我们决定:

    1. 聚类数量 vs. 总体平方和

    首先使用 fviz_nbclust 函数创建一个图,展示聚类数量及总体平方和之间的关系:

    fviz_nbclust(df, kmeans, method = "wss")
    

    在这里插入图片描述

    通常我们创建这类图形寻找某个K类对应的平方和值开始弯曲或趋于平缓的肘形。这通常是最理想的聚类数量。上图中显然在k = 4个时出现肘形

    1. 聚类数量 vs. 差距统计

    另一个决定最佳聚类数量的是使用指标:差距统计。它用于比较不同k值聚类差距变化情况。使用cluster包中的clusGap()以及fviz_gap_stat()函数画图:

    #calculate gap statistic based on number of clusters
    gap_stat <- clusGap(df,
                        FUN = kmeans,
                        nstart = 25,
                        K.max = 10,
                        B = 50)
    
    #plot number of clusters vs. gap statistic
    fviz_gap_stat(gap_stat)
    

    在这里插入图片描述

    从上图可以看到k=4时,差距统计最大,这与前面图的结果一致。

    使用最优k执行kmeans聚类

    最后,我们执行kmeans函数,使用k=4作为最优值:

    # 设置随机种子,让结果可以重现
    set.seed(1)
    
    # 调用kmeans聚类算法 k = 4
    km <- kmeans(df, centers = 4, nstart = 25)
    
    # 查看结果
    km
    
    # Show in New Window
    # Clustering k = 1,2,..., K.max (= 10): .. done
    # Bootstrapping, b = 1,2,..., B (= 50)  [one "." per sample]:
    # .................................................. 50 
    # R Console
    # 
    # 
    # Show in New Window
    # K-means clustering with 4 clusters of sizes 13, 13, 16, 8
    # 
    # Cluster means:
    #       Murder    Assault   UrbanPop        Rape
    # 1 -0.9615407 -1.1066010 -0.9301069 -0.96676331
    # 2  0.6950701  1.0394414  0.7226370  1.27693964
    # 3 -0.4894375 -0.3826001  0.5758298 -0.26165379
    # 4  1.4118898  0.8743346 -0.8145211  0.01927104
    # 
    # Clustering vector:
    #        Alabama         Alaska        Arizona       Arkansas     California       Colorado 
    #              4              2              2              4              2              2 
    #    Connecticut       Delaware        Florida        Georgia         Hawaii          Idaho 
    #              3              3              2              4              3              1 
    #       Illinois        Indiana           Iowa         Kansas       Kentucky      Louisiana 
    #              2              3              1              3              1              4 
    #          Maine       Maryland  Massachusetts       Michigan      Minnesota    Mississippi 
    #              1              2              3              2              1              4 
    #       Missouri        Montana       Nebraska         Nevada  New Hampshire     New Jersey 
    #              2              1              1              2              1              3 
    #     New Mexico       New York North Carolina   North Dakota           Ohio       Oklahoma 
    #              2              2              4              1              3              3 
    #         Oregon   Pennsylvania   Rhode Island South Carolina   South Dakota      Tennessee 
    #              3              3              3              4              1              4 
    #          Texas           Utah        Vermont       Virginia     Washington  West Virginia 
    #              2              3              1              3              3              1 
    #      Wisconsin        Wyoming 
    #              1              3 
    # 
    # Within cluster sum of squares by cluster:
    # [1] 11.952463 19.922437 16.212213  8.316061
    #  (between_SS / total_SS =  71.2 %)
    # 
    # Available components:
    # 
    # [1] "cluster"      "centers"      "totss"        "withinss"     "tot.withinss"
    # [6] "betweenss"    "size"         "iter"         "ifault"     
    

    从结果可见:

    • 16 州分在第一个类
    • 13 州分在第二个类
    • 13 州分在第三个类
    • 8 州分在第四个类

    我们可以通过fviz_cluster()函数在二维空间中以散点图方式展示结果:

    #plot results of final k-means model
    fviz_cluster(km, data = df)
    

    在这里插入图片描述

    也可以使用aggregate()函数查看每个类中变量的均值:

    #find means of each cluster
    aggregate(USArrests, by=list(cluster=km$cluster), mean)
    
    # cluster	  Murder   Assault	UrbanPop	    Rape
    # 				
    # 1	3.60000	  78.53846	52.07692	12.17692
    # 2	10.81538 257.38462	76.00000	33.19231
    # 3	5.65625	 138.87500	73.87500	18.78125
    # 4	13.93750 243.62500	53.75000	21.41250
    

    输出结果解释如下:

    • 在第一类中的州中平均每100,000人谋杀数为 3.6
    • 在第一类中的州中平均每100,000人袭击数为 78.5
    • 在第一类中的州中平均每100,000人城区居民率为 52.1%
    • 在第一类中的州中平均每100,000人强奸数为 3.6 12.2

    最后我们把聚类结果附加到原始数据集中:

    #add cluster assigment to original data
    final_data <- cbind(USArrests, cluster = km$cluster)
    
    #view final data
    head(final_data)
    
    # 	    Murder	Assault	UrbanPop  Rape	 cluster
    # 				
    # Alabama	    13.2	236	58	  21.2	 4
    # Alaska	    10.0	263	48	  44.5	 2
    # Arizona	     8.1	294	80	  31.0	 2
    # Arkansas     8.8	190	50	  19.5	 4
    # California   9.0	276	91	  40.6	 2
    # Colorado     7.9	204	78	  38.7	 2
    

    kmeans 算法的优缺点

    优点:

    • 很快的算法
    • 能够处理大数据集

    缺点:

    • 在执行算法之前需要指定聚类数量
    • 对异常值敏感

    总结

    本文我们讨论了kmeans算法的概念,并在R中给详细实现示例和步骤。

    更多相关内容
  • 本节内容:本节内容是根据上学期所上的模式识别课程的作业整理而来,第一道题目是Kmeans聚类算法,数据集是Iris(鸢尾花的数据集),分类数k是3,数据维数是4。 关于聚类  聚类算法是这样的一种算法:给定样本数据...
  • 本文实例讲述了Python实现的KMeans聚类算法。分享给大家供大家参考,具体如下: 菜鸟一枚,编程初学者,最近想使用Python3实现几个简单的机器学习分析方法,记录一下自己的学习过程。 关于KMeans算法本身就不做介绍...
  • Kmeans聚类算法-手肘法

    2022-01-08 12:22:52
    Kmeans聚类算法-手肘法,jupyter notebook 编写,打开可以直接运行,使用iris等5个数据集,机器学习。
  • 无监督学习-kmeans聚类算法及手动实现jupyter代码.ipynb
  • 该程序获取图像和所需的分区数,并找到不同类别的均值并提供分类图像(面具)。
  • java实现的kmeans聚类算法, 对某张表的某个字段进行kmeans聚类算法,并写到新创建的表中
  • 获得数据集anchor box的大小
  • 在记性深度学习目标检测时,运用YOLO算法训练模型时,能求出训练数据集里图片的锚框坐标。
  • sklearn学习中所需要的聚类算法解析,文档中主要解析了kmeans算法用法
  • K-means算法是很典型的基于距离的聚类算法,k-medoids聚类算法同样有效
  • Kmeans聚类算法详解与实现,Kmeans算法的MATLAB实现、python实现源代码都有。附有算法原理的解析。 对应的博客地址:http://blog.csdn.net/zengxiantao1994/article/details/73441922
  • KMEANS聚类算法的MATLAB代码 Algorithm 用Python,Matlab写的一些算法 \ (主目录) 文件名:算法名_功能 DeepLearning 来自吴恩达的深度学习课程 IntelligentAlgorithm 智能算法的代码 粒子群 模拟退火 鱼群算法 ...
  • 基于Hadoop平台Canopy-Kmeans聚类算法优化改进研究.pdf
  • KMeans聚类算法应用

    2021-01-20 03:42:21
    KMeans聚类算法应用 1999年31个省份平均每人全年消费支出 import numpy as np from sklearn.cluster import KMeans def loadData(filePath): #利用loadData读取数据 fr = open(filePath,’r+’) #r+:读写打开一个...
  • Python biKmeans 二分聚类算法
  • 基于Python3.7实现整图分割功能,调用sklearn模块的KMeans聚类算法。包括源程序、测试图片和结果图片。
  • 基于无监督学习,无需训练数据, 使用SIFT算法提取图像特征,再使用KMeans聚类算法进行图像分类。 对源代码进行了优化,实现了对应图片自动分类到各自文件夹功能,并且优化了分类准确率。 设计思路: 1)首先编写...
  • kmeans聚类分析,无监督学习实现Matlab代码
  • kmeans聚类算法

    2016-10-27 16:42:25
    kmeans聚类算法,目前只支持一位数组。亲测可用。
  • KMeans聚类算法首先需要确定N个初始中心点,初始中心点的选择对聚类结果影响很大,常用的初始中心点的选择有随机选择、自定义、采用Canopy聚类算法结果作为初始中心点,然后是重复遍历点与簇中心的距离,并不断修正...
  • 该文档详细地讲述了kmeans聚类算法的概念,以及各个参数,各个参数的属性的详细意思及应用,并且通过及例分析讲述了该算法 的应用。
  • Kmeans 聚类算法

    2021-02-20 12:36:24
    KMeans算法属于无监督学习,解决聚类的问题 对于数据集D, 不需提供数据标记,大大减少工作量 数据集D必须是凸集,非凸数据集难以收敛 必须先指定聚类簇数k k-means优点 原理简单,实现容易,可解释性较强 聚类...

    KMeans

    典型的 划 分 聚 类 划分聚类

    使用场景

    1. KMeans算法属于无监督学习,解决聚类的问题
    2. 对于数据集D, 不需提供数据标记,大大减少工作量
    3. 数据集D必须是凸集,非凸数据集难以收敛
    4. 必须先指定聚类簇数k

    k-means优点

    1. 原理简单,实现容易,可解释性较强
    2. 聚类效果较好
    3. 主要的调参只有k

    k-means缺点

    1. k值的选择不好把握
    2. 只适用于凸集,非凸数据集难以收敛
    3. 损失函数非凸,易收敛于局部最优解
    4. 对于噪声和异常点比较敏感

    基本思想

    簇内尽量紧凑,簇间尽量分散

    算法步骤

    1. 随机初始化 k k k个聚类中心点:可以从样本集S中随机选择,也可以随机生成
    2. 遍历样本集S所有样本点,计算每个样本 x i x_i xi k k k个中心点的距离,将 x i x_i xi分配给距离最近的中心点所在的簇(给 x i x_i xi一个标记 y ^ i \hat y_{i} y^i)
    3. 取各个簇内所有样本的均值样本作为新的聚类中心点
    4. 重复2,3过程,直到达到一定的迭代次数或者聚类中心不再改变
      初始化中心点
      聚类效果

    python实现

    import numpy as np
    from matplotlib import pyplot as plt
    import logging
    logging.basicConfig(level=logging.INFO,format="%(asctime)s %(message)s")
    import os
    
    
    #计算欧式距离
    def l2(x,y):
        """
        x:样本点向量
        y:样本点向量
        return:距离标量
        """
        return np.sqrt(np.sum(np.power(x-y,2)))
    
    #初始化聚类中心 函数
    def init_centers(S,k,method="select"):
        """
        S:样本数据集,np数组
        k:初始化聚类中心点的个数
        method:初始化的方式
                defaul,'select',random select k points from S
                        'random',random generation of k points
        
        return np数值
        """
        if method=="select":
            #select k points from S
            points=np.arange(S.shape[0])
            select_points=np.random.choice(points,k)
            return S[select_points]
        
        elif method=="random":
            #random generation
            #样本集S每一列特征的min,max之间随机生成一个数值
            
            #样本集的特征数
            n=S.shape[1]
            #初始化聚类中心点
            centers=np.empty((k,n))
            
            #生成聚类中心点每个特征的值
            for j in range(n):
                min_j,max_j=S[:,j].min(),S[:,j].max()
                range_j=max_j-min_j
                
                #生成第j特征的值,一维赋值
                centers[:,j]=(min_j+range_j*np.random.rand(k,1)).ravel()
                         
            
            return centers
        
        else:
            #待扩展功能
            pass
    
    def nearest_neighbors(x,centers):
        """
        x:单个样本向量
        centers:聚类中心点,np数值
        
        return (min_index,min_dist)
        min_index:最近邻的索引
        min_dist:最近邻的距离
        """
        #初始化最小距离及其索引
        min_index=-1
        min_dist=np.inf #正无穷
        
        #遍历中心点,计算距离
        for idx,center in enumerate(centers):
            x_center_dist=l2(x,center)
            
            if x_center_dist<min_dist:
                min_dist=x_center_dist
                min_index=idx
                
        return min_index,min_dist
            
        
    #定义KMeans聚类函数
    def kmeans(S,k,dist_measure=l2,max_iter=10,min_threshold=0.05):
        """
        S:样本集,np数组
        k:聚类簇数
        dist_measure:距离度量,默认欧式距离
        max_iter:最大迭代次数,int
        min_threshold:聚类中心点变化的距离阈值,小于这个幅度则停止迭代
            
        return (tag,centers,sse_list)
        tag:样本标签
        centers:聚类中心点
        sse_list:误差平方和 list
        """
        
        #样本总数,特征总数
        m,n=S.shape
        logging.info("current samples shape:%d,%d"%(m,n))
        
        
        #1初始化k个聚类中心点
        cluster_centers=init_centers(X,k,method="random")
        #初始化样本标签 tag
        tag=np.zeros(m)
        #迭代过程中的sse
        sse_list=[]
        
        #控制迭代的轮数,只实现max_iter
        iter_times=0
        while max_iter and iter_times<max_iter:
            #初始化误差平方和
            sse=0
            #2 计算所有样本的  最近邻 聚类中心
            for i in range(m):
                min_index,min_dist=nearest_neighbors(S[i,:],cluster_centers)
                
                #样本i放入最近邻中心点所在簇
                tag[i]=min_index
                sse+=min_dist**2
            sse_list.append(sse)
            #重新计算聚类中心点
            for idx in range(k):
                cluster_centers[idx,:]=np.mean(S[y_hat==idx],axis=0)
            
            iter_times+=1
            
        return tag,cluster_centers,sse_list
            
    if __name__=="__main__":
        X=np.loadtxt("kmeansSamples.txt")
        y_hat,centers,sse_list=kmeans(X,3,max_iter=6)
        print("cluster tag:",y_hat)
        print("sse list",sse_list)
        fig=plt.figure()
        plt.scatter(X[:,0],X[:,1],s=50,c=y_hat,label="samples")
        plt.scatter(centers[:,0],centers[:,1],s=300,c=np.unique(y_hat),marker="*",label="centers")
        plt.grid()
        plt.legend(loc="best",frameon=True,framealpha=0.7)
        plt.title("KMeans cluster")
        plt.axis("equal")
        fig.show()
    

    sklearn库的实现

    from sklearn.cluster import KMeans
    from sklearn.preprocessing import StandardScaler
    import numpy as np
    from matplotlib import pyplot as plt
    #实例化一个kmeans对象
    kmeans=KMeans(n_clusters=3,random_state=9)
    #加载数据
    x=np.loadtxt("kmeansSamples.txt")
    #数据归一化
    ss=StandardScaler()
    x_scale=ss.fit_transform(x)
    #聚类拟合
    kmeans.fit(x_scale)
    #聚类标签
    kmeans.labels_
    #聚类中心点
    kmeans.cluster_centers_
    #对未知样本分簇
    y_pred=kmeans.predict(x_new)
    

    改进的kmeans

    1. 二分k-means:对每个簇进行k=2的kmeans聚类分簇,对SSE减少最多的簇优先二分聚类,促使算法收敛于全局最优解
    2. k-means++:初始化距离较远的聚类中心点(避免初始化中心点的扎堆),促使算法收敛于全局最优解
    3. k-mediods:重新选择聚类中心,而不是取每个簇的均值,让本簇所有其他样本点到该点的距离和最小,减少噪声的干扰
    4. mini batch kmeans:对大数据集时,采用抽样部分数据集做kmeans聚类,利用找到的聚类中心,对整个数据集分簇,从而降低kmeans的时间复杂度,但是以降低部分优化质量为代价。

    基于kmeans项目

    KMeans总结

    在这里插入图片描述

    展开全文
  • kmeans聚类分析,无监督学习实现Matlab代码
  • 最后一次回顾KMeans聚类算法KMeans聚类算法的原理 一个数据集如下,我们希望将它分为两个簇(因为通过人的观察,它看起来像是可以分成两个簇,KMeans聚类算法的K是需要操作人员自己选择的,这也是这个算法的弊端...

    最后一次回顾KMeans聚类算法。

    KMeans聚类算法的原理

    • 一个数据集如下,我们希望将它分为两个簇(因为通过人的观察,它看起来像是可以分成两个簇,KMeans聚类算法的K是需要操作人员自己选择的,这也是这个算法的弊端之一,可以通过肘部法则(手肘法)来改善)👇。
      在这里插入图片描述
    • KMeans聚类算法的第一步,是初始化聚类中心。通常我们使用随机初始化的方法,即,在已经给定的样本点中选取聚类中心。但此处为了说明问题,使用了另一种方法初始化聚类中心,但是无论使用哪种初始化的方法,最终都是有可能得到最佳结果的。
      在这里插入图片描述
      👆生成两个聚类中心,因为我们希望将数据集分为两个簇。
    • 显然,KMeans聚类算法是一个需要迭代的方法,它通过不断的迭代,改变聚类中心的位置和样本点与聚类中心的关系划分,当迭代不使结果产生改变时 ,说明分类的工作已经完成,可以退出循环返回结果了。每一步的迭代,KMeans聚类算法要做两件事,第一件事是为样本点寻找合适的聚类中心,即,某个样本点与哪一个聚类中心的欧氏距离最近,那么就将这个样本点划分给哪个聚类中心。
      在这里插入图片描述
    • KMeans聚类算法要做的另一件事情,是改变聚类中心,由上图可知,由于该例中只需要将数据集分为两个簇,因此使用红色和蓝色代表两个簇的聚类中心和簇中样本点。改变聚类中心,说的是将某个簇的聚类中心重新放到属于这个簇的样本点的平均中心位置。
      在这里插入图片描述
      👆聚类中心改变前,聚类中心改变后👇
      在这里插入图片描述
      划分完聚类中心之后,便进入到了下一次迭代,此时要先重新为所有样本点选择新的聚类中心,因为上一次迭代的最后一步,聚类中心的位置改变了。之后再改变聚类中心的位置,依次迭代,直到聚类中心的位置和样本点的划分都不再发生改变,结束迭代,分类完成。
      在这里插入图片描述

    KMeans聚类算法的缺点

    • 聚类的个数在开始就要设定。
    • 聚类的结果取决于初始设定的聚类中心。
    • 对异常值很敏感。
    • 不适合用于发现非凸聚类问题。
    • 不能保证得到全局最优解,它往往会陷入一个局部最优解。 此时重复运行算法是有可能得到全局最优解的。

    KMeans聚类算法的Python实现

    import numpy as np
    import matplotlib.pyplot as plt
    import random
    from sklearn.datasets import make_blobs
    np.random.seed(123)
    
    # 从自带的机器学习库中获取数据,转移到变量中
    X,y = make_blobs(centers=4,n_samples=1000) #四个聚类中心,1000个样本点
    print(f'Shape of dataset:{X.shape}')# 打印数据集的大小
    fig = plt.figure(figsize=(8,6))#准备绘制簇图像
    plt.scatter(X[:,0],X[:,1],c = y)#X[:,0]代表取所有行中的第0个数据,即第0列数据
    #👆数据集X的维度是(1000,2)的。
    plt.title("Dataset with 4 clusters")#手动选择聚类中心,此处选择为4
    #👆通过肘部法则可以选择聚类中心
    plt.xlabel("First feature")
    plt.ylabel("Second feature")
    plt.show()
    #👆展示初始数据集
    
    #👇KMeans聚类算法:
    class KMeans():
        def __init__(self,n_clusters = 4):
            self.k = n_clusters #初始化K为聚类中心个数
    
        def fit(self,data):#训练KMeans聚类算法模型
            """
            取数据集当中的一小部分用来训练K-Means聚类算法模型
            """
            n_samples,_ = data.shape #样本量为数据集的大小。
            #👇初始化聚类中心
            self.centers = np.array(random.sample(list(data),self.k)) #随机初始化聚类中心,个数为4
            self.initial_centers = np.copy(self.centers) #随机初始化
            #继续追踪样本点到聚类中心的欧氏距离是否改变,如果不再改变,停止迭代,分类完成
            #停止迭代的条件是,每一个样本点被分配到的聚类中心不再改变,重点在于每一个样本点
            old_assigns = None
            n_iters = 0 #记录迭代次数
    
            while True: #永真循环,因为结束迭代的条件是聚类中心位置和样本点的聚类划分不再改变。
                new_assigns = [self.classify(datapoint) for datapoint in data]
                #👆对于本例,有1000个数据,因为有1000个样本点
                #👆为所有样本点重新划分新的聚类中心。
                if new_assigns == old_assigns: #如果划分没有改变,那么就代表聚类中心的位置没有改变
                #如果这两条都满足,那么就说明划分完成,实际上,只要一条满足,就代表划分完成。
                    print(f"Training finished after {n_iters} iterations!")
                    return
    
                old_assigns = new_assigns
                n_iters += 1
    
                #根据欧氏距离重新计算聚类中心
                for id_ in range(self.k): #重新部署聚类中心的位置。
                    points_idx = np.where(np.array(new_assigns) == id_)
                    datapoints = data[points_idx]
                    self.centers[id_] = datapoints.mean(axis = 0)
        def l2_distance(self,datapoint):#计算欧氏距离
            dists = np.sqrt(np.sum((self.centers - datapoint)**2,axis=1))
            return dists
    
        def classify(self,datapoint):#为样本点分配它们的聚类中心
            """
            Given a datapoint, compute the cluster closest to the datapoint.
            Return the cluster ID of that cluster.
            """
            dists = self.l2_distance(datapoint)
            return np.argmin(dists)#为许许多多的样本点重新分配聚类中心
    
        def plot_clusters(self,data):
            plt.figure(figsize=(12,10))
            plt.title("Initial centers in black,final centers in red")
            plt.scatter(data[:,0],data[:,1],marker = '.',c=y)
            plt.scatter(self.centers[:,0],self.centers[:,1],c='r')
            plt.scatter(self.initial_centers[:,0],self.initial_centers[:,1],c='k')
            plt.show()
    
    if __name__ == '__main__':
        kmeans = KMeans(n_clusters = 4)
        kmeans.fit(X)
        kmeans.plot_clusters(X)
    

    总结

    总的来说,KMeans聚类算法是一个相当入门的用于分类的无监督学习算法,本文使用Python实现,更是简化了KMeans聚类算法的难度(Python算是描述性语言)。本文使用了Python自带的机器学习库sklearn,使用的样本也是来自sklearn库中的样本。

    展开全文
  • 中科大2019春AI 实验二,包括Kmeans算法,PCA算法和层次聚类算法
  • 包含KMeans以及KMeans++聚类算法的python实现,以及测试文件读写的框架程序。其中KMeans.py是以随机初始化聚类中心的方法实现聚类,KMeanspp.py则是以KMeans++的方式初始化聚类中心。testKMeans.py则是主函数入口,...
  • Kmeans聚类算法

    2014-01-19 19:52:06
    KMEANS算法为非监督分类算法,比较基础

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,878
精华内容 9,151
关键字:

kmeans聚类算法