机器学习—决策树

决策树

ID	拥有房产	婚姻状态	年收入	无法偿还债务
1	是	单身	125	否
2	否	已婚	100	否
3	否	单身	10	否
4	是	已婚	110	否
5	是	离婚	60	否
6	否	离婚	95	是
7	否	单身	85	是
8	否	已婚	75	否
9	否	单身	90	是
10	否	离婚	220	否

• 当构建好一个判断模型后，新来一个用户后，可以根据构建好的模型直接进行判断，比如新用户特性为：无房产、单身、年收入55K，那么根据判断得出该用户无法进行债务偿还。这种决策对于借贷业务有比较好的指导意义。

比特化(Bits)

假设存在一组随机变量X，P(X=A)=1/4 P(X=B)=1/4 P(X=C)=1/4 P(X=D)=1/4

现在有一组由X变量组成的序列: BACADDCBAC…；如果现在希望将这个序列转换为二进制来进行网络传输，那么我们得到一个得到一个这样的序列:01001000111110010010…

结论: 在这种情况下，我们可以使用两个比特位来表示一个随机变量。

• 而当X变量出现的概率值不一样的时候，对于一组序列信息来讲，每个变量平均需要多少个比特位来描述？

P(X=A)=1/2 P(X=B)=1/4 P(X=C)=1/8 P(X=D)=1/8

A	B	C	D
0	10	110	111

$$

$$

$$\begin{gathered} E=1\ast \frac{1}{2}+2\ast frac13+3\ast \frac{1}{8}+3\ast \frac{1}{8} \\ E=-lo{g}_2(\frac{1}{2})\ast \frac{1}{2}-lo{g}_2(\frac{1}{4})\ast \frac{1}{4}--lo{g}_2(\frac{1}{8})\ast \frac{1}{8}\ast 2 \end{gathered}$$

一般化的比特化(Bits)

假设现在随机变量X具有m个值，分别为: V1 ,V2 ,…,Vm；并且各个值出现的概率如下表所示；那么对于一组序列信息来讲，每个变量平均需要多少个比特位来描述?

P(X=V1 )=p1 ,P(X=V2 )=p2, P(X=V3 )=p3… P(X=Vm)=pm

可以使用这些变量的期望来表示每个变量需要多少个比特位来描述信息:
$$\begin{gathered} E(X)=-p_{1}lo{g}_2(p_1)-p_{2}lo{g}_2(p_2)-...-p_{1}lo{g}_m(p_m) \\ =-\sum _{i=1}^m{p}_{i}lo{g}_2(p_i) \end{gathered}$$

信息熵(Entropy)

H(X)就叫做随机变量X的信息熵；
$$H(X)=-\sum _{i=1}^m{p}_{i}lo{g}_2(p_i)$$
• 信息量：指的是一个样本/事件所蕴含的信息，如果一个事件的概率越大，那么就可以认为该事件所蕴含的信息越少。极端情况下，比如：“太阳从东方升起” ，因为是确定事件，所以不携带任何信息量。

• 信息熵：1948年，香农引入信息熵；一个系统越是有序，信息熵就越低，一个系统越是混乱，信息熵就越高，所以信息熵被认为是一个系统有序程度的度量。

• 信息熵就是用来描述系统信息量的不确定度。

• High Entropy(高信息熵)：表示随机变量X是均匀分布的，各种取值情况是等概率出现的。

• Low Entropy(低信息熵)：表示随机变量X各种取值不是等概率出现。可能出现有的事件概率很大，有的事件概率很小。

信息熵(Entropy)案例

• 赌马比赛中，有两组赛马共八匹，获胜的概率如下：

	第一组	第二组
P(X=A)	1/4	13/20
P(X=B)	1/4	5/20
P(X=C)	1/4	1/20
P(X=D)	1/4	1/20

• 在比赛前，对于第一组而言，我们只知道A/B/C/D获胜的概率是一样的，我们是判断不出来任何偏向的；但是对于第二组而言，我们很清楚的就能够判断A会获胜。

