精华内容
下载资源
问答
  • k均值聚类

    2020-05-10 15:04:16
    k均值聚类
  • k均值聚类的扩展,带核函数的k均值聚类以及多核k均值聚类
  • Matlab基于K均值聚类的神经网络-基于K均值聚类的RBF神经网络.rar 基于K均值聚类的RBF神经网络
  • 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均值聚类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均值聚类 在这个项目中,我使用K均值聚类为虹膜数据搜索了最佳聚类数。
  • 遥感影像K均值聚类中的初始化方法-遥感影像K均值聚类中的初始化方法.pdf 遥感影像K均值聚类中的初始化方法
  • Matlab基于k均值聚类学习算法的rbf神经网络实现-基于k均值聚类学习算法的rbf神经网络实现.rar 基于k均值聚类学习算法的rbf神经网络实现
  • 聚类中心的向量值可任意设定,例如可选开始的K个.k均值聚类:---------一种硬聚类算法,隶属度只有两个取值0或1,提出的基本根据是“类内误差平方和最小化”准则; 模糊的c均值聚类算法:-------- 一种模糊聚类算法...

    ? 算法:第一步:选K个初始聚类中心,z1(1),z2(1),…,zK(1),其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定,例如可选开始的K个.

    k均值聚类:---------一种硬聚类算法,隶属度只有两个取值0或1,提出的基本根据是“类内误差平方和最小化”准则; 模糊的c均值聚类算法:-------- 一种模糊聚类算法,是.

    K均值聚类算法是先随机选取K个对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配给距离它最近的聚类中心。聚类中心以及.

    #include <stdio.h> #include <math.h>#define TRUE 1#define FALSE 0 int N. //初始化K个簇集合}/*算法描述:K均值算法: 给定类的个数K,将N个对象分到K个类.

    k-means 算法接受输入量 k ;然后将n个数据对象划分为 k个聚类以便使得所获得的聚类满足:同一聚类中的对象相似度较高;而不同聚类中的对象相似度较小。聚类相似.

    用k均值算法给出 : 在第一轮执行后的三个簇中心点为多少? 2.最后的三个簇。

    第一轮 A1(2,10) B1(5,8),A3(8,4), B2(7,5),B3(6,4),C2(4,9) C1(1,2),A2(2,5) 对应中心分别是(2,10),(6,6),(1.5, 3.5) 最后结果:{A1(2,10),B1(5,8),C2(4,9)} {A3(8,4), B2(7,5).

    #include #include #define TRUE 1#define FALSE 0 int N;//数据. //初始化K个簇集合 }/* 算法描述:K均值算法: 给定类的个数K,将N个对象分到K个类.

    假设你有n个样本,想聚成k类。1. 从n个样本中随机抽取k个,作为最初的类中心。. 计算方法就是此类中包含的所有样本的均值。4. 计算每个样本到k个新的类中心的距离.

    一,k-means聚类算法原理 k-means 算法接受参数 k ;然后将事先输入的n个数据对象划分为 k个聚类以便使得所获得的聚类满足:同一聚类中的对象相似度较高;而不同.

    在聚类分析中,K-均值聚类算法(k-means algorithm)是无监督分类中的一种基本方法,其也称为C-均值算法,其基本思想是:通过迭代的方法,逐次更新各聚类中心的值.

    1、初始化选取各簇中心时,是随机的,影响聚类结果。canopy算法可以改进这点。2、聚类结果是圆形状,对条状和线状支持不好3、要事先指定K值

    ① 在 K-means 算法中 K 是事先给定的,这个 K 值的选定是非常难以估计的。很多时候,事先并不知道给定的数据集应该分成多少个类别才最合适。这也是 K-means 算法.

    k 均值聚类法 快速高效,特别是大量数据时,准确性高一些,但是需要你自己指定聚类的类别数量 系统聚类法则是系统自己根据数据之间的距离来自动列出类别,所以通过.

    理论上是不需要的,因为标准化的线性变换不会影响距离的相对大小,但是实践时,数据标准化与否结果是不同的,可能与算法具体实现有关。

    实验题:利用K均值算法对以下30个点集合实施聚类。10个点:X方向:均值3。

    这种问题明显是取巧的题目,是不是老师布置的作业呀。建议你还是自己认真做做吧,如果有具体的问题我想会有很多人帮你的。但不是帮你偷懒。 帮你修改好了,从你所.

    强弱指标计算公式:RSI=100-[100/(1+RS)] 其 RS=14内收市价涨数平均值/14内收市价跌数平均值 举例说明: 近14涨跌情形: 第升2元第二跌2元第三至第五各升3元;.

    请用k-均值算法把表1中的点聚为3个类,假设第一次迭代选择序号1、4和。

    初始点为1,4,7;根据K-Means聚类的最近邻思想,可以计算其余5个点与这些初始聚类中心的欧氏距离。

    选取欧氏距离最小的点归到相应的类,然后根据均值法.

    是k均值聚类吧,k均值聚类就是为了分类,是一种无监督学习方法。具体算法用迭代实现,代码可以私下给你。

    K均值聚类是随机选取聚类中心,但是算法最终不一定会收敛到最优解,这与初值的选取有关,模糊C均值聚类:我觉得是在K均值的基础上,人为的加入了隶属度这个概念.

    k-means算法是很典型的基于距离的聚类算法,采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。该算法认为簇是由距离靠近的对象组成的.

    展开全文
  • K均值聚类(K-means):硬聚类算法,隶属度取0或1,类内误差平方和最小化。模糊的c均值聚类(FCM):模糊聚类算法,隶属度取[0,1],类内加权误差平方和最小化。1.K-means聚类算法 先随机选取K个对象作为初始的聚类中心...

    K均值聚类(K-means):硬聚类算法,隶属度取0或1,类内误差平方和最小化。

    模糊的c均值聚类(FCM):模糊聚类算法,隶属度取[0,1],类内加权误差平方和最小化。

    1.K-means聚类算法

    先随机选取K个对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离,把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。一旦全部对象都被分配了,每个聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是以下任何一个:

    1)没有(或最小数目)对象被重新分配给不同的聚类。

    2)没有(或最小数目)聚类中心再发生变化。

    3)误差平方和局部最小。

    99815ddc57640cd12d2e9846ee9045af.png

    数据之间的相似度使用欧式距离度量。

    import numpy as np
    
    x = np.random.randn(20)
    y = np.random.randn(20)
    k = 3
    #1.选取聚类中心
    center0=np.array([x[0],y[0]])
    center1=np.array([x[1],y[1]])
    
    #2.开始迭代
    iter = 100
    while iter > 0:
          print('111111')
          res = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
          for i in range(20):
              # 2.1计算每个对象与聚类中心的距离
              dis0 = np.sqrt((x[i] - center0[0]) ** 2 + (y[i] - center0[1]) ** 2)
              dis1 = np.sqrt((x[i] - center1[0]) ** 2 + (y[i] - center1[1]) ** 2)
    
              #2.1归类
              if(dis0 > dis1):
                  res[i]=1
              else:
                  res[i]=0
    
          #2.3新的聚类中心
          res0 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
          res01 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
          res1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
          res11 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
          n0 = 0
          n1 = 0
          for i in range(20):
              if res[i] == 0:
                  res0[n0] = x[i]
                  res01[n0] = y[i]
                  n0 += 1
              else:
                  res1[n1] = x[i]
                  res11[n1] = y[i]
                  n1 += 1
    
          center0_new = np.array([np.array(res0).mean(), np.array(res01).mean()])
          center1_new = np.array([np.array(res1).mean(), np.array(res11).mean()])
    
          #3.判定聚类中心位置是否发生变换
          if all((center0 == center0_new) & (center1 == center1_new)):
              # 如果没发生变换则退出循环,表示已得到最终的聚类中心
              break
    
          center1=center1_new
          center0=center0_new
    
    #4.输出结果
    for i in range(20):
        if res[i] == 0:
            print(x[i],y[i],'0')
        else:
            print(x[i],y[i],'1')

    2.模糊的c均值聚类算法

    大部分情况下,数据集中的对象不能划分成为明显分离的簇,指派一个对象到一个特定的簇有些生硬,也可能会出错。故,对每个对象和每个簇赋予一个权值,指明对象属于该簇的程度。当然,基于概率的方法也可以给出这样的权值,但是有时候我们很难确定一个合适的统计模型,因此使用具有自然地、非概率特性的模糊c均值就是一个比较好的选择。

    5a5e35b4373033200af15b9a63e4d5d0.png

    算法步骤

    可以将模糊c均值聚类的过程归纳为以下几步:

    1. 初始化隶属度矩阵 U(0),若有 N个样本,指定类别数为 k,则隶属度矩阵应当是 N∗k 的矩阵;
    2. 根据式(5)更新聚类中心 mj,j=1,...,k;
    3. 根据式(4)更新隶属矩阵 U(t),U(t+1);
    4. 若满足终止条件 maxij{∣∣u(t+1)iju(t)ij∣∣}<ε, 则停止迭代,否则返回步骤2。
    import numpy as np
    import pandas as pd
    
    def loadData(datapath):
        data = pd.read_csv(datapath)
        data = data.sample(frac=1.0)   # 打乱数据顺序
        dataX = data.iloc[:, :-1].values # 特征
        labels = data.iloc[:, -1].values # 标签
        # 将标签类别用 0, 1, 2表示
        labels[np.where(labels == "Iris-setosa")] = 0
        labels[np.where(labels == "Iris-versicolor")] = 1
        labels[np.where(labels == "Iris-virginica")] = 2
    
        return dataX, labels
    
    
    def initialize_U(samples, classes):
        U = np.random.rand(samples, classes)  # 先生成随机矩阵
        sumU = 1 / np.sum(U, axis=1)   # 求每行的和
        U = np.multiply(U.T, sumU)   # 使隶属度矩阵每一行和为1
    
        return U.T
    
    # 计算样本和簇中心的距离,这里使用欧氏距离
    def distance(X, centroid):
        return np.sqrt(np.sum((X-centroid)**2, axis=1))
    
    
    def computeU(X, centroids, m=2):
        sampleNumber = X.shape[0]  # 样本数
        classes = len(centroids)
        U = np.zeros((sampleNumber, classes))
        # 更新隶属度矩阵
        for i in range(classes):
            for k in range(classes):
                U[:, i] += (distance(X, centroids[i]) / distance(X, centroids[k])) ** (2 / (m - 1))
        U = 1 / U
    
        return U
    
    
    def ajustCentroid(centroids, U, labels):
        newCentroids = [[], [], []]
        curr = np.argmax(U, axis=1)  # 当前中心顺序得到的标签
        for i in range(len(centroids)):
            index = np.where(curr == i)   # 建立中心和类别的映射
            trueLabel = list(labels[index])  # 获取labels[index]出现次数最多的元素,就是真实类别
            trueLabel = max(set(trueLabel), key=trueLabel.count)
            newCentroids[trueLabel] = centroids[i]
        return newCentroids
    
    def cluster(data, labels, m, classes, EPS):
        """
        :param data: 数据集
        :param m: 模糊系数(fuzziness coefficient)
        :param classes: 类别数
        :return: 聚类中心
        """
        sampleNumber = data.shape[0]  # 样本数
        cNumber = data.shape[1]       # 特征数
        U = initialize_U(sampleNumber, classes)   # 初始化隶属度矩阵
        U_old = np.zeros((sampleNumber, classes))
    
        while True:
            centroids = []
            # 更新簇中心
            for i in range(classes):
                centroid = np.dot(U[:, i]**m, data) / (np.sum(U[:, i]**m))
                centroids.append(centroid)
    
            U_old = U.copy()
            U = computeU(data, centroids, m)  # 计算新的隶属度矩阵
    
            if np.max(np.abs(U - U_old)) < EPS:
                # 这里的类别和数据标签并不是一一对应的, 调整使得第i个中心表示第i类
    
                #centroids = ajustCentroid(centroids, U, labels)
                return centroids, U
    
    
    # 预测所属的类别
    def predict(X, centroids):
        labels = np.zeros(X.shape[0])
        U = computeU(X, centroids)  # 计算隶属度矩阵
        labels = np.argmax(U, axis=1)  # 找到隶属度矩阵中每行的最大值,即该样本最大可能所属类别
    
        return labels
    
    
    def main():
        datapath = "iris.csv"
        dataX, labels = loadData(datapath)  # 读取数据
    
        # 划分训练集和测试集
        ratio = 0.6  # 训练集的比例
        trainLength = int(dataX.shape[0] * ratio)  # 训练集长度
        trainX = dataX[:trainLength, :]
        trainLabels = labels[:trainLength]
        testX = dataX[trainLength:, :]
        testLabels = labels[trainLength:]
    
        EPS = 1e-6   # 停止误差条件
        m = 2        # 模糊因子
        classes = 3  # 类别数
        # 得到各类别的中心
        centroids, U = cluster(trainX, trainLabels, m, classes, EPS)
        print(centroids)
        print(U)
    
    
        #trainLabels_prediction = predict(trainX, centroids)
        #testLabels_prediction = predict(testX, centroids)
    
    
        #train_error = 1 - np.sum(np.abs(trainLabels_prediction - trainLabels)) / trainLength
        #test_error = 1 - np.sum(np.abs(testLabels_prediction - testLabels)) / (dataX.shape[0] - trainLength)
        #print("Clustering on traintset is %.2f%%" % (train_error*100))
        #print("Clustering on testset is %.2f%%" % (test_error*100))
    
    
    
    if __name__ == "__main__":
        main()
    展开全文
  • 本文很长很长,有很多很多图,包含以下部分:1....k均值聚类算法(k-means clustering algorithm)是一种迭代求解的聚类分析算法,其步骤是随机选取K个对象作为初始的聚类中心,然后计算每个对象...
  • K均值聚类K均值聚类是最简单也是最常用的聚类算法之一。它试图找到代表数据特征区域的簇中心。算法交替执行以下两个步骤:将每个数据点分配给最近的簇中心,然后将每个簇中心设置为所分配的数据点...
  • K均值聚类-源码

    2021-02-25 08:12:38
    K均值聚类
  • k均值聚类-源码

    2021-02-12 10:57:53
    k均值聚类
  • 参考链接k均值聚类是一种比较常用的聚类方法,R语言里做k均值聚类比较常用的函数是kmeans(),需要输入3个参数,第一个是聚类用到的数据,第二个是你想将数据聚成几类k,第三个参数是nstart ...这篇链接里提到默认...
  • K - 均 值 聚 类1、sklearn.cluster简介 使用 sklearn.cluster 模块里的 KMeans 函数即可实现K均值聚类。同样,函数中参数众多。具体如下:n_clusters:生成的聚类数,即产生的质心(centroids)数。默认为8init:指定...
  • K均值聚类算法.ppt

    2020-03-02 23:00:46
    主 讲 单 位电子信息工程学院 K均值聚类算法 目 录 K均值聚类简介 K均值聚类的原理 K均值算法的优缺点 K均值聚类的MATLAB实现 待聚类样本的分类结果 结论 一.K均值聚类简介 K均值聚类发明于1956年该算法最常见的形式...
  • k均值聚类 支持向量机,逻辑回归,决策树等经典的机器学习算法主要用于分类问题,即根据一些已经给定的类别的样本,训练某种分类器,使得他能够对类别未知的样本进行分类。 与分类问题不同,聚类是事先并不知道...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,958
精华内容 1,983
关键字:

k均值聚类