精华内容
下载资源
问答
  • k均值matlabk均值matlabk均值matlabk均值matlabk均值matlabk均值matlabk均值matlabk均值matlab
  • 这是先实现k均值算法,再在这个基础上实现约束种子k均值算法。k均值算法有直接调用接口实现,有用代码一步一步实现,训练数据清晰,每一个函数都有解释,是一个学习k均值算法很好的资源。
  • K-MEANS(K均值聚类算法,C均值算法) K-MEANS(K均值聚类算法,C均值算法) K-MEANS(K均值聚类算法,C均值算法)
  • K均值聚类算法.ppt

    2020-03-02 23:00:46
    主 讲 单 位电子信息工程学院 K均值聚类算法 目 录 K均值聚类简介 K均值聚类的原理 K均值算法的优缺点 K均值聚类的MATLAB实现 待聚类样本的分类结果 结论 一.K均值聚类简介 K均值聚类发明于1956年该算法最常见的形式...
  • k均值聚类和二分k均值聚类

    千次阅读 2018-09-21 16:58:24
    二分k均值聚类是K均值聚类改进(还有一种是K中值聚类),是一种层次聚类方法,以K均值聚类为基础,通过比较和方差得到最好的分法。 K均值聚类步骤 1.得到K个数据范围类的随机质心 2.把数据划分给最近的质心得到K个簇...

    一、参考《机器学习与实践》

    K均值聚类是一种通过距离公式把属性相近对象划分到同一类的算法,此算法对异常点和质心的选取较为敏感。二分k均值聚类是K均值聚类改进(还有一种是K中值聚类),是一种层次聚类方法,以K均值聚类为基础,通过比较和方差得到最好的分法。

    K均值聚类步骤

    1.得到K个数据范围类的随机质心

    2.把数据划分给最近的质心得到K个簇

    3.通过每个簇的平均值算出新的质点

    4.重复2和3直到不再改变

    二分K均值聚类

    1.初始化质心和并算出每个点到质心的距离

    2.分成两个簇后计算和方差选取最小误差为最好的分配方法

    3.重新分配簇和质心

    4.重复2和3达到K个类

    python代码实现:

    import numpy as np
    from matplotlib import pyplot as plt
    data=np.array( [
            [1.658985, 4.285136],
            [-3.453687, 3.424321],
            [4.838138, -1.151539],
            [-5.379713, -3.362104],
            [0.972564, 2.924086],
            [-3.567919, 1.531611],
            [0.450614, -3.302219],
            [-3.487105, -1.724432],
            [2.668759, 1.594842],
            [-3.156485, 3.191137],
            [3.165506, -3.999838],
            [-2.786837, -3.099354],
            [4.208187, 2.984927],
            [-2.123337, 2.943366],
            [0.704199, -0.479481],
            [-0.392370, -3.963704],
            [2.831667, 1.574018],
            [-0.790153, 3.343144],
            [2.943496, -3.357075],
            [-3.195883, -2.283926],
            [2.336445, 2.875106],
            [-1.786345, 2.554248],
            [2.190101, -1.906020],
            [-3.403367, -2.778288],
            [1.778124, 3.880832],
            [-1.688346, 2.230267],
            [2.592976, -2.054368],
            [-4.007257, -3.207066],
            [2.257734, 3.387564],
            [-2.679011, 0.785119],
            [0.939512, -4.023563],
            [-3.674424, -2.261084],
            [2.046259, 2.735279],
            [-3.189470, 1.780269],
            [4.372646, -0.822248],
            [-2.579316, -3.497576],
            [1.889034, 5.190400],
            [-0.798747, 2.185588],
            [2.836520, -2.658556],
            [-3.837877, -3.253815],
            [2.096701, 3.886007],
            [-2.709034, 2.923887],
            [3.367037, -3.184789],
            [-2.121479, -4.232586],
            [2.329546, 3.179764],
            [-3.284816, 3.273099],
            [3.091414, -3.815232],
            [-3.762093, -2.432191],
            [3.542056, 2.778832],
            [-1.736822, 4.241041],
            [2.127073, -2.983680],
            [-4.323818, -3.938116],
            [3.792121, 5.135768],
            [-4.786473, 3.358547],
            [2.624081, -3.260715],
            [-4.009299, -2.978115],
            [2.493525, 1.963710],
            [-2.513661, 2.642162],
            [1.864375, -3.176309],
            [-3.171184, -3.572452],
            [2.894220, 2.489128],
            [-2.562539, 2.884438],
            [3.491078, -3.947487],
            [-2.565729, -2.012114],
            [3.332948, 3.983102],
            [-1.616805, 3.573188],
            [2.280615, -2.559444],
            [-2.651229, -3.103198],
            [2.321395, 3.154987],
            [-1.685703, 2.939697],
            [3.031012, -3.620252],
            [-4.599622, -2.185829],
            [4.196223, 1.126677],
            [-2.133863, 3.093686],
            [4.668892, -2.562705],
            [-2.793241, -2.149706],
            [2.884105, 3.043438],
            [-2.967647, 2.848696],
            [4.479332, -1.764772],
            [-4.905566, -2.911070]
            ])
    
    class cluster():
        def __init__(self,data,classNum):
            self.__data=np.array(data)
            if self.__data.ndim==1:
                self.__data = np.c_[np.ones(self.__data.shape[0]),self.__data]
            self.__classNum=classNum
            self.__elementNum, self.__dimension = data.shape
        def __randCenter(self,data,classNum):
            dimension=data.ndim
            centroids=np.ones((classNum,dimension))
            for i in range(dimension):
                min=np.min(data[:,i])
                max=np.max(data[:,i])
                centroids[:,i]=(min+(max-min)*np.random.rand(classNum,1))[:,0]
            return centroids
        def dist(self,pA,pB):
            return np.sqrt(np.sum(np.power(pA-pB,2)))
        def __kMeans(self,data,classNum):
            #初始化一个二维数组存储最小距离的index和最小距离
            elementNum,dimension = data.shape
            clusterList=np.zeros((elementNum,2))
            indexList=np.array([-1]*elementNum)
            centroids=self.__randCenter(data,classNum)
            while True:
                for i in range(elementNum):
                    minDist=np.inf
                    minIndex=-1
                    for j in range(classNum):
                        currentDist=self.dist(centroids[j],data[i])
                        if minDist > currentDist:
                            minDist=currentDist
                            minIndex=j
                    clusterList[i]=minIndex,minDist**2
                for x in range(classNum):
                    #指定index输出self.__data[[0, 1, 2,]]
                    currentCluster=data[np.nonzero(clusterList[:,0]==x)]
                    if currentCluster.any():
                        centroids[x]=np.mean(currentCluster,axis=0)
                #对比两个数组是否全部相同,如果相同则跳出循环
                if (indexList==clusterList[:,0]).all():
                    break
                else:
                    indexList = clusterList[:,0].copy()
            return centroids,clusterList
        def kMeans(self):
            self.__centroids,self.__clusterList=self.__kMeans(self.__data,self.__classNum)
            return self.__centroids,self.__clusterList
        def bikMeans(self):
            elementNum, dimension = data.shape
            #初始化一个质心
            centList=[np.mean(self.__data,axis=0)]
            # 初始化一个二维数组存储最小距离的index和最小距离
            clusterList = np.zeros((elementNum, 2))
            #计算每个点到初始质心的距离
            for i in range(elementNum):
                clusterList[:,1][i]=self.dist(self.__data[i],centList[0])**2
            while(len(centList)<self.__classNum):
                #和方差计算最小的误差
                minSSE = np.inf
                for i in range(len(centList)):
                    currentCluster=self.__data[np.nonzero(clusterList[:,0]==i)]
                    subCent,subCluserList=self.__kMeans(currentCluster,2)
                    #分配后的误差
                    splitSSE=np.sum(subCluserList[:,1])
                    #未分配的误差
                    notSplitSSE=np.sum(clusterList[np.nonzero(clusterList[:,0]!=i),1])
                    if notSplitSSE+splitSSE<minSSE:
                        minSSE=notSplitSSE+splitSSE
                        bestCent,bestSplit,bestIndex=subCent,subCluserList,i
                #中心点重分配
                centList[bestIndex]=bestCent[0]
                centList.append(bestCent[1])
                #簇重分配(注意先后顺序,否则会产生覆盖问题)
                bestSplit[np.nonzero(bestSplit[:, 0] == 1), 0] = len(centList) - 1
                bestSplit[np.nonzero(bestSplit[:, 0] == 0), 0]=bestIndex
                clusterList[np.nonzero(clusterList[:,0]==bestIndex)]=bestSplit
            self.__centroids,self.__clusterList=np.array(centList), clusterList
            return self.__centroids,self.__clusterList
        def showplt(self):
            mark = ['or', 'ob', 'og', 'ok', '^r', '+r', 'sr', 'dr', '<r', 'pr']
            for i in range(self.__elementNum):
                markIndex = int(self.__clusterList[i, 0])
                plt.plot(self.__data[i, 0], self.__data[i, 1], mark[markIndex])
            mark = ['Dr', 'Db', 'Dg', 'Dk', '^b', '+b', 'sb', 'db', '<b', 'pb']
            for i in range(self.__classNum):
                plt.plot(self.__centroids[i, 0], self.__centroids[i, 1], mark[i], markersize=12)
            plt.show()
    cl=cluster(data,4)
    # cl.kMeans()
    cl.bikMeans()
    cl.showplt()

     

    展开全文
  • K均值聚类

    千次阅读 2021-01-28 11:14:47
    K均值聚类将样本集合划分为k个子集,构成k个类,将n个样本分到k个类中,每个样本到其所属类的中心距离最小,每个样本仅属于一个类,这就是k均值聚类,同时根据一个样本仅属于一个类,也表示了k均值聚类是一种硬聚类...

    K-均值聚类算法

    1. 什么是K均值聚类算法

    K均值聚类(k-means)是基于样本集合划分的聚类算法。K均值聚类将样本集合划分为k个子集,构成k个类,将n个样本分到k个类中,每个样本到其所属类的中心距离最小,每个样本仅属于一个类,这就是k均值聚类,同时根据一个样本仅属于一个类,也表示了k均值聚类是一种硬聚类算法。

    2:K均值聚类算法的过程

    2.1 k均值聚类的算法过程

    输入:n个样本的集合

    输出:样本集合的聚类

    过程:

    (1)初始化。随机选择k的样本作为初始聚类的中心。

    (2)对样本进行聚类。针对初始化时选择的聚类中心,计算所有样本到每个中心的距离,默认欧式距离,将每个样本聚集到与其最近的中心的类中,构成聚类结果。

    (3)计算聚类后的类中心,计算每个类的质心,即每个类中样本的均值,作为新的类中心。

    (4)然后重新执行步骤(2)(3),直到聚类结果不再发生改变。

    K均值聚类算法的时间复杂度是O(nmk),n表示样本个数,m表示样本维数,k表示类别个数。
    K均值聚类算法流程图

    3:K均值聚类算法的习题

    3.1 例题

    五个样本的集合,使用K均值聚类算法,将五个样本聚于两类,五个样本分别是(0,2)(0,0)(1,0)(5,0)(5,2)。

    例题图示

    3.2 初始化

    初始化。随机选择2个样本作为初始聚类的中心。
    初始化聚类中心

    3.3 聚类

    对样本进行聚类。计算每个样本距离每个中心的距离,将每个样本聚集到与其最近的中心的类中,构成两类。
    根据距离判定属于红色的中心点
    相同的方法对剩余两个点进行聚类,结果如下:
    第一次聚类结果

    3.4 寻找新的类中心

    计算新的类中心。对新的类计算样本的均值,作为新的类中心。
    新的中心点

    3.5 再次聚类

    对样本进行聚类。计算每个样本距离每个中心的距离,将每个样本聚集到与其最近的中心的类中,构成新的类。
    根据距离判定属于蓝色的中心点
    使用相同的方法对其余四个点进行聚类,结果如下:
    第二次聚类结果

    3.6 结果

    第二次聚类结果与第一次聚类结果相同,则聚类停止。得到最终的结果。

    3.7 例题

    若选择不同的初识聚类中心,会出现什么结果。初始化聚类中心
    选择不同的初始中心,会得到不同的聚类结果。

    4:K均值聚类算法的实现

    4.1 K均值聚类算法

    导入聚类库:

    from sklearn.cluster import KMeans

    聚类语法:

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

    参数解释:

    • n_clusters:簇的个数,即你想聚成几类
    • init: 初始簇中心的获取方法
    • n_init: 获取初始簇中心的更迭次数,为了弥补初始质心的影响,算法默认会初始10次质心,实现算法,然后返回最好的结果。
    • max_iter: 最大迭代次数(因为kmeans算法的实现需要迭代)
    • tol: 容忍度,即kmeans运行准则收敛的条件
    • precompute_distances:是否需要提前计算距离,这个参数会在空间和时间之间做权衡,如果是True 会把整个距离矩阵都放到内存中,auto 会默认在数据样本大于featurs*samples 的数量大于12e6 的时候False,False 时核心实现的方法是利用Cpython 来实现的
    • verbose: 冗长模式
    • random_state: 随机生成簇中心的状态条件。
    • copy_x: 对是否修改数据的一个标记,如果True,即复制了就不会修改数据。bool 在scikit-learn 很多接口中都会有这个参数的,就是是否对输入数据继续copy 操作,以便不修改用户的输入数据。这个要理解Python 的内存机制才会比较清楚。
    • n_jobs: 并行设置
    • algorithm: kmeans的实现算法,有:‘auto’, ‘full’, ‘elkan’, 其中 'full’表示用EM方式实现

    属性:

    • cluster_centers_:聚类中心点
    • labels_:每个样本所属的聚类标签
    • inertia_:样本到其最近的聚类中心的平方距离的总和
    • n_iter_:运行的迭代次数

    方法:

    • fit(X[,y]):训练样本
    • fit_predict(X[,y]):计算聚类中心并预测每个样本的聚类索引
    • fit_transform(X[,y]):计算聚类并将X转换为聚类距离空间
    • predict(X):预测X中每个样本所属的最近簇。
    4.2 对鸢尾花数据进行聚类
    # 导入所需要的库,绘图库,numpy库,sklearn机器学习库内的数据集,聚类,划分数据集方法
    import matplotlib.pyplot as plt  
    import numpy as np  
    from sklearn.cluster import KMeans
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import load_iris 
    
    iris=load_iris()   # 导入鸢尾花数据集
    X = iris.data[:, 2:4] ##表示我们只取特征空间中的后两个维度
    y = iris.target     # 将鸢尾花的标签赋值给y
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)  # 划分鸢尾花数据集,其中训练集占70%,测试集占30%
    #绘制数据分布图
    plt.scatter(X[:, 0], X[:, 1], c = "red", marker='o', label='iris')  
    plt.xlabel('petal length')  
    plt.ylabel('petal width')  
    plt.legend(loc=2)  
    plt.show()  
    estimator = KMeans(n_clusters=3) # 构造聚类器,将样本聚于3类
    estimator.fit(X_train)     # 开始聚类
    label_pred = estimator.labels_   # 获取聚类标签
    print(estimator.cluster_centers_)   # 获取聚类中心点
    #绘制k-means结果,将训练集聚类后的结果绘图展示,三种颜色表示三类,红色表示第一类,绿色表示第二类,蓝色表示第三类
    x0 = X_train[label_pred == 0]
    x1 = X_train[label_pred == 1]
    x2 = X_train[label_pred == 2]
    plt.scatter(x0[:, 0], x0[:, 1], c = "red", marker='o', label='label0')  
    plt.scatter(x1[:, 0], x1[:, 1], c = "green", marker='*', label='label1')  
    plt.scatter(x2[:, 0], x2[:, 1], c = "blue", marker='+', label='label2')  
    plt.xlabel('petal length')       # 坐标轴属性
    plt.ylabel('petal width')  
    plt.legend(loc=2)  
    plt.show()
    print(estimator.predict(X_test))    # 使用训练出的KMeans模型预测测试集中的数据属于哪一类
    #绘制k-means预测结果,将测试集集聚类后的结果绘图展示,三种颜色表示三类,橘色表示第一类,天蓝色表示第二类,蓝绿色表示第三类。
    predict_0=X_test[estimator.predict(X_test) == 0]
    predict_1=X_test[estimator.predict(X_test) == 1]
    predict_2=X_test[estimator.predict(X_test) == 2]
    plt.scatter(predict_0[:, 0], predict_0[:, 1], c = "tomato", marker='o', label='predict0')  
    plt.scatter(predict_1[:, 0], predict_1[:, 1], c = "skyblue", marker='*', label='predict1')  
    plt.scatter(predict_2[:, 0], predict_2[:, 1], c = "greenyellow", marker='+', label='predict2')  
    plt.xlabel('petal length')  
    plt.ylabel('petal width')  
    plt.legend(loc=2)  
    plt.show()
    

    程序结果

    展开全文
  • K均值聚类算法PPT

    2017-08-24 10:04:22
    K均值聚类算法的PPT,包含最基本的K均值算法,以及改进性算法:K-means++算法 ,Isodate算法,二分K均值算法
  • K均值算法

    2018-08-21 14:55:21
    K均值算法   K均值算法是一种聚类算法,把样本分配到离它最近的类中心所属的类,类中心由属于这个类的所有样本确定。   k均值算法是一种无监督的聚类算法。算法将每个样本分配到离它最近的那个类中心所代表的...

    K均值算法

     

    K均值算法是一种聚类算法,把样本分配到离它最近的类中心所属的类,类中心由属于这个类的所有样本确定。

     

    k均值算法是一种无监督的聚类算法。算法将每个样本分配到离它最近的那个类中心所代表的类,而类中心的确定又依赖于样本的分配方案。

     

    在实现时,先随机初始化每个类的类中心,然后计算样本与每个类的中心的距离,将其分配到最近的那个类,然后根据这种分配方案重新计算每个类的中心。这也是一种分阶段优化的策略。

     

    与k近邻算法一样,这里也依赖于样本之间的距离,因此需要定义距离的计算方式,最常用的是欧氏距离,也可以采用其他距离定义。算法在实现时要考虑下面几个问题:

     

    1.类中心向量的初始化。一般采用随机初始化。最简单的是Forgy算法,它从样本集中随机选择k个样本作为初始类中心。第二种方案是随机划分,它将所有样本随机的分配给k个类中的一个,然后按照这种分配方案计算各个类的类中心向量。

     

    2.参数k的设定。可以根据先验知识人工指定一个值,或者由算法自己确定。

     

    3.迭代终止的判定规则。一般做法是计算本次迭代后的类中心和上一次迭代时的类中心之间的距离,如果小于指定阈值,则算法终止。

     

     

     

     

     

    展开全文
  • k均值聚类python实现

    2018-10-18 09:30:23
    k-means(k均值)算法的python代码实现,可以显示聚类效果与聚类的迭代次数,初学者使用更方便。
  • K均值聚类分析

    千次阅读 2019-05-13 10:11:59
    聚类分析一、基本K均值算法1、算法的过程2、质心的计算3、距离的度量曼哈顿距离欧几里得距离最大距离闵可夫斯基距离点乘积相关系数4、性能的评估   K均值算法,是一种最古老的,也是最广泛使用的聚类算法。   ...


      KK均值算法,是一种最古老的,也是最广泛使用的聚类算法。
      通常,KK均值聚类应用于nn维连续空间中的对象。从数学的角度讲,假定样本集(数据集)DD包含mm个样本(对象),每个样本均为nn维向量,则KK均值聚类将样本集DD划分为kk个互不相交的簇(clustercluster)。
      例如,研究电信用户留存时,想知道哪些客户群容易流失,可以使用KK均值聚类对用户群体进行划分。

    一、基本K均值算法

    1、算法的过程

      首先,选择kk个对象作为初始的质心,其中kk是预先指定的参数,即所期望的clustercluster的个数。初始质心的选取通常是随机的,当然这么做的聚类效果往往很一般。
      其次,选取一个对象,计算对象到各个质心的距离,把对象分配给距离最近的质心。质心以及分配给其的对象就组成一个clustercluster
      然后,根据现有的clustercluster,计算clustercluster的质心——clustercluster内对象的平均值,并更新cluster的质心。
      接着,不断的循环执行对象分配以及质点更新的步骤。
      最后,当clustercluster不再发生变化,或者等价地,clustercluster的质心不再发生变化时,终止循环,结束过程。

    选择K个点作为初始质心;
    repeat
    	将每个点指派到最近的质心,形成K个cluster;
    	重新计算每个cluster的质心;
    until 质心不发生变化;
    

    2、质心的计算

      假设数据集包含nn个对象,每个对象对应一个22维的线性空间,(xc,ycx_{c},y_{c})为质心的坐标:
    xc=1ni=1nxix_{c}=\frac{1}{n}\sum_{i=1}^{n}x_{i} yc=1ni=1nyiy_{c}=\frac{1}{n}\sum_{i=1}^{n}y_{i}
      对于高维的数据样本,可依次进行推广。

    3、距离的度量

      由于KK均值算法往往应用于nn维连续空间中的对象,因此在计算对象到质心的距离时,该距离的定义方式应符合度量空间的定义——正定性、对称性、三角不等式。nn维度量空间中,常见的距离的度量方式有:

    ①曼哈顿距离

    d(x,y)=i=1nxiyid\left ( x,y \right)=\sum_{i=1}^{n}\left | x_{i}-y_{i} \right |

    ②欧几里得距离

    d(x,y)=i=1n(xiyi)2d\left ( x,y \right )=\sqrt{\sum_{i=1}^{n}{(x_{i}- y_{i})^2}}

    ③闵可夫斯基距离

    d(x,y)=i=1nxiyippd\left ( x,y \right)=\sqrt[p]{\sum_{i=1}^{n}\left | x_{i}-y_{i} \right |^{p}}
      其中,p=1p=1时,即曼哈顿距离;p=2p=2时,即欧几里得距离。

    4、性能的评估

      对于聚类的结果,我们希望尽可能的“物以类聚”。即同一clustercluster内的样本尽可能彼此相似(相关性强),隶属不同clustercluster的样本尽可能不同(不相关)。换言之,聚类结果的簇内相似度高,且簇间相似度低。

    ①偏差平方和

      最常见的,可以使用偏差平方和SSESSE(Sum of the Squared Error),即每个数据点到其最近质心的欧几里得距离平方和,来进行衡量:
    SSE=i=1kxϵCidisc(ci,x)2SSE=\sum_{i=1}^{k}\sum_{x\epsilon C_{i}}^{}disc\left ( c_{i},x \right )^2
      其中,CiC_{i}代表kkclusterclustercic_{i}代表clustercluster的质心;xx代表数据集中的数据点;discdisc代表两点间的欧几里得距离。
      显然,SSESSE越小,簇内相似度越高,聚类效果越好。

    ②轮廓系数

      另一个常见的度量方式是轮廓系数,不同于SSESSE只衡量了簇内相似度,轮廓系数通过clustercluster内的聚合度和不同clustercluster间的离散度的比值来衡量:
    \frac{离散度}{聚合度}

      轮廓系数对于单个点的定义如下:
    Si=biaimax(ai,bi)S_{i}=\frac{b_{i}-a_{i}}{\max \left ( a_{i},b_{i} \right )}
      其中,aia_{i}代表点ii到其隶属的clustercluster中所有其他点的平均距离;bib_{i}代表先求取点ii到其不隶属的某个clustercluster中所有点的平均距离,再取这些平均距离的最小值,换句话说,bib_{i}代表点ii到最近clustercluster的离散度。
      整体的轮廓系数SS,即为所有点的轮廓系数的平均值。
      显然,轮廓系数SS的取值范围是[1,1]\left [ -1,1 \right ]SS的值越大,说明聚类的效果越好。负值代表clustercluster的半径比两个clustercluster之间的距离大,说明clustercluster之间有重叠,聚类效果很糟糕。

    二、二分K均值算法

      二分KK均值算法是基本KK均值算法的直接扩充,其思想是:为了得到KKclustercluster,将所有点的集合分裂成两个clustercluster,从这些clustercluster中选取一个继续分裂,如此下去,直到产生KKclustercluster

    初始化数据,将所有数据作为一个cluster;
    repeat
    	选取一个cluster;
    	for i=1 to 实验次数;
    		使用基本K均值,令k=2,二分选定的cluster;
    	end for 
    	根据选取的不同的初始cluster,计算二分后的SSE;
    	将使SSE最小的cluster二分后的结果,加入到总的cluster集中;
    until 数据集分为k个cluster;
    

    三、K均值的优点和缺点

    1、K均值的优点

      KK均值算法简单,且可用于各种数据类型。
      KK均值算法往往相当有效,甚至有些变种算法(包括二分KK均值)更加有效,并且不太受初始化问题的影响。

    2、K均值的缺点

      KK均值算法并不适合所有的数据类型。
      KK均值算法不能处理非球形clustercluster、不同尺寸和不同密度的clustercluster,尽管指定足够大的KK值时它通常可以发现纯子clustercluster
      对包含离群点的数据进行聚类时,KK均值也有问题。这种情况下,离群点检测和删除大有帮助。
      KK均值算法只限于有质心概念的数据,对于没有质心概念的数据,可以使用KK中心点聚类,但是开销更大。

    展开全文
  • k均值聚类 支持向量机,逻辑回归,决策树等经典的机器学习算法主要用于分类问题,即根据一些已经给定的类别的样本,训练某种分类器,使得他能够对类别未知的样本进行分类。 与分类问题不同,聚类是事先并不知道...
  • K均值算法 K均值算法是一个经典的,被广泛使用的聚类算法。 算法过程 K均值算法中首先选择K个初值。K是用户指定的参数,即希望聚成的簇的个数。每个点指派到最近的质心,指派到一个质心的点集为一个簇。然后更新每个...
  • k均值图像分割

    2012-03-12 16:41:49
    本程序用matlab实现了基于k均值算法的图像分割,效果很好。
  • k均值图像分割的GPU加速

    千次阅读 2019-06-04 17:08:45
    K均值聚类算法是目前最受欢迎和应用最为广泛的聚类分析方法之一。K均值聚类算法用于图像分割具有直观、快速、易于实现的特点。不过当图像很大或者k很大时,采用k均值算法进行图像分割会异常缓慢,所以我们需要对其...
  • IDL 核K均值聚类

    2014-03-11 22:09:40
    很好用的一个ENVI 中IDL语言编写的核K均值聚类程序
  • 聚类算法从原理上大致课划分为3类:(1)基于原型的聚类(2)基于密度的聚类(3)基于层次的聚类,而在每一类下面又有好多算法,今天我要介绍的就是k均值聚类算法,它属于”基于原型聚类“这一类别。( 先提个问题:...
  • spss实现k均值聚类

    千次阅读 2020-04-10 12:30:46
    机器学习中的k均值聚类属于无监督学习,所谓k指的是簇类的个数,也即均值向量的个数。算法初始状态下,要根据我们设定的k随机生成k个中心向量,随机生成中心向量的方法既可以随机从样本中抽取k个样本作为中心向量,...
  • 根据《机器学习实战》一书第十章学习k均值聚类算法和二分k均值聚类算法,自己把代码边敲边理解了一下,修正了一些原书中代码的细微差错。目前代码有时会出现如下3种报错信息,这有待继续探究和完善。 报错信息: ...
  • K均值聚类的理解和实现

    万次阅读 多人点赞 2018-10-27 11:23:08
    2. K均值的基本理论 2.1 K均值的原理和实现 2.2 K均值的缺点 2.3 K均值改进 3. 算法实现 3.1 获取样本 3.2 协方差逆阵方根的计算方法 3.3 聚类实验 3.3.1 一般的K均值聚类 3.3.2 基于马氏距离...
  • k均值介绍

    2017-07-13 22:12:06
    K均值聚类 算法介绍: K-Means算法思想简单,效果却很好,是最有名的聚类算法。 它的基本思想是:通过迭代寻找k个聚类的一种划分方案,使得用这k个聚类的均值来代表相应各类样本时所得的总体误差最小。  k-...
  • 聚类分析之 K均值

    2019-12-17 15:22:04
    通常,K均值聚类用于 n 维连续空间中的对象。可以用于广泛的数据,因为它只需要对象之间的邻近性度量。 K 中心点使用中心点定义原型,其中中心点是一组点中最有代表性的点。 基本 K 均值算法 选取 K 个初始质心,...
  • python机器学习库sklearn——k均值聚类

    千次阅读 2018-01-04 08:36:58
    k均值聚类的相关的知识内容可以参考 http://blog.csdn.net/luanpeng825485697/article/details/78347433 这里只讲述sklearn中如何使用k均值进行聚类。 k均值聚类过程: 1、构造数据集。 2、使用数据集进行k均值...
  • k均值聚类

    2017-08-31 18:36:20
    什么是K均值聚类K-means算法是最简单的一种聚类算法。算法的目的是使各个样本与所在类均值的误差平方和达到最小(这也是评价K-means算法最后聚类效果的评价标准)一般步骤 初始化 输入基因表达矩阵作为对象集X,...
  • 怎么确定K均值聚类中的K(基于matlab)

    万次阅读 多人点赞 2018-06-12 16:35:01
    k均值算法原理和优缺点 点击打开链接 定义 D=类内平均距离/类间平均距离 不同的K有不同的D,D越小越好,但k也不能过大,根据实际情况取。 数据集 96个维度的616条数据。 matlab代码 clc;clear data=...
  • K均值算法是无监督学习,属于聚类算法 区别二:具体流程 K近邻算法是找与数据最近的K个点,如果多数属于某类,则归为该类,达到分类的效果 K均值算法是将所有数据归到距其最近的中心点,并不断迭代中心点以达到聚类...
  • K-means(K均值

    千次阅读 2016-05-12 15:24:09
    聚类算法很多,如K-means、凝聚层次聚类和DBSCAN等,本篇博客只会介绍K-means(K均值)算法。本篇博客的结构如下: 一、详细介绍K-means算法的详细细节 二、K-means的优化目标 三、K-means初始质心的随机初始化 四、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 87,831
精华内容 35,132
关键字:

K均值