不确定性计算之粗糙集属性约简

灰太狼 2023-02-27 05:38 10阅读 0赞

# 粗糙集属性约简 #

**本实验同时采用区别矩阵和依赖度约简。  
在依赖度约简中，设置依赖度计算函数和相对约简函数，对读取的数据进行处理，最后根据依赖度约简。  
在读取数据后判断有无矛盾，若有则进行决策表分解，然后进行区别矩阵约简得到约简后的条件属性。**

**区分矩阵代码如下：**

import xlrd #读取Excel的扩展工具
    from copy import deepcopy
    import numpy as np#numerical python
    from pprint import pprint
    import itertools
    
    def read_excel(path):
        #打开excel
        x_matrix = []
        workbook = xlrd.open_workbook(path,'r') 
        table = workbook.sheets()[0] 
        for rown in range(1,table.nrows):
            x_matrix.append(table.row_values(rown))
        x_matrix = np.array(x_matrix)
        #print(x_matrix)
        return x_matrix
    
    #决策表分解
    def divide(matrix):
        len_attribute = len(matrix[0])-1
        matrix_delete = []
        #print(len(matrix))
        #决策表分解
        for j in range(len(matrix)):
            for k in range(j,len(matrix)):
                if ((matrix[j][0:len_attribute] == matrix[k][0:len_attribute]).all() and matrix[j][len_attribute] != matrix[k][len_attribute]):
                    matrix_delete.append(list(matrix[j]))
                    matrix_delete.append(list(matrix[k]))
                    matrix = np.delete(matrix,k,axis=0)
                    matrix = np.delete(matrix,j,axis=0)
        if(len(matrix_delete)):
            print('矛盾:',matrix_delete)
        else:
            print('不存在矛盾数据！')
            print('-------------------------------------------')
        
        if(len(matrix)):
            print('完全一致表:')
            pprint(matrix)
            deal(matrix)
        else:
            print('不存在完全一致表:')
    
        if(len(matrix_delete)):
            print('完全不一致表:')
            print(matrix_delete)
    
    #约简
    def deal(matrix):
        matrix_T = matrix.T
        number_sample = len(matrix)#样本数量
        number_attribute = len(matrix_T)-1#属性数量
        attribute = ['年龄','收入','学生','信誉']
        # 二维列表的创建：
        excel = [[ [] for col in range(number_sample)] for row in range(number_sample)] 
        pprint(matrix)
        #比较各样本哪些属性的值不同（只对决策属性不同的个体进行比较）
        for k in range(len(attribute)):#属性
            for i in range(number_sample):#第几个样本
                for j in range(i,number_sample):
                    if(matrix[i][k] != matrix[j][k] and matrix[i][number_attribute] != matrix[j][number_attribute]):
                        excel[i][j].append(attribute[k])
        for i in range(number_sample):
            for j in range(i,number_sample):
                excel[j][i] = set(excel[i][j])
                excel[i][j] = {
        }
        #pprint(excel)#excel
        yuejian = []
        for i in range(number_sample):
            for j in range(number_sample):
                if(excel[i][j] and excel[i][j] not in yuejian):
                    yuejian.append(excel[i][j])
        print(yuejian)
        #约简
        i=0
        j=0
        k=len(yuejian)#k=6
        for i in range(k):
            for j in range(k):
                if(yuejian[i] > yuejian[j]):#i更大，应该删除i
                    yuejian[i] = yuejian[j]
                if(yuejian[i] & yuejian[j]):
                    yuejian[i] = yuejian[i] & yuejian[j]
                    yuejian[j] = yuejian[i] & yuejian[j]
        '''
        #print(yuejian)
        #去重
        yuejian_new = []
        for id in yuejian:
            if id not in yuejian_new:
                yuejian_new.append(id)
        yuejian = yuejian_new
        '''
        #print('约简为:',yuejian)
        #print('yuejian:',yuejian)
        #类似于笛卡儿积
        flag = 0
        result =[]
        for i in yuejian:
            if (len(i) > 1):
                flag = 1
        if(flag == 1):#将集合分解开，逐个取其与其他集合的并集
            simple = yuejian[0]
            nosimple = deepcopy(yuejian)
            i=0
            while (i < len(nosimple)):
                if(len(nosimple[i]) == 1):
                    simple = simple | nosimple[i]
                    nosimple.pop(i)
                else:
                    i = i + 1
            for i in range(len(nosimple)):
                nosimple[i] = list(nosimple[i])
            simple = list(simple)
            
            for i in range(len(nosimple)):
                for j in range(len(nosimple[i])):
                    simple_temp = deepcopy(simple)
                    simple_temp.append(nosimple[i][j])
                    result.append(simple_temp)
        else:
            simple = yuejian[0]
            for i in yuejian:
                simple = simple | i#如果只有单元素，则将取其与其他集合的并集
            result.append(list(simple))
        print(result)
        #约简矩阵的各属性的样本值
        matrix_new = []
        for i in range(len(result)):
            matrix_new.append([])
        for i in range(len(result)):
            for j in range(len(result[i])):
                for k in range(len(attribute)):
                    if(result[i][j] == attribute[k]):
                        matrix_new[i].append(list(matrix_T[k]))
        #输出
        for i in range(len(matrix_new)):
            print('------------------------------------')
            print('序号 ',end='')
            for j in range(len(result[i])):
                print(result[i][j],'',end='')
            print(' 归类：买计算机?')
            for j in range(len(matrix_new[0][0])):
                print(j+1,end = '    ')
                for k in range(len(result[i])):
                    print(matrix_new[i][k][j], end = '   ')
                print(' ',matrix[j][number_attribute])
    
    if __name__ == '__main__':
        path = 'data.xlsx'
        # 读取数据
        matrix = read_excel(path)
        #deal(matrix)
        divide(matrix)

