devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【机器学习】决策树（理论与代码）_决策树代码

作者：正经夜光杯 | 2024-08-22 03:38:04

赞

踩

决策树代码

文章目录

一、理论部分

二、代码实现

1、代码解释。

2、完整代码 

3、可视化

一、理论部分

下班到家，打开博客，源码实现下决策树。

理论部分这里不再详细讲。计算可以参考周志华西瓜书。

计算信息熵Ent(D)与信息增益Gain（D）。

原理的话就是选取信息增益最大的为根，以此类推。

观察公式可以看到：

信息增益Gain（D）= 根节点信息熵（X） -  权重*分支节点信息熵和（Y）= X - Y

由于根节点确定后 X不变，要选取最大Gain（D），就是选择最小Y。

因为Y计算过程会取负数，所以选择节点时只需取 乘积和的最大值就行了。

二、代码实现

1、代码解释。

老样子还是fit 函数 。x是特征数据集，y是结果集，多出的x_label是各个特征对应的标签

np.c_[x,y] 拼接x，y。下面看下build_tree 构建树的函数

  1.     def fit(self,x,y,x_label):
  2.         self.label = x_label    # x数据集对应的 特征标签
  3.         numpy_data = np.c_[x,y]    # 把x,y拼接成一个numpy矩阵，方便后面操作
  4.         self.tree = self.build_tree(numpy_data)    # 构建树

 这部分是构建树，在代码里解释，可以看注释。直接上代码

  1. import numpy as np
  2.  
  3.  
  4. class DecisionTree():
  5.     def fit(self,x,y,x_label):
  6.         self.label = x_label    # x数据集对应的 特征标签
  7.         numpy_data = np.c_[x,y]    # 把x,y拼接成一个numpy矩阵，方便后面操作
  8.         self.tree = self.build_tree(numpy_data)    # 构建树
  9.     
  10.     def build_tree(self,numpy_data):   # numpy_data n行m列的矩阵,最后一列是结果集。返回字典
  11.         """
  12.         判断结束:如果最后一列去重后为一个值就结束
  13.         最后分类全部是ng或者ok时递归，不能再分 ！！！关键点1！！！
  14.         这里还有一种情况，就是所有的特征值都一样，但结果不同
  15.         我们可以选择取结果多的为return值。(暂不考虑，实现也不难)
  16.         """
  17.         finish_columns = np.unique(numpy_data)[:,-1]
  18.         if len(finish_columns) == 1:
  19.             return finish_columns [0]    # 返回ng与ok，表面这个分支已经分到叶子了
  20.         rows,columns = numpy_data.shape    # numpy行数与列数
  21.         root_numpy = np.zeros(columns-1)    # 构造全为0的numpy数组，保存信息熵数据
  22.         # 遍历每个特征。"触感","色泽","敲声",...    
  23.         for i in range(columns-1):
  24.             sum = 0
  25.             # 每个特征有多少种，如“纹理” 这个特征 numpy_data为("清晰","稍糊","模糊")
  26.             unique_data = np.unique(numpy_data[:,i])
  27.             for j in unique_data:
  28.                 len_whole = len(numpy_data[(numpy_data[:,i] == j)])  
  29.                 len_ng = len(numpy_data[(numpy_data[:i]==j)&(numpy_data[:,-1]=="ng")])
  30.                 # ok的长度 = 总长度-ng的长度
  31.                 len_ok = len_whole-len_ng          
  32.                 if len_ng !=0 and len_ok!=0:    # 有一个为0就不用参与计算
  33.                     x = len_ok/len_whole
  34.                     # 每个特征{x属于(0,1) (x*np.log2(x)+(1-x)log2(1-x))*个数比例} 
  35.                     # 得到单个sum
  36.                     # 迭代求和
  37.                     sum = sum + round(len_whole/rows*(x*np.log2(x)+(1-x)*np.log2(1-x)),3)
  38.             root_numpy[i] = sum    # 保存各个特征的信息熵
  39.         root = root_numpy.argsort()[-1]    # -1 选取最大值索引。np.argsort():排序后的索引
  40.         """
  41.         构建字典存放树的数据
  42.         计算得到 tree_dict为:{"纹理":{}}
  43.         """
  44.         tree_dict = {self.label[root]:{}}
  45.         # print(tree_dict)
  46.         """
  47.         拿到根节点为“纹理”后还要继续分
  48.         np.unique(numpy_data[:,root])计算根节点后面有几分支，("清晰"、"稍糊"、"模糊")继续分
  49.         """
  50.         for values in np.unique(numpy_data[:,root]):
  51.             # 把对应的数据进行区分，切割出符合条件的数据后面继续分
  52.             numpy_root = numpy_data[(numpy_data[:,root] == values)]
  53.             # print(values,numpy_root)
  54.             """
  55.             继续往下走，递归后面数据 ！！！关键点2！！！
  56.             拿到根节点，分支后得到新的数据，新的数据选节点计算方式一样，
  57.             递归直到叶子结束。我们已经对数据进行处理了，后面计算方式是一样的
  58.             """
  59.             # 字典新的key 继续存
  60.             tree_dict[self.label[root]][values] = self.build_tree(numpy_root)
  61.         
  62.         return tree_dict

