《菜菜的机器学习sklearn课堂》sklearn入门与决策树

￡神魔★判官ぃ 2022-10-29 09:04 648阅读 0赞

### 决策树 ###

*  sklearn简介
 *  决策树 - 概述
 *   *  决策树是如何工作的
     *  sklearn中的决策树
 *  分类树 DecisionTreeClassifier
 *   *  重要参数
     *   *  criterion
         *  建立一颗树（只有一个参数）
         *  random\_state、splitter
         *  剪枝参数
         *  目标权重参数 class\_weight、min\_weight\_fraction\_leaf
     *  重要属性 feature\_importances\_
     *  常用接口 fit、score、apply、predict
 *  实例：分类树在合成数集上的表现
 *  决策树的优缺点
 *  附录（Ctrl + F 搜索）
 *   *  分类树参数列表
     *  分类树属性列表
     *  分类树接口列表

> [《菜菜的机器学习sklearn课堂》笔记目录 + 课件][sklearn_ _]

课程要求的配置如下，但是环境只要 >= 它即可。  
（**一般来说安装 Anaconda3 后是不需要担心环境问题的**）

> Python 3.7.1  
> Scikit-learn 0.20.0  
> **Graphviz 0.8.4** (没有画不出决策树哦，安装代码 `conda install python-graphviz`）  
> Numpy 1.15.3  
> Pandas 0.23.4  
> Matplotlib 3.0.1  
> SciPy 1.1.0

# sklearn简介 #

**scikit-learn**，又写作 **sklearn**，是一个开源的基于python语言的机器学习工具包。它通过 **NumPy**、**SciPy**、**Matplotlib** 等python数值计算的库实现高效的算法应用，并且涵盖了几乎所有主流机器学习算法。

scikit-learn官网：[http://scikit-learn.org/stable/index.html][http_scikit-learn.org_stable_index.html]

在工程应用中：

*  用python手写代码来从头实现一个算法的可能性非常低
 *  更多情况下，是分析采集到的数据，根据数据特征选择适合的算法，再去调用

本门课的学习重点：

*  sklearn中对算法的说明，**调参**，**属性**，**接口**，以及**实例应用**
 *  本门课不涉及详细的算法原理，只会专注于算法在sklearn中的实现

# 决策树 - 概述 #

## 决策树是如何工作的 ##

**决策树 (Decision Tree)** 是一种**非参数**的**有监督学习**方法；它能够从一系列有**特征**和**标签**的数据中总结出决策规则，并用**树状图的结构**来呈现这些规则，以解决**分类**和**回归**问题。

决策树算法的本质是一种图结构，我们只需要问一系列问题就可以对数据进行分类了。  
比如，下面这组数据集，这是一系列已知物种以及所属类别的数据：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70]  
我们现在的目标是：将动物们分为哺乳类和非哺乳类。

根据已经收集到的数据，决策树算法为我们算出了下面的这棵决策树：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 1]  
假如我们现在发现了一种新物种 Python，它是冷血动物，体表带鳞片，并且不是胎生，我们就可以通过这棵决策树来判断它的所属类别。

可以看出，在这个决策过程中，我们一直在对记录的特征进行提问。

*  最初的问题所在的地方叫做**根节点**
 *  在得到结论前的每一个问题都是**中间节点**
 *  而得到的每一个结论（动物的类别）都叫做**叶子节点**

> **关键概念：节点**
> 
>  *  **根节点**：没有进边，有出边；包含最初的针对特征的提问。
>  *  **中间节点**：既有进边也有出边，进边只有一条，出边可以有很多条；都是针对特征的提问。
>  *  **叶子节点**：有进边，没有出边；每个叶子节点都是一个类别标签。
>  *  **子节点和父节点**：在两个相连的节点中，更接近根节点的是父节点，另一个是子节点。

决策树算法的核心是要解决两个问题：

1.  如何从数据表中找出最佳节点和最佳分枝？
2.  如何让决策树停止生长，防止**过拟合**？  
    **过拟合**是指在训练集上表现很好，在测试集上却表现糟糕。

## sklearn中的决策树 ##

sklearn中决策树的类都在 `sklearn.tree` 这个模块下。这个模块总共包含五个类：

<table> 
 <thead> 
  <tr> 
   <th>类</th> 
   <th>树</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>tree.DecisionTreeClassifier</strong></td> 
   <td><strong>分类树</strong></td> 
  </tr> 
  <tr> 
   <td><strong>tree.DecisionTreeRegressor</strong></td> 
   <td><strong>回归树</strong></td> 
  </tr> 
  <tr> 
   <td><strong>tree.export_graphviz</strong></td> 
   <td><strong>将生成的决策树导出为DOT格式，画图专用</strong></td> 
  </tr> 
  <tr> 
   <td><strong>tree.ExtraTreeClassifier</strong></td> 
   <td><strong>高随机版本的分类树</strong></td> 
  </tr> 
  <tr> 
   <td><strong>tree.ExtraTreeRegressor</strong></td> 
   <td><strong>高随机版本的回归树</strong></td> 
  </tr> 
 </tbody> 
</table>

