机器学习基础之《分类算法（6）—决策树》

一、决策树

1、认识决策树
决策树思想的来源非常朴素，程序设计中的条件分支结构就是if-else结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法

2、一个对话的例子

想一想这个女生为什么把年龄放在最上面判断！！！
如何高效的进行决策？特征的先后顺序

二、决策树分类原理详解

1、我们通过一个问题例子

已知有四个特征值，预测是否贷款给某个人
（1）先看房子，再看工作 --> 是否贷款（只看了两个特征）
（2）年龄，信贷情况，工作 --> 看了三个特征
第二种这种方式就没有第一种高效
希望能够找到一种数学的方法，快速自动的判断，应该先看哪个特征

2、信息论基础
需要引入信息熵、信息增益等信息论的知识！！！

（1）信息
香农定义的：消除随机不定性的东西
小明 年龄 "我今年18岁"
小华 "小明明年19岁"

小明说了之后，小华说的这句话就变成废话了，不是信息

（2）信息的衡量 -- 信息量 -- 信息熵

3、信息熵的定义
H的专业术语称之为信息熵，单位为比特bit

4、以银行贷款数据为例，计算信息熵
某人，已知年龄、工作、房子、信贷情况，是否贷款给这个人？
需要衡量不确定性的大小
这里有两种情况，一种是贷款，一种是不贷款
不贷款的概率是6/15，贷款的概率是9/15
H(总) = -(6/15 * log 6/15 + 9/15 * log 9/15) = 0.971

当我们知道某一个特征之后，不确定性会减少
那么我们如果能求出，知道某个特征之后，不确定性减少的程度。再比较，知道哪一个特征之后，不确定性减少的程度是最多的。我们是不是可以先看这个特征

求当知道某个特征之后，它的信息熵是多少？
引入—信息增益

5、信息增益
决策树的划分依据之一—信息增益

（1）定义和公式
特征A对训练数据集D的信息增益g(D,A)，定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差
g(D,A) = H(D) - 条件熵H(D|A)
信息增益就衡量了，知道某个特征之后，它的不确定性的减少程度

计算知道年龄之后的信息增益是多少：
g(D,年龄) = H(D) - H(D|年龄)

求H(D|年龄)：
H(青年) = -(2/5 * log 2/5 + 3/5 * log 3/5) = 
H(中年) = -(2/5 * log 2/5 + 3/5 * log 3/5) = 
H(老年) = -(1/5 * log 1/5 + 4/5 * log 4/5) = 
H(D|年龄) = 1/3 * H(青年) + 1/3 * H(中年) + 1/3 * H(老年)

我们以A1、A2、A3、A4代表年龄、有工作、有自己的房子和贷款情况。最终计算的结果g(D, A1) = 0.313, g(D, A2) = 0.324, g(D, A3) = 0.420,g(D, A4) = 0.363。所以我们选择A3作为划分的第一个特征

（2）公式

（3）当然决策树的原理不止信息增益这一种，还有其他方法
ID3：
  信息增益，最大的准则
C4.5：
  信息增益比，最大的准则
CART：
  分类树：基尼系数，最小的准则，在sklearn中可以选择划分的默认原则
  优势：划分更加细致（从后面的例子来理解）

三、决策树API

1、API
class sklearn.tree.DecisionTreeClassifier(criterion='gini', max_depth=None, random_state=None)
决策树分析器
criterion：默认是'gini'系数，也可以选择信息增益的熵'entropy'
max_depth：树的深度大小
  树的深度太大，会过拟合
  过拟合会导致模型泛化能力差，即过度适合当前样本集而缺乏适应（预测）新样本的能力
random_state：随机数种子

2、决策树对鸢尾花分类

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.tree import DecisionTreeClassifier

def KNN_iris():
    """
    用KNN算法对鸢尾花进行分类
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None
 
def KNN_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier()
    # 加入网格搜索和交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    #最佳参数：best_params_
    print("最佳参数：\n", estimator.best_params_)
    #最佳结果：best_score_
    print("最佳结果：\n", estimator.best_score_)
    #最佳估计器：best_estimator_
    print("最佳估计器：\n", estimator.best_estimator_)
    #交叉验证结果：cv_results_
    print("交叉验证结果：\n", estimator.cv_results_)
    return None

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    """
    # 1、获取数据
    news = fetch_20newsgroups(subset="all")
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)
    # 3、特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4、朴素贝叶斯算法预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None

def decision_iris():
    """
    用决策树对鸢尾花数据进行分类
    """
    # 1、获取数据集
    iris = load_iris()
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、决策树预估器
    estimator = DecisionTreeClassifier(criterion='entropy')
    estimator.fit(x_train, y_train)
    # 4、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None

if __name__ == "__main__":
    # 代码1：用KNN算法对鸢尾花进行分类
    KNN_iris()
    # 代码2：用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    #KNN_iris_gscv()
    # 代码3：用朴素贝叶斯算法对新闻进行分类
    #nb_news()
    # 代码4：用决策树对鸢尾花数据进行分类
    decision_iris()

运行结果：

y_predict：
 [0 2 0 0 2 1 1 0 2 1 2 1 2 2 1 1 2 1 1 0 0 2 0 0 1 1 1 2 0 1 0 1 0 0 1 2 1
 2]
直接比对真实值和预测值：
 [ True  True  True  True  True  True False  True  True  True  True  True
  True  True  True False  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True False  True
  True  True]
准确率为：
 0.9210526315789473
y_predict：
 [0 2 0 0 2 1 1 0 2 1 2 1 2 2 1 1 2 1 1 0 0 2 0 0 1 1 1 2 0 1 0 1 0 0 1 2 1
 2]
直接比对真实值和预测值：
 [ True  True  True  True  True  True False  True  True  True  True  True
  True  True  True False  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True False  True
  True  True]
