日常学习记录——skope-rules

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()

运行结果：

感觉可以借助规则学习的一些算法帮助我找到模糊决策的一些基本规则。

2 修改代码时遇到的问题

1. 列向量转换为行向量：np.array(watermelon.target)，或者说是列表与数组之间的转换。
2. 判断列表或者数组中的元素种类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
    )

计算属性子集的信息增益时，感觉还是不太熟练，所以代码的可迁移性不强，进行代码迁移时需要结合数据集特点进行修改。

今日总结

1、今天发现了skope-rules逻辑规则模块，算是一件值得高兴的事情，有了这些参照我就可以根据严谨的算法流程对一些分类规则进行总结和推导。但是对于算法的流程还不太理解，所以生成的结果又是过于理想化了，不能直接使用。

2、其次的话，能看懂西瓜书上的一些数学公式了，是一个很大的进步。