条件熵H(Y|X)

• 给定条件X的情况下，随机变量Y的信息熵就叫做条件熵。

专业**(X)**	性别**(Y)**
数学	M
IT	M
英语	F
数学	F
数学	M
IT	M
英语	F
数学	F

$$\begin{gathered} P(X=数学)=0.5 \\ P(Y=M)=0.5 \\ P(X=数学,Y=F)=0.25 \\ P(Y=M|X=英语)=0 \\ H(X)=1.5 \\ H(Y)=1 \end{gathered}$$

• 当专业(X)为数学的时候，Y的信息熵的值为:H(Y|X=数学)=1

• 给定条件X的情况下，所有不同x值情况下Y的信息熵的平均值叫做条件熵。
$$H(Y|X)=\sum _{j=1}P(X=v_j)H(Y|X=v_j)$$
• 给定条件X的情况下，所有不同x值情况下Y的信息熵的平均值叫做条件熵。另外一个公式如下所示：
$$H(Y|X)=H(X,Y)-H(X)$$
事件(X,Y)发生所包含的熵，减去事件X单独发生的熵，即为在事件X发生的前提下，Y发生“新”带来的熵，这个也就是条件熵本身的概念。

决策树

• 决策树(Decision Tree)是在已知各种情况发生概率的基础上，通过构建决策树来进行分析的一种方式，是一种直观应用概率分析的一种图解法；决策树是一种预测模型，代表的是对象属性与对象值之间的映射关系；决策树是一种树形结构，其中每个内部节点表示一个属性的测试，每个分支表示一个测试输出，每个叶节点代表一种预测类别；决策树是一种非常常用的有监督的分类算法。

• 决策树的决策过程就是从根节点开始，测试待分类项中对应的特征属性，并按照其值选择输出分支，直到叶子节点，将叶子节点的存放的类别作为决策结果。

• 决策树分为两大类：分类树和回归树，前者用于分类标签值，后者用于预测连续值，常用算法有ID3、C4.5、CART等。

决策树构建过程

• 决策树算法的重点就是决策树的构造；决策树的构造就是进行属性选择度量，确定各个特征属性之间的拓扑结构(树结构)；构建决策树的关键步骤就是分裂属性，分裂属性是指在某个节点按照某一类特征属性的不同划分构建不同的分支，其目标就是让各个分裂子集尽可能的’纯’(让一个分裂子数据集中待分类的项尽可能的属于同一个类别)。

• 构建步骤如下:

• 1. 将所有的特征看成一个一个的节点；

• 2. 遍历当前特征的每一种分割方式，找到最好的分割点；将数据划分为不同的子节点，eg： N1、N2 …Nm；计算划分之后所有子节点的’纯度’信息；

• 3. 使用第二步遍历所有特征，选择出最优的特征以及该特征的最优的划分方式；得出最终的子节点:N1、N2 …Nm

• 4. 对子节点N1、N2 …Nm分别继续执行2-3步，直到每个最终的子节点都足够’纯’ 。

决策树特征属性类型

• 根据特征属性的类型不同，在构建决策树的时候，采用不同的方式，具体如下：

• 属性是离散值，而且不要求生成的是二叉决策树，此时一个属性就是一个分支

• 属性是离散值，而且要求生成的是二叉决策树，此时使用属性划分的子集进行测试，按照“属于此子集”和“不属于此子集”分成两个分支

• 属性是连续值，可以确定一个值作为分裂点split_point，按照>split_point和<=split_point生成两个分支

决策树分割属性选择

• 决策树算法是一种“贪心”算法策略，只考虑在当前数据特征情况下的最好分割方式，不能进行回溯操作。

• 对于整体的数据集而言，按照所有的特征属性进行划分操作，对所有划分操作的结果集的“纯度”进行比较，选择“纯度”越高的特征属性作为当前需要分割的数据集进行分割操作，持续迭代，直到得到最终结果。决策树是通过“纯度”来选择分割特征属性点的。