> **sklearn建模的基本流程**  
> ![x][]  
> 在这个流程下，**分类树**对应的代码是：
> 
>     from sklearn import tree  #导入需要的模块
>     clf = tree.DecisionTreeClassifier()  #1.实例化,建立评估模型对象:分类树
>     clf = clf.fit(X_train, y_train)  #2.用训练集数据训练模型
>     result = clf.score(X_test,y_test)  #3.导入测试集,从接口中调用需要的信息

# 分类树 DecisionTreeClassifier #

我们将学习 **分类树DecisionTreeClassifier** 和 **用决策树绘图(export\_graphviz)** 的基础。  
包括决策树的基本流程，分类树的7个参数，1个属性，4个接口，以及绘图代码。

7 个参数：

*  **Criterion**
 *  2个随机性相关的参数：**random\_state**，**splitter**
 *  4个剪枝参数：**max\_depth**, **min\_sample\_leaf**，**max\_feature**，**min\_impurity\_decrease**

1 个属性：**feature\_importances\_**

4 个接口：**fit**，**score**，**apply**，**predict**

--------------------

class 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, 
    	min_impurity_split=None,
    	class_weight=None, 
    	presort=False
    )

`DecisionTreeClassifier` 有以上参数，但我们不会全部用到，只会学习一些**重要参数**。

## 重要参数 ##

### criterion ###

为了要将表格转化为一棵树，决策树需要找出**最佳节点**和**最佳的分枝方法**，对分类树来说，衡量这个“最佳”的指标叫“**不纯度**”。通常来说，不纯度越低，决策树对训练集的拟合越好。

现在的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。

不纯度基于节点来计算，树中的每个节点都会有一个不纯度，并且**子节点的不纯度一定是低于父节点的**，也就是说，在同一棵决策树上，**叶子节点的不纯度一定是最低的**。

Criterion 这个参数正是用来决定不纯度的计算方法的。sklearn提供了两种选择：  
1）输入 `entropy`，使用**信息熵（Entropy）**  
 E n t r o p y ( t ) = − ∑ i = 0 c − 1 p ( i ∣ t ) l o g 2 p ( i ∣ t ) Entropy(t) = -\\sum\_\{i=0\}^\{c-1\}p(i|t)log\_2p(i|t) Entropy(t)=−i=0∑c−1p(i∣t)log2p(i∣t)

2）输入`gini`，使用**基尼系数（Gini Impurity）**  
 G i n i ( t ) = 1 − ∑ i = 0 c − 1 p ( i ∣ t ) 2 Gini(t) = 1 - \\sum\_\{i=0\}^\{c-1\}p(i|t)^2 Gini(t)=1−i=0∑c−1p(i∣t)2

t代表给定的节点，i代表标签的任意分类， p ( i ∣ t ) p(i|t) p(i∣t)代表标签分类i在节点t上所占的比例。

*  信息熵的计算比基尼系数缓慢一些，因为基尼系数的计算不涉及对数。

> 当使用信息熵时，sklearn实际计算的是基于信息熵的**信息增益(Information Gain)**，即父节点的信息熵和子节点的信息熵之差。  
>   
> 比起基尼系数，信息熵对不纯度更加敏感，对不纯度的惩罚最强。但是**在实际使用中，信息熵和基尼系数的效果基本相同**。另外，因为信息熵对不纯度更加敏感，所以信息熵作为指标时，决策树的生长会更加“精细”，因此对于高维数据或者噪音很多的数据，信息熵很容易过拟合，基尼系数在这种情况下效果往往比较好。当然，这不是绝对的。

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>criterion</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>如何影响模型?</td> 
   <td>确定不纯度的计算方法，帮忙找出最佳节点和最佳分枝，不纯度越低，决策树对训练集的拟合越好</td> 
  </tr> 
  <tr> 
   <td>可能的输入有哪些？</td> 
   <td>不填默认基尼系数；填写<code>gini</code>使用基尼系数，填写<code>entropy</code>使用信息增益</td> 
  </tr> 
 </tbody> 
</table>

怎样选取参数？

*  通常就使用基尼系数
 *  数据维度很大，噪音很大时使用基尼系数
 *  维度低，数据比较清晰的时候，信息熵和基尼系数没区别
 *  当决策树的拟合程度不够的时候，使用信息熵
 *  两个都试试，不好就换另外一个

决策树的基本流程可以简单概括如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 2]  
直到没有更多的特征可用，或整体的不纯度指标已经最优，决策树就会停止生长。

### 建立一颗树（只有一个参数） ###

以下代码建议放到 jupyter notebook 中执行一下。

1、导入需要的算法库和模块

from sklearn import tree
    from sklearn.datasets import load_wine
    from sklearn.model_selection import train_test_split

2、探索数据

wine = load_wine() #读取红酒数据集

wine.data #特征数据
    
    wine.target # 标签
    
    wine.feature_names #特征名
    
    wine.target_names #标签名

#如果wine是一张表，应该长这样:
    import pandas as pd
    pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis=1)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 3]  
3、划分训练集和测试集

#划分30%的数据作为测试集
    Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data, wine.target, test_size=0.3)
    
    Xtrain.shape #训练集: 124行,13个标签
    Xtest.shape #测试集: 54行,13个标签
    wine.data.shape #初始数据集: 178行,13个标签

4、建立模型（**只有一个参数criterion**）