准确率为：
 0.9210526315789473

KNN是一种懒惰算法，在计算的时候，它在内存里疯狂的计算跟每个样本之间的距离
决策树应用场景更适合运用在数据量比较大的情况下

四、决策树的可视化

1、保存树的结构到dot文件
sklearn.tree.export_graphviz()
该函数能够导出DOT格式

2、tree.export_graphviz(estimator, out_file='tree.dot', feature_names=['',''])
estimator：预估器对象
out_file：导出的名字
feature_names：特征的名字

3、修改代码

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.tree import DecisionTreeClassifier, export_graphviz

def KNN_iris():
    """
    用KNN算法对鸢尾花进行分类
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None
 
def KNN_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    """
    # 1、获取数据
    iris = load_iris()
    print("iris.data：\n", iris.data)
    print("iris.target：\n", iris.target)
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    # 用训练集的平均值和标准差对测试集的数据来标准化
    # 这里测试集和训练集要有一样的平均值和标准差，而fit的工作就是计算平均值和标准差，所以train的那一步用fit计算过了，到了test这就不需要再算一遍自己的了，直接用train的就可以
    x_test = transfer.transform(x_test)
    # 4、KNN算法预估器
    estimator = KNeighborsClassifier()
    # 加入网格搜索和交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    #最佳参数：best_params_
    print("最佳参数：\n", estimator.best_params_)
    #最佳结果：best_score_
    print("最佳结果：\n", estimator.best_score_)
    #最佳估计器：best_estimator_
    print("最佳估计器：\n", estimator.best_estimator_)
    #交叉验证结果：cv_results_
    print("交叉验证结果：\n", estimator.cv_results_)
    return None

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    """
    # 1、获取数据
    news = fetch_20newsgroups(subset="all")
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)
    # 3、特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4、朴素贝叶斯算法预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    return None

def decision_iris():
    """
    用决策树对鸢尾花数据进行分类
    """
    # 1、获取数据集
    iris = load_iris()
    # 2、划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 3、决策树预估器
    estimator = DecisionTreeClassifier(criterion='entropy')
    estimator.fit(x_train, y_train)
    # 4、模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict：\n", y_predict)
    print("直接比对真实值和预测值：\n", y_test == y_predict)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    # 可视化决策树
    export_graphviz(estimator, out_file='iris_tree.dot', feature_names=iris.feature_names)
    return None

if __name__ == "__main__":
    # 代码1：用KNN算法对鸢尾花进行分类
    #KNN_iris()
    # 代码2：用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    #KNN_iris_gscv()
    # 代码3：用朴素贝叶斯算法对新闻进行分类
    #nb_news()
    # 代码4：用决策树对鸢尾花数据进行分类
    decision_iris()

运行后生成iris_tree.dot文件：

digraph Tree {
node [shape=box] ;
0 [label="petal width (cm) <= 0.8\nentropy = 1.584\nsamples = 112\nvalue = [38, 38, 36]"] ;
1 [label="entropy = 0.0\nsamples = 38\nvalue = [38, 0, 0]"] ;
0 -> 1 [labeldistance=2.5, labelangle=45, headlabel="True"] ;
2 [label="petal width (cm) <= 1.65\nentropy = 0.999\nsamples = 74\nvalue = [0, 38, 36]"] ;
0 -> 2 [labeldistance=2.5, labelangle=-45, headlabel="False"] ;
3 [label="sepal length (cm) <= 7.1\nentropy = 0.179\nsamples = 37\nvalue = [0, 36, 1]"] ;
2 -> 3 ;
4 [label="entropy = 0.0\nsamples = 36\nvalue = [0, 36, 0]"] ;
3 -> 4 ;
5 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 0, 1]"] ;
3 -> 5 ;
6 [label="petal length (cm) <= 5.05\nentropy = 0.303\nsamples = 37\nvalue = [0, 2, 35]"] ;
2 -> 6 ;
7 [label="sepal width (cm) <= 2.9\nentropy = 0.863\nsamples = 7\nvalue = [0, 2, 5]"] ;
6 -> 7 ;
8 [label="entropy = 0.0\nsamples = 4\nvalue = [0, 0, 4]"] ;
7 -> 8 ;
9 [label="petal width (cm) <= 1.75\nentropy = 0.918\nsamples = 3\nvalue = [0, 2, 1]"] ;
7 -> 9 ;
10 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ;
9 -> 10 ;
11 [label="sepal width (cm) <= 3.1\nentropy = 1.0\nsamples = 2\nvalue = [0, 1, 1]"] ;
9 -> 11 ;
12 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 0, 1]"] ;
11 -> 12 ;
13 [label="entropy = 0.0\nsamples = 1\nvalue = [0, 1, 0]"] ;
11 -> 13 ;
14 [label="entropy = 0.0\nsamples = 30\nvalue = [0, 0, 30]"] ;
6 -> 14 ;
}

4、生成图像
http://webgraphviz.com
一直显示loading......

后来网上找到一个生成了
访问http://www.tasksteper.com:8099/flow/home/；以用户名/密码：testuser1/ testuser1登录；进入“集成工具”项目后；点击“创建条目”

5、判断过程
（1）先看花瓣的宽度，如果宽度小于等于0.8
（2）如果不满足，继续往下分
（3）entropy：计算信息增益
（4）samples：样本数量

五、决策树优缺点

1、有点
简单和易于理解，并且可以可视化
可视化—可解释能力强

2、缺点
树过于复杂，容易产生过拟合

3、改进
减枝cart算法，决策树API当中已经实现
随机森林
 文章来源地址https://www.toymoban.com/news/detail-699249.html

到了这里，关于机器学习基础之《分类算法（6）—决策树》的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！