机器学习之决策树原理详解、公式推导（手推）、面试问题、简单实例（python实现，sklearn调包）

最新推荐文章于 2023-10-27 17:30:00 发布
最新推荐文章于 2023-10-27 17:30:00 发布
阅读量730 收藏 2
点赞数 3
分类专栏： 机器学习 文章标签： 决策树 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hjh1906008151/article/details/128180458
版权

在这里插入图片描述

目录

1. 决策树原理

1.1. 特性

决策树属于非参数监督学习方法，在学习数据特征推断出简单的决策规划创建一个预测目标变量值的模型。

优点

  1. 可解释型强，而且决策树很容易可视化。此外，决策树使用“白箱模型”，比起黑箱模型，解释性也更强。
  2. 能处理多输出问题。
  3. 即使其假设与生成数据的真实模型有一定程度的违背，也能很好地执行。
  4. 使用树（即预测数据）的成本在用于训练树的数据点的数量上是对数的。

缺点

  1. 很容易就过拟合了。所以才需要剪枝等技巧或者设置叶节点所需最小样本树或者设置树最大深度。
  2. 不稳定，因为时递归出来的，很微小的变化可能导致整个树结构大变。
  3. 不擅长泛化和外推。因为决策树的预测不是平滑的也不是连续的，所以中间的空挡很难处理，所以在外推方面表现差。
  4. 决策树基于的启发式算法可能会导致产生的决策树并非最优决策树，比如在使用贪心算法的时候。因此才会有人提出特征和样本需要被随机抽样替换。
  5. 在一些问题上先天不足。如：XOR、奇偶校验或多路复用器问题。
  6. 不支持缺失值，这点在随机森林中也有所提现，所以采取本方法时注意缺失值处理或填补。

1.2. 思路

在计算机中，决策树更多的时用于分类。有点类似于用 if else 语句去穷举每一种可能，但是面对多个判断的情况时，每个判断出现的位置还不确定，我们需要通过某种方法确定各个条件出现顺序（谁在树根谁在下面），这个方法是决策树的一个难点。此外，面对大量数据时，建立的决策树模型可能会特别特别大，深度深，叶子节点多且节点中的样例少等可能性，优化这个问题需要的方法也是一个难题。

所有的决策树的步骤的最终目的都是希望通过学习产生一个泛化能力强的决策树，即处理未见示例能力强的决策树。

1.3. 概念

决策树概念

在这里插入图片描述

根据西瓜书的定义：⼀棵决策树包含⼀个根节点，若⼲个内部节点和若⼲个叶⼦节点。叶结点对应决策树决策结果，其他每个结点则对应于⼀个属性测试。

信息论

决策树这里用到了信息论中间很基础的知识，我们希望决策树的分支节点所包含的样本尽可能都属于一个类别，那么这么衡量这个？这需要用到纯度。直观上讲就是分类纯度越低，里面的标签就越杂 。

那么纯度怎么表示？

可以用信息熵表示。假定当前样本集合 D 中第 k 类样本所占的比例为 P k P_k Pk​ (k =1, 2,. . . , ∣ γ ∣ |\gamma| ∣γ∣) ，则D的信息熵定义为:
E n t ( D ) = − ∑ k = 1 ∣ γ ∣ p k l o g 2 p k Ent(D)=-\sum^{|\gamma|}_{k=1}{p_klog_2p_k} Ent(D)=−k=1∑∣γ∣​pk​log2​pk​

Ent(D)的值越小，则D的纯度越⾼。
Ent(D)的值越大，则D的不纯度越大，则D的不确定性越大。

2. 公式推导

决策树模型构建一般分为三步，

  1. 特征选择
  2. 决策树生成
  3. 决策树修剪

特征选择更多的是取决于数据集，在生活中的问题里可能更加重要，一般来说没有什么特定的标准，需要注意的点比较琐碎，这边不细讲。

决策树生成和修剪的难度更大，这里做出总结。

2.1. 构造决策树

如何构造决策树其实就是如何选取每层节点的问题，西瓜书上介绍了三种方法，这边也按照这三种方法总结，其他的方法我将在面试题中提到。

2.1.1. ID3

理论

靠信息增益区分。

我们知道信息熵可以确定经过一个节点划分后每个分支节点的纯度，但是我们这里需要确定节点的顺序，所以单单知道划分后每个分支节点的纯度还不够，应该通过某种方法利用分支节点的纯度反映到划分节点的优劣。