决策树量化纯度

• 决策树的构建是基于样本概率和纯度进行构建操作的，那么进行判断数据集是否“纯”可以通过三个公式进行判断，分别是Gini系数、熵(Entropy)、错误率，这三个公式值越大，表示数据越“不纯”；越小表示越“纯”；实践证明这三种公式效果差不多，一般情况使用熵公式。
$$\begin{gathered} Gini=1-\sum _{i=1}^{n}p(i{)}^2 \\ H(Entropy)=-\sum _{i=1}^m{p}_{i}lo{g}_2(p_i) \\ Error=1-ma{x}_{i=1}^{n}P(i) \end{gathered}$$

决策树量化纯度

• 当计算出各个特征属性的量化纯度值后使用信息增益度来选择出当前数据集的分割特征属性；如果信息增益度的值越大，表示在该特征属性上会损失的纯度越大 ，那么该属性就越应该在决策树的上层，计算公式为：
$$Gain=H(D)-H(D|A)$$
• D目标属性，A为某一个待划分的特征属性；Gain为A为特征对训练数据集D的信息增益，它为集合D的经验熵H(D)与特征A给定条件下D的经验条件熵H(D|A)之差

决策树算法的停止条件

• 决策树构建的过程是一个递归的过程，所以必须给定停止条件，否则过程将不会进行停止，一般情况有两种停止条件：

• 当每个子节点只有一种类型的时候停止构建

• 当前节点中样本数小于某个阈值，同时迭代次数达到给定值时，停止构建过程，此时使用max(p(i))作为节点的对应类型

• NOTE：方式一可能会使树的节点过多，导致过拟合(Overfiting)等问题；比较常用的方式是使用方式二作为停止条件。

决策树算法效果评估

• 决策树的效果评估和一般的分类算法一样，采用混淆矩阵来进行计算准确率、召回率、精确率等指标

• 也可以采用叶子节点的不纯度值总和来评估算法的效果，值越小，效果越好
$$loss=C(T)=\sum _{t=1}^{leaf}\frac{|D_t|}{D}H(t)$$
当构建好一个判断模型后，新来一个用户后，可以根据构建好的模型直接进行判断，当构建好一个判断模型后，新来一个用户后，可以根据构建好的模型直接进行判断，当构建好一个判断模型后，新来一个用户后，可以根据构建好的模型直接进行判断.

决策树主要算法

• 建立决策树的主要是以下三种算法

ID3、C4.5、CART（Classification And Regression Tree）

ID3算法

• ID3算法是决策树的一个经典的构造算法，内部使用信息熵以及信息增益来进行构建；每次迭代选择信息增益最大的特征属性作为分割属性

1. ID3算法只支持离散的特征属性，不支持连续的特征属性

2. ID3算法构建的是多叉树
   $$\begin{gathered} H(X)=-\sum _{i=1}^m{p}_{i}lo{g}_2(p_i) \\ Gain=H(D)-H(D|A) \end{gathered}$$

   ID3算法优缺点

• 优点:

• 决策树构建速度快；实现简单；

• 缺点：

• 计算依赖于特征取值数目较多的特征，而属性值最多的属性并不一定最优

• ID3算法不是递增算法

• ID3算法是单变量决策树，对于特征属性之间的关系不会考虑

• 抗噪性差

• 只适合小规模数据集，需要将数据放到内存中

C4.5算法

• 在ID3算法的基础上，进行算法优化提出的一种算法(C4.5)；现在C4.5已经是特别经典的一种决策树构造算法；使用信息增益率来取代ID3算法中的信息增益，在树的构造过程中会进行剪枝操作进行优化；能够自动完成对连续属性的离散化处理；C4.5构建的是多分支的决策树；C4.5算法在选中分割属性的时候选择信息增益率最大的属性，涉及到的公式为：
$$\begin{gathered} H(X)=-\sum _{i=1}^m{p}_{i}lo{g}_2(p_i) \\ Gain=H(D)-H(D|A) \\ Gai{n}_{r}atio(A)=\frac{Gain(A)}{H(A)} \end{gathered}$$