构造数据集进行计算。这个举例子有点难，我们直接用西瓜书的数据集进行测试，也方便验证。

这里大家可能会有个疑问。

data1,2,3,4,5,6 为什么顺序跟西瓜书不一样呢，因为在计算信息熵的时候，最大值可能有多个值，所以构建的树可能不同，都正确。西瓜书选取的是第一次最大值就分，而np.argsort()取得索引最后一位是最后一次出现的最大值。为了保持一致，顺序调了下。

  1. if __name__ == "__main__":
  2.     data2 = ["青绿", "乌黑", "乌黑", "青绿", "浅白", "青绿", "乌黑", "乌黑",
  3.              "乌黑", "青绿", "浅白", "浅白", "青绿", "浅白", "乌黑", "浅白", "青绿"]
  4.     data6 = ["蜷缩", "蜷缩", "蜷缩", "蜷缩", "蜷缩", "稍蜷", "稍蜷", "稍蜷",
  5.              "稍蜷", "硬挺", "硬挺", "蜷缩", "稍蜷", "稍蜷", "稍蜷", "蜷缩", "蜷缩"]
  6.     data3 = ["浊响", "沉闷", "浊响", "沉闷", "浊响", "浊响", "浊响", "浊响",
  7.              "沉闷", "清脆", "清脆", "浊响", "浊响", "沉闷", "浊响", "浊响", "沉闷"]
  8.     data4 = ["清晰", "清晰", "清晰", "清晰", "清晰", "清晰", "稍糊", "清晰",
  9.              "稍糊", "清晰", "模糊", "模糊", "稍糊", "稍糊", "清晰", "模糊", "稍糊"]
  10.     data5 = ["凹陷", "凹陷", "凹陷", "凹陷", "凹陷", "稍凹", "稍凹", "稍凹",
  11.              "稍凹", "平坦", "平坦", "平坦", "凹陷", "凹陷", "稍凹", "平坦", "稍凹"]
  12.     data1 = ["硬滑", "硬滑", "硬滑", "硬滑", "硬滑", "软粘", "软粘", "硬滑",
  13.              "硬滑", "软粘", "硬滑", "软粘", "硬滑", "硬滑", "软粘", "硬滑", "硬滑"]
  14.     result = ["ok", "ok", "ok", "ok", "ok", "ok", "ok", "ok",
  15.               "ng", "ng", "ng", "ng", "ng", "ng", "ng", "ng", "ng"]
  16.     x_label = ["触感", "色泽", "敲声", "纹理", "脐部", "根蒂"]
  17.     x = np.array([data1, data2, data3, data4, data5, data6]).transpose()
  18.     y = np.array(result)
  19.     # print("标签:",x_label)
  20.     # print(x)
  21.     decisionTree = DecisionTree()
  22.     decisionTree.fit(x, y, x_label)
  23.     print(decisionTree.tree)
  24.  
  25.     """
  26.     # print("标签:",x_label)
  27.     # print(x)
  28.     标签: ['触感', '色泽', '敲声', '纹理', '脐部', '根蒂']
  29.             [['硬滑' '青绿' '浊响' '清晰' '凹陷' '蜷缩']
  30.              ['硬滑' '乌黑' '沉闷' '清晰' '凹陷' '蜷缩']
  31.              ['硬滑' '乌黑' '浊响' '清晰' '凹陷' '蜷缩']
  32.              ['硬滑' '青绿' '沉闷' '清晰' '凹陷' '蜷缩']
  33.              ['硬滑' '浅白' '浊响' '清晰' '凹陷' '蜷缩']
  34.              ['软粘' '青绿' '浊响' '清晰' '稍凹' '稍蜷']
  35.              ['软粘' '乌黑' '浊响' '稍糊' '稍凹' '稍蜷']
  36.              ['硬滑' '乌黑' '浊响' '清晰' '稍凹' '稍蜷']
  37.              ['硬滑' '乌黑' '沉闷' '稍糊' '稍凹' '稍蜷']
  38.              ['软粘' '青绿' '清脆' '清晰' '平坦' '硬挺']
  39.              ['硬滑' '浅白' '清脆' '模糊' '平坦' '硬挺']
  40.              ['软粘' '浅白' '浊响' '模糊' '平坦' '蜷缩']
  41.              ['硬滑' '青绿' '浊响' '稍糊' '凹陷' '稍蜷']
  42.              ['硬滑' '浅白' '沉闷' '稍糊' '凹陷' '稍蜷']
  43.              ['软粘' '乌黑' '浊响' '清晰' '稍凹' '稍蜷']
  44.              ['硬滑' '浅白' '浊响' '模糊' '平坦' '蜷缩']
  45.              ['硬滑' '青绿' '沉闷' '稍糊' '稍凹' '蜷缩']]
  46.     print(decisionTree.tree)
  47.     {'纹理': {
  48.               '模糊': 'ng',
  49.               '清晰': {'根蒂': {'硬挺': 'ng', '稍蜷': {'色泽': {'乌黑': {'触感': {'硬滑': 'ok', '软粘': 'ng'}}, '青绿': 'ok'}}, '蜷缩': 'ok'}}, 
  50.               '稍糊': {'触感': {'硬滑': 'ng', '软粘': 'ok'}}
  51.               }
  52.     }
  53.     """