ID3就是使用信息增益来判断每个节点的划分能力的。信息增益公式如下：

G a i n ( D , α ) = E n t ( D ) − ∑ v = 1 V ∣ D v ∣ ∣ D ∣ E n t ( D v ) Gain(D, \alpha)=Ent(D)-\sum^{V}_{v=1}{\frac{|D^v|}{|D|}Ent(D^v)} Gain(D,α)=Ent(D)−v=1∑V​∣D∣∣Dv∣​Ent(Dv)

∣ D v ∣ ∣ D ∣ \frac{|D^v|}{|D|} ∣D∣∣Dv∣​就是每个分支节点的划分权重，所以样本数量越多划分权重越大。 G a i n ( D , α ) Gain(D, \alpha) Gain(D,α)就是使用 α \alpha α属性划分对整体纯度提升的能力。因此我们有 ID3 的逻辑顺序：

  • 从根节点开始，会节点计算所有可能的特征的信息增益，选择信息增益最大的特征作为节点的特征。
  • 由该特征的不同取值建立子节点，在对子节点递归地调用上面方法，构建决策树，知道所有的特征信息增益都很小或者没有特征可以选为止。
  • 得到决策树模型。
示例

西瓜数据集

编号色泽根蒂敲声纹理脐部触感密度含糖率好瓜
10000000.6970.461
21010000.7740.3761
31000000.6340.2641
40010000.6080.3181
52000000.5560.2151
60100110.4030.2371
71101110.4810.1491
81100100.4370.2111
91111100.6660.0910
100220210.2430.2670
112222200.2450.0570
122002210.3430.0990
130101000.6390.1610
142111000.6570.1980
151100110.360.370
162002200.5930.0420
170011100.7190.1030

计算根蒂的信息增益：

在这里插入图片描述

缺点

对种类多的属性有偏好，比如编号属性。这个属性的信息增益会特别高，但是实际上它所包含的信息没多少。

此时就需要另一个算法 C4.5

2.1.2. C4.5

理论

靠增益率区分。

既然考虑到信息增益对种类多的属性的偏好，增益率应该削弱这类属性的权重。于是提出增益的权重，也称为属性的固有值。

对信息增益提出了惩罚，特征可取值数量较多时，惩罚参数大；特征可取值数量较少时，惩罚参数小。

I V ( α ) = − ∑ v = 1 V ∣ D v ∣ ∣ D ∣ l o g 2 ∣ D v ∣ ∣ D ∣ IV(\alpha)=-\sum^{V}_{v=1}{\frac{|D^v|}{|D|}}log_2\frac{|D^v|}{|D|} IV(α)=−v=1∑V​∣D∣∣Dv∣​log2​∣D∣∣Dv∣​
G a i n _ r a t i o = G a i n ( D , α ) I V ( α ) Gain\_ratio=\frac{Gain(D,\alpha)}{IV(\alpha)} Gain_ratio=IV(α)Gain(D,α)​

底层思路是讲连续特征离散化，所有也可以用来处理连续型数据。

示例

西瓜数据集

编号色泽根蒂敲声纹理脐部触感密度含糖率好瓜
10000000.6970.461
21010000.7740.3761
31000000.6340.2641
40010000.6080.3181
52000000.5560.2151
60100110.4030.2371
71101110.4810.1491
81100100.4370.2111
91111100.6660.0910
100220210.2430.2670
112222200.2450.0570
122002210.3430.0990
130101000.6390.1610
142111000.6570.1980
151100110.360.370
162002200.5930.0420
170011100.7190.1030

计算根蒂的信息增益率：

缺点

缺点也很明显，就是矫枉过正。面对可取数值比较少的属性时，增益率存在偏好。因此有了基指系数。

2.1.3. CART

靠基尼指数划分。

我们可以理解为随机抽取两个样本，其类别不一样的概率的加权和。这个权重跟 C4.5 的权重划分方法相同。

这个本质上是一个回归树，对于计算机来说虽然很多时候结果跟信息熵算出来的差不多，但是计算会快很多，因为没有对数。

数据集的基尼指数：