C4.5算法优缺点

• 优点：

• 产生的规则易于理解

• 准确率较高

• 实现简单

• 缺点：

• 对数据集需要进行多次顺序扫描和排序，所以效率较低

• 只适合小规模数据集，需要将数据放到内存中

CART算法

• 使用基尼系数(分类树)作为数据纯度的量化指标来构建的决策树算法就叫做CART(Classification And Regression Tree，分类回归树)算法。CART算法使用GINI增益率作为分割属性选择的标准，选择GINI增益率最大的作为当前数据集的分割属性；可用于分类和回归两类问题。强调备注：CART构建****是二叉树。
$$\begin{gathered} Gini=1-\sum _{i=1}^{n}p(i{)}^2 \\ Gain=Gini(D)-Gini((D|A) \\ Gain\_ratio(A)=\frac{Gain(A)}{Gini(A)} \end{gathered}$$

ID3、C4.5、CART分类树算法总结

• ID3、C4.5和CART算法均只适合在小规模数据集上使用

• ID3、C4.5和CART算法都是单变量决策树

• 当属性值取值比较多的时候，最好考虑C4.5算法，ID3得出的效果会比较差

• 决策树分类一般情况只适合小数据量的情况(数据可以放内存)

• CART算法是三种算法中最常用的一种决策树构建算法(sklearn中仅支持CART)。

• 三种算法的区别仅仅只是对于当前树的评价标准不同而已，ID3使用信息增益、

C4.5使用信息增益率、CART使用基尼系数。（不是主要区别）

• CART算法构建的一定是二叉树，ID3和C4.5构建的不一定是二叉树。(主要区别)

分类树和回归树的区别

• 分类树采用信息增益、信息增益率、基尼系数来评价树的效果，都是基于概率值进行判断的；而分类树的叶子节点的预测值一般为叶子节点中概率最大的类别作为当前叶子的预测值。

• 在回归树中，叶子节点的预测值一般为叶子节点中所有值的均值来作为当前叶子节点的预测值。所以在回归树中一般采用MSE或者MAE作为树的评价指标，即均方差
$$\begin{gathered} MSE=\frac{1}{n}\sum _{i=1}^n(y_i-\hat{y}{)}^2 \\ MAE=\frac{1}{n}\sum _{i=1}^n|y_i-\hat{y}| \end{gathered}$$
一般情况下，只会使用CART算法构建回归树。

决策树可视化

• graphviz服务安装(windows的安装)：

• 下载安装包(msi安装包): http://www.graphviz.org/；

• 执行下载好的安装包(双击msi安装包)；

• 将graphviz的根目录下的bin文件夹路径添加到PATH环境变量中；

• 方式一：将模型输出dot文件，然后使用graphviz的命令将dot文件转换为pdf格式的文件

• 方式二：直接使用pydotplus插件直接生成pdf文件进行保存

• 方式三：使用Image对象直接显示pydotplus生成的图片

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report, roc_curve, auc
import matplotlib
matplotlib.use('TkAgg')  # 或 'Agg', 'Qt5Agg' 等
import matplotlib.pyplot as plt


# 获取数据
datas = pd.read_csv("D:/save/datas/iris.data", sep=",", header=None, names=['A', 'B', 'C', 'D', 'cla'])
# print(datas.info())


# 数据清洗
class_name_2_label = {'Iris-setosa': 0, 'Iris-versicolor': 1, 'Iris-virginica': 2}
datas['cla'] = list(map(lambda cla: class_name_2_label[cla], datas['cla'].values))
# print(datas['cla'].values)


# 数据划分
X = datas.iloc[:, :4]
X = np.asarray(X).astype(np.float64)
print(X.shape)
Y = datas['cla']
# 对目标属性做一个类别的转换，将字符串的数据转换为从0开始的int值
# label_encode = LabelEncoder()
# Y = label_encode.fit_transform(Y)

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=28)
print("训练数据的类型:{}, 训练数据的格式:{}".format(type(x_train), x_train.shape))
# print(x_train)
print("测试数据的格式:{}".format(x_test.shape))
# print(x_test)

