决策树（机器学习）

import numpy as np
import pandas as pd
data=pd.read_excel("西瓜数据集.xlsx")
D=data
A=D.columns[1:-1]#列标签作为属性集，除去编号，和好瓜（它们不是特征）
class TreeNode:
    def __init__(self):
        self.mark=None#如果mark=-1 则该节点是叶子节点，否则是分支决策节点
        self.decision=None#如果是叶子节点，则是类别（好瓜：是or否），如果是分支决策节点，则是划分的属性
        self.chids={}#用字典存储分支的孩子{属性值：分支节点}
def Max_class(D):#取D数据集中类别的最多的那个类
    max_class=D["好瓜"].iloc[0]
    max_value=0
    for i in set(D["好瓜"]):#{否，是}
        count=np.sum(D["好瓜"]==i)#统计类别个数
        if max_value<count:
            max_value=count
            max_class=i
    return max_class#返回最多的那个类名称
 
def Ent(D):#数据集的熵，当前样本的纯度
    ent_d=0
    for i in set(D["好瓜"]):#{是，否}
        class_num=np.sum(D["好瓜"]==i)#统计某类样本的个数
        pk=class_num/D.shape[0]#计算该类在数据集中的占比
        ent_d+=pk*np.log2(pk)#计算某类的熵，并累加
    return -1*ent_d#返回最终的数据集熵值
 
def Gain(D,a):
    dv_ent_sum=0
    for v in set(D[a]):
        site=np.where(D[a]==v)#得到符合条件样本的下标
        Dv=D.iloc[site]#通过iloc函数取出对应下标的样本，组成子集Dv
        Dv_div_D=Dv.shape[0]/D.shape[0]#计算|Dv|/|D|的值
        ent_dv=Ent(Dv)#得到某个属性取值Dv子集的信息熵
        dv_ent_sum+=Dv_div_D*ent_dv#得到a属性总的信息熵
    return Ent(D)-dv_ent_sum
 
def AttChoice(D,A):#获得信息增益最大的那个属性
    max_gain_a=A[0]#假定好的是第0个属性
    max_gain=0#假定信息增益取值为0
    for a in A:#循环找到最大信息增益的属性
        print(a,"的信息增益为：",Gain(D,a))
        if max_gain<Gain(D,a):
            max_gain=Gain(D,a)
            max_gain_a=a
    print("当前选择的最优属性决策是：",max_gain_a)
    return max_gain_a#返回信息增益最大的属性
 
def TreeGenerate(D, A, node):
    if len(set(D['好瓜'])) == 1:  # 如果类别集合长度==1则说明只有一类
        print(D)
        print("样本集合已经非常纯了，全是同类样本！选择最多那个类即可！")
        node.mark = -1  # 标记为-1 ，是叶子节点
        node.decision = Max_class(D)  # 把数据集中最多的那个类作为分类结果
        if node.decision == "是":
            print("是【好瓜】")
        else:
            print("是【坏瓜】")
        print("==========返回了===========")
        return
    if len(A) == 0 or np.sum(D[A].values[:] == D[A].values[0]) == D[A].shape[0] * D[A].shape[1]:
        print("没有可以选择的属性来作为决策，需要立即得到分类结果，或者样本的属性取值都一样，无需分类，选择最多的那个类即可！")
        node.mark = -1  # 标记为-1 ，是叶子节点
        node.decision = Max_class(D)  # 把数据集中最多的那个类作为分类结果
        if node.decision == "是":
            print("是【好瓜】")
        else:
            print("是【坏瓜】")
        print("==========返回了===========")
        return
    good_a = AttChoice(D, A)  # 从A中选择最优划分属性good_a
    for a_v in set(D[good_a]):
        print("当前选择的分支属性是：", a_v)
        node_c = TreeNode()  # 生成分支节点
        node.chids[a_v] = node_c  # 链接分支
        Dv = D.iloc[np.where(D[good_a] == a_v)]  # 得到属性good_a 取值为a_v的样本集
        if Dv.shape[0] == 0:  # 判断Dv是否为空
            print("当前分支的样本数是0，无法分类，直接选择样本集最多的类作为分类结果。")
            node_c.mark = -1  # 标记为叶子节点
            node_c.decision = Max_class(D)
            print("==========返回了===========")
            return
        else:
            node.mark = 1  # 不是分类节点（叶子节点）,赋值为非-1的值即可
            node.decision = good_a  # node节点为分支决策节点，节点的值为最优划分属性即可
            TreeGenerate(Dv, np.delete(A, np.where(A == good_a)), node_c)  # 递归，下一层，同样是决策树，只是数据集更小，属性越少
 
node = TreeNode()
Root = node
TreeGenerate(D,A,node)
print("測試一下")
for i in range(0,data.shape[0]-1):
    test_sample=D.iloc[i]
    print("=============START==================")
    print("类别应该是:",test_sample["好瓜"])
    root=Root
    while(root.mark!=-1):#如果不是叶子节点(需要我们对属性进行决策)
        a_v=test_sample[root.decision]#利用决策树的decision来获取要决策的属性
        root=root.chids[a_v]
    #mark==-1的时候结束，说明可以输出最终的分类了
    print("分类结果：",root.decision)
    print("==============END===================")