人工智能实验四决策树实验

最新推荐文章于 2024-04-30 20:17:27 发布

安静的火

最新推荐文章于 2024-04-30 20:17:27 发布

阅读量507

点赞数 8

文章标签：人工智能决策树算法 python

本文链接：https://blog.youkuaiyun.com/m0_63093530/article/details/137491449

版权

将下面的文件按下图方式放置：

test_data.csv

色泽,根蒂,敲声,纹理,脐部,触感,好瓜
青绿,蜷缩,沉闷,清晰,凹陷,硬滑,1
浅白,蜷缩,浊响,清晰,凹陷,硬滑,1
乌黑,稍蜷,浊响,清晰,稍凹,硬滑,1
乌黑,稍蜷,沉闷,稍糊,稍凹,硬滑,0
浅白,硬挺,清脆,模糊,平坦,硬滑,0
浅白,蜷缩,浊响,模糊,平坦,软粘,0
青绿,稍蜷,浊响,稍糊,凹陷,硬滑,0

train_data.csv

色泽,根蒂,敲声,纹理,脐部,触感,好瓜
青绿,蜷缩,浊响,清晰,凹陷,硬滑,1
乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,1
乌黑,蜷缩,浊响,清晰,凹陷,硬滑,1
青绿,稍蜷,浊响,清晰,稍凹,软粘,1
乌黑,稍蜷,浊响,稍糊,稍凹,软粘,1
青绿,硬挺,清脆,清晰,平坦,软粘,0
浅白,稍蜷,沉闷,稍糊,凹陷,硬滑,0
乌黑,稍蜷,浊响,清晰,稍凹,软粘,0
浅白,蜷缩,浊响,模糊,平坦,硬滑,0
青绿,蜷缩,沉闷,稍糊,稍凹,硬滑,0

123.py

# 导入模块
import pandas as pd
import numpy as np
import os
from collections import Counter
from math import log2
#ID3算法

"""
功能：从给定的文件路径读取Excel文件，并返回pandas的DataFrame对象。
输入：filePath（文件路径）。
输出：DataFrame对象，包含Excel文件中的数据。
"""
def getData(filePath):
    data = pd.read_excel(filePath)
    return data

"""
功能：处理DataFrame数据，去掉第一列（通常是索引或ID列），并转换为列表的列表（即二维列表）形式。
输入：data（DataFrame对象）。
输出：处理后的二维列表。
"""
def dataDeal(data):
    dataList = np.array(data).tolist()
    dataSet = [element[1:] for element in dataList]
    return dataSet

"""
功能：从DataFrame中提取除第一列和最后一列外的所有列标签（特征标签）。
输入：data（DataFrame对象）。
输出：特征标签的列表。
"""
def getLabels(data):
    labels = list(data.columns)[1:-1]
    return labels

"""
功能：从数据集中提取所有不同的目标类别。
输入：dataSet（二维列表形式的数据集）。
输出：包含所有不同目标类别的集合。
"""
def targetClass(dataSet):
    classification = set([element[-1] for element in dataSet])
    return classification

"""
功能：使用多数投票规则确定数据集中最常见的目标类别。
输入：dataSet（二维列表形式的数据集）。
输出：最常见的目标类别。
"""
def majorityRule(dataSet):
    mostKind = Counter([element[-1] for element in dataSet]).most_common(1)
    majorityKind = mostKind[0][0]
    return majorityKind

"""
功能：计算数据集的信息熵，用于衡量数据集的混乱程度。
输入：dataSet（二维列表形式的数据集）。
输出：数据集的信息熵。
"""
def infoEntropy(dataSet):
    classColumnCnt = Counter([element[-1] for element in dataSet])
    Ent = 0
    for symbol in classColumnCnt:
        p_k = classColumnCnt[symbol] / len(dataSet)
        Ent = Ent - p_k * log2(p_k)
    return Ent

"""
功能：根据给定的属性值，从数据集中筛选出具有该属性值的所有行。
输入：dataSet（二维列表形式的数据集）、value（属性值）、iColumn（属性所在的列索引）。
输出：筛选后的二维列表。
"""
def makeAttributeData(dataSet, value, iColumn):
    attributeData = []
    for element in dataSet:
        if element[iColumn] == value:
            row = element[:iColumn]
            row.extend(element[iColumn + 1:])
            attributeData.append(row)
    return attributeData

"""
功能：计算按照某列属性划分数据集后得到的信息增益。信息增益用于衡量按该属性划分数据后，数据集混乱程度的减少量。
输入：dataSet（二维列表形式的数据集）、iColumn（属性所在的列索引）。
输出：按该属性划分数据集后的信息增益。
"""
def infoGain(dataSet, iColumn):
    Ent = infoEntropy(dataSet)
    tempGain = 0.0
    attribute = set([element[iColumn] for element in dataSet])
    for value in attribute:
        attributeData = makeAttributeData(dataSet, value, iColumn)
        tempGain = tempGain + len(attributeData) / len(dataSet) * infoEntropy(attributeData)
        Gain = Ent - tempGain
    return Gain