G i n i ( D ) = ∑ k = 1 ∣ γ ∣ ∑ k ′ ≠ k p k p k ′ = 1 − ∑ k = 1 ∣ γ ∣ p k 2 = 1 − ∑ k = 1 ∣ γ ∣ ( ∣ D i ∣ ∣ D ∣ ) 2 Gini(D)=\sum^{|\gamma|}_{k=1}\sum_{k^{'} \ne k}p_kp_{k^{'}}=1-\sum^{|\gamma|}_{k=1}p_{k}^{2}=1-\sum^{|\gamma|}_{k=1}{(\frac{|D_i|}{|D|})^2} Gini(D)=k=1∑∣γ∣​k′=k∑​pk​pk′​=1−k=1∑∣γ∣​pk2​=1−k=1∑∣γ∣​(∣D∣∣Di​∣​)2

数据集纯度越高， ∑ k = 1 ∣ γ ∣ p k 2 \sum^{|\gamma|}_{k=1}p_{k}^{2} ∑k=1∣γ∣​pk2​ 越大，Gini 越小。

属性的基尼指数：

G i n i _ i n d e x ( D , α ) = ∑ v = 1 V ∣ D v ∣ ∣ D ∣ G i n i ( D v ) Gini\_index(D, \alpha )=\sum^{V}_{v=1}{\frac{|D^v|}{|D|}Gini(D^{v})} Gini_index(D,α)=v=1∑V​∣D∣∣Dv∣​Gini(Dv)

最优划分属性就是 G i n i _ i n d e x ( D , α ) Gini\_index(D, \alpha ) Gini_index(D,α) 最小的属性。

示例

西瓜数据集

编号色泽根蒂敲声纹理脐部触感密度含糖率好瓜
10000000.6970.461
21010000.7740.3761
31000000.6340.2641
40010000.6080.3181
52000000.5560.2151
60100110.4030.2371
71101110.4810.1491
81100100.4370.2111
91111100.6660.0910
100220210.2430.2670
112222200.2450.0570
122002210.3430.0990
130101000.6390.1610
142111000.6570.1980
151100110.360.370
162002200.5930.0420
170011100.7190.1030

计算根蒂的基尼指数：

在这里插入图片描述

对比分析

在这里插入图片描述

2.2. 剪枝

剪枝 (pruning)是决策树学习算法对付"过拟合"的主要⼿段。在决策树学习中，为了尽可能正确分类训练样本，结点划分过程将不断重复，有时会造成决策树分支过多，这时就可能因训练样本学得"太好"了，以致于把训练集自身的⼀些特点当作所有数据都具有的⼀般性质⽽导致过拟合。

决策树剪枝的基本策略有“预剪枝” (prepruning)和“后剪枝 ”(post pruning) [Quinlan, 1993]. 预剪枝是指在决策树⽣成过程中，对每个结点在划分前先进⾏估计，若当前结点的划分不能带来决策树泛化性能提升，则停⽌划分并将当前结点标记为叶结点；后剪枝则是先从训练集⽣成⼀棵完整的决策树， 然后自底向上地对非叶结点进⾏考察，若将该结点对应的⼦树替换为叶结点能带来决策树泛化性能提升，则将该⼦树替换为叶结点。

3. 实例

3.1. 数据集

watermelon.csv

x1,x2,x3,x4,x5,x6,label
0,0,0,0,0,0,1
1,0,1,0,0,0,1
1,0,0,0,0,0,1
0,0,1,0,0,0,1
2,0,0,0,0,0,1
0,1,0,0,1,1,1
1,1,0,1,1,1,1
1,1,0,0,1,0,1
1,1,1,1,1,0,0
0,2,2,0,2,1,0
2,2,2,2,2,0,0
2,0,0,2,2,1,0
0,1,0,1,0,0,0
2,1,1,1,0,0,0
1,1,0,0,1,1,0
2,0,0,2,2,0,0
0,0,1,1,1,0,0

3.2. ID3

# 计算信息熵
def c_entropy(label):
    # 每类有几个
    count_class = Counter(label)
    ret = 0
    for classes in count_class.keys():
        ret += count_class[classes]/len(label)*np.log2(count_class[classes]/len(label))
    return -ret


# 计算单个属性信息增益
def c_entropy_gain(data, label):
    ent = c_entropy(label)
    # 几个值循环几次
    count_value = Counter(data)
    sum_entropy = 0
    for value_a in count_value.keys():
        sum_entropy += count_value[value_a] / len(label) * c_entropy(label[data == value_a])
    return ent - sum_entropy


# 计算计算每个属性的信息增益并求最大的
def find_entropy_index(data, label):
    label = label.flatten()
    feature_count = data.shape[1]
    max_list = []
    for i in range(feature_count):
        max_list.append(c_entropy_gain(data[:, i], label))
    max_value = max(max_list)  # 求列表最大值
    max_idx = max_list.index(max_value)  # 求最大值对应索引
    return max_idx