clf = tree.DecisionTreeClassifier(criterion="entropy") #建模
    clf = clf.fit(Xtrain, Ytrain) #训练模型
    score = clf.score(Xtest, Ytest) #返回预测的准确度
    
    score

5、画出一棵树吧

feature_name = ['酒精','苹果酸','灰','灰的碱性','镁','总酚','类黄酮','非黄烷类酚类','花青素','颜色强度','色调','od280/od315稀释葡萄酒','脯氨酸']
    
    import graphviz
    dot_data = tree.export_graphviz(clf, #模型
                                    feature_names = feature_name, #特征名
                                    class_names = ['琴酒', '雪莉', '贝尔摩德'], #分类名
                                    filled = True, #填充颜色表示不同的分类
                                    rounded = True #圆角显示
                                   ) 
    graph = graphviz.Source(dot_data)
    
    graph

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 4]  
6、探索决策树

clf.feature_importances_ #特征重要性
    
    [*zip(feature_name, clf.feature_importances_)]

[('酒精', 0.0),
     ('苹果酸', 0.0),
     ('灰', 0.0),
     ('灰的碱性', 0.0),
     ('镁', 0.05809139359761723),
     ('总酚', 0.0),
     ('类黄酮', 0.42809846427963527),
     ('非黄烷类酚类', 0.0),
     ('花青素', 0.0),
     ('颜色强度', 0.18211551456095545),
     ('色调', 0.0),
     ('od280/od315稀释葡萄酒', 0.0),
     ('脯氨酸', 0.331694627561792)]

我们已经在只了解一个参数的情况下，建立了一棵完整的决策树。但是回到步骤4建立模型，score会在某个值附近波动，引起步骤5中画出来的每一棵树都不一样。它为什么会不稳定呢？如果使用其他数据集，它还会不稳定吗？

我们之前提到过，无论决策树模型如何进化，在分枝上的本质都还是追求某个不纯度相关的指标的优化，而正如我们提到的，**不纯度是基于节点来计算的**，也就是说，决策树在建树时，是靠优化节点来追求一棵优化的树，但最优的节点能够保证最优的树吗？集成算法被用来解决这个问题：sklearn表示，既然一棵树不能保证最优，那就建更多的不同的树，然后从中取最好的。怎样从一组数据集中建不同的树？在每次分枝时，不从使用全部特征，而是随机选取一部分特征，从中选取不纯度相关指标最优的作为分枝用的节点。这样，每次生成的树也就不同了。

clf = tree.DecisionTreeClassifier(criterion="entropy",random_state=30)
    clf = clf.fit(Xtrain, Ytrain)
    score = clf.score(Xtest, Ytest) #返回预测的准确度
    
    score

### random\_state、splitter ###

**random\_state** 用来设置分枝中的随机模式的参数，默认None，在高维度时随机性会表现更明显，低维度的数据（比如鸢尾花数据集），随机性几乎不会显现。输入任意整数，会一直长出同一棵树，让模型稳定下来。

**splitter** 也是用来控制决策树中的随机选项的，有两种输入值，

*  输入`best`，决策树在分枝时虽然随机，但是还是会优先选择更重要的特征进行分枝（重要性可以通过属性`feature_importances_`查看）
 *  输入`random`，决策树在分枝时会更加随机，树会因为含有更多的不必要信息而更深更大，并因这些不必要信息而降低对训练集的拟合。这也是防止过拟合的一种方式。

当你预测到你的模型会过拟合，用这两个参数来帮助你降低树建成之后过拟合的可能性。当然，树一旦建成，我们依然是使用**剪枝参数**来防止过拟合。

clf = tree.DecisionTreeClassifier(criterion="entropy"
                                     ,random_state=30
                                     ,splitter="random"
                                     )
    clf = clf.fit(Xtrain, Ytrain) #训练模型
    score = clf.score(Xtest, Ytest)  #返回预测的准确度
    
    score

import graphviz
    dot_data = tree.export_graphviz(clf
                                   ,feature_names= feature_name
                                   ,class_names=["琴酒","雪莉","贝尔摩德"]
                                   ,filled=True
                                   ,rounded=True
                                   )  
    graph = graphviz.Source(dot_data)
    
    graph

### 剪枝参数 ###

在不加限制的情况下，一棵决策树会生长到衡量不纯度的指标最优，或者没有更多的特征可用为止。这样的决策树往往会**过拟合**，这就是说，**它会在训练集上表现很好，在测试集上却表现糟糕**。我们收集的样本数据不可能和整体的状况完全一致，因此当一棵决策树对训练数据有了过于优秀的解释性，它找出的规则必然包含了训练样本中的噪声，并使它对未知数据的拟合程度不足。

#我们的树对训练集的拟合程度如何？
    score_train = clf.score(Xtrain, Ytrain)
    score_train

为了让决策树有更好的泛化性，我们要对决策树进行剪枝。**剪枝策略对决策树的影响巨大，正确的剪枝策略是优化决策树算法的核心**。sklearn为我们提供了不同的剪枝策略：

**max\_depth**

*  限制树的最大深度，超过设定深度的树枝全部剪掉
 *  这是用得最广泛的剪枝参数，在高维度低样本量时非常有效。决策树多生长一层，对样本量的需求会增加一倍，所以限制树深度能够有效地限制过拟合。在集成算法中也非常实用。实际使用时，建议从`=3`开始尝试，看看拟合的效果再决定是否增加设定深度。

