精华内容
下载资源
问答
  • 2020-07-30 16:04:14

    模糊C均值聚类的python实现

    存在的问题:

    用来判断终止条件的变量dist,是前后两次隶属度矩阵的对应元素做差,取绝对值,再取最大值。用鸢尾花数据集的话,dist的值最低只能到小数点后两位,但是网上别的代码能达到小数点后6、7位。

    但是标准互信息指数NMI的值相差不大,都在0.74左右。

    import numpy as np
    from sklearn import metrics
    import time
    
    
    def read_txt(path, delimiter=','):
        data = np.loadtxt(path, delimiter=delimiter)
        n_row, n_col = data.shape
        n_col = n_col - 1
        y = np.array(data[:, -1], dtype=np.int)
        X = data[:, 0:n_col]
    
        return X, y
    
    
    
    def random_membership_matrix(n_sample, k):
        # 初始化一个隶属度矩阵
        membership_matrix = np.zeros((n_sample, k), dtype=np.float)
        for i in range(n_sample):
            temp = np.random.random(k)  # 生成k个随机浮点数
            temp = temp / sum(temp)
            membership_matrix[i] = temp
        return membership_matrix
    
    
    def iterate(X, u, k, m):
        # 停止条件来自:https://blog.csdn.net/lyxleft/article/details/88964494
        # 前后两次隶属度矩阵对应元素做差,差的最大值不超过某一阈值
        n_sample, dim = X.shape
        # 先把前一次的隶属度矩阵存起来
        old_u = np.array(u)
        ter = 0.0000001  # 阈值
        iteration = 0
        dist = float('inf')
        max_iter = 20  # 最大迭代次数,这个次数之内达不到阈值,就得重新随机隶属度矩阵了
        center = np.zeros((k, dim), dtype=np.float)  # 类中心,每行存一个类中心
    
        # 满足最小阈值,或者达到最大迭代次数时停止
        while dist > ter and iteration < max_iter:
    
            iteration = iteration + 1
    
            # 根据隶属度矩阵求中心
            for i in range(k):
                up = np.zeros((dim,), dtype=np.float)
                down = 0.0
                for j in range(n_sample):
                    up += np.power(u[j, i], m) * X[j]
                    down += np.power(u[j, i], m)
                center[i] = up / down
    
            # 根据中心求隶属度矩阵
            for p in range(n_sample):
                for q in range(k):
                    down = 0.0
                    up = np.power(np.linalg.norm(X[p] - center[q]), -2/(m-1))
                    for e in range(k):
                        down += np.power(np.linalg.norm(X[p] - center[e]), -2/(m-1))
                    u[p, q] = up / down
    
    
            # 求终止条件
            dist = (abs(u - old_u)).max()
    
        return center, u
    
    
    def cluster(membership_matrix):
        # 根据隶属度求聚类结果,把样本点归到隶属度最大的类
        n_sample = membership_matrix.shape[0]
        y_pred = np.zeros((n_sample,), dtype=np.int)
        for i in range(n_sample):
            y_pred[i] = np.argmax(membership_matrix[i])
        return y_pred
    
    
    if __name__ == '__main__':
        k = 3
        m = 2
        fileName = 'iris'
        X, y = read_txt('./dataset/' + fileName + '.txt')
        n_sample, dim = X.shape
        # 多跑几次取最好结果
        best_y_pred = np.zeros((n_sample,), dtype=np.int)
        best_nmi = 0.0
        center = np.zeros((k, dim), dtype=np.float)
        for d in range(10):
            print('**********第%d次随机隶属度矩阵**********' % d)
            membership_matrix = random_membership_matrix(n_sample, k)
            center, membership_matrix = iterate(X, membership_matrix, k, m)
            y_pred = cluster(membership_matrix)
            nmi = metrics.normalized_mutual_info_score(y, y_pred)
            if nmi > best_nmi:
                best_nmi = nmi
                best_y_pred = y_pred
        print('best_nmi: %f' % best_nmi)
        print(center)
    
    
    
    

     

    更多相关内容
  • 模糊C均值聚类Python算法,新数据的类别预测
  • c- 均值聚类(IFCM) 的途径和方法, 分析了现有的几种IFCM 算法, 并提出了一种基于直觉模糊集的模糊??c- 均值 聚类算法. 该算法首先定义了直觉模糊集之间的距离; 然后构造了聚类的目标函数; 最后给出了聚类算法...
  • 这是一个基于python图像分割的模糊c均值算法
  • class pattern: x=0 y=0 def __init__(self,x,y): self.x=x self.y=y def dis(a,b): return ((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))**0.5 eps=0.00001 ...inf=4000000000000000000 print("请输入需要将...c=
    class pattern:
        x=0
        y=0
        def __init__(self,x,y):
            self.x=x
            self.y=y
    
    def dis(a,b):
        return ((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y))**0.5
    
    eps=0.00001
    maxn=1000050
    inf=4000000000000000000
    print("请输入需要将模式分为的类别数 c :")
    c=input()
    c=int(c)
    print("请输入模式总数 n :")
    n=input()
    n=int(n)
    print("请输入各模式的两个特征点 :")
    a=[]
    b=[]
    for i in range(n):
        x,y=map(int,input().split())
        tmp=pattern(x,y)
        a.append(tmp)
    for i in range(c):
        tmp=pattern(a[i].x,a[i].y)
        b.append(tmp)
    ans=0
    while ans<c:
        cnt=[0]*maxn
        belong=[-1]*maxn
        for i in range(n):
            minn=4000000000000000000
            mini=-1
            for j in range(c):
                dis_to_center=dis(a[i],b[j])
                if dis_to_center<minn:
                    minn=dis_to_center
                    mini=j
            belong[i]=mini
            cnt[mini]=cnt[mini]+1
        sum=[]
        for i in range(c):
            tmp=pattern(0,0)
            sum.append(tmp)
        for i in range(n):
            sum[belong[i]].x+=a[i].x
            sum[belong[i]].y+=a[i].y
            print(a[i].x,a[i].y,belong[i],sum[belong[i]].x,sum[belong[i]].y)
        ans=0
        for i in range(n):
            print(i,"号点",a[i].x,a[i].y)
        for i in range(c):
            if cnt[i]!=0:
                sum[i].x=sum[i].x/cnt[i]
                sum[i].y=sum[i].y/cnt[i]
                if abs(sum[i].x-b[i].x)<eps and abs(sum[i].y-b[i].y)<eps:
                    ans=ans+1
                b[i].x=sum[i].x
                b[i].y=sum[i].y
            if a[1].x!=1 or a[1].y!=0:
                print("i=",i)
        for i in range(n):
            print(i,"号点",a[i].x,a[i].y)
    print("C均值聚类算法已经完成!\n\nc个类中心分别为\n")
    for i in range(c):
        print("第",i+1,"类的聚类中心的两个特征值分别为",b[i].x,b[i].y)
    
    print()
    for i in range(c):
        print("属于第",i+1,"类的点有:")
        for j in range(n):
            if belong[j]==i:
                print(j+1,"号点",a[j].x,a[j].y)
        print()
    
    
    展开全文
  • python实现K均值聚类算法

    千次阅读 2021-05-14 21:13:50
    K-Means算法的思想很简单,对于给定的样本集,按照样本之间的距离大小,将样本集划分为K个簇。让簇内的点尽量紧密的连在一起,而让簇间的距离尽量的大。 如何计算? 如果用数据表达式表示,假设簇划分为(C1,C2,...Ck

    之前做大作业的时候本来想用聚类法给点集分类的,但是太复杂了,于是最后没有采用这个方案。现在把之前做的一些工作整理出来写个小博客。

    K-means聚类法原理:

    聚类是一个将数据集中在某些方面相似的数据成员进行分类组织的过程,聚类就是一种发现这种内在结构的技术,聚类技术经常被称为无监督学习。

    K-Means算法的思想很简单,对于给定的样本集,按照样本之间的距离大小,将样本集划分为K个簇。让簇内的点尽量紧密的连在一起,而让簇间的距离尽量的大。

    如何计算?

    如果用数据表达式表示,假设簇划分为 ( C 1 , C 2 , . . . C k ) ({C_1},{C_2},...{C_k}) (C1,C2,...Ck),则我们的目标是最小化平方误差E:
    E = ∑ i = 1 k ∑ x ∈ C i ∥ x − μ i ∥ 2 2 E = \sum\limits_{i = 1}^k {\sum\limits_{x \in {C_i}} {\left\| {x - {\mu _i}} \right\|_2^2} } E=i=1kxCixμi22
    其中 μ i μ_i μi是簇 C i C_i Ci的均值向量,有时也称为质心,表达式为:
    μ i = 1 ∣ C i ∣ ∑ x ∈ C i x {\mu _i} = \frac{1}{{\left| {{C_i}} \right|}}\sum\limits_{x \in {C_i}} x μi=Ci1xCix
    如果我们想直接求上式的最小值并不容易,这是一个NP难的问题,因此只能采用启发式的迭代方法。
    下图是K均值聚类法的一个示意图:
    在这里插入图片描述
    上图a表达了初始的数据集,假设k=2。在图b中,我们随机选择了两个k类所对应的类别质心,即图中的红色质心和蓝色质心,然后分别求样本中所有点到这两个质心的距离,并标记每个样本的类别为和该样本距离最小的质心的类别,如图c所示,经过计算样本和红色质心和蓝色质心的距离,我们得到了所有样本点的第一轮迭代后的类别。此时我们对我们当前标记为红色和蓝色的点分别求其新的质心,如图4所示,新的红色质心和蓝色质心的位置已经发生了变动。图e和图f重复了我们在图c和图d的过程,即将所有点的类别标记为距离最近的质心的类别并求新的质心。最终我们得到的两个类别如图f。

    当然在实际K-Mean算法中,我们一般会多次运行图c和图d,才能达到最终的比较优的类别。

    我的解决方案是在代码中使用的是循环10次(可调),选择总距离最小的那个方案。

    代码部分:

    class KMeansClusterer:  # k均值聚类
        def __init__(self, ndarray, cluster_num):
            self.ndarray = ndarray
            self.cluster_num = cluster_num
            self.points = self.__pick_start_point(ndarray, cluster_num)
    
        def cluster(self):
            result = []
            for i in range(self.cluster_num):
                result.append([])
            for item in self.ndarray:
                distance_min = sys.maxsize
                index = -1
                for i in range(len(self.points)):
                    distance = self.__distance(item, self.points[i])
                    if distance < distance_min:
                        distance_min = distance
                        index = i
                result[index] = result[index] + [item.tolist()]
            new_center = []
            for item in result:
                new_center.append(self.__center(item).tolist())
            # 中心点未改变,说明达到稳态,结束递归
            if (self.points == new_center).all():
                sum=self.__sumdis(result)
                return result,self.points,sum
            self.points = np.array(new_center)
            return self.cluster()
    
        def __sumdis(self,result):
            #计算总距离和
            sum=0
            for i in range(len(self.points)):
                for j in range(len(result[i])):
                    sum+=self.__distance(result[i][j],self.points[i])
            return sum
    
        def __center(self, list):
            # 计算每一列的平均值
            return np.array(list).mean(axis=0)
    
        def __distance(self, p1, p2):
            #计算两点间距
            tmp = 0
            for i in range(len(p1)):
                tmp += pow(p1[i] - p2[i], 2)
            return pow(tmp, 0.5)
    
        def __pick_start_point(self, ndarray, cluster_num):
            if cluster_num < 0 or cluster_num > ndarray.shape[0]:
                raise Exception("簇数设置有误")
            # 取点的下标
            indexes = random.sample(np.arange(0, ndarray.shape[0], step=1).tolist(), cluster_num)
            points = []
            for index in indexes:
                points.append(ndarray[index].tolist())
            return np.array(points)
    
    

    运行结果如下:
    运行结果
    结果如上图所示,这是之前大作业得到的点集,不同颜色的点分属于不同类型的点集,五角星为每个点集的中心点。

    调用函数后得到的是点集以及总距离。代码使用示例我放在资源包里,有需要自取。

    展开全文
  • 基于模糊C均值聚类算法的图像分割
  • K均值聚类(K-Means) k-means 算法:根据给定的数据样本构建 k 个划分聚类,每个划分聚类即为一个簇。 该算法是一个典型的基于距离的聚类算法,采用距离作为相似性的评价指标(两个样本的距离越近,相似度就越大...

    K均值聚类(K-Means)

            k-means 算法:根据给定的数据样本构建 k 个划分聚类,每个划分聚类即为一个簇。

            该算法是一个典型的基于距离的聚类算法,采用距离作为相似性的评价指标(两个样本的距离越近,相似度就越大)。

    每个数据样本必须属于而且只能属于一个簇。

    同一簇中的数据样本相似度高,不同簇中的数据样本相似度较小。

    聚类相似度是利用各簇中样本的均值来进行计算的。

    注:因为在该算法第一步中是随机的选取任意k个对象作为初始聚类的中心,初始地代表一个簇,因此k个初始类聚类中心点的选取对聚类结果具有较大的影响。

    聚类步骤:
    1)随机指定k个质心点(中心点)
    2)根据距离分类(靠近质心点的划归为同一类)
    3)采用平均值更新质心点
    4)重复迭代步骤2-3,直到质心点不在变化或者达到指点具体迭代次数。

    python代码实现

    import numpy as np
    import matplotlib.pyplot as plt
    # 引入scipy中的距离函数,默认欧式距离
    from scipy.spatial.distance import cdist
    # 从sklearn中直接生成聚类数据
    from sklearn.datasets._samples_generator import make_blobs
    
    
    # -------------1. 数据加载---------
    x, y = make_blobs(n_samples=100, centers=6, random_state=1234, cluster_std=0.6)
    
    #plt.figure(figsize=(6, 6))
    #plt.scatter(x[:, 0], x[:, 1], c=y)
    #plt.show()
    
    # --------------2. 算法实现--------------
    class K_Means(object):
        # 初始化,参数 n_clusters(K)、迭代次数max_iter、初始质心 centroids
        def __init__(self, n_clusters=5, max_iter=300, centroids=[]):
            self.n_clusters = n_clusters
            self.max_iter = max_iter
            self.centroids = np.array(centroids, dtype=np.float)
    
        # 训练模型方法,k-means聚类过程,传入原始数据
        def fit(self, data):
            # 假如没有指定初始质心,就随机选取data中的点作为初始质心
            if (self.centroids.shape == (0,)):
                # 从data中随机生成0到data行数的6个整数,作为索引值
                self.centroids = data[np.random.randint(0, data.shape[0], self.n_clusters), :]
    
            # 开始迭代
            for i in range(self.max_iter):
                # 1. 计算距离矩阵,得到的是一个100*6的矩阵
                distances = cdist(data, self.centroids)
    
                # 2. 对距离按有近到远排序,选取最近的质心点的类别,作为当前点的分类
                c_ind = np.argmin(distances, axis=1)
    
                # 3. 对每一类数据进行均值计算,更新质心点坐标
                for i in range(self.n_clusters):
                    # 排除掉没有出现在c_ind里的类别
                    if i in c_ind:
                        # 选出所有类别是i的点,取data里面坐标的均值,更新第i个质心
                        self.centroids[i] = np.mean(data[c_ind == i], axis=0)
    
        # 实现预测方法
        def predict(self, samples):
            # 跟上面一样,先计算距离矩阵,然后选取距离最近的那个质心的类别
            distances = cdist(samples, self.centroids)
            c_ind = np.argmin(distances, axis=1)
    
            return c_ind
    
    
    dist = np.array([[121, 221, 32, 43],
                     [121, 1, 12, 23],
                     [65, 21, 2, 43],
                     [1, 221, 32, 43],
                     [21, 11, 22, 3], ])
    c_ind = np.argmin(dist, axis=1)
    print(c_ind)
    x_new = x[0:5]
    print(x_new)
    print(c_ind == 2)
    print(x_new[c_ind == 2])
    np.mean(x_new[c_ind == 2], axis=0)
    
    # --------------3. 测试------------
    # 定义一个绘制子图函数
    def plotKMeans(x, y, centroids, subplot, title):
        # 分配子图,121表示1行2列的子图中的第一个
        plt.subplot(subplot)
        plt.scatter(x[:, 0], x[:, 1], c='cyan')
        # 画出质心点
        plt.scatter(centroids[:, 0], centroids[:, 1], c=np.array(range(5)), s=100)
        plt.title(title)
    
    kmeans = K_Means(max_iter=300, centroids=[[2, 1], [2, 2], [2, 3], [2, 4], [2, 5]])
    
    plt.figure(figsize=(16, 6))
    plotKMeans(x, y, kmeans.centroids, 121, 'start')
    
    # 开始聚类
    kmeans.fit(x)
    
    plotKMeans(x, y, kmeans.centroids, 122, 'k-means')
    
    # 预测新数据点的类别
    x_new = np.array([[0, 0], [10, 7]])
    y_pred = kmeans.predict(x_new)
    
    print(kmeans.centroids)
    print(y_pred)
    
    plt.scatter(x_new[:, 0], x_new[:, 1], s=100, c='black')
    plt.show()

    展开全文
  • 2.编写k-均值聚类算法程序,对人工生成数据集AriGen 与 Iris数据集进行聚类﹐并计算DB指数。 一、数据集(150) 具体数据如下(如果不能运行,尝试在末尾加回车) 5.1 3.5 1.4 0.2 1 4.9 3 1.4 0.2 1 4.7 3...
  • C均值聚类 算法步骤 在样本集合中选择C个点作为初始类中心; 在剩下的样本点中选择一个,计算其到各个中心点的距离,选取距离最短者将其归为那个类别; 选择下一个样本,重复2直到计算完所有样本,若集合不发生变化...
  • k均值聚类算法原理详解 示例为链接中的例题 直接调用python机器学习的库scikit-learn中k均值算法的相关方法 from sklearn.cluster import KMeans import numpy as np import matplotlib.pyplot as plt x = np.array...
  • 模糊C均值聚类(FCM)算法介绍及其Python实现

    千次阅读 多人点赞 2020-07-22 16:55:33
    目录一、理论介绍二、算法实现思路三、FCM算法核心代码的python实现四、使用示例1.对数据进行聚类2.图片分割五、实现时出现的错误总结六、源码链接 一、理论介绍 二、算法实现思路 下面给出该算法的基本思路: ...
  •     模糊c均值聚类融合了模糊理论的精髓。相较于k-means的硬聚类,模糊c提供了更加灵活的聚类结果。因为大部分情况下,数据集中的对象不能划分成为明显分离的簇,指派一个对象到一个特定的簇有些生硬,也可能会...
  • 关于聚类问题的算法python代码实现-K-均值聚类方法
  • python3模糊C均值聚类算法,数据集为iris,放在和代码同一目录即可。算法原理及步骤参考:https://wenku.baidu.com/view/ee968c00eff9aef8941e06a2.html
  • Fuzzy C-Means算法原理 算法步骤 python实现 参考资料 本文采用数据集为iris,将iris.txt放在程序的同一文件夹下。请先自行下载好。 模糊理论 模糊控制是自动化控制领域的一项经典方法。其原理则是模糊数学、...
  • 模糊c均值聚类算法原理详细讲解

    万次阅读 多人点赞 2020-11-29 15:27:53
    模糊c均值聚类算法详细讲解python(一)聚类和模糊简述(二)模糊c均值聚类原理(1)目标函数(三)模糊c均值聚类算法步骤 (一)聚类和模糊简述 聚类分析是多元统计分析的一种,也是无监督模式识别的一个重要分支,...
  • 针对传统的模糊C均值聚类算法(FCM)在图像分割中对噪声十分敏感这一局限性,提出一种自适应的FCM图像分割方法。该方法充分考虑图像像素的灰度信息和空间信息,根据像素的空间位置自适应地计算一个合适的相似度距离...
  • C均值聚类算法

    万次阅读 多人点赞 2019-06-28 14:18:03
    请使用C均值聚类方法对数据集进行聚类,给每个样本一个类别标签,并画出聚类结果(参考图trainning sample的画法),并与其真实标签(在truelabel.mat中)进行对比,计算聚类的准确率; 3.算法思想 采用距离作为...
  • Python实现C-均值聚类

    2020-12-04 13:10:30
    C): currentCenter=centers[j] if mp[i][currentCenter][i][currentCenter] index=j result[index].append(i) return result #C均值聚类 def Cmeans(data,P,C): #获取距离列表,初始类心和初始聚类结果 mp=[...
  • 聚类算法中 K均值聚类(KMeans)的python实现 ** import numpy as np import matplotlib.pyplot as plt from sklearn.datasets.samples_generator import make_blobs from sklearn import cluster from sklearn....
  • 无监督学习的数据集中没有输出标签y,常用的无监督学习算法聚类和降维。 概要 聚类人有归纳和总结的能力,机器也有。聚类就是让机器把数据集中的样本按照特征的性质分组,这个过程中没有标签的存在。 聚类和...
  • k-均值聚类Python代码实现

    千次阅读 2018-02-10 17:25:09
    k-均值聚类Python代码实现
  • 模式识别学习,课程实例分享。...其中,C均值算法聚类准则是以最小欧式距离方法,将每个点分配到最近的聚类中来实现的。 本节主要分成两个测试小节来描述C均值算法的特性,并用三维图像模型对聚类效果进行直观展示...
  • K-Means聚类算法原理 """ K-means impl, take square for example @Author: JiananYuan @Date: 2021/12/14 """ import random import matplotlib.pyplot as plt import numpy as np def check_consistent(last_...
  • 聚类算法python实现——模糊C均值(FCM) 模糊C和K均值的区别 K均值:硬聚类,隶属度只有0和1,基于“类内误差平方和最小化”原则 模糊C:模糊聚类,隶属度取值为[0,1],基于“类内加权误差平方和最小化”原则 步骤...
  • Python k-均值聚类算法二维实例

    千次阅读 2018-02-10 21:44:56
    k-均值聚类算法二维实例,不多解释,解释就是掩饰,复制粘贴即可运行。 import time import numpy as np import random import matplotlib.pyplot as plt import operator def func01(): #生成二维随机点 #...
  • 模糊局部信息c均值聚类算法(flicm) ** 下面是 flicm。 function [u_flicm,vi_flicm,out_flicm]=flicm(m,n,c,vi,img,mc) [ui,vi]=fcm(m,n,c,vi,img,mc);%%使用fcm对隶属度U以及聚类中心进行初始化 ee=0.1;kk=0; ...
  • 模糊C均值聚类算法

    2021-10-04 14:31:46
    关于算法的原理,大家可以看这篇博客:聚类分析之模糊C均值算法核心思想,注意博客中有关隶属度计算的公式有点小问题,这里更正如下: Wij=(1/dist⁡(xi,cj)2)1p−1/∑q=1k(1/dist⁡(xi,cq)2)1p−1W _ { i j } = ( 1...
  • 1. 初始化类中心,从样本中随机选取K个点作为初始的聚类中心点def kMeansInitCentroids(X,K):m = X.shape[0]m_arr = np.arange(0,m) # 生成0-m-1centroids = np.zeros((K,X.shape[1]))np.random.shuffle(m_arr) # ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,401
精华内容 2,960
关键字:

c均值聚类的python算法