在这里插入图片描述

3.3. C4.5

# 计算信息熵
def c_entropy(label):
    # 每类有几个
    count_class = Counter(label)
    ret = 0
    for classes in count_class.keys():
        ret += count_class[classes]/len(label)*np.log2(count_class[classes]/len(label))
    return -ret


# 计算单个属性信息增益率
def c_entropy_gain_rate(data, label):
    ent = c_entropy(label)
    # 几个值循环几次
    count_value = Counter(data)
    sum_entropy = 0
    sum_iv = 0
    for value_a in count_value.keys():
        d = count_value[value_a] / len(label)
        sum_entropy += d * c_entropy(label[data == value_a])
        sum_iv -= d * np.log2(d)
    return (ent - sum_entropy) / sum_iv


# 计算计算每个属性的信息增益率并求最大的
def find_entropy_ratio(data, label):
    # 返回大于中位数的下标
    def get_mid_index(list):
        mid = int(len(list)/2)
        b = sorted(enumerate(list), key=lambda x: x[1])  # x[1]是因为在enumerate(a)中，a数值在第1位
        c = [x[0] for x in b]  # 获取排序好后b坐标,下标在第0位
        return c[mid:]


    label = label.flatten()
    feature_count = data.shape[1]
    max_list_e = []
    max_list = []
    for i in range(feature_count):
        max_list_e.append(c_entropy_gain(data[:, i], label))
        max_list.append(c_entropy_gain_rate(data[:, i], label))
    # 只保留信息增益大于平均水平的
    max_list_mid = [max_list[i] for i in get_mid_index(max_list_e)]
    max_value = max(max_list_mid)  # 求列表最大值
    max_idx = max_list_mid.index(max_value)  # 求最大值对应索引
    return max_idx

在这里插入图片描述

3.4. CART

# 计算单个属性基尼指数
def c_gini(data, label):
    # 几个值循环几次
    count_value = Counter(data)

    gini = 0
    for value_a in count_value.keys():
        d = count_value[value_a] / len(label)
        class_gini = 1
        # 取出值一样的data的value
        same_value_class = label[data == value_a]
        count_labels = Counter(same_value_class)
        for i in count_labels.values():
            class_gini -= (i / count_value[value_a])**2
        gini += d * class_gini
    return gini


# 计算计算每个属性的基尼指数并求最小的
def find_gini(data, label):
    label = label.flatten()
    feature_count = data.shape[1]
    min_list = []
    for i in range(feature_count):
        min_list.append(c_gini(data[:, i], label))
    min_value = min(min_list)  # 求列表最小值
    min_idx = min_list.index(min_value)  # 求最小值对应索引
    return min_idx

在这里插入图片描述

3.5. sklearn实现


def sk(data_train, label_train, data_test, label_test):
    clf = tree.DecisionTreeClassifier(criterion="entropy")
    clf = clf.fit(data_train, label_train)
    score = clf.score(data_test, label_test)  # 返回精确度
    print("准确率为：", score * 100, "%")

    # 画决策树
    feature_name = ['色泽', '根蒂', '敲声', '纹理', '脐部', '触感']
    import matplotlib as mpl
    mpl.rcParams['font.sans-serif'] = ['FangSong']  # 指定中文字体
    mpl.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False  # 正常显示负号
    fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(4, 4), dpi=300)
    tree.plot_tree(clf,
                feature_names=feature_name,
                class_names=["好瓜", "坏瓜"],
                filled=True,  # 填充颜色，颜色越深，不纯度越低
                rounded=True  # 框的形状
                )
    plt.show()

结果如下

在这里插入图片描述

可视化一下：

在这里插入图片描述

4. 几个注意点(面试问题)

  决策树有几个注意点，可能会在面试中被提到，还是比较能体现被面试者对这个算法的理解的。当然我们也不一定就是为了面试，搞清楚这些问题对帮助我们理解这个算法还是很有好处的。其中部分答案是博主自己的理解，如果有问题麻烦路过的大佬评论区指正。

  1. 决策树常使用那些常用的启发函数？

答：

  • ID3 => 最大信息增益
  • C4.5 => 最大信息增益比
  • CART => 最大基尼指数