**min\_samples\_leaf** & **min\_samples\_split**

*  **min\_samples\_leaf** 限定一个节点在分枝后的每个子节点都必须包含至少min\_samples\_leaf个训练样本，否则分枝就不会发生，或者分枝会朝着满足每个子节点都包含min\_samples\_leaf个样本的方向去发生  
    一般搭配 **max\_depth** 使用，在回归树中有神奇的效果，可以让模型变得更加平滑。这个参数的数量设置得太小会引起过拟合，设置得太大就会阻止模型学习数据。一般来说，建议从`=5`开始使用。如果叶节点中含有的样本量变化很大，建议输入浮点数作为样本量的百分比来使用。同时，这个参数可以保证每个叶子的最小尺寸，可以在回归问题中避免低方差，过拟合的叶子节点出现。对于类别不多的分类问题，`=1`通常就是最佳选择。
 *  **min\_samples\_split** 限定一个节点必须要包含至少min\_samples\_split个训练样本，这个节点才允许被分枝，否则分枝就不会发生。

clf = tree.DecisionTreeClassifier(criterion="entropy"
                                     ,random_state=30
                                     ,splitter="random"
                                     ,max_depth=3
                                     ,min_samples_leaf=10
                                     ,min_samples_split=10
                                     )
    clf = clf.fit(Xtrain, Ytrain)
    dot_data = tree.export_graphviz(clf
                                   ,feature_names= feature_name
                                   ,class_names=["琴酒","雪莉","贝尔摩德"]
                                   ,filled=True
                                   ,rounded=True
                                   )  
    graph = graphviz.Source(dot_data)	
    
    graph

clf.score(Xtrain,Ytrain)
    clf.score(Xtest,Ytest)

**max\_features** & **min\_impurity\_decrease**

*  **max\_features** 是限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃。  
    和max\_depth异曲同工，**max\_features**是用来限制高维度数据的过拟合的剪枝参数，但其方法比较暴力，是直接限制可以使用的特征数量而强行使决策树停下的参数，在不知道决策树中的各个特征的重要性的情况下，强行设定这个参数可能会导致模型学习不足。如果希望通过降维的方式防止过拟合，建议使用PCA，ICA或者特征选择模块中的降维算法。
 *  **min\_impurity\_decrease** 限制信息增益的大小，信息增益小于设定数值的分枝不会发生。这是在0.19版本中更新的功能，在0.19版本之前时使用**min\_impurity\_split**

--------------------

**如何确认最优的剪枝参数？**

*  使用**确定超参数的曲线**来进行判断；  
    继续使用我们已经训练好的决策树模型clf。  
    **超参数的学习曲线**，是一条以**超参数的取值**为**横坐标**，**模型的度量指标**为**纵坐标**的曲线，它是用来衡量不同超参数取值下模型的表现的线。  
    在我们建好的决策树里，我们的模型度量指标就是score。

import matplotlib.pyplot as plt
    test = []
    for i in range(10):
        clf = tree.DecisionTreeClassifier(max_depth=i+1
                                         ,criterion="entropy"
                                         ,random_state=30
                                         ,splitter="random"
                                         )
        clf = clf.fit(Xtrain, Ytrain)
        score = clf.score(Xtest, Ytest)
        test.append(score)
    plt.plot(range(1,11),test,color="red",label="max_depth")
    plt.legend()
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 5]

--------------------

思考：  
1、剪枝参数一定能够提升模型在测试集上的表现吗？  
答：调参没有绝对的答案，一切都是看数据本身。

2、这么多参数，一个个画学习曲线？  
答：无论如何，剪枝参数的默认值会让树无尽地生长，这些树在某些数据集上对内存的消耗可能非常巨大。所以如果你手中的数据集非常大，你已经预测到无论如何都是要剪枝的，那提前设定这些参数来控制树的复杂性和大小会比较好。

### 目标权重参数 class\_weight、min\_weight\_fraction\_leaf ###

> 完成样本**标签平衡**的参数。  
> **样本不平衡**是指**在一组数据集中，标签的一类天生占有很大的比例**。  
> 比如说，在银行要判断 “一个办了信用卡的人是否会违约”，就是 “是"vs"否” (1% : 99%) 的比例。这种分类状况下，即便模型什么也不做，全把结果预测成"否"，正确率也能有99%。

**class\_weight**

*  我们要使用**class\_weight**参数对样本标签进行一定的均衡，给少量的标签更多的权重，让模型更偏向少数类，向捕获少数类的方向建模。  
    该参数默认None，此模式表示自动给与数据集中的所有标签相同的权重。

**min\_weight\_fraction\_leaf**

*  有了权重之后，样本量就不再是单纯地记录数目，而是受输入的权重影响了，因此这时候剪枝，就需要搭配**min\_weight\_fraction\_leaf**这个基于权重的剪枝参数来使用。  
    另请注意，基于权重的剪枝参数（例如min\_weight\_fraction\_leaf）将比不知道样本权重的标准（比如min\_samples\_leaf）更少偏向主导类。如果样本是加权的，则使用基于权重的预修剪标准来更容易优化树结构，这确保叶节点至少包含样本权重的总和的一小部分。