"""
功能：选择最优的划分属性，即信息增益最大的属性。
输入：dataSet（二维列表形式的数据集）、labels（特征标签的列表）。
输出：最优划分属性的列索引。
"""
def selectOptimalAttribute(dataSet, labels):
    bestGain = 0
    sequence = 0
    for iColumn in range(0, len(labels)):  # 不计最后的类别列
        Gain = infoGain(dataSet, iColumn)
        if Gain > bestGain:
            bestGain = Gain
            sequence = iColumn
        print(labels[iColumn], Gain)
    return sequence

"""
这个函数是构建决策树的核心。它接受两个参数：
dataSet：包含样本的数据集，每个样本是一个特征向量。
labels：与dataSet中每个样本的特征向量对应的标签列表。
"""
def createTree(dataSet, labels):
    classification = targetClass(dataSet)  # 获取类别种类（集合去重）
    if len(classification) == 1:
        return list(classification)[0]
    if len(labels) == 1:
        return majorityRule(dataSet)  # 返回样本种类较多的类别
    sequence = selectOptimalAttribute(dataSet, labels)
    print(labels)
    optimalAttribute = labels[sequence]
    del (labels[sequence])
    myTree = {optimalAttribute: {}}
    attribute = set([element[sequence] for element in dataSet])
    for value in attribute:
        print(myTree)
        print(value)
        subLabels = labels[:]
        myTree[optimalAttribute][value] = \
            createTree(makeAttributeData(dataSet, value, sequence), subLabels)
    return myTree

"""
这个函数是程序的入口点，它执行以下操作：

读取数据：
从给定的文件路径（Excel文件）读取数据。
数据处理：
使用dataDeal函数处理读取的数据，可能是为了转换为适合算法处理的格式。
获取标签：
使用getLabels函数获取数据的特征标签。
构建决策树：
调用createTree函数，传入处理后的数据集和特征标签，得到决策树。
返回决策树：
返回构建的决策树。
"""
def main():
    filePath = r'C:\Users\Lenovo\Desktop\Artificial\jueceshu001\西瓜数据集.xls'
    data = getData(filePath)
    dataSet = dataDeal(data)
    labels = getLabels(data)
    myTree = createTree(dataSet, labels)
    return myTree


if __name__ == '__main__':
    myTree = main()
print(myTree)

# 绘制可视化树

import matplotlib.pylab as plt
import matplotlib

# 能够显示中文
matplotlib.rcParams['font.sans-serif'] = ['SimHei']
matplotlib.rcParams['font.serif'] = ['SimHei']

# 分叉节点，也就是决策节点
decisionNode = dict(boxstyle="sawtooth", fc="0.8")

# 叶子节点
leafNode = dict(boxstyle="round4", fc="0.8")

# 箭头样式
arrow_args = dict(arrowstyle="<-")


def plotNode(nodeTxt, centerPt, parentPt, nodeType):
    """
    绘制一个节点
    :param nodeTxt: 描述该节点的文本信息
    :param centerPt: 文本的坐标
    :param parentPt: 点的坐标，这里也是指父节点的坐标
    :param nodeType: 节点类型,分为叶子节点和决策节点
    :return:
    """
    createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',
                            xytext=centerPt, textcoords='axes fraction',
                            va="center", ha="center", bbox=nodeType, arrowprops=arrow_args)


def getNumLeafs(myTree):
    """
    获取叶节点的数目
    :param myTree:
    :return:
    """
    # 统计叶子节点的总数
    numLeafs = 0

    # 得到当前第一个key，也就是根节点
    firstStr = list(myTree.keys())[0]

    # 得到第一个key对应的内容
    secondDict = myTree[firstStr]

    # 递归遍历叶子节点
    for key in secondDict.keys():
        # 如果key对应的是一个字典，就递归调用
        if type(secondDict[key]).__name__ == 'dict':
            numLeafs += getNumLeafs(secondDict[key])
        # 不是的话，说明此时是一个叶子节点
        else:
            numLeafs += 1
    return numLeafs