这仨还有一些特点：

  • ID3 泛化能力弱，C4.5一定程度上惩罚了取值较多的特征，避免ID3的过拟合，提升泛化能力。

  • ID3 只能处理离散数据，其他俩都可以处理连续型变量，C4.5靠排序后找分割线把连续型变量转化为布尔型，CART靠对特征二值划分。

  • ID3 C4.5 只能做分类任务，CART可以分类也可以回归。

  • ID3 对缺失值特别敏感。

  • ID3 C4.5 每个节点可以产生多分支，CART只会产生二分支。

  1. 决策树是如何进行剪枝的？

答：

老生常谈的问题了，前面也有讲。这里就重复讲下。

预剪枝

在树长到一定深度后停止生长，当树的节点样本数小于某个阈值时停止生长，每次分裂树带来的提升小于某个阈值时停止生长。

可能导致欠拟合。不过比较适合大规模的问题，在分类后期准确率会有显著增长。需要有经验的人确定相关参数（节点样本数、最大深度等）

后剪枝

后剪枝是在树建立后，从下往上计算是否需要剪掉一部分子树并用叶子代替。比较难的地方是几个后剪枝的方法（错误率降低后剪枝、悲观剪枝、代价复杂度剪枝、最小误差剪枝、CVP、OPP 等）。这个比较复杂，不详细介绍。

  1. 决策树递归时导致递归返回的三种条件？

答：

  • 当前节点包含的样本全部属于统同一类别，无需划分。
  • 当前属性集为空，或是所有样本在所有属性上取值相同，无法划分。
  • 当前节点包含的样本集合为空，不能划分。
  1. 计算恋爱数据集。数据集如下：
样本颜值（A）身材（B）性格（C）收入（D）学历（E）交往（R）
1101111
2110000
3111111
4101010
5110100
6010110
7110000
8101111
9001110
10111111
11101000
12001110
13111011
14101111
15111111

答：
暂时就算一个颜值和身材哈~~

在这里插入图片描述
在这里插入图片描述

5. 运行（可直接食用）

import random
from collections import Counter
import numpy as np
import pandas as pd
import warnings
from matplotlib import pyplot as plt
warnings.filterwarnings("ignore")
from sklearn import tree


class Node(object):
    def __init__(self, son=None, data=None, label=None, node_label=None):
        self.son = son      # 节点的子节点
        self.data = data    # 节点包含的数据
        self.label = label  # 节点包含的标签
        self.node_label = node_label    # 按照哪个属性分类
        self.if_leaf = False        # 默认不是子节点


def build_tree(data, label, choice):
    mytree = Node()
    # 全部属于一个类别
    if np.unique(label.flatten()).shape[0] == 1:
        mytree.if_leaf = True
        mytree.label = label[0]
        return mytree
    # 当前属性都属于一个类别
    if np.unique(data, axis=0).shape[0] == 1:
        mytree.if_leaf = True
        # 听天由命，直接选第一个
        mytree.label = label[0]
        return mytree
    # 样本或属性集合是空的
    if label.shape[0] == 0:
        mytree.if_leaf = True
        # 从来没碰到这种情况，默认0
        mytree.label = 0
        return mytree
    # 判断
    if choice == 1:
        mytree = Node(data=data, label=label, node_label=find_entropy_index(data, label))
    if choice == 2:
        mytree = Node(data=data, label=label, node_label=find_entropy_ratio(data, label))
    if choice == 3:
        mytree = Node(data=data, label=label, node_label=find_gini(data, label))
    mytree.son_label = Counter(data[:, mytree.node_label]).keys()
    # 递归
    # for feature_class in Counter(data[:, mytree.node_label]).keys():
    #     print(data[data[:, mytree.node_label] == feature_class], "\n", label[data[:, mytree.node_label] == feature_class],"\n\n")

    mytree.son = {feature_class: build_tree(data[data[:, mytree.node_label] == feature_class], label[data[:, mytree.node_label] == feature_class], choice) for feature_class in Counter(data[:, mytree.node_label]).keys()}
    return mytree



# 计算信息熵
def c_entropy(label):
    # 每类有几个
    count_class = Counter(label)
    ret = 0
    for classes in count_class.keys():
        ret += count_class[classes]/len(label)*np.log2(count_class[classes]/len(label))
    return -ret


# 计算单个属性信息增益
def c_entropy_gain(data, label):
    ent = c_entropy(label)
    # 几个值循环几次
    count_value = Counter(data)
    sum_entropy = 0
    for value_a in count_value.keys():
        sum_entropy += count_value[value_a] / len(label) * c_entropy(label[data == value_a])
    return ent - sum_entropy