## 重要属性 feature\_importances\_ ##

属性是在模型训练之后，能够调用查看的模型的各种性质。

对决策树来说，最重要的是`feature_importances_`，能够查看各个特征对模型的重要性。

## 常用接口 fit、score、apply、predict ##

sklearn中许多算法的接口都是相似的，比如说我们之前已经用到的`fit`和`score`，几乎对每个算法都可以使用。除了这两个接口之外，决策树最常用的接口还有`apply`和`predict`。

*  `apply`中输入测试集返回每个测试样本所在的**叶子节点的索引**
 *  `predict`输入测试集返回每个测试样本的**标签**，返回的内容一目了然并且非常容易

#apply返回每个测试样本所在的叶子节点的索引
    clf.apply(Xtest)
    
    #predict返回每个测试样本的分类/回归结果
    clf.predict(Xtest)

# 实例：分类树在合成数集上的表现 #

> 啊啊，好难

我们在红酒数据集上画出了一棵树，并且展示了多个参数会对树形成这样的影响，接下来，我们将在不同结构的数据集上测试一下决策树的效果，来更好地理解决策树。

**1、导入需要的库**

import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.colors import ListedColormap
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.datasets import make_moons, make_circles, make_classification
    from sklearn.tree import DecisionTreeClassifier

**2、生成三种数据集**  
我们从sklearn自带的数据库中生成三种类型的数据集：  
1）月亮型数据，2）环形数据，3）二分型数据

#make_classification库生成随机的二分型数据
    X, y = make_classification(n_samples=100, #生成100个样本
                               n_features=2,  #包含2个特征，即生成二维数据
                               n_redundant=0, #添加冗余特征0个
                               n_informative=2, #包含信息的特征是2个
                               random_state=1,  #随机模式1
                               n_clusters_per_class=1 #每个簇内包含的标签类别有1个
                             )
    #在这里可以查看一下X和y，其中X是100行带有两个2特征的数据，y是二分类标签
    #也可以画出散点图来观察一下X中特征的分布
    #plt.scatter(X[:,0],X[:,1])

#从图上可以看出，生成的二分型数据的两个簇离彼此很远，这样不利于我们测试分类器的效果，因此我们使用np生成
    #随机数组，通过让已经生成的二分型数据点加减0~1之间的随机数，使数据分布变得更散更稀疏
    #注意，这个过程只能够运行一次，因为多次运行之后X会变得非常稀疏，两个簇的数据会混合在一起，分类器的效应会继续下降
    rng = np.random.RandomState(2) #生成一种随机模式
    X += 2 * rng.uniform(size=X.shape) #加减0~1之间的随机数
    linearly_separable = (X, y) #生成了新的X，依然可以画散点图来观察一下特征的分布
    #plt.scatter(X[:,0],X[:,1])

#用make_moons创建月亮型数据，make_circles创建环形数据，并将三组数据打包起来放在列表datasets中
    datasets = [make_moons(noise=0.3, random_state=0),
                make_circles(noise=0.2, factor=0.5, random_state=1),
                linearly_separable]

**3、画出三种数据集和三棵决策树的分类效应图像**

