决策树分类算法【sklearn/决策树分裂指标/鸢尾花分类实战】

-指短琴长-2024-11-24 7:04

决策树分类算法

  • [1. 什么是决策树？](#1. 什么是决策树？)
  • [2. DecisionTreeClassifier的使用（sklearn）](#2. DecisionTreeClassifier的使用（sklearn）)
    • [2.1 算例介绍](#2.1 算例介绍)
    • [2.2 构建决策树并实现可视化](#2.2 构建决策树并实现可视化)
  • [3. 决策树分裂指标](#3. 决策树分裂指标)
    • [3.1 信息熵（ID3）](#3.1 信息熵（ID3）)
    • [3.2 信息增益](#3.2 信息增益)
    • [3.3 基尼指数（CART）](#3.3 基尼指数（CART）)
  • [4. 代码实现选择最优划分属性](#4. 代码实现选择最优划分属性)
  • [5. 鸢尾花分类实战](#5. 鸢尾花分类实战)

1. 什么是决策树？

决策树属于有监督机器学习的一种，起源非常早，符合直觉并且非常直观，模仿人类做决策的过程，早期人工智能模型中有很多应用，现在更多的是使用基于决策树的一些集成学习的算法。这一章我们先把决策树算法理解透彻，有利于后面学习集成学习。

1. 示例一

  • 我们有如下数据：
ID 拥有房产（是/否） 婚姻[单身，已婚，离婚] 年收入（单位：千元） 无法偿还债务（是/否）
1 是 单身 125 否
2 否 已婚 100 否
3 否 单身 70 否
4 是 已婚 120 否
5 否 离婚 95 是
6 否 已婚 60 否
7 是 离婚 220 否
8 否 单身 85 是
9 否 已婚 75 否
10 否 单身 90 是
  • 上表根据历史数据，记录已有的用户是否可以偿还债务，以及相关的信息。通过该数据，构建的决策树如下：
  • 比如新来一个用户：无房产，单身，年收入55K，那么根据上面的决策树，可以预测他无法偿还债务（蓝色虚线路径）。从上面的决策树，还可以知道是否拥有房产可以很大程度上决定用户是否可以偿还债务，对借贷业务具有指导意义。

2. 示例二

  • 女孩母亲要给她介绍对象，女孩问母亲该对象的具体情况：年龄是多少，母亲说24。长得帅吗？挺帅的。收入高吗？中等收入。是公务员吗？母亲说，是的。女孩决定去见见。
  • 由此也可以构建出一棵决策树：
  • 上面那棵树中，属性为绿色的节点（年龄、长相、收入、是否是公务员），
    一般使用X表示。跟属性对应的是目标值（橘色节点），一般使用y表示。
  • 构建这棵树时，每个人，标准不同，树结构不同。那么用计算机该如何构建决策树呢？划分的标准又是什么。

2. DecisionTreeClassifier的使用（sklearn）

2.1 算例介绍

接下来我们要用sklearn现成的方法，解决区分一个用户，是真人还是机器的问题。训练集数据如下：

ID 日志密度 好友密度 真实头像 账号真伪
0 s s N N
1 s l Y Y
2 l m Y Y
3 m m Y Y
4 l m Y Y
5 m l N Y
6 m s Y N
7 l m Y Y
8 m s Y Y
9 s s Y N

其中s、m和l分别表示小、中和大。账号是否真实跟属性：日志密度、好友密度、是否使用真实头像有关系。

2.2 构建决策树并实现可视化

1. 构建决策树

python 复制代码 
import numpy as np
import pandas as pd
from sklearn.tree import DecisionTreeClassifier

y = np.array(list('NYYYYYNYYN'))	# 目标值	
X = pd.DataFrame({'日志密度':list('sslmlmmlms'),
                  '好友密度':list('slmmmlsmss'),
                  '真实头像':list('NYYYYNYYYY')})

# 整理数据，将字符类型转化为整型
X['日志密度'] = X['日志密度'].map({'s':0, 'm':1, 'l':2})
X['好友密度'] = X['好友密度'].map({'s':0, 'm':1, 'l':2})
X['真实头像'] = X['真实头像'].map({'N':0, 'Y':1})

# 建模和预测
model = DecisionTreeClassifier() # 默认划分标准是基尼指数

model.fit(X, y)		# 训练模型
model.score(X, y)	# 训练集评估

2. 实现可视化

  • sklearn的tree模块中提供了丰富的可视化功能。
python 复制代码 
# 决策树可视化
from sklearn import tree
import matplotlib.pyplot as plt

plt.rcParams['font.family'] = 'STKaiti'		# 修改字符显示
plt.figure(figsize=(12, 12))
fn = X.columns		# 拿出属性名

tree.plot_tree(model, filled=True, feature_names=fn)
  • 大家可以看到，上图形成的是一棵二叉树。今天我们所学习的二叉树，默认引入二分法连续值处理机制。

3. 使用信息熵来生成决策树

python 复制代码 
model = DecisionTreeClassifier(criterion='entropy') # 指定划分标准为entropy

model.fit(X, y)
model.score(X, y)

# 决策树可视化
from sklearn import tree
import matplotlib.pyplot as plt

plt.rcParams['font.family'] = 'STKaiti'
plt.figure(figsize=(12, 12))
fn = X.columns

tree.plot_tree(model, filled=True, feature_names=fn)

还可以配合graphviz来实现可视化，大家可以去看我的另一篇博客。

3. 决策树分裂指标

3.1 信息熵（ID3）

1. 概念

  • 在物理学热力第二定律中，描述的是封闭系统中的混乱程度。今天，在机器学习的理念中，描述的是一个样本集的纯粹程度。

2. 公式
H ( x ) = − ∑ i = 1 n p ( x ) l o g 2 p ( x ) H(x) = -\sum\limits_{i = 1}^n p(x)log_2p(x) H(x)=−i=1∑np(x)log2p(x)
H ( x ) = ∑ i = 1 n p ( x ) l o g 2 1 p ( x ) H(x) = \sum\limits_{i = 1}^n p(x)log_2\frac{1}{p(x)} H(x)=i=1∑np(x)log2p(x)1

  • 其中 p ( x ) p(x) p(x) 表示某类样本出现的概率。放在上面的例子中就是，样本集中真假账号的占比。

3. 手动计算信息熵（用到的数据还是2中的X，y）

  • 未分类的信息熵（根节点信息熵）：
python 复制代码 
y = np.array(list('NYYYYYNYYN'))
X = pd.DataFrame({'日志密度':list('sslmlmmlms'),
                  '好友密度':list('slmmmlsmss'),
                  '真实头像':list('NYYYYNYYYY')})
X['真实用户'] = y       # 把目标值这一列也添加进X

X['日志密度'] = X['日志密度'].map({'s':0, 'm':1, 'l':2})
X['好友密度'] = X['好友密度'].map({'s':0, 'm':1, 'l':2})
X['真实头像'] = X['真实头像'].map({'N':0, 'Y':1})

p1 = (y == 'N').mean()  # N类型数据的占比
p2 = (y == 'Y').mean()  # Y类型数据的占比
entropy = p1 * np.log2(1/p1) + p2 * np.log2(1/p2) # 0.8812908992306926
print(entropy)

"""
输出：
0.8812908992306926
"""
  • 按照日志密度进行划分后，得到的子样本信息熵带权加和：
    • 如果按照日志密度进行划分，可选的二分划分点有两个[0.5, 1.5]，因为日志密度的取值为[0, 1, 2]。
    • 这里的entropy不再是单纯的信息熵，而是每个划分后子节点的信息熵，带权加和。权重就是子节点样本数占根节点的比重。
    • 这里之所以计算的是子样本信息熵的带权加和，而不是单独各个子样本的信息熵，是为了之后计算信息增益做准备。
python 复制代码 
x = X['日志密度'].unique() 
# 拿到的结果可能是乱序的，我们排一下序
x.sort() # [0, 1, 2]

for i in range(len(x) - 1):
    split = x[i:i+2].mean() # 遍历划分点
    cond = X['日志密度'] <= split   # 分成两边，每一边分别计算信息熵
    # 计算概率分布
    p = cond.value_counts()/cond.size # 得到的p是Series类型数据，索引是True, Flase，值是比率
    indexs = p.index    # 拿到索引True, False
    entropy = 0 # 信息熵
    for index in indexs:
        sub = X[cond == index]['真实用户']
        # 子节点的概略分布
        p_sub = sub.value_counts()/sub.size
        # 每个分支节点的信息熵带权加和，权重是p[index]
        entropy += (p_sub * np.log2(1/p_sub)).sum() * p[index]
    print(split, entropy)

"""
输出：
0.5 0.689659695223976
1.5 0.689659695223976
"""

上面我们用sklearn形成的决策树中，根节点很明显是根据好友密度划分的，为什么不能先根据日志密度或者其他属性划分？这个最优划分属性又是如何确定的？

3.2 信息增益

1. 概念及公式

  • 信息增益是指通过某个属性划分后，事件的不确定性下降的程度。写作 g ( X , y ) g(X,y) g(X,y)。它的计算方式为熵减去条件熵，公式如下：

g ( X , y ) = H ( Y ) − H ( Y ∣ X ) g(X,y) = H(Y) - H(Y|X) g(X,y)=H(Y)−H(Y∣X)​

  • 表示的是，知道了某个条件后，原来事件不确定性降低的幅度。那这个值肯定越大越好。
  • 这个 H ( Y ) H(Y) H(Y) 指的就是根节点信息熵， H ( Y ∣ X ) H(Y|X) H(Y∣X) 指的就是子节点信息熵带权加和。

2. 对比不同属性的信息增益

  • 使用日志密度划分的信息增益：
    • 之前已经算过了，划分点为0.5或1.5得到的条件熵一样，为0.689，任选一个。根节点的信息熵为0.811。故信息增益为0.881 - 0.689 = 0.192。
  • 使用好友密度划分的信息增益：
    • 最优的划分点是0.5，此时条件熵为0.324，最小。故信息增益为0.881 - 0.324 = 0.557。
python 复制代码 
x = X['好友密度'].unique() 
# 拿到的结果可能是乱序的，我们排一下序
x.sort() 

for i in range(len(x) - 1):
    split = x[i:i+2].mean() # 遍历划分点
    cond = X['好友密度'] <= split   # 分成两边，每一边分别计算信息熵
    # 计算概率分布
    p = cond.value_counts()/cond.size # 得到的p是Series类型数据，索引是True, Flase，值是比率
    indexs = p.index    # 拿到索引True, False
    entropy = 0 # 信息熵
    for index in indexs:
        sub = X[cond == index]['真实用户']
        # 子节点的概略分布
        p_sub = sub.value_counts()/sub.size
        # 每个分支节点的信息熵带权加和，权重是p[index]
        entropy += (p_sub * np.log2(1/p_sub)).sum() * p[index]
    print(split, entropy)
    
"""
输出：
0.5 0.32451124978365314
1.5 0.763547202339972
"""
  • 使用真实头像划分的信息增益：
    • 只有一个划分点0.5，条件熵为0.849，故信息增益为0.881 - 0.849 = 0.032。
python 复制代码 
x = X['真实头像'].unique() 
# 拿到的结果可能是乱序的，我们排一下序
x.sort() 

for i in range(len(x) - 1):
    split = x[i:i+2].mean() # 遍历划分点
    cond = X['真实头像'] <= split   # 分成两边，每一边分别计算信息熵
    # 计算概率分布
    p = cond.value_counts()/cond.size # 得到的p是Series类型数据，索引是True, Flase，值是比率
    indexs = p.index    # 拿到索引True, False
    entropy = 0 # 信息熵
    for index in indexs:
        sub = X[cond == index]['真实用户']
        # 子节点的概略分布
        p_sub = sub.value_counts()/sub.size
        # 每个分支节点的信息熵带权加和，权重是p[index]
        entropy += (p_sub * np.log2(1/p_sub)).sum() * p[index]
    print(split, entropy)

"""
输出：
0.5 0.8490224995673064
"""
  • 使用好友密度划分得到的信息增益是最大的，故选择好友密度作为最优划分属性。

3.3 基尼指数（CART）

1. 概念

  • 基尼系数是指国际上通用的、用以衡量一个国家或地区居民收入差距的常用指标。
  • 基尼系数最大为"1"，最小等于"0"。基尼系数越接近 0 表明收入分配越是趋向平等。国际惯例把 0.2 以下视为收入绝对平均，0.2-0.3 视为收入比较平均；0.3-0.4 视为收入相对合理；0.4-0.5 视为收入差距较大，当基尼系数达到 0.5 以上时，则表示收入悬殊。
  • 基尼系数的实际数值只能介于 0～1 之间，基尼系数越小收入分配越平均，基尼系数越大收入分配越不平均。国际上通常把 0.4 作为贫富差距的警戒线，大于这一数值容易出现社会动荡。
  • Gini 系数越小，代表集合中的数据越纯，所有我们可以计算分裂前的值在按照某个维度对数据集进行划分，然后可以去计算多个节点的 Gini 系数。

2. 公式

g i n i = ∑ i = 1 n p i ( 1 − p i ) gini = \sum\limits_{i = 1}^np_i(1 - p_i) gini=i=1∑npi(1−pi)

  • 在对数据进行分类是gini系数的变化越大，说明划分越纯，效果越好。

4. 代码实现选择最优划分属性

1. 准备数据

python 复制代码 
import numpy as np
import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import graphviz

y = np.array(list('NYYYYYNYYN'))
X = pd.DataFrame({'日志密度':list('sslmlmmlms'),
                  '好友密度':list('slmmmlsmss'),
                  '真实头像':list('NYYYYNYYYY'),
                  '真实用户':y})

X['日志密度'] = X['日志密度'].map({'s':0, 'm':1, 'l':2})
X['好友密度'] = X['好友密度'].map({'s':0, 'm':1, 'l':2})
X['真实头像'] = X['真实头像'].map({'N':0, 'Y':1})

2. 使用sklearn生成决策树

  • 信息熵版本：
python 复制代码 
model = DecisionTreeClassifier(criterion='entropy')
model.fit(X.iloc[:,:-1], y)

dot_data = tree.export_graphviz(model, filled=True, rounded=True, feature_names=X.columns[:-1])

graphviz.Source(dot_data)
  • 基尼指数版本：
python 复制代码 
model = DecisionTreeClassifier()
model.fit(X.iloc[:,:-1], y)

# dot 点
dot_data = tree.export_graphviz(model, filled=True, rounded=True, feature_names=X.columns[:-1])

graphviz.Source(dot_data)

3. 用信息熵选择最优划分属性

python 复制代码 
cols = ['日志密度', '好友密度', '真实头像']

lower_entropy = 1   # 最小信息熵
best_split = {}      # 最佳划分条件

for col in cols:
    x = X[col].unique()
    x.sort()
    for i in range(len(x) - 1): # 获取最佳划分点
        split = x[i:i+2].mean()
        # 概率分布
        cond = X[col] <= split
        p = cond.value_counts() / cond.size

        indexs = p.index
        entropy = 0
        for index in indexs:
            sub = X[cond == index]['真实用户']
            # 子节点概率分布
            p_sub = sub.value_counts() / sub.size
            entropy += (p_sub * np.log2(1/p_sub)).sum() * p[index]
        if entropy < lower_entropy:
            lower_entropy = entropy
            best_split.clear()
            best_split[col] = split

print('最佳划分条件是：', best_split)

"""
输出：
最佳划分条件是： {'好友密度': 0.5}
"""

4. 使用基尼指数选择最优划分属性：

python 复制代码 
cols = ['日志密度', '好友密度', '真实头像']

lower_gini = 1   # 最小信息熵
best_split = {}      # 最佳划分条件

for col in cols:
    x = X[col].unique()
    x.sort()
    for i in range(len(x) - 1): # 获取最佳划分点
        split = x[i:i+2].mean()
        # 概率分布
        cond = X[col] <= split
        p = cond.value_counts() / cond.size

        indexs = p.index
        gini = 0
        for index in indexs:
            sub = X[cond == index]['真实用户']
            # 子节点概率分布
            p_sub = sub.value_counts() / sub.size
            gini += (p_sub * (1 - p_sub)).sum() * p[index]
        if gini < lower_gini:
            lower_gini = gini
            best_split.clear()
            best_split[col] = split

print('最佳划分条件是：', best_split)

"""
输出：
最佳划分条件是： {'好友密度': 0.5}
"""

5. 鸢尾花分类实战

1. 决策树分类鸢尾花数据集

python 复制代码 
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets

from sklearn.model_selection import train_test_split

iris = datasets.load_iris()
X = iris['data']    # 属性值
y = iris['target']  # 目标值

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=256)

model = DecisionTreeClassifier(criterion='gini')
model.fit(X_train, y_train)

# 测试数据得分
print('测试数据得分：', model.score(X_test, y_test))

print('算法预测的结果: ', model.predict(X_test))
print('真实的结果是:   ', y_test)

"""
输出：
测试数据得分： 0.9666666666666667
算法预测的结果:  [0 2 2 0 2 1 0 1 1 1 2 2 2 0 0 1 2 1 0 2 1 0 1 1 2 0 0 1 0 0]
真实的结果是:    [0 2 1 0 2 1 0 1 1 1 2 2 2 0 0 1 2 1 0 2 1 0 1 1 2 0 0 1 0 0]
"""

2. 可视化

python 复制代码 
import graphviz
from sklearn import tree

feature_names = iris['feature_names']    # 特征名
dot_data = tree.export_graphviz(model, filled=True, rounded=True, feature_names=feature_names)
graph = graphviz.Source(dot_data)

graph.render('Account',format='png')

3. 剪枝

python 复制代码 
iris = datasets.load_iris()

X = iris['data']
y = iris['target']
fn = iris['feature_names']
# 随机拆分
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 256)

# max_depth 调整树深度：剪枝操作
# max_depth 默认，深度最大，延伸到将数据完全划分开为止。
# min_impurity_decrease（节点划分最小不纯度）如果某节点的不纯度(基尼系数，信息增益，均方差)小于这个阈值，则该节点不再生成子节点
# max_depth（决策树最大深度）
# min_samples_split（内部节点再划分所需最小样本数）
# min_samples_leaf（叶子节点最少样本数）
# max_leaf_nodes（最大叶子节点数）
model = DecisionTreeClassifier(criterion='entropy',min_impurity_decrease=0.2)
model.fit(X_train,y_train)
y_ = model.predict(X_test)
print('真实类别是：',y_test)
print('算法预测是：',y_)
print('准确率是：',model.score(X_test,y_test))
# 导出数据
dot_data = tree.export_graphviz(model,feature_names=fn,
                     class_names=iris['target_names'],# 类别名
                     filled=True, # 填充颜色
                     rounded=True,)
graph = graphviz.Source(dot_data)
graph.render('./13-iris-裁剪', format='png')


4. 选择合适的超参，并可视化

python 复制代码 
import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn import tree
import matplotlib.pyplot as plt

X,y = datasets.load_iris(return_X_y=True)

# 随机拆分
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 256)
depth = np.arange(1,16)
err = []
for d in depth:
    model = DecisionTreeClassifier(criterion='entropy',max_depth=d)
    model.fit(X_train,y_train)
    score = model.score(X_test,y_test)
    err.append(1 - score)
    print('错误率为%0.3f%%' % (100 * (1 - score)))
plt.rcParams['font.family'] = 'STKaiti'
plt.plot(depth,err,'ro-')
plt.xlabel('决策树深度',fontsize = 18)
plt.ylabel('错误率',fontsize = 18)
plt.title('筛选合适决策树深度')
plt.grid()
plt.savefig('./14-筛选超参数.png',dpi = 200)
  • 输出：
0 复制代码 
错误率为31.579%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%
错误率为2.632%

5. 决策树副产物

  • 特征重要性：
python 复制代码 
model.feature_importances_

"""
输出：
array([0.        , 0.04621936, 0.89613255, 0.05764808])
"""
相关推荐
lu_rong_qq3 小时前
决策树 DecisionTreeClassifier() 模型参数介绍
算法·决策树·机器学习
weixin_466202788 小时前
第31周：天气识别(Tensorflow实战第三周)
分类·数据挖掘·tensorflow
吾门17 小时前
YOLO入门教程（三）——训练自己YOLO11实例分割模型并预测【含教程源码+一键分类数据集 + 故障排查】
yolo·分类·数据挖掘
Sxiaocai19 小时前
使用 PyTorch 实现并训练 VGGNet 用于 MNIST 分类
pytorch·深度学习·分类
shansjqun19 小时前
教学内容全覆盖：航拍杂草检测与分类
人工智能·分类·数据挖掘
爱敲代码的憨仔20 小时前
《线性代数的本质》
线性代数·算法·决策树
CV学术叫叫兽1 天前
快速图像识别：落叶植物叶片分类
人工智能·分类·数据挖掘
CV学术叫叫兽1 天前
一站式学习：害虫识别与分类图像分割
学习·分类·数据挖掘
Sxiaocai1 天前
使用TensorFlow实现简化版 GoogLeNet 模型进行 MNIST 图像分类
分类·tensorflow·neo4j
热门推荐
01【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07逆向微博热搜时光机(js逆向)08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