# 计算计算每个属性的信息增益并求最大的
def find_entropy_index(data, label):
    label = label.flatten()
    feature_count = data.shape[1]
    max_list = []
    for i in range(feature_count):
        max_list.append(c_entropy_gain(data[:, i], label))
    max_value = max(max_list)  # 求列表最大值
    max_idx = max_list.index(max_value)  # 求最大值对应索引
    return max_idx


# 计算单个属性信息增益率
def c_entropy_gain_rate(data, label):
    ent = c_entropy(label)
    # 几个值循环几次
    count_value = Counter(data)
    sum_entropy = 0
    sum_iv = 0
    for value_a in count_value.keys():
        d = count_value[value_a] / len(label)
        sum_entropy += d * c_entropy(label[data == value_a])
        sum_iv -= d * np.log2(d)
    return (ent - sum_entropy) / sum_iv


# 计算计算每个属性的信息增益率并求最大的
def find_entropy_ratio(data, label):
    # 返回大于中位数的下标
    def get_mid_index(list):
        mid = int(len(list)/2)
        b = sorted(enumerate(list), key=lambda x: x[1])  # x[1]是因为在enumerate(a)中，a数值在第1位
        c = [x[0] for x in b]  # 获取排序好后b坐标,下标在第0位
        return c[mid:]


    label = label.flatten()
    feature_count = data.shape[1]
    max_list_e = []
    max_list = []
    for i in range(feature_count):
        max_list_e.append(c_entropy_gain(data[:, i], label))
        max_list.append(c_entropy_gain_rate(data[:, i], label))
    # 只保留信息增益大于平均水平的
    max_list_mid = [max_list[i] for i in get_mid_index(max_list_e)]
    max_value = max(max_list_mid)  # 求列表最大值
    max_idx = max_list_mid.index(max_value)  # 求最大值对应索引
    return max_idx


# 计算单个属性基尼指数
def c_gini(data, label):
    # 几个值循环几次
    count_value = Counter(data)

    gini = 0
    for value_a in count_value.keys():
        d = count_value[value_a] / len(label)
        class_gini = 1
        # 取出值一样的data的value
        same_value_class = label[data == value_a]
        count_labels = Counter(same_value_class)
        for i in count_labels.values():
            class_gini -= (i / count_value[value_a])**2
        gini += d * class_gini
    return gini


# 计算计算每个属性的基尼指数并求最小的
def find_gini(data, label):
    label = label.flatten()
    feature_count = data.shape[1]
    min_list = []
    for i in range(feature_count):
        min_list.append(c_gini(data[:, i], label))
    min_value = min(min_list)  # 求列表最小值
    min_idx = min_list.index(min_value)  # 求最小值对应索引
    return min_idx


def sk(data_train, label_train, data_test, label_test):
    clf = tree.DecisionTreeClassifier(criterion="entropy")
    clf = clf.fit(data_train, label_train)
    score = clf.score(data_test, label_test)  # 返回精确度
    print("准确率为：", score * 100, "%")

    # 画决策树
    feature_name = ['色泽', '根蒂', '敲声', '纹理', '脐部', '触感']
    import matplotlib as mpl
    mpl.rcParams['font.sans-serif'] = ['FangSong']  # 指定中文字体
    mpl.rcParams['axes.unicode_minus'] = False  # 解决保存图像是负号'-'显示为方块的问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False  # 正常显示负号
    fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(4, 4), dpi=300)
    tree.plot_tree(clf,
                feature_names=feature_name,
                class_names=["好瓜", "坏瓜"],
                filled=True,  # 填充颜色，颜色越深，不纯度越低
                rounded=True  # 框的形状
                )
    plt.show()


def pridect(data, mytree):

    # 找下个节点
    def find_result(mytree, row):
        # 如果是叶子节点
        if mytree.if_leaf:
            return mytree.label
        # 不是叶子节点就继续找
        row_the_value = row[mytree.node_label]
        return find_result(mytree.son[row_the_value], row)

    ret = np.array([find_result(mytree, row) for row in data])
    return ret


def eveluate(predict, result):
    correct = 0
    for i in range(predict.shape[0]):
        correct += (int(predict[i][0]+0.5) == result[0])
    print("准确率为：", correct / predict.shape[0] * 100, "%")