#创建画布，宽高比为6*9
    figure = plt.figure(figsize=(6, 9))
    #设置用来安排图像显示位置的全局变量i
    i = 1
    #开始迭代数据，对datasets中的数据进行for循环
    for ds_index, ds in enumerate(datasets):
        
        #对X中的数据进行标准化处理，然后分训练集和测试集
        X, y = ds
        X = StandardScaler().fit_transform(X)
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4,random_state=42)
        
        #找出数据集中两个特征的最大值和最小值，让最大值+0.5，最小值-0.5，创造一个比两个特征的区间本身更大一点的区间
        x1_min, x1_max = X[:, 0].min() - .5, X[:, 0].max() + .5
        x2_min, x2_max = X[:, 1].min() - .5, X[:, 1].max() + .5
        
        #用特征向量生成网格数据，网格数据，其实就相当于坐标轴上无数个点
        #函数np.arange在给定的两个数之间返回均匀间隔的值，0.2为步长
        #函数meshgrid用以生成网格数据，能够将两个一维数组生成两个二维矩阵。
        #如果第一个数组是narray，维度是n，第二个参数是marray，维度是m。那么生成的第一个二维数组是以narray为行，m行的矩阵，而第二个二维数组是以marray的转置为列，n列的矩阵
        #生成的网格数据，是用来绘制决策边界的，因为绘制决策边界的函数contourf要求输入的两个特征都必须是二维的
        array1,array2 = np.meshgrid(np.arange(x1_min, x1_max, 0.2),
                             np.arange(x2_min, x2_max, 0.2))
        #接下来生成彩色画布
        #用ListedColormap为画布创建颜色，#FF0000正红，#0000FF正蓝
        cm = plt.cm.RdBu
        cm_bright = ListedColormap(['#FF0000', '#0000FF'])
        
        #在画布上加上一个子图，数据为len(datasets)行，2列，放在位置i上
        ax = plt.subplot(len(datasets), 2, i)
        
        #到这里为止，已经生成了0~1之间的坐标系3个了，接下来为我们的坐标系放上标题
        #我们有三个坐标系，但我们只需要在第一个坐标系上有标题，因此设定if ds_index==0这个条件
        if ds_index == 0:
            ax.set_title("Input data")
        
        #将数据集的分布放到我们的坐标系上
        #先放训练集
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train,
                   cmap=cm_bright,edgecolors='k')
        #放测试集
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test,
                   cmap=cm_bright, alpha=0.6,edgecolors='k')
        
        #为图设置坐标轴的最大值和最小值，并设定没有坐标轴
        ax.set_xlim(array1.min(), array1.max())
        ax.set_ylim(array2.min(), array2.max())
        ax.set_xticks(())
        ax.set_yticks(())
        
        #每次循环之后，改变i的取值让图每次位列不同的位置
        i += 1
        
        #至此为止，数据集本身的图像已经布置完毕，运行以上的代码，可以看见三个已经处理好的数据集
        
        #############################从这里开始是决策树模型##########################
        
        #迭代决策树，首先用subplot增加子图，subplot(行，列，索引)这样的结构，并使用索引i定义图的位置
        #在这里，len(datasets)其实就是3，2是两列
        #在函数最开始，我们定义了i=1，并且在上边建立数据集的图像的时候，已经让i+1,所以i在每次循环中的取值是2，4，6
        ax = plt.subplot(len(datasets),2,i)
        
        #决策树的建模过程：实例化 → fit训练 → score接口得到预测的准确率
        clf = DecisionTreeClassifier(max_depth=5)
        clf.fit(X_train, y_train)
        score = clf.score(X_test, y_test)
        
        #绘制决策边界，为此，我们将为网格中的每个点指定一种颜色[x1_min，x1_max] x [x2_min，x2_max]
        #分类树的接口，predict_proba，返回每一个输入的数据点所对应的标签类概率
        #类概率是数据点所在的叶节点中相同类的样本数量/叶节点中的样本总数量
        #由于决策树在训练的时候导入的训练集X_train里面包含两个特征，所以我们在计算类概率的时候，也必须导入
        #结构相同的数组，即是说，必须有两个特征
        #ravel()能够将一个多维数组转换成一维数组
        #np.c_是能够将两个数组组合起来的函数
        #在这里，我们先将两个网格数据降维降维成一维数组，再将两个数组链接变成含有两个特征的数据，再带入决策
        #树模型，生成的Z包含数据的索引和每个样本点对应的类概率，再切片，且出类概率
        Z = clf.predict_proba(np.c_[array1.ravel(),array2.ravel()])[:, 1]
        
        #np.c_[np.array([1,2,3]), np.array([4,5,6])]
        
        #将返回的类概率作为数据，放到contourf里面绘制去绘制轮廓
        Z = Z.reshape(array1.shape)
        
        ax.contourf(array1, array2, Z, cmap=cm, alpha=.8)
        
        #将数据集的分布放到我们的坐标系上
        # 将训练集放到图中去
        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright,
                   edgecolors='k')
        # 将测试集放到图中去
        ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright,
                   edgecolors='k', alpha=0.6)
        
        #为图设置坐标轴的最大值和最小值
        ax.set_xlim(array1.min(), array1.max())
        ax.set_ylim(array2.min(), array2.max())
        #设定坐标轴不显示标尺也不显示数字
        ax.set_xticks(())
        ax.set_yticks(())
        
        #我们有三个坐标系，但我们只需要在第一个坐标系上有标题，因此设定if ds_index==0这个条件
        if ds_index == 0:
            ax.set_title("Decision Tree")
        
        #写在右下角的数字 
        ax.text(array1.max() - .3, array2.min() + .3, ('{:.1f}%'.format(score*100)),
                size=15, horizontalalignment='right')
        
        #让i继续加一
        i += 1
        plt.tight_layout()
        plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 6]

# 决策树的优缺点 #

决策树优点：

1.  **易于理解**，因为树可以被画出来
2.  **需要很少的数据准备**。其他很多算法通常都需要数据规范化，需要创建虚拟变量并删除空值等。  
    但请注意，sklearn中的决策树模块不支持对缺失值的处理。
3.  使用树的成本（比如说，在预测数据的时候）是用于训练树的数据点的数量的对数，相比于其他算法，这是一个**很低的成本**。
4.  能够同时处理数字和分类数据，**既可以做回归又可以做分类**。  
    其他技术通常专门用于分析仅具有一种变量类型的数据集。
5.  **能够处理多输出问题**，**即含有多个标签的问题**。  
    注意与一个标签中含有多种标签分类的问题区别开。
6.  **决策树是一个白盒模型，结果很容易能够被解释**。如果在模型中可以观察到给定的情况，则可以通过布尔逻辑轻松解释条件。  
    在黑盒模型中（例如，在人工神经网络中），结果可能更难以解释。
7.  可以使用统计测试验证模型，这让我们可以考虑模型的可靠性。
8.  即使其假设在某种程度上违反了生成数据的真实模型，也能够表现良好 。

--------------------

决策树的缺点：

1.  决策树学习者可能创建过于复杂的树，这些树不能很好地推广数据，这称为过度拟合。  
    修剪，设置叶节点所需的最小样本数或设置树的最大深度等机制是避免此问题所必需的，而这些参数的整合和调整对初学者来说会比较晦涩。
2.  **决策树可能不稳定**，数据中微小的变化可能导致生成完全不同的树。  
    这个问题需要通过**集成算法**来解决。