2、完整代码 

  1. import numpy as np
  2.  
  3.  
  4. class DecisionTree():
  5.     def fit(self, x, y, x_label):
  6.         self.label = x_label  # x数据集对应的 特征标签
  7.         numpy_data = np.c_[x, y]  # 把x,y拼接成一个numpy矩阵，方便后面操作
  8.         self.tree = self.build_tree(numpy_data)  # 构建树
  9.  
  10.     def build_tree(self, numpy_data):  # numpy_data n行m列的矩阵,最后一列是结果集。返回字典
  11.         finish_columns = np.unique(numpy_data[:, -1])
  12.         if len(finish_columns) == 1:
  13.             return finish_columns[0]  # 返回ng与ok，表面这个分支已经分到叶子了
  14.         rows, columns = numpy_data.shape  # numpy行数与列数
  15.         root_numpy = np.zeros(columns - 1)  # 构造全为0的numpy数组，保存信息熵数据
  16.         for i in range(columns - 1):
  17.             sum = 0
  18.             unique_data = np.unique(numpy_data[:, i])
  19.             for j in unique_data:
  20.                 len_whole = len(numpy_data[(numpy_data[:, i] == j)])
  21.                 len_ng = len(numpy_data[((numpy_data[:,i] == j) 
  22.                               & (numpy_data[:, -1] == "ng"))])
  23.                 len_ok = len_whole - len_ng
  24.                 if len_ng != 0 and len_ok != 0:  # 有一个为0就不用参与计算
  25.                     x = len_ok / len_whole
  26.                     sum = sum + round(len_whole / rows *
  27.                              (x * np.log2(x) + (1-x) * np.log2(1-x)), 3)
  28.             root_numpy[i] = sum  # 保存各个特征的信息熵
  29.         root = root_numpy.argsort()[-1]  # -1 选取最大值索引。np.argsort():排序后的索引
  30.         tree_dict = {self.label[root]: {}}
  31.         for values in np.unique(numpy_data[:, root]):
  32.             numpy_root = numpy_data[(numpy_data[:, root] == values)]
  33.             tree_dict[self.label[root]][values] = self.build_tree(numpy_root)
  34.         return tree_dict
  35.  
  36.  
  37. if __name__ == "__main__":
  38.     data2 = ["青绿", "乌黑", "乌黑", "青绿", "浅白", "青绿", "乌黑", "乌黑",
  39.              "乌黑", "青绿", "浅白", "浅白", "青绿", "浅白", "乌黑", "浅白", "青绿"]
  40.     data6 = ["蜷缩", "蜷缩", "蜷缩", "蜷缩", "蜷缩", "稍蜷", "稍蜷", "稍蜷",
  41.              "稍蜷", "硬挺", "硬挺", "蜷缩", "稍蜷", "稍蜷", "稍蜷", "蜷缩", "蜷缩"]
  42.     data3 = ["浊响", "沉闷", "浊响", "沉闷", "浊响", "浊响", "浊响", "浊响",
  43.              "沉闷", "清脆", "清脆", "浊响", "浊响", "沉闷", "浊响", "浊响", "沉闷"]
  44.     data4 = ["清晰", "清晰", "清晰", "清晰", "清晰", "清晰", "稍糊", "清晰",
  45.              "稍糊", "清晰", "模糊", "模糊", "稍糊", "稍糊", "清晰", "模糊", "稍糊"]
  46.     data5 = ["凹陷", "凹陷", "凹陷", "凹陷", "凹陷", "稍凹", "稍凹", "稍凹",
  47.              "稍凹", "平坦", "平坦", "平坦", "凹陷", "凹陷", "稍凹", "平坦", "稍凹"]
  48.     data1 = ["硬滑", "硬滑", "硬滑", "硬滑", "硬滑", "软粘", "软粘", "硬滑",
  49.              "硬滑", "软粘", "硬滑", "软粘", "硬滑", "硬滑", "软粘", "硬滑", "硬滑"]
  50.     result = ["ok", "ok", "ok", "ok", "ok", "ok", "ok", "ok",
  51.               "ng", "ng", "ng", "ng", "ng", "ng", "ng", "ng", "ng"]
  52.     x_label = ["触感", "色泽", "敲声", "纹理", "脐部", "根蒂"]
  53.     x = np.array([data1, data2, data3, data4, data5, data6]).transpose()
  54.     y = np.array(result)
  55.     decisionTree = DecisionTree()
  56.     decisionTree.fit(x, y, x_label)
  57.     print(decisionTree.tree)
  58.

