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表示类别个数。


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均值聚类为基础，通过比较和方差得到最好的分法。

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个初始聚类中心，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个对象作为初始的聚类中心。然后计算每个对象与各个种子聚类中心之间的距离，把每个对象分配给距离它最近的聚类中心。聚类中心以及分配给它们的对象就代表一个聚类。一旦全部对象都被分配了，每个聚类的聚类中心会根据聚类中现有的对象被重新计算。这个过程将不断重复直到满足某个终止条件。终止条件可以是以下任何一个：
1)没有（或最小数目）对象被重新分配给不同的聚类。
2)没有（或最小数目）聚类中心再发生变化。
3)误差平方和局部最小。
       数据之间的相似度使用欧式距离度量。
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均值就是一个比较好的选择。
算法步骤
可以将模糊c均值聚类的过程归纳为以下几步：
初始化隶属度矩阵 U(0)，若有 N个样本，指定类别数为 k，则隶属度矩阵应当是 N∗k 的矩阵；
根据式(5)更新聚类中心 mj,j=1,...,k；
根据式(4)更新隶属矩阵 U(t),U(t+1)；
若满足终止条件 maxij{∣∣u(t+1)ij−u(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()