3.  **决策树的学习是基于贪婪算法**，它靠优化局部最优（每个节点的最优）来试图达到整体的最优，但这种做法不能保证返回全局最优决策树。  
    这个问题也可以由**集成算法**来解决，在随机森林中，特征和样本会在分枝过程中被随机采样。
4.  有些概念很难学习，因为决策树不容易表达它们，例如XOR，奇偶校验或多路复用器问题。
5.  如果标签中的某些类占主导地位，**决策树学习者会创建偏向主导类的树**。  
    因此，建议在拟合决策树之前平衡数据集。

# 附录（Ctrl + F 搜索） #

建议用 Ctrl + F 来搜索。。太多了。。

## 分类树参数列表 ##

> 注意，这里的参数实在是太多了，很多都十分晦涩难懂，记录一下…方便查询

criterion

*  字符型，可不填，默认基尼系数`"gini"`
 *  用来**衡量分枝质量**的指标  
    输入`criterion="gini"`使用基尼系数  
    输入`criterion="entropy"`使用信息增益（Information Gain）

splitter

*  字符型，可不填，默认最佳分枝`"best"`
 *  确定每个节点的**分枝策略**  
    输入`splitter="best"`使用最佳分枝  
    输入`splitter="random"`使用最佳随机分枝

max\_depth

*  整数或None，可不填，默认None
 *  树的最大深度如果是None，树会持续生长直到所有叶子节点的不纯度为0  
    否则，直到每个叶子节点所含的样本量都小于参数min\_samples\_split中输入的数字

min\_samples\_split

*  整数或浮点数，可不填，默认=2
 *  **一个中间节点要分枝所需要的最小样本量**。如果一个节点包含的样本量小于min\_samples\_split中填写的数字，这个节点的分枝就不会发生，也就是说，这个节点一定会成为一个叶子节点  
    1）如果输入整数，则认为输入的数字是分枝所需的最小样本量  
    2）如果输入浮点数，则认为输入的浮点数是比例，**输入的浮点数** \* **输入模型的数据集的样本量(n\_samples)** 是分枝所需的最小样本量
 *  浮点数功能是0.18版本以上的sklearn才可以使用

min\_ sample\_leaf

*  整数或浮点数，可不填，默认=1
 *  **一个叶节点要存在所需要的最小样本量**。一个节点在分枝后的每个子节点中，必须要包含至少min\_sample\_leaf个训练样本，否则分枝就不会发生。这个参数可能会有着使模型更平滑的效果，尤其是在回归中：  
    1）如果输入整数，则认为输入的数字是叶节点存在所需的最小样本量  
    2）如果输入浮点数，则认为输入的浮点数是比例，**输入的浮点数** \* **输入模型的数据集的样本量(n\_samples)** 是叶节点存在所需的最小样本量

min\_ weight\_fraction\_leaf

*  整数，浮点数，字符型或None，可不填，默认None
 *  **在做最佳分枝的时候考虑的特征个数**:  
    1）输入整数，则每一次分枝都考虑max\_features个特征  
    2）输入浮点数，则认为输入的浮点数是比例，每次分枝考虑的特征数目是max\_features
 *  **输入模型的数据集的特征个数(n\_features)**：  
    3）输入`"auto"`，采用n features的平方根作为分枝时考虑的特征数目  
    4）输入`"sqrt"`，采用n\_features的平方根作为分枝时考虑的特征数目  
    5）输入`"log2"`，采用 l o g 2 ( n f r e a t u r e s ) log\_2(n\_freatures) log2(nfreatures)作为分枝时考虑的特征数目  
    6）输入`"None"`，n\_features就是分枝时考虑的特征数目
 *  注意：如果在限制的max\_features中，决策树无法找到节点样本上至少一个有效的分枝，那对分枝的搜索不会停止，决策树将会检查比限制的max\_features数目更多的特征

random\_state

*  整数，sklearn中设定好的RandomState实例，或None，可不填，默认None  
    1）输入整数，random\_state是由随机数生成器生成的随机数种子  
    2）输入RandomState实例，则random\_state是一个随机数生成器  
    3）输入None，随机数生成器会是np.random模块中的一个RandomState实例

max\_leaf\_nodes

*  整数或None，可不填，默认None
 *  **最大叶节点数量**。  
    在最佳分枝方式下(`splitter="best"`)，以max\_leaf nodes为限制来生长树。  
    如果是None，则没有叶节点数量的限制。

min\_ impurity\_decrease

*  ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]

min\_ impurity\_split

*  浮点数
 *  **防止树生长的阈值之一**。  
    如果一个节点的不纯度高于min.impurity\_split，这个节点就会被分枝  
    否则的话这个节点就只能是叶子节点。
 *  在0.19以上版本中，这个参数的功能已经被ming\_impurity\_decrease取代  
    在0.21版本中这个参数将会被删除，请使用ming\_impurity\_decrease

class\_weight  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 1]  
presort

*  布尔值，可不填，默认False
 *  **是否预先分配数据以加快拟合中最佳分枝的发现**。  
    大型数据集上使用默认设置决策树时，设置`presort=true`可能会降低训练速度。  
    在较小的数据集或限制树的深度时，设置`presort=true`可能会加快训练速度。