# 特征工程
std = StandardScaler()
x_train = std.fit_transform(x_train, y_train)
x_test = std.transform(x_test)


"""
def __init__(self,
             criterion="gini",
             splitter="best",
             max_depth=None,
             min_samples_split=2,
             min_samples_leaf=1,
             min_weight_fraction_leaf=0.,
             max_features=None,
             random_state=None,
             max_leaf_nodes=None,
             min_impurity_decrease=0.,
             min_impurity_split=None,
             class_weight=None,
             presort=False)
    criterion: 给定决策树构建过程中的纯度的衡量指标，可选值: gini、entropy， 默认gini
    splitter：给定选择特征属性的方式，best指最优选择，random指随机选择(局部最优)
    max_features：当splitter参数设置为random的有效，是给定随机选择的局部区域有多大。
    max_depth：剪枝参数，用于限制最终的决策树的深度，默认为None，表示不限制
    min_samples_split=2：剪枝参数，给定当数据集中的样本数目大于等于该值的时候，允许对当前数据集进行分裂；如果低于该值，那么不允许继续分裂。
    min_samples_leaf=1, 剪枝参数，要求叶子节点中的样本数目至少为该值。
    class_weight：给定目标属性中各个类别的权重系数。
"""
# 构建模型
algo = DecisionTreeClassifier(max_depth=3)

# 训练模型
algo.fit(x_train, y_train)

# 模型效果评估
print("各个特征属性的重要性权重系数（值越大，对应的特征属性就越重要）:{}".format(algo.feature_importances_))
print("训练数据上的分析报告")
print(classification_report(y_test, algo.predict(x_test)))
print("训练数据上的准确率:{}".format(algo.score(x_train, y_train)))
print("测试数据上的准确率:{}".format(algo.score(x_test, y_test)))

test1 = [x_test[6]]
print(x_test[6])
print("预测函数")
print(algo.predict(test1))

# ROC和AUC的计算
# # 对于三个类别分开计算auc和roc的值
y_predice_prob = algo.predict_proba(x_train)
# print(y_predice_prob)

# print(y_train)
y1_true = (y_train == 0).astype(np.int32)
# print(y1_true)
y1_score = y_predice_prob[:, 0]
fpr1, tpr1, _ = roc_curve(y1_true, y1_score)
auc1 = auc(fpr1, tpr1)

# 针对于类别2
y2_true = (y_train == 1).astype(np.int32)
y2_score = y_predice_prob[:, 1]
fpr2, tpr2, _ = roc_curve(y2_true, y2_score)
auc2 = auc(fpr2, tpr2)

# 针对于类别3
y3_true = (y_train == 2).astype(np.int32)
y3_score = y_predice_prob[:, 2]
fpr3, tpr3, _ = roc_curve(y3_true, y3_score)
auc3 = auc(fpr3, tpr3)

print(auc1, auc2, auc3)

plt.plot(fpr1, tpr1, 'r-o')
plt.plot(fpr2, tpr2, 'g-o')
plt.plot(fpr3, tpr3, 'b-o')
plt.show()

可视化

import os

import numpy as np
import pandas as pd

from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report

# 1、获取数据
names = ['A', 'B', 'C', 'D', 'cla']
df = pd.read_csv("D:/save/datas/iris.data", header=None, names=names, sep=',')
print(df.head())

# 2、数据清洗
X = df.drop('cla', axis=1)
X = np.asarray(X).astype(np.float64)
Y = df['cla']
lab = LabelEncoder()
Y = lab.fit_transform(Y)


# 3、数据划分
x_train, x_test, y_train,  y_test = train_test_split(X, Y, test_size=0.2, random_state=22)

