精华内容
下载资源
问答
  • C++均值聚类算法C++均值聚类算法C++均值聚类算法
  • 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()
    展开全文
  • k均值聚类的扩展,带核函数的k均值聚类以及多核k均值聚类
  • Matlab基于K均值聚类的神经网络-基于K均值聚类的RBF神经网络.rar 基于K均值聚类的RBF神经网络
  • 模糊C均值聚类声纳图像分割:通过模糊C均值聚类的声纳图像分割实现
  • K均值聚类 在这个项目中,我使用K均值聚类为虹膜数据搜索了最佳聚类数。
  • 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均值聚类中的初始化方法-遥感影像K均值聚类中的初始化方法.pdf 遥感影像K均值聚类中的初始化方法
  • Matlab基于k均值聚类学习算法的rbf神经网络实现-基于k均值聚类学习算法的rbf神经网络实现.rar 基于k均值聚类学习算法的rbf神经网络实现
  • ? 算法:第一步:选K个初始聚类中心,z1(1),z2(1),…,zK(1),其中括号内的序号为寻找聚类中心的迭代运算的次序... 模糊的c均值聚类算法:-------- 一种模糊聚类算法,是.K均值聚类算法是先随机选取K个对象作为初始...

    ? 算法:第一步:选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算法是很典型的基于距离的聚类算法,采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。该算法认为簇是由距离靠近的对象组成的.

    展开全文
  • 使用Opencv实现区域增长法、K均值聚类算法、模糊C均值聚类算法对图像处理;可处理单通道图像以及多通道图像。用法:建立Opencv工程后添加此cpp文件,在该工程中添加lena .jpg图片即可运行程序(当然也可以自己修改...
  • 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)误差平方和局部最小。

    e18fc5618868b83f2ece0f082e1122b7.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均值就是一个比较好的选择。

    0e29d3cf960f8194e92b774c5f012f51.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个对象作为初始的聚类中心,然后计算每个对象...
  • RFM数据是指最近一次消费,消费频率以及消费金额,分别构成R,F,M,给定200行用户行为数据,我们用模糊C均值聚类进行分析 首先简单介绍一下模糊C均值聚类,每一个样本距各个聚类中心(初始聚类中心需要随机指定)都有...
  • 点击上方“蓝字”关注我们了解更多精彩模糊C-均值聚类算法(Fuzzy C-means Algoriythm,FCMA)是隶属度确定每个数据点属于某个聚类的程度的一种聚类算法。1973年,Bezdek提出了该算法,作为硬C-均值聚类(HCM)方法的一...
  • 根据《机器学习实战》一书第十章学习k均值聚类算法和二分k均值聚类算法,自己把代码边敲边理解了一下,修正了一些原书中代码的细微差错。目前代码有时会出现如下3种报错信息,这有待继续探究和完善。 报错信息: ...
  • k均值聚类

    2020-05-10 15:04:16
    k均值聚类
  • K均值聚类:K均值聚类是最简单也是最常用的聚类算法之一。它试图找到代表数据特征区域的簇中心。算法交替执行以下两个步骤:将每个数据点分配给最近的簇中心,然后将每个簇中心设置为所分配的数据点...
  • K均值聚类算法.ppt

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

    2021-01-28 11:14:47
    K-均值聚类算法 1. 什么是K均值聚类算法 K均值聚类(k-means)是基于样本集合划分的聚类算法。K均值聚类将样本集合划分为k个子集,构成k个类,将n个样本分到k个类中,每个样本到其所属类的中心距离最小,每个样本仅...
  • 参考链接k均值聚类是一种比较常用的聚类方法,R语言里做k均值聚类比较常用的函数是kmeans(),需要输入3个参数,第一个是聚类用到的数据,第二个是你想将数据聚成几类k,第三个参数是nstart ...
  • K是需要我们预先给定的质心的数量,K取多少需要我们去试凑,它直接影响着最后的聚类结果,是K-均值聚类算法的缺点之一。给定K之后,如何选出这K个质心呢? 我们的数据集特征的取值有最大值最小值,而这些最大...
  • 参考《机器学习实战》,实现K均值聚类和二分K均值聚类。 最后测试,对同一组数据,分别计算了两种算法的SSE(平方误差和),前者在150左右,后者在70左后。可见二分K-均值聚类的算法效果要好很多。 import numpy ...
  • K-means是一种无监督学习,对未标记的数据(即... K均值聚类算法的结果是:1.K簇的质心,可用于标记新数据2.训练数据的标签(每个数据点分配给一个集群)一、k-means简述1、聚类“类”指的是具有相似性的集合,聚类...
  • 2020年08月13日 KMEANSK均值聚类算法C均值算法 * 2020年08月13日 KMEANSK均值聚类算法C均值算法 * 资料仅可参考如有不妥请联系本人改正或者删除 * 2020年08月13日 KMEANSK均值聚类算法C均值算法 资料仅可参考如有...
  • K均值聚类-源码

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

    2021-02-12 10:57:53
    k均值聚类
  • 聚类算法从原理上大致课划分为3类:(1)基于原型的聚类(2)基于密度的聚类(3)基于层次的聚类,而在每一类下面又有好多算法,今天我要介绍的就是k均值聚类算法,它属于”基于原型聚类“这一类别。( 先提个问题:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,981
精华内容 2,792
关键字:

均值聚类