**依赖度约简代码如下：**

from copy import deepcopy
    import numpy as np
    import pandas as pd
    import xlrd
    from pprint import pprint
    from itertools import combinations, permutations
    import random
    
    #import 决策函数
    def basic_set(df):
        basic = {
        }
        for i in df.drop_duplicates().values.tolist():
            basic[str(i)] = []
            for j, k in enumerate(df.values.tolist()):
                if k == i:
                    basic[str(i)].append(j)
        return basic
    
    def divide():
        path = 'data.xlsx'
        global matrix,mistake
        matrix = read_excel(path)
        len_attribute = len(matrix[0])-1
        matrix_delete = []
        #决策表分解
        mistake = []
        
        for j in range(len(matrix)):
            for k in range(j,len(matrix)):
                if ((matrix[j][0:len_attribute] == matrix[k][0:len_attribute]).all() and matrix[j][len_attribute] != matrix[k][len_attribute]):
                    matrix_delete.append(list(matrix[j]))
                    matrix_delete.append(list(matrix[k]))
                    matrix = np.delete(matrix,k,axis=0)
                    matrix = np.delete(matrix,j,axis=0)
                    mistake.append(j)
                    mistake.append(k)
    
        if(len(matrix_delete)):
            print('矛盾:',matrix_delete)
        else:
            print('不存在矛盾数据！')
            print('-------------------------------------------')
        if(len(matrix)):
            print('完全一致表:')
            pprint(matrix)
        else:
            print('不存在完全一致表:')
    
        if(len(matrix_delete)):
            print('完全不一致表:')
            print(matrix_delete)
        
    def intersection_2(someone_excel):
        x_list = someone_excel[0]
        y_list = someone_excel[1]
        #print(x_list)
        #print(y_list)
        x_set = [[]]*len(x_list)
        for i in range(len(x_list)):
            x_set[i] = set(x_list[i])
    
        y_set = [[]]*len(y_list)
        for i in range(len(y_list)):
            y_set[i] = set(y_list[i])
    
        a = []
        for  i in range(len(x_list)):
            for  j in range(len(y_list)):
                if(x_set[i] & y_set[j]):
                    a.append(x_set[i] & y_set[j])
        return a
    
    def intersection(excel_temp):
        if (len(excel_temp)>1):
            a = intersection_2([excel_temp[0],excel_temp[1]])
            for k in range(2,len(excel_temp)):
                a = intersection([a,excel_temp[k]])
        else:
            a = excel_temp[0]
        return a
    
    # 收集属性依赖性
    def dependence_degree(x_list):
        count = 0 
        for i in x_list:
            for j in y_basic_list:
                if(set(i) <= set(j)):
                    count = count + len(i)
        degree = round(count/len(x_data),4)
        return degree
    
    def yilaidu_fun(k):
        excel_temp = list(combinations(excel,k))#排列组合数
        title_temp = list(combinations(title,k))
        for i in range(len(title_temp)):
            excel_temp[i] = list(excel_temp[i])
            title_temp[i] = list(title_temp[i])
        #print('title_temp:',title_temp)
        #print(excel_temp)
        a = []
        for i in range(len(excel_temp)):
            temp = intersection(excel_temp[i])
            #print(temp)
            print(title_temp[i],end=' ')
            print('依赖度:',dependence_degree(temp))
            if (dependence_degree(temp) == 1):
                a.append(set(title_temp[i]))
        #print(a)
        return a
    
    def deal(data):
        data = data.dropna(axis=0, how='any')
        for i in sorted(mistake , reverse=True):
            data.drop(data.index[i], inplace=True)
        #使用pandas的loc来读取并把各属性值赋给变量（loc通过行标签索引数据）
        age_data = data.loc[:, 'C1']
        age_basic_list = sorted([v for k, v in basic_set(age_data).items() ])
        #print('age:',age_basic_list)
    
        income_data = data.loc[:, 'C2']
        income_basic_list = sorted([v for k, v in basic_set(income_data).items()])
        #print('income:',income_basic_list)
    
        student_data = data.loc[:, 'C3']
        student_basic_list = sorted([v for k, v in basic_set(student_data).items() ])
        #print('student_data',student_data)
    
        credit_data = data.loc[:, 'C4']
        credit_basic_list = sorted([v for k, v in basic_set(credit_data).items()])
        #print('student',credit_basic_list)
        
        global x_data,y_data,y_basic_list,excel
        x_data = data.drop(['judge'], axis=1)
        y_data = data.loc[:, 'judge']
        # 决策属性基本集
        y_basic_list = sorted([v for k, v in basic_set(y_data).items() ])
        #print(y_basic_list)
    
        excel = []
        excel.append(age_basic_list)
        excel.append(income_basic_list)
        excel.append(student_basic_list)
        excel.append(credit_basic_list)
        #print(excel)
    
        yilaidu = []
        for i in range(1,len(matrix)+1):
            yilaidu.extend(yilaidu_fun(i))
        print('依赖度为1的属性有:',yilaidu)
        #print(yilaidu)
        
        #约简
        i=0
        j=0
        k=len(yilaidu)#k=6
        for i in range(k):
            for j in range(k):
                if(yilaidu[i] > yilaidu[j]):#i更大，应该删除i
                    yilaidu[i] = yilaidu[j]
        #去重
        yilaidu_new = []
        for i in yilaidu:
            if i not in yilaidu_new:
                yilaidu_new.append(i)
        for i in range(len(yilaidu_new)):
            yilaidu_new[i] = sorted(list(yilaidu_new[i]))
        result = yilaidu_new
    
        #各约简属性的属性值
        matrix_new = []
        for i in range(len(result)):
            matrix_new.append([])
        for i in range(len(result)):
            for j in range(len(result[i])):
                for k in range(len(title)):
                    if(result[i][j] == title[k]):
                        matrix_new[i].append(list(matrix_T[k]))
    
        for i in range(len(matrix_new)):
            print('------------------------------------')
            print('序号 ',end='')
            for j in range(len(result[i])):
                print(result[i][j],'',end='')
            print('归类：买计算机?')
            for j in range(len(matrix_new[0][0])):
                print(j+1,end='    ')
                for k in range(len(result[i])):
                    print(matrix_new[i][k][j], end = '  ')
                print(' ',matrix[j][len(matrix[0])-1])
        if(result == []):
            print('  年龄 收入 学生 信誉 归类：买计算机？')
            print(matrix)
    
    def read_excel(path):
        #打开excel
        x_matrix = []
        workbook = xlrd.open_workbook(path,'r') 
        table = workbook.sheets()[0] 
        for rown in range(1,table.nrows):
            x_matrix.append(table.row_values(rown))
        x_matrix = np.array(x_matrix)
        #print(x_matrix)
        return x_matrix
    
    def main():
        #读取文件数据
        data = pd.read_csv(filepath_or_buffer='data.CSV',encoding='unicode_escape')
        divide()
        global matrix_T 
        matrix_T = matrix.T
        len = data.iloc[:,0].size
        #数据集
        arr = data.iloc[0:len]
        global title 
        title= ['年龄','收入','学生','信誉']
        deal(arr)
    
    if __name__ == '__main__':
        main()

**测试表格如下：**  
![在这里插入图片描述][20200716131842820.png]

[20200716131842820.png]: /images/20230209/524b0524d8ba45419baace5c0a5329b5.png