1 skope-rules

偶然发现的好东西：Skope-rules是一个基于逻辑规则的Python机器学习模块，官网介绍：skope-rules。

根据第一个网址鸢尾花实例修改的西瓜数据集实例：

from sklearn.utils import Bunch
from skrules import SkopeRules
from openpyxl import load_workbook
import numpy as np

# 读取数据集
def readDataSet():
    FeatureNames = []
    FeatureList = []
    LabelList = []

    wb = load_workbook('E:\My Word\study\RL0504\西瓜.xlsx')
    sheet1 = wb.worksheets[4]  # 获取第4张sheet 模糊化以后的数据集

    # 迭代读取所有的行
    cnt = 0
    for row in sheet1.rows:
        row_val = [col.value for col in row]
        if cnt == 0:
            FeatureNames = row_val[0:len(row_val) - 1]
        else:
            FeatureList.append(row_val[0:len(row_val) - 1])
            LabelList.append(row_val[-1])
        cnt = cnt + 1

    print(FeatureNames)
    print(FeatureList)
    print(LabelList)

    return Bunch(
        data=FeatureList,
        target=LabelList,
        feature_names=FeatureNames,
    )


def main():
    watermelon = readDataSet()  # 读取模糊化数据集

    target_names = ['好瓜', '坏瓜']
    feature_names = watermelon.feature_names
    clf = SkopeRules(max_depth_duplication=2,
                     n_estimators=30,
                     precision_min=0.3,
                     recall_min=0.1,
                     feature_names=feature_names)

    for idx, species in enumerate(target_names):
        X, y = watermelon.data, np.array(watermelon.target)
        clf.fit(X, y == idx)
        rules = clf.rules_[0:3]
        print("Rules for watermenlon", species)
        for rule in rules:
            print(rule)
        print()
        print(20 * '=')
        print()


if __name__ == "__main__":
    main()

运行结果：
rules运行结果
感觉可以借助规则学习的一些算法帮助我找到模糊决策的一些根本规则。

2 修改代码时遇到的问题

列向量转换为行向量：np.array(watermelon.target)，或者说是列表与数组之间的转换。
判断列表或者数组中的元素种类set()函数的使用：list(set(LabelList))。

3 多标签数据集信息熵计算

想要分析一些多标签的数据集，发现自己不会算多标签的数据集的信息熵和信息增益。参照的是这篇博客：决策树中的信息熵+鸢尾花数据集举例。
实现代码：

# 计算数据集的信息熵
def cal_entD(target, target_names):
    sumD = len(target)
    entD = 0
    for i in range(len(target_names)):
        sumi = target.count(target_names[i])
        pi = sumi / sumD
        entD = entD - pi * math.log2(pi)
    #     print(sumi, sumD, pi)
    # print(entD)
    return entD
    
# 计算单列属性的信息熵，如计算C1_L时的信息熵
def cal_Ak(data, target, target_names, index):
    sumAk = 0
    sumTarget = [0, 0, 0, 0, 0, 0, 0]
    for i in range(len(data)):
        if data[i][index] != 0:
            sumAk = sumAk + data[i][index]
            if target[i] == 0:
                sumTarget[0] = sumTarget[0] + 1 * data[i][index]
            elif target[i] == 1:
                sumTarget[1] = sumTarget[1] + 1 * data[i][index]
            elif target[i] == 2:
                sumTarget[2] = sumTarget[2] + 1 * data[i][index]
            elif target[i] == 3:
                sumTarget[3] = sumTarget[3] + 1 * data[i][index]
            elif target[i] == 4:
                sumTarget[4] = sumTarget[4] + 1 * data[i][index]
            elif target[i] == 5:
                sumTarget[5] = sumTarget[5] + 1 * data[i][index]
            elif target[i] == 6:
                sumTarget[6] = sumTarget[6] + 1 * data[i][index]
    # print(sumAk)
    # print(sumTarget)
    entAk = 0
    for i in range(len(target_names)):
        if sumTarget[i] != 0:
            entAk = entAk - (sumTarget[i] / sumAk) * math.log2(sumTarget[i] / sumAk)
            # print(i, entAk)

    entDV_D = sumAk / len(target) * entAk
    print(sumAk, len(data), entAk, entDV_D)
    return Bunch(
        sumAk=sumAk,
        entAk=entAk,
        entDV_D=entDV_D
    )