模糊C均值(FCM)python实现

模糊C均值聚类算法是一种常用的无监督分类方法,广泛的应用于数据挖掘领域中,主要融合了K均值聚类算法和模糊理论,算法步骤如下所示:
在这里插入图片描述
Python实现

import torch
import random
import numpy as np
from sklearn import datasets


def FCM(data, N_way, iteration):
    # data : N*S, N为样本数,S为特征维数,tensor
    # N_way : 类别数
    #iteration:迭代次数
    #初始化
    N = data.shape[0]
    U = torch.rand(N_way, N)       #C*N,C为类别,N为样本
    for i in range(N):
        U[:,i] = U[:,i]/(U[:,i].sum())
    index = range(N)
    C = data[random.sample(index, N_way),:]        #C*S,C为类别,N为样本
    D = torch.zeros(N_way, N)                      #样本和类中心的距离矩阵


    count = 0
    #循环迭代
    while True:
        #计算聚类中心
        u = 1/U.sum(dim=1).reshape((N_way,1))
        c = torch.mm(U,data)
        C = c*u
        #更新划分矩阵
        for i in range(N_way):
            c_i = C[i,:]
            c_i = c_i.unsqueeze(0).expand(N, -1)
            d = (c_i - data)*(c_i - data)
            d = d.sum(dim=1)
            D[i,:] = d
        for i in range(N):
            mid = D[:,i]
            U[:,i] = D[:,i].sum()/D[:,i]
            U[:, i] = U[:, i] / (U[:, i].sum())
        #判断是否满足终止条件
        if(count>iteration):
            break
        count += 1
        #或者根据U(count+1)-U(count)判断
    return U,C


if __name__ == '__main__':
    iris = datasets.load_iris()
    n_sample, n_feature = iris.data.shape
    data = iris.data
    data = data.astype(np.float32)
    data = torch.from_numpy(data)
    U,C = FCM(data,3,100)
    label = iris.target
    count = 0
    for i in range(150):
        pre = torch.max(U[:,i],0)[1]
        print(pre)
        if pre==label[i]:
            count += 1

    print(count)

蝙蝠算法(Bat Algorithm)是一种基于自然界蝙蝠的行为模式而设计的优化算法,其主要思想是通过模拟蝙蝠的寻食过程,实现在搜索空间找到全局最优解的目标。而模糊C均值聚类(FCM)则是一种基于模糊理论的聚类算法,其主要思想是通过将每个数据点分配到多个不同的聚类心,从而实现对数据点的分类。 在Python,可以使用以下代码实现蝙蝠算法优化模糊C均值聚类: ```python import numpy as np import skfuzzy as fuzz # 定义蝙蝠算法参数 N = 20 # 蝙蝠数量 A = 0.9 # 脉冲率 r = 0.1 # 响度 fmin = 0 # 最小频率 fmax = 2 # 最大频率 alpha = 0.9 # 声波常数 # 定义模糊C均值聚类参数 m = 2 # 模糊度 e = 0.01 # 收敛阈值 max_iter = 1000 # 最大迭代次数 # 初始化蝙蝠位置和速度 x = np.random.rand(N, 2) # N个点在2维空间的位置 v = np.zeros_like(x) # 初始速度为0 # 计算每个点的适应度 def fitness(x): cntr, u, _, _, _, _, _ = fuzz.cluster.cmeans(data.T, 3, m, error=e, maxiter=max_iter, init=x.T) d = np.linalg.norm(data[:, np.newaxis, :] - cntr, axis=2) J = np.sum(u ** m * d ** 2) return 1 / (1 + J) # 初始化最优解和最优适应度 best_x = x[0] best_fit = fitness(x[0]) # 开始迭代 for t in range(max_iter): # 计算每个蝙蝠的频率和速度 f = fmin + (fmax - fmin) * np.random.rand(N) v = v + (x - best_x) * f[:, np.newaxis] x = x + v # 对每个蝙蝠进行随机扰动 for i in range(N): if np.random.rand() > A: x[i] = best_x + r * np.random.randn(2) # 计算每个蝙蝠的适应度 fit = np.array([fitness(xi) for xi in x]) # 更新最优解和最优适应度 idx = np.argmax(fit) if fit[idx] > best_fit: best_x = x[idx] best_fit = fit[idx] # 更新每个蝙蝠的位置和速度 v = alpha * v + (best_x - x) * np.random.randn(N, 2) x = x + v # 输出当前迭代次数和最优适应度 print("Iteration %d: Best Fitness = %f" % (t+1, best_fit)) ``` 在上述代码,我们首先定义了蝙蝠算法模糊C均值聚类的参数,然后初始化蝙蝠的位置和速度。接着,我们定义了一个适应度函数`fitness(x)`,用于计算每个点的适应度。在每次迭代,我们根据蝙蝠的频率和速度更新其位置和速度,并随机扰动一些蝙蝠的位置。然后,我们计算每个蝙蝠的适应度,并更新最优解和最优适应度。最后,我们根据更新后的速度和最优解更新每个蝙蝠的位置和速度,并输出当前迭代次数和最优适应度。 需要注意的是,在本例,我们使用模糊C均值聚类来计算每个点的适应度,因此需要导入skfuzzy库。此外,我们使用了numpy库来进行向量和矩阵的计算。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值