if __name__ == '__main__':
    random.seed(1129)
    data = pd.read_csv("watermelonData.csv").sample(frac=1, random_state=1129)
    # 因为西瓜数据集每列都是0到2的，所以这里就不进行标准化了

    labels = data["label"]
    data_shuffled = np.array(data[data.columns[:-1]])
    # 划分训练集测试集
    data_train = data_shuffled[:int(data_shuffled.shape[0]*0.6), :]
    label_train = np.array(labels[:data_train.shape[0]]).reshape(-1, 1)
    data_test = data_shuffled[data_train.shape[0]:, :]
    label_test = np.array(labels[data_train.shape[0]:]).reshape(-1, 1)

    choice = 0
    while choice != 5:
        print("1. ID3求解\n2. C45求解\n3. CART求解\n4. sklearn求解\n5. 退出")
        try:
            choice = int(input())
        except:
            break
        if choice == 1:
            print("ID3求解中...")
            mytree = build_tree(data_train, label_train, choice)
            eveluate(pridect(data_test, mytree), label_test)
            # find_entropy_index(data_train, label_train)
        elif choice == 2:
            print("C45求解中...")
            mytree = build_tree(data_train, label_train, choice)
            eveluate(pridect(data_test, mytree), label_test)
            # find_entropy_ratio(data_train, label_train)
        elif choice == 3:
            print("CART求解中...")
            mytree = build_tree(data_train, label_train, choice)
            eveluate(pridect(data_test, mytree), label_test)
            # find_gini(data_train, label_train)
        elif choice == 4:
            print('sklearn yyds')
            sk(data_train, label_train, data_test, label_test)
        else:
            print("退出成功")
            break

参考：
吴恩达《机器学习》
sklearn官网
《百面机器学习》

