（十一）决策树算法（分类）

2020-04-07 本文已影响0人羽天驿

一、原理及概念

计算机中的是二叉树，越往下越大。

决策树

sklearn中决策树分为DecisionTreeClassifier和DecisionTreeRegressor，所以用的算法是CART算法，也就是分类与回归树算法(classification and regression tree,CART)，划分标准默认使用的也是Gini，ID3和C4.5用的是信息熵

树
基本数据结构
二叉树
计算机中的树，倒着的
自然界中树，越往上，越大
计算机中的树，越往下越大
图片是二叉树吗？
- 不是二叉树，收入分成三叉
决策树，标准的二叉树
女孩母亲要给她介绍对象，年龄是多少，母亲说24。长得帅吗？挺帅的。收入高吗？中等收入。是公务员吗？母亲说，是的。女孩：好，我去见见。
上面那棵树中，属性：绿色的节点（年龄、长相、收入、是否是公务员）
- 属性叫做，data，数据，一般使用X表示
- 跟属性对应，目标值（橘色节点），一般使用y表示
构建这棵树时，先后顺序，每个人，标准不同，树结构不同
计算机，构建树，标准一致的，构建出来的树，一致
- 构建好一颗树，数据变的有顺序了（构建前，一堆数据，杂乱无章；构建一颗，整整齐齐，顺序），用什么度量衡表示，数据是否有顺序：信息熵
- 物理学，热力学第二定律（熵），描述的是封闭系统的混乱程度
- 信息熵，和物理学中熵类似的
- $H(x) = -\sum\limits_{i = 1}^n p(x)log_2p(x)$
- $H(x) = \sum\limits_{i = 1}^n p(x)log_2\frac{1}{p(x)}$
- gini系数
- $gini = \sum\limits_{i = 1}^np_i(1 - p_i)$
- 信息熵和gini系数中 p表示概率
- 对数据进行排序，数据，变得有序了，衡量标准，信息熵，gini系数
- 信息熵，越无序，越混乱，信息熵就越大，越有序，信息熵，就越小
- 数据进行排序之后，
  - 排序之前，混乱的，无序的，所以信息熵比较大
  - 排序之后，有序，信息熵变小
  - 排序之前和排序之后，信息熵，差值。大的数减去小的数
  - 差值叫做，信息增益（信息变得有序）
- 决策树理论基础是：信息论
- 决策树划分，是根据概率吗？不是，信息论！
- KNN、逻辑斯蒂回归概率论
- <img src="./熵案例.png" style="zoom:67%;" />
信息熵是什么
gini系数和信息熵，一个意思
- 信息熵，越大越混乱，越不纯，越小越好
- entropy = 1*log2(1) = 0
- gini系数，越大越混乱，越不纯；越小越好
- gini系数=0，纯净系统，系统（箱子全是红球），红球的概率是100% = 1.0
- gini = 1*（1-1） = 0
Tree Algorithms 决策树算法
- 代码2中，具体案例数据，进行计算
- 结论是，好友密度属性列分效果好于日志密度
- 理论依据就是：信息增益
- 这种算法就是ID3算法。

二、代码的案例

（一、信息熵的计算）

import numpy as np

image.png

$H = -\sum\limits_{i =1}^np_ilog_2p_i$

# 三个属性：日志密度、好友密度、是否使用真实头像
# 目标值：账号是否真实

# 构建决策树，使用属性进行裂分
# 不进行划分 3no 0.3 7yes 0.7
H1 = -(0.3*np.log2(0.3) + 0.7*np.log2(0.7))
H1

0.8812908992306927

$H = \sum\limits_{i =1}^np_ilog_2\frac{1}{p_i}$

H1 = (0.3*np.log2(1/0.3) + 0.7*np.log2(1/0.7))
H1

0.8812908992306926

根据某一属性，对类别进行划分，计算信息熵

根据信息增益，判别，属性重要性