# 4、特征工程
std = StandardScaler()
x_train = std.fit_transform(x_train, y_train)
x_test = std.transform(x_test)

# 5、构建模型
algo = DecisionTreeClassifier(criterion='entropy', max_depth=5, min_samples_split=2, min_samples_leaf=1)
algo.fit(x_train, y_train)
print("模型评估：")
print("各个特征属性的重要性权重系数(值越大，对应的特征属性就越重要):{}".format(algo.feature_importances_))
print("训练数据上的分类报告:")
print(classification_report(y_train, algo.predict(x_train)))
print("测试数据上的分类报告:")
print(classification_report(y_test, algo.predict(x_test)))
print("训练集上的准确率:{}".format(algo.score(x_train, y_train)))
print("测试集上的准确率：{}".format(algo.score(x_test, y_test)))

# 查看相关属性
test1 = x_test[0:5]
print("预测函数:")
print(algo.predict(test1))
print("预测概率函数:")
print(algo.predict_proba(test1))
print("叶节点索引:", algo.apply(test1))

# 决策树可视化
# 方式一：输出dot文件，然后使用dot的命令进行转换
# 命令：dot -Tpdf iris01.dot -o iris01.pdf 或者dot -Tpng iris01.dot -o iris01.png
from sklearn import tree
#
# with open('iris01.dot', 'w') as writer:
#     tree.export_graphviz(decision_tree=algo, out_file=writer)

# 方式二：直接使用pydotpuls库将数据输出为图像
import pydotplus
os.environ["PATH"] += os.pathsep + "D:/my_program/graphvize/Graphviz/bin"

dot_data = tree.export_graphviz(decision_tree=algo, out_file=None,
                                feature_names=['A1', 'B1', 'C1', 'D1'],
                                class_names=['a', 'b', 'c', 'd'],
                                filled=True, rounded=True,
                                special_characters=True, node_ids=True)
graph = pydotplus.graph_from_dot_data(dot_data)
graph.write_png("iris02.png")

import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import pydotplus

# 1.获取数据
names = ['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10', 'A11', 'A12', 'A13', 'A14', 'A15', 'A16']
df = pd.read_csv("D:/save/datas/crx.data", header=None, sep=',', names=names)
# print(df.info())
# print(df.count())

# 2.数据处理
X = df.iloc[:, :-1]
Y = df.iloc[:, -1]
x_lisan = X[['A1', 'A4', 'A5', 'A6', 'A7', 'A9', 'A10', 'A12', 'A13']]
x_lisan = pd.get_dummies(x_lisan, dtype=np.int32)
# print(x_lisan.head())

x_lianxu = X[['A2', 'A3', 'A8', 'A11', 'A14', 'A15']].copy()
x_lianxu.replace('?', np.nan, inplace=True)
# print(x_lianxu.info())

# 数据填充的一种方法
impt = SimpleImputer(missing_values=np.nan, strategy='mean')
x_lianxu = impt.fit_transform(x_lianxu)
# print(x_lianxu)
x_liaxu = pd.DataFrame(x_lianxu, columns=['A2', 'A3', 'A8', 'A11', 'A14', 'A15'])

#合并连续特征和离散特征
X = pd.concat([x_lisan, x_liaxu], axis=1)
column_names = X.columns  ###获取列名
# print(X.columns)

# 3.数据划分
x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=22)
# print(x_train.info())
# print(x_train.describe())

# 4.特征工程
std = StandardScaler()
x_train = std.fit_transform(x_train, y_train)
x_test = std.transform(x_test)

# 5. 模型构建
algo = DecisionTreeClassifier(max_depth=2, min_samples_split=15, min_samples_leaf=5)
algo.fit(x_train, y_train)
print("训练集的准确率：", algo.score(x_train, y_train))
print("测试集的准确率：", algo.score(x_test, y_test))

# 可视化
dot_data = tree.export_graphviz(algo,
                                out_file=None,
                                feature_names=column_names,
                                filled=True, rounded=True,
                                special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data)
graph.write_png('crx03.png')