铖铖的花嫁
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
决策树在sklearn中的实现
Nefelidata_do的博客
04-18 316
决策树在sklearn中的实现 一、sklearn scikit-learn是一个开源的基于python语言的机器学习工具包，通过Numpy，Scipy，matplotlib等python数值计算的库实现高效的算法应用，并且涵盖了几乎所有主流的机器学习算法。 二、决策树 1、决策树概述 决策树（Decision tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并且用树状图来呈现这些规则，以解决分类和回归问题。 2、决策树工作原理 不断的对某条数据的特征进行提问，直至
【sklearn】使用sklearn实现决策树
Eli_Code
03-19 8850
1. 决策树介绍 1. 信息熵 2. 信息增益 3. 信息熵和信息增益 2. 使用sklearn实现决策树 1. 导入包和数据 2. 数据处理 3. 开始训练模型 4. 使用模型预测 决策树可视化 3. 附录 1. 关于 `DictVectorizer( )` 2. 关于 `dict(zip())` 3. 关于 `tree.DecisionTreeClassifier`
机器学习之决策树(手推公式版)
夏小悠的博客
02-02 2939
本篇博文主要介绍了机器学习里面的决策树算法，并给出了相关的计算过程，最后使用主流的机器学习库sklearn来实现决策树。机器学习(手推公式版)系列持续更新中...
机器学习基础|Sklearn实现决策树
yangke
07-09 911
Sklearn决策树API sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2,min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None, min_impurity_decrease=0.0,
机器学习实验七：决策树-基于信贷数据集，使用sklearn中相关库实现决策树的构造
weixin_60530224的博客
10-27 346
住房 (1表示拥有住房，0表示没有住房) ;婚姻 (0表示单身1表示已婚，2表示离异) ;年收入一栏中单位为1000元; (拖欠贷款一栏0表示不拖欠，1表示拖欠) 讨论sklearn中tree.DecisionTreeClassifier()重要的参数有哪些，怎么调整； 使用tree.DecisionTreeClassifier()、 graphviz函数，选择合适的算法，构造并绘制决策树
Python机器学习之决策树算法实例详解
12-25
本文实例讲述了Python机器学习之决策树算法。分享给大家供大家参考，具体如下： 决策树学习是应用最广泛的归纳推理算法之一，是一种逼近离散值目标函数的方法，在这种方法中学习到的函数被表示为一棵决策树。决策树...
机器学习-基于Python实现的机器学习算法之决策树.zip
最新发布
03-03
机器学习_基于Python实现的机器学习算法之决策树
python机器学习之决策树分类详解
01-20
决策树分类与上一篇博客k近邻分类的最大的区别就在于，k近邻是没有训练过程的，而决策树是通过对训练数据进行分析，从而构造决策树，通过决策树来对测试数据进行分类，同样是属于监督学习的范畴。决策树的结果类似如...
西瓜书《机器学习》---第四章 决策树python代码实现
06-21
4.4 编程实现基于基尼指数进行划分选择的决策树算法，为西瓜数据集2.0生成预剪枝、后剪枝决策树，并与未剪枝决策树进行比较。 4.6 选择4个UCI数据集，对上述2种算法产生的未剪枝，预剪枝，后剪枝的决策树进行实验...
决策树(Decision tree)基本原理与基于scikit-learn的实现
weixin_60737527的博客
08-13 1406
决策树(Decision Tree)基本原理与基于scikit-learn的实现。
机器学习之决策树的原理及sklearn实现
starlet_kiss的博客
09-04 542
1.概述 1.1 决策树是如何工作的？ 决策树（Decision Tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并用树状图的结构来呈现这些规则，以解决分类和回归问题。决策树算法容易理解，适用各种数据，在解决各种问题时都有良好表现，尤其是以树模型为核心的各种集成算法，在各个行业和领域都有广泛的应用。 决策树算法的本质是一种图结构，我们只需要问一系列问题就可以对数据进行分类了。比如说，来看看下面这组数据集，这是一系列已知物种以及所属类别的数据： 目标是，将动物们分为
决策树入门、sklearn实现、原理解读和算法分析
taozibaby的博客
04-23 359
决策树入门、sklearn实现、原理解读和算法分析
sklearn入门&决策树在sklearn中的实现
momokofly的博客
03-15 4029
sklearn入门 scikit-learn官网：http://scikit-learn.org/stable/index.html 中文翻译网址：https://sklearn.apachecn.org/docs/master/2.html 算法原理推荐书籍：《数据挖掘导论》、《机器学习》 决策树 1 概述 非参数的有监督学习方法，决策树算法的本质是一种图结构 通过对记录的特征的提问，对样本进行分类 关于决策树的节点概念： 1、根节点：没有进边，有出边，包含最初的，针对特征的提问 2、中间节点：既有进边也
python-sklearn数据拆分与决策树的实现
rettbbetter的博客
02-10 1516
学习sklearn对数据拆分的实现，以及实现决策树模型并绘制决策树。数据集用sklearn内置数据及进行举例🌷。 小L希望可以在这里与大家一起进步！💪
sklearn决策树
叁的Blog
09-13 2679
sklearn决策树学习
机器学习系列（1）——决策树的简单总结
从此醉
08-15 4187
文章目录0x01、决策树的基本概念1.1 Hunt算法1.2 决策树归纳的设计问题1.3 决策树归纳算法的框架0x02、决策树的过拟合2.1 泛化误差估计2.2 过拟合的处理方法0x03、评估分类器的性能0x04、决策树的总结4.1 决策树算法的要点4.2 算法比较4.3 决策树算法的优缺点参考资料 本文主要是对决策树的概念性的归纳和总结。 0x01、决策树的基本概念 决策树是一种由结点和有向边组成的层次结构。树中包含三种结点：根结点、内部结点和叶结点。 决策树通常采用贪心策略，在选择划分数据的属性时，采取
python调包侠_sklearn调包侠之决策树算法
weixin_39681644的博客
02-21 602
决策树原理改进算法但使用信息增益作为特征选择指标(ID3算法)容易造成过拟合。举一个简单例子，每个类别如果都有一个唯一ID，通过ID这个特征就可以简单分类，但这并不是有效的。为了解决这个问题，有了C4.5和CART算法，其区别如下所示：ID3 是信息增益划分C4.5 是信息增益率划分CART 做分类工作时，采用 GINI 值作为节点分裂的依据实战——泰坦尼克号生还预测数据导入与预处理该数据可在ka...
sklearn实现决策树
qq_47180202的博客
09-23 9516
sklearn实现决策树sklearn中的决策树一、DecisionTreeClassifier1、重要参数1.1 criterion1.2 random_state & splitter1.3剪枝参数2、建立一棵树 sklearn中的决策树 模块：sklearn.tree tree.DecisionTreeClassifier 分类树 tree.DecisionTreeRegressor 回归树 tree.export_graphviz 将生成的决策树导出为DOT模式，画图专
机器学习之决策树实例python
05-16
决策树是常用的机器学习算法之一，通过对数据的分类和特征值计算来完成对未知数据的预测。本文将介绍使用Python实现决策树算法的相关步骤。 首先，需要导入决策树算法工具包，使用以下代码： ```python from ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

铖铖的花嫁

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值