def getTreeDepth(myTree):
    """
    得到数的深度层数
    :param myTree:
    :return:
    """
    # 用来保存最大层数
    maxDepth = 0

    # 得到根节点
    firstStr = list(myTree.keys())[0]

    # 得到key对应的内容
    secondDic = myTree[firstStr]

    # 遍历所有子节点
    for key in secondDic.keys():
        # 如果该节点是字典，就递归调用
        if type(secondDic[key]).__name__ == 'dict':
            # 子节点的深度加1
            thisDepth = 1 + getTreeDepth(secondDic[key])

        # 说明此时是叶子节点
        else:
            thisDepth = 1

        # 替换最大层数
        if thisDepth > maxDepth:
            maxDepth = thisDepth

    return maxDepth


def plotMidText(cntrPt, parentPt, txtString):
    """
    计算出父节点和子节点的中间位置，填充信息
    :param cntrPt: 子节点坐标
    :param parentPt: 父节点坐标
    :param txtString: 填充的文本信息
    :return:
    """
    # 计算x轴的中间位置
    xMid = (parentPt[0] - cntrPt[0]) / 2.0 + cntrPt[0]
    # 计算y轴的中间位置
    yMid = (parentPt[1] - cntrPt[1]) / 2.0 + cntrPt[1]
    # 进行绘制
    createPlot.ax1.text(xMid, yMid, txtString)


def plotTree(myTree, parentPt, nodeTxt):
    """
    绘制出树的所有节点，递归绘制
    :param myTree: 树
    :param parentPt: 父节点的坐标
    :param nodeTxt: 节点的文本信息
    :return:
    """
    # 计算叶子节点数
    numLeafs = getNumLeafs(myTree=myTree)

    # 计算树的深度
    depth = getTreeDepth(myTree=myTree)

    # 得到根节点的信息内容
    firstStr = list(myTree.keys())[0]

    # 计算出当前根节点在所有子节点的中间坐标,也就是当前x轴的偏移量加上计算出来的根节点的中心位置作为x轴（比如说第一次：初始的x偏移量为：-1/2W,计算出来的根节点中心位置为：(1+W)/2W，相加得到：1/2），当前y轴偏移量作为y轴
    cntrPt = (plotTree.xOff + (1.0 + float(numLeafs)) / 2.0 / plotTree.totalW, plotTree.yOff)

    # 绘制该节点与父节点的联系
    plotMidText(cntrPt, parentPt, nodeTxt)

    # 绘制该节点
    plotNode(firstStr, cntrPt, parentPt, decisionNode)

    # 得到当前根节点对应的子树
    secondDict = myTree[firstStr]

    # 计算出新的y轴偏移量，向下移动1/D，也就是下一层的绘制y轴
    plotTree.yOff = plotTree.yOff - 1.0 / plotTree.totalD

    # 循环遍历所有的key
    for key in secondDict.keys():
        # 如果当前的key是字典的话，代表还有子树，则递归遍历
        if isinstance(secondDict[key], dict):
            plotTree(secondDict[key], cntrPt, str(key))
        else:
            # 计算新的x轴偏移量，也就是下个叶子绘制的x轴坐标向右移动了1/W
            plotTree.xOff = plotTree.xOff + 1.0 / plotTree.totalW
            # 打开注释可以观察叶子节点的坐标变化
            # print((plotTree.xOff, plotTree.yOff), secondDict[key])
            # 绘制叶子节点
            plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
            # 绘制叶子节点和父节点的中间连线内容
            plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))

    # 返回递归之前，需要将y轴的偏移量增加，向上移动1/D，也就是返回去绘制上一层的y轴
    plotTree.yOff = plotTree.yOff + 1.0 / plotTree.totalD


def createPlot(inTree):
    """
    需要绘制的决策树
    :param inTree: 决策树字典
    :return:
    """
    # 创建一个图像
    fig = plt.figure(1, facecolor='white')
    fig.clf()
    axprops = dict(xticks=[], yticks=[])
    createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
    # 计算出决策树的总宽度
    plotTree.totalW = float(getNumLeafs(inTree))
    # 计算出决策树的总深度
    plotTree.totalD = float(getTreeDepth(inTree))
    # 初始的x轴偏移量，也就是-1/2W，每次向右移动1/W，也就是第一个叶子节点绘制的x坐标为：1/2W，第二个：3/2W，第三个：5/2W，最后一个：(W-1)/2W
    plotTree.xOff = -0.5 / plotTree.totalW
    # 初始的y轴偏移量，每次向下或者向上移动1/D
    plotTree.yOff = 1.0
    # 调用函数进行绘制节点图像
    plotTree(inTree, (0.5, 1.0), '')
    # 绘制
    plt.show()


if __name__ == '__main__':
    createPlot(myTree)

C45_er.py

import pandas as pd
import numpy as np

#计算信息熵
def cal_information_entropy(data):
    data_label = data.iloc[:,-1]
    label_class =data_label.value_counts() #总共有多少类
    Ent = 0
    for k in label_class.keys():
        p_k = label_class[k]/len(data_lab