## 分类树属性列表 ##

classes\_

*  输出一个数组(array)或者一个数组的列表(list)，结构为标签的数目(n\_classes)
 *  **输出所有标签**

feature\_ importances\_

*  输出一个数组，结构为特征的数目(n\_features)
 *  **返回每个特征的重要性**，一般是这个特征在多次分枝中产生的信息增益的综合，也被称为“基尼重要性”(Gini Importance)

max\_ features\_

*  输出整数
 *  **参数max\_features的推断值**

n\_classes\_

*  输出整数或列表
 *  **标签类别的数据**

n\_features\_

*  **在训练模型(fit)时使用的特征个数**

n\_outputs\_

*  **在训练模型(fit)时输出的结果的个数**

tree\_

*  **输出一个可以导出建好的树结构的端口**
 *  通过这个端口，可以访问树的结构和低级属性包括但不仅限于查看：  
    1）二叉树的结构  
    2）每个节点的深度以及它是否是叶子  
    3）使用decision\_path方法的示例到达的节点  
    4）用apply这个接口取样出的叶子  
    5）用于预测样本的规则  
    6）一组样本共享的决策路径

> tree\_的更多内容可以参考：  
> [http://scikit-learn.org/stable/auto\_examples/tree/plot\_unveil\_tree\_structure.html\#sphx-glr-auto-examples-tree-plot-unveil-tree-structure-py][http_scikit-learn.org_stable_auto_examples_tree_plot_unveil_tree_structure.html_sphx-glr-auto-examples-tree-plot-unveil-tree-structure-py]

## 分类树接口列表 ##

**apply(X\[, check\_input\])**

*  输入测试集或样本点，**返回每个样本被分到的叶节点的索引**
 *  check\_\_input是接口apply的参数，输入布尔值，默认True，通常不使用

**decision\_path(X\[, check\_input)**

*  输入测试集或样本点，**返回树中的决策树结构**
 *  check\_input同样是参数

**fit(X, y\[, sample weight, check input, …\])**

*  训练模型的接口，其中**X代表训练样本的特征**，**y代表目标数据，即标签**，X和y都必须是类数组结构，一般我们都使用ndarray来导入
 *  sample\_weight是fit的参数，用来为样本标签设置权重，输入的格式是一个和测试集样本量一致长度的数字数组，数组中所带有的数字表示每个样本量所占的权重，数组中数字的综合代表整个测试集的权重总数
 *  返回训练完毕的模型

**get\_ params(\[deep\])**

*  布尔值，**获取这个模型评估对象的参数**
 *  接口本身的参数deep，默认为True，表示返回此估计器的参数并包含作为估算器的子对象
 *  返回模型评估对象在实例化时的参数设置

**predict(X\[, check. input\])**

*  **预测所提供的测试集X中样本点的标签**  
    这里的测试集X必须和fit中提供的训练集结构一致
 *  返回模型预测的测试样本的标签或回归值

**predict\_log\_proba(X)**

*  **预测所提供的测试集X中样本点归属于各个标签的对数概率**

**predict\_proba(X\[, check input\])**

*  **预测所提供的测试集X中样本点归属于各个标签的概率**
 *  返回测试集中每个样本点对应的每个标签的概率，各个标签按词典顺序排序  
    预测的类概率是叶中相同类的样本的分数

**score(X, y\[, sample\_weight\])**

*  **用给定测试数据和标签的平均准确度作为模型的评分标准，分数越高模型越好**。  
    X是测试集，y是测试集的真实标签。
 *  sample\_\_weight是score的参数，用法与fit的参数一致
 *  返回给定策树数据和标签的平均准确度，在多标签分类中，这个指标是子集精度

**set\_params(\*\*params)**

*  可以为已经建立的评估器重设参数
 *  返回重新设置的评估器本身

[sklearn_ _]: https://blog.csdn.net/weixin_43734095/article/details/113793087
[http_scikit-learn.org_stable_index.html]: http://scikit-learn.org/stable/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70]: /images/20221024/f0a8933907da42e7ab735fcf98143d0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 1]: /images/20221024/30935a3e128a4b26bca508a18e3c5aba.png
[x]: /images/20221024/da7679c8a0d7448a89f126cb165f6c39.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 2]: /images/20221024/7ffb5141660f4c61bafd7eaed94fe115.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 3]: /images/20221024/785ec73993744cb79e46aeb9021dbb4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 4]: /images/20221024/38672e37e9f0446c951a55cb381d4e2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 5]: /images/20221024/acdfdf5b8bee4951aa33d3d177a38356.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_1_color_FFFFFF_t_70 6]: /images/20221024/a72b7c6dd66d4404ad4ab2e0d48623ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70]: /images/20221024/50fd639f5215416c83638ff1a58d5e2a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzczNDA5NQ_size_16_color_FFFFFF_t_70 1]: /images/20221024/1784257b8ef44f6cb2b4c51abe8a3348.png
[http_scikit-learn.org_stable_auto_examples_tree_plot_unveil_tree_structure.html_sphx-glr-auto-examples-tree-plot-unveil-tree-structure-py]: http://scikit-learn.org/stable/auto_examples/tree/plot_unveil_tree_structure.html#sphx-glr-auto-examples-tree-plot-unveil-tree-structure-py