-
k均值聚类
2020-05-10 15:04:16k均值聚类 -
MKKM(多核k均值聚类算法)KKM(核k均值聚类算法)
2018-08-01 15:33:00k均值聚类的扩展,带核函数的k均值聚类以及多核k均值聚类 -
Matlab基于K均值聚类的神经网络-基于K均值聚类的RBF神经网络.rar
2019-08-12 19:01:05Matlab基于K均值聚类的神经网络-基于K均值聚类的RBF神经网络.rar 基于K均值聚类的RBF神经网络 -
K均值聚类
2021-01-28 11:14:47K均值聚类将样本集合划分为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表示类别个数。
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均值聚类
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均值聚类为虹膜数据搜索了最佳聚类数-源码
2021-02-26 03:57:42K均值聚类 在这个项目中,我使用K均值聚类为虹膜数据搜索了最佳聚类数。 -
遥感影像K均值聚类中的初始化方法-遥感影像K均值聚类中的初始化方法.pdf
2019-08-13 00:56:54遥感影像K均值聚类中的初始化方法-遥感影像K均值聚类中的初始化方法.pdf 遥感影像K均值聚类中的初始化方法 -
Matlab基于k均值聚类学习算法的rbf神经网络实现-基于k均值聚类学习算法的rbf神经网络实现.rar
2019-08-12 23:09:42Matlab基于k均值聚类学习算法的rbf神经网络实现-基于k均值聚类学习算法的rbf神经网络实现.rar 基于k均值聚类学习算法的rbf神经网络实现 -
k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题)
2021-01-27 04:08:22聚类中心的向量值可任意设定,例如可选开始的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算法是很典型的基于距离的聚类算法,采用距离作为相似性的评价指标,即认为两个对象的距离越近,其相似度就越大。该算法认为簇是由距离靠近的对象组成的.
-
模糊c均值聚类_k均值聚类、模糊的c均值聚类算法
2020-12-08 15:20:48K均值聚类(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)误差平方和局部最小。
数据之间的相似度使用欧式距离度量。
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()
-
k均值聚类算法优缺点_Grasshopper实现K均值聚类算法
2020-11-29 19:10:26本文很长很长,有很多很多图,包含以下部分:1....k均值聚类算法(k-means clustering algorithm)是一种迭代求解的聚类分析算法,其步骤是随机选取K个对象作为初始的聚类中心,然后计算每个对象... -
k均值聚类算法优缺点_第31集 python机器学习:K均值聚类
2020-11-27 04:14:18K均值聚类:K均值聚类是最简单也是最常用的聚类算法之一。它试图找到代表数据特征区域的簇中心。算法交替执行以下两个步骤:将每个数据点分配给最近的簇中心,然后将每个簇中心设置为所分配的数据点... -
K均值聚类-源码
2021-02-25 08:12:38K均值聚类 -
k均值聚类-源码
2021-02-12 10:57:53k均值聚类 -
k均值聚类算法案例 r语言iris_R语言做K均值聚类的一个简单小例子
2020-12-24 17:22:11参考链接k均值聚类是一种比较常用的聚类方法,R语言里做k均值聚类比较常用的函数是kmeans(),需要输入3个参数,第一个是聚类用到的数据,第二个是你想将数据聚成几类k,第三个参数是nstart ...这篇链接里提到默认... -
k均值聚类算法优缺点_机器学习算法之K均值聚类使用sklearn
2020-11-26 10:29:08K - 均 值 聚 类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均值聚类。简述K均值聚类算法的具体步骤。K均值算法的优缺点是什么?如何对其进行调优?
2019-03-24 13:53:06k均值聚类 支持向量机,逻辑回归,决策树等经典的机器学习算法主要用于分类问题,即根据一些已经给定的类别的样本,训练某种分类器,使得他能够对类别未知的样本进行分类。 与分类问题不同,聚类是事先并不知道...