模糊领域粗糙集(FNRS)

文章目录

• 前言
• 一、FNRS是什么？
• 二、使用步骤
• 三、总结

---

前言

需要复现模糊领域粗糙集(FNRS)算法作为对比算法。

算法来源：C.Z. Wang, M.W. Shao, Q. He, Y. Qian, Y.L. Qi, Feature subset selection based on fuzzy neighborhood rough sets, Knowl.-Based Syst. 111 (2016) 173–179.

一、FNRS是什么？

二、使用步骤

2.1 引入库

from sklearn.preprocessing import MinMaxScaler
from sklearn.preprocessing import LabelEncoder 
from itertools import product
import numpy as np 
import pandas as pd 
import skfuzzy as fuzz
import numba as nb 

2.2 读入数据

使用鸢尾花数据集Iris进行验证

# 读取数据
data = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', header=None, names=['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'class'])
le = LabelEncoder()
for col in data.columns:
    if data[col].dtype == 'object':
        data[col] = le.fit_transform(data[col])
decision_table = data.to_numpy() 
data = decision_table[:,[0,1,2,3]]
U = decision_table[:,4]

array = np.array(data)
array = gaussian(array) # 模糊化处理:获取模糊相似关系矩阵
n,m = array.shape

2.3 函数功能

# 高斯隶属度函数
def gaussian(x):
    #x = np.array(x) 
    # 按列计算均值和标准差
    means = x.mean(axis=0)
    stds = x.std(axis=0)
    for column in range(len(means)):
        x[:,column] = np.exp(-np.power(x[:,column] - means[column], 2) / (2 * np.power(stds[column], 2)))
    return x



@nb.jit(nopython=True) 
def get_FSR_All_Ai(array):
    FSR_All_Ai = np.zeros((m,n,n))  
    for k in range(m):  # 每个属性
        for i in range(n):
            for j in range(i + 1, n):  # 只计算上三角矩阵
                value = min(array[:, k][i] , array[:, k][j])
                FSR_All_Ai[k][i][j] = value
                FSR_All_Ai[k][j][i] = value  # 对称赋值
    return FSR_All_Ai

@nb.jit(nopython=True)
def Fuzzy_relation_matrix_A(array): 
    FSR_A = np.zeros((n, n))  # 相似度矩阵
    # 计算属性之间的相似度
    for i in range(n):
        FSR_A[i, i]=1
        for j in range(i+1,n):
            FSR_A[i, j] = np.minimum(array[i],array[j]).min()
            FSR_A[j, i] = FSR_A[i, j]
    return FSR_A

# @nb.jit(nopython=True)
def fuzzy_decisions(FSR_A,true_class):
    #true_class = tuple([np.where(U==i)[0]  for i in set(U)])
    fuzzy_class = np.zeros((len(set(U)),n))  
    for Di in range(fuzzy_class.shape[0]):
        for xi in range(n):
            fuzzy_class[Di][xi]=sum(np.take(FSR_A[xi],true_class[Di]))/sum(FSR_A[xi])
    return fuzzy_class

@nb.jit(nopython=True)
def Fuzzy_relation_matrix_Ai(FSR_All_Ai,lamda):
    FSR_Part_Ai = np.zeros((n, n))  # 相似度矩阵
    # 计算属性之间的相似度
    for i in range(n):
        FSR_Part_Ai[i, i]=1
        for j in range(i+1,n):
            min_values = np.min(FSR_All_Ai[:,i,j])
            if min_values>=lamda:
                FSR_Part_Ai[i, j] = FSR_A[i, j]
                FSR_Part_Ai[j, i] = FSR_A[i, j]  # 对称赋值
                # FSR_Part_Ai[i, j] = min_values
                # FSR_Part_Ai[j, i] = min_values
    return FSR_Part_Ai

# @nb.jit(nopython=True)
def fuzzy_decisions_Ai(FSR_Ai,fuzzy_class_A,true_class,alpha):
    '''
    希望各位同学朋友能够关注、评论
    后续私聊，会发完整算法。
    '''
    pass
    

2.4 运行

results = []
true_class = np.array(tuple([np.where(U==i)[0]  for i in set(U)]))
FSR_All_Ai = get_FSR_All_Ai(array)
FSR_A = Fuzzy_relation_matrix_A(array)
fuzzy_class_A = fuzzy_decisions(FSR_A,true_class)

for lamda in np.arange(0.1, 0.55, 0.05):
    for alpha in np.arange(0.5, 1.05, 0.05):
        result = []
        print("lamda：",lamda,"alpha：",alpha)
        result.extend([lamda,alpha])

        R = []
        B = [i for i in range(m) if i not in R]
        dependency_R = 0
        Start = True
        while Start:
            dependencys = np.zeros((m)) 
            for ai in B:
                R.append(ai) 
                FSR_Part_Ai = Fuzzy_relation_matrix_Ai(FSR_All_Ai[R,:,:],lamda=lamda)
                dependency_Ai_la = fuzzy_decisions_Ai(FSR_Part_Ai,fuzzy_class_A,true_class,alpha=alpha)
                dependencys[ai]=dependency_Ai_la
                R.remove(ai)
            max_index = np.argmax(dependencys)
            if dependencys[max_index]>dependency_R:
                dependency_R = dependencys[max_index]
                R.append(max_index)
                B.remove(max_index)
                #print("已接受",max_index)
            else:Start=False
            print(dependencys,R)


        print("约简结果：",R,"\n\n")
        result.append(R)
        results.append(result)

2.5 约简结果

第一个数值是lamda，第二个数值是alpha，最后一个是约简结果。

不同的参数取值，结果也会不一样。

三、总结

使用python复现模糊领域粗糙集(FNRS)，如有问题可点赞，评论私信交流。

算法可直接调用，使用不同的UCI数据集作为对比算法之一。