# 根据日志密度进行划分，数据，变得有序一点，所以，熵变小！
# 根据日志密度进行划分
# s 3 0.3 -----> 2no 1yes
# m 4 0.4 -----> 1no 3yes
# l 3 0.3 -----> 3yes
H2 = 0.3*(2/3*np.log2(3/2) + 1/3*np.log2(3)) + 0.4*(0.25*np.log2(4) + 0.75*np.log2(4/3)) + 0.3*(1*np.log2(1))
print('根据日志密度进行划分，信息熵是：',H2)
print('信息增益是：',(H1 - H2))

根据日志密度进行划分，信息熵是： 0.5999999999999999
信息增益是： 0.2812908992306927

# 根据好友密度进行划分
# 好友比较少，容易是假账号，僵尸账号。
# s 4 0.4 -----> 3no 1yes
# m 4 0.4 -----> 4yes
# l 2 0.2 -----> 2yes
H3 = 0.4*(0.75*np.log2(4/3) + 0.25*np.log2(4)) + 0.4*(1*np.log2(1)) + 0.2*(1*np.log2(1))
print('根据好友密度进行划分，信息熵是：',H3)
print('信息增益是：',(H1 - H3))

根据好友密度进行划分，信息熵是： 0.32451124978365314
信息增益是： 0.5567796494470394

对比好友密度和日志密度

好友密度将数据划分的更加有序，更能找对规律！

构建决策树时，优先考虑好友密度！

（二、决策树的分类）

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(True)

# 随机拆分
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state = 256)

# max_depth调整树深度：剪枝操作
# max_depth默认，深度最大，延伸到将数据完全划分开为止。
model = DecisionTreeClassifier(max_depth=None,criterion='entropy')
model.fit(X_train,y_train)
y_ = model.predict(X_test)
print('真实类别是：',y_test)
print('算法预测是：',y_)
print('准确率是：',model.score(X_test,y_test))

真实类别是： [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 0 2 2 1 2 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 0 1 2 1 2 0
 0]
准确率是： 0.9736842105263158

# 决策树提供了predict_proba这个方法，发现这个方法，返回值要么是0，要么是1
model.predict_proba(X_test)

array([[1., 0., 0.],
       [0., 0., 1.],
       [0., 1., 0.],
       [1., 0., 0.],
       [0., 0., 1.],
       [0., 1., 0.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 1.],
       [0., 0., 1.],
       [1., 0., 0.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 1., 0.],
       [1., 0., 0.],
       [0., 0., 1.],
       [0., 1., 0.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [1., 0., 0.],
       [1., 0., 0.],
       [0., 1., 0.],
       [1., 0., 0.],
       [1., 0., 0.],
       [0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 1., 0.],
       [0., 0., 1.],
       [1., 0., 0.],
       [1., 0., 0.]])

一图顶千言，绘制决策树

# 设置图片的尺寸
# 鸢尾花4个属性
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默认，深度最大，延伸到将数据完全划分开为止。
model = DecisionTreeClassifier(max_depth=None,criterion='entropy')
model.fit(X_train,y_train)
y_ = model.predict(X_test)
print('真实类别是：',y_test)
print('算法预测是：',y_)
print('准确率是：',model.score(X_test,y_test))
plt.figure(figsize=(12,18))
_ = tree.plot_tree(model,filled = True,feature_names=fn)

真实类别是： [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 0 2 2 1 2 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 0 1 2 1 2 0
 0]
准确率是： 0.9736842105263158

output_4_1.png

对上面的决策树，进行剪枝

# 设置图片的尺寸
# 鸢尾花4个属性
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默认，深度最大，延伸到将数据完全划分开为止。
model = DecisionTreeClassifier(max_depth=2,criterion='entropy')
model.fit(X_train,y_train)
y_ = model.predict(X_test)
print('真实类别是：',y_test)
print('算法预测是：',y_)
print('准确率是：',model.score(X_test,y_test))
plt.figure(figsize=(6,9))
_ = tree.plot_tree(model,filled = True,feature_names=fn)

真实类别是： [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 0 2 2 1 2 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 0 1 2 1 2 0
 0]
准确率是： 0.9736842105263158

output_6_1.png