3、可视化

可视化树这里有点难度，用《机器学习实战》的代码

  1. import numpy as np
  2. import matplotlib.pylab as plt
  3. import matplotlib
  4.  
  5. # 能够显示中文
  6. matplotlib.rcParams['font.sans-serif'] = ['SimHei']
  7. matplotlib.rcParams['font.serif'] = ['SimHei']
  8.  
  9. # 分叉节点，也就是决策节点
  10. decisionNode = dict(boxstyle="sawtooth", fc="0.8")
  11.  
  12. # 叶子节点
  13. leafNode = dict(boxstyle="round4", fc="0.8")
  14.  
  15. # 箭头样式
  16. arrow_args = dict(arrowstyle="<-")
  17.  
  18.  
  19. def plotNode(nodeTxt, centerPt, parentPt, nodeType):
  20.     """
  21.     绘制一个节点
  22.     :param nodeTxt: 描述该节点的文本信息
  23.     :param centerPt: 文本的坐标
  24.     :param parentPt: 点的坐标，这里也是指父节点的坐标
  25.     :param nodeType: 节点类型,分为叶子节点和决策节点
  26.     :return:
  27.     """
  28.     createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',
  29.                             xytext=centerPt, textcoords='axes fraction',
  30.                             va="center", ha="center", bbox=nodeType, arrowprops=arrow_args)
  31.  
  32.  
  33. def getNumLeafs(myTree):
  34.     """
  35.     获取叶节点的数目
  36.     :param myTree:
  37.     :return:
  38.     """
  39.     # 统计叶子节点的总数
  40.     numLeafs = 0
  41.  
  42.     # 得到当前第一个key，也就是根节点
  43.     firstStr = list(myTree.keys())[0]
  44.  
  45.     # 得到第一个key对应的内容
  46.     secondDict = myTree[firstStr]
  47.  
  48.     # 递归遍历叶子节点
  49.     for key in secondDict.keys():
  50.         # 如果key对应的是一个字典，就递归调用
  51.         if type(secondDict[key]).__name__ == 'dict':
  52.             numLeafs += getNumLeafs(secondDict[key])
  53.         # 不是的话，说明此时是一个叶子节点
  54.         else:
  55.             numLeafs += 1
  56.     return numLeafs
  57.  
  58.  
  59. def getTreeDepth(myTree):
  60.     """
  61.     得到数的深度层数
  62.     :param myTree:
  63.     :return:
  64.     """
  65.     # 用来保存最大层数
  66.     maxDepth = 0
  67.  
  68.     # 得到根节点
  69.     firstStr = list(myTree.keys())[0]
  70.  
  71.     # 得到key对应的内容
  72.     secondDic = myTree[firstStr]
  73.  
  74.     # 遍历所有子节点
  75.     for key in secondDic.keys():
  76.         # 如果该节点是字典，就递归调用
  77.         if type(secondDic[key]).__name__ == 'dict':
  78.             # 子节点的深度加1
  79.             thisDepth = 1 + getTreeDepth(secondDic[key])
  80.  
  81.         # 说明此时是叶子节点
  82.         else:
  83.             thisDepth = 1
  84.  
  85.         # 替换最大层数
  86.         if thisDepth > maxDepth:
  87.             maxDepth = thisDepth
  88.  
  89.     return maxDepth
  90.  
  91.  
  92. def plotMidText(cntrPt, parentPt, txtString):
  93.     """
  94.     计算出父节点和子节点的中间位置，填充信息
  95.     :param cntrPt: 子节点坐标
  96.     :param parentPt: 父节点坐标
  97.     :param txtString: 填充的文本信息
  98.     :return:
  99.     """
  100.     # 计算x轴的中间位置
  101.     xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]
  102.     # 计算y轴的中间位置
  103.     yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]
  104.     # 进行绘制
  105.     createPlot.ax1.text(xMid, yMid, txtString)
  106.  
  107.  
  108. def plotTree(myTree, parentPt, nodeTxt):
  109.     """
  110.     绘制出树的所有节点，递归绘制
  111.     :param myTree: 树
  112.     :param parentPt: 父节点的坐标
  113.     :param nodeTxt: 节点的文本信息
  114.     :return:
  115.     """
  116.     # 计算叶子节点数
  117.     numLeafs = getNumLeafs(myTree=myTree)
  118.  
  119.     # 计算树的深度
  120.     depth = getTreeDepth(myTree=myTree)
  121.  
  122.     # 得到根节点的信息内容
  123.     firstStr = list(myTree.keys())[0]
  124.  
  125.     # 计算出当前根节点在所有子节点的中间坐标,也就是当前x轴的偏移量加上计算出来的根节点的中心位置作为x轴（比如说第一次：初始的x偏移量为：-1/2W,计算出来的根节点中心位置为：(1+W)/2W，相加得到：1/2），当前y轴偏移量作为y轴
  126.     cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)
  127.  
  128.     # 绘制该节点与父节点的联系
  129.     plotMidText(cntrPt, parentPt, nodeTxt)
  130.  
  131.     # 绘制该节点
  132.     plotNode(firstStr, cntrPt, parentPt, decisionNode)
  133.  
  134.     # 得到当前根节点对应的子树
  135.     secondDict = myTree[firstStr]
  136.  
  137.     # 计算出新的y轴偏移量，向下移动1/D，也就是下一层的绘制y轴
  138.     plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD
  139.  
  140.     # 循环遍历所有的key
  141.     for key in secondDict.keys():
  142.         # 如果当前的key是字典的话，代表还有子树，则递归遍历
  143.         if isinstance(secondDict[key], dict):
  144.             plotTree(secondDict[key], cntrPt, str(key))
  145.         else:
  146.             # 计算新的x轴偏移量，也就是下个叶子绘制的x轴坐标向右移动了1/W
  147.             plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
  148.             # 打开注释可以观察叶子节点的坐标变化
  149.             # print((plotTree.xOff, plotTree.yOff), secondDict[key])
  150.             # 绘制叶子节点
  151.             plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
  152.             # 绘制叶子节点和父节点的中间连线内容
  153.             plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
  154.  
  155.     # 返回递归之前，需要将y轴的偏移量增加，向上移动1/D，也就是返回去绘制上一层的y轴
  156.     plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD
  157.  
  158.  
  159. def createPlot(inTree):
  160.     """
  161.     需要绘制的决策树
  162.     :param inTree: 决策树字典
  163.     :return:
  164.     """
  165.     # 创建一个图像
  166.     fig = plt.figure(1, facecolor='white')
  167.     fig.clf()
  168.     axprops = dict(xticks=[], yticks=[])
  169.     createPlot.ax1 = plt.subplot(111, frameon=False, **axprops)
  170.     # 计算出决策树的总宽度
  171.     plotTree.totalW = float(getNumLeafs(inTree))
  172.     # 计算出决策树的总深度
  173.     plotTree.totalD = float(getTreeDepth(inTree))
  174.     # 初始的x轴偏移量，也就是-1/2W，每次向右移动1/W，也就是第一个叶子节点绘制的x坐标为：1/2W，第二个：3/2W，第三个：5/2W，最后一个：(W-1)/2W
  175.     plotTree.xOff = -0.5/plotTree.totalW
  176.     # 初始的y轴偏移量，每次向下或者向上移动1/D
  177.     plotTree.yOff = 1.0
  178.     # 调用函数进行绘制节点图像
  179.     plotTree(inTree, (0.5, 1.0), '')
  180.     # 绘制
  181.     plt.show()
  182.  
  183. class DecisionTree():
  184.     def fit(self, x, y, x_label):
  185.         self.label = x_label  # x数据集对应的 特征标签
  186.         numpy_data = np.c_[x, y]  # 把x,y拼接成一个numpy矩阵，方便后面操作
  187.         self.tree = self.build_tree(numpy_data)  # 构建树
  188.  
  189.     def build_tree(self, numpy_data):  # numpy_data n行m列的矩阵,最后一列是结果集。返回字典
  190.         finish_columns = np.unique(numpy_data[:, -1])
  191.         if len(finish_columns) == 1:
  192.             return finish_columns[0]  # 返回ng与ok，表面这个分支已经分到叶子了
  193.         rows, columns = numpy_data.shape  # numpy行数与列数
  194.         root_numpy = np.zeros(columns - 1)  # 构造全为0的numpy数组，保存信息熵数据
  195.         for i in range(columns - 1):
  196.             sum = 0
  197.             unique_data = np.unique(numpy_data[:, i])
  198.             for j in unique_data:
  199.                 len_whole = len(numpy_data[(numpy_data[:, i] == j)])
  200.                 len_ng = len(numpy_data[((numpy_data[:,i] == j) & (numpy_data[:, -1] == "ng"))])
  201.                 len_ok = len_whole - len_ng
  202.                 if len_ng != 0 and len_ok != 0:  # 有一个为0就不用参与计算
  203.                     x = len_ok / len_whole
  204.                     sum = sum + round(len_whole / rows * (x * np.log2(x) + (1-x) * np.log2(1-x)), 3)
  205.             root_numpy[i] = sum  # 保存各个特征的信息熵
  206.         root = root_numpy.argsort()[-1]  # -1 选取最大值索引。np.argsort():排序后的索引
  207.         tree_dict = {self.label[root]: {}}
  208.         for values in np.unique(numpy_data[:, root]):
  209.             numpy_root = numpy_data[(numpy_data[:, root] == values)]
  210.             tree_dict[self.label[root]][values] = self.build_tree(numpy_root)
  211.         return tree_dict
  212.  
  213.  
  214. if __name__ == "__main__":
  215.     data2 = ["青绿", "乌黑", "乌黑", "青绿", "浅白", "青绿", "乌黑", "乌黑",
  216.              "乌黑", "青绿", "浅白", "浅白", "青绿", "浅白", "乌黑", "浅白", "青绿"]
  217.     data6 = ["蜷缩", "蜷缩", "蜷缩", "蜷缩", "蜷缩", "稍蜷", "稍蜷", "稍蜷",
  218.              "稍蜷", "硬挺", "硬挺", "蜷缩", "稍蜷", "稍蜷", "稍蜷", "蜷缩", "蜷缩"]
  219.     data3 = ["浊响", "沉闷", "浊响", "沉闷", "浊响", "浊响", "浊响", "浊响",
  220.              "沉闷", "清脆", "清脆", "浊响", "浊响", "沉闷", "浊响", "浊响", "沉闷"]
  221.     data4 = ["清晰", "清晰", "清晰", "清晰", "清晰", "清晰", "稍糊", "清晰",
  222.              "稍糊", "清晰", "模糊", "模糊", "稍糊", "稍糊", "清晰", "模糊", "稍糊"]
  223.     data5 = ["凹陷", "凹陷", "凹陷", "凹陷", "凹陷", "稍凹", "稍凹", "稍凹",
  224.              "稍凹", "平坦", "平坦", "平坦", "凹陷", "凹陷", "稍凹", "平坦", "稍凹"]
  225.     data1 = ["硬滑", "硬滑", "硬滑", "硬滑", "硬滑", "软粘", "软粘", "硬滑",
  226.              "硬滑", "软粘", "硬滑", "软粘", "硬滑", "硬滑", "软粘", "硬滑", "硬滑"]
  227.     result = ["ok", "ok", "ok", "ok", "ok", "ok", "ok", "ok",
  228.               "ng", "ng", "ng", "ng", "ng", "ng", "ng", "ng", "ng"]
  229.     x_label = ["触感", "色泽", "敲声", "纹理", "脐部", "根蒂"]
  230.     x = np.array([data1, data2, data3, data4, data5, data6]).transpose()
  231.     y = np.array(result)
  232.     decisionTree = DecisionTree()
  233.     decisionTree.fit(x, y, x_label)
  234.     print(decisionTree.tree)
  235.     createPlot(decisionTree.tree)
  236.

可视化得到图如下： 

 对比西瓜书

对比发现又两点不同 

一是 发现纹理-->根蒂-->色泽 这里缺少浅白，这是因为数据集本身就不存在（清晰、稍蜷、浅白）。这里可以进行填充。感兴趣的可以试下。

二是 在纹理为稍糊、触感这里，ng与ok反了，这里是西瓜书打印错误。

最后亿点说明：

为什么构建树的时候只需要计算信息熵就可以了，而且不用移除出之前的特征？

因为我们实际上计算的是

 sum = sum + x * np.log2(x) + (1-x) * np.log2(1-x)

这个值我们可以观察下y = x * np.log2(x) + (1-x) * np.log2(1-x)。这个函数关于x=1/2对称

当x属于（0，1）时连续，求导，计算出（0，1/2）递减，（1/2，1）递增

当x = 1/2最小，y越小说明信息增益越小，文章开头讲过。求极限，利用洛必达法则，上下求导就可以算出。当x趋于0时 y也趋于0且连续所以函数曲线大致为可以画出类似于  "- sin（πx）" 在（0，1）。因为结果ok，ng为同一组的时候时不能在分的。当可以再分时，我们前面选出的特征一定是负的最大的。对公式简单处理，就可以快速构造决策树

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/1014564
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号