lee_x_lee
lee_x_lee

决策树在sklearn中的实现

1 概述

　　1.1 决策树是如何工作的

　　1.2 构建决策树
　　　　1.2.1 ID3算法构建决策树
　　　　1.2.2 简单实例
　　　　1.2.3 ID3的局限性
　　1.3 C4.5算法 & CART算法
　　　　1.3.1 修改局部最优化条件
　　　　1.3.2 连续变量处理手段

　　1.4 sklearn中的决策树

2 DecisionTreeClassifier与红酒数据集

　　2.1 重要参数

　　　　2.1.1 criterion

　　　　2.1.2 random_state & splitter

　　　　2.1.3 剪枝参数

　　　　2.1.4 目标权重参数

　　2.2 重要属性和接口

3 DecisionTreeRegressor

　　3.1 重要参数，属性及接口

　　　　criterion

　　3.2 实例：一维回归的图像绘制

4 实例：泰坦尼克号幸存者的预测

5 决策树的优缺点

6 附录

　　6.1 分类树参数列表

　　6.2 分类树属性列表

　　6.3 分类树接口列表

Bonus Chapter I 实例：分类树在合成数集上的表现

 

1 概述

1.1 决策树是如何工作的

　　决策树（Decision Tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并用树状图的结构来呈现这些规则，以解决分类和回归问题。决策树算法容易理解，适用各种数据，在解决各种问题时都有良好表现，尤其是以树模型为核心的各种集成算法，在各个行业和领域都有广泛的应用。
　　我们来简单了解一下决策树是如何工作的。决策树算法的本质是一种图结构，我们只需要问一系列问题就可以对数据进行分类了。比如说，来看看下面这组数据集，这是一系列已知物种以及所属类别的数据：

　　我们现在的目标是，将动物们分为哺乳类和非哺乳类。那根据已经收集到的数据，决策树算法为我们算出了下面的这棵决策树：

　　假如我们现在发现了一种新物种Python，它是冷血动物，体表带鳞片，并且不是胎生，我们就可以通过这棵决策树来判断它的所属类别。

　　可以看出，在这个决策过程中，我们一直在对记录的特征进行提问。最初的问题所在的地方叫做根节点，在得到结论前的每一个问题都是中间节点，而得到的每一个结论（动物的类别）都叫做叶子节点。

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

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

　　1）如何从数据表中找出最佳节点和最佳分枝？

　　2）如何让决策树停止生长，防止过拟合？

　　几乎所有决策树有关的模型调整方法，都围绕这两个问题展开。接下来，我们就来了解一下决策树背后的原理。

 

1.2构建决策树

　　接下来讨论如何根据已有的数据集来建立有效的决策树。原则上讲，任意一个数据集上的所有特征都可以被拿来分枝，特征上的任意节点又可以自由组合，所以一个数据集上可以发展出非常非常多棵决策树，其数量可达指数级。在这些树中，总有那么一棵树比其他的树分类效力都好，那样的树叫做”全局最优树"。

 

　　关键概念：全局最优，局部最优

　　　　全局最优：经过组合形成的，整体来说分类效果最好的模型；
　　　　局部最优：每一次分枝的时候都向着更好的分类效果分枝，但无法确认如此生成的树在全局上是否是最优的。

 

　　要在这么多棵决策树中去一次性找到分类效果最佳的那一棵是不可能的，如果通过排列组合来进行筛选，计算量过于大而且低效，因此我们不会这样做。相对的，机器学习研究者们开发了一些有效的算法，能够在合理的时间内构造出具有一定准确率的次最优决策树。这些算法基本都执行”贪心策略"，即通过局部的最优来达到我们相信是最接近全局最优的结果。

 

　　关键概念：贪心算法
　　　　通过实现局部最优来达到接近全局最优结果的算法，所有的树模型都是这样的算法。

 

　　最典型的决策树算法是Hunt算法，该算法是由Hunt等人提出的最早的决策树算法。现代，Hunt算法是许多决策树算法的基础，包括ID3、C4.5和CART等。Hunt算法诞生时间较早，且基础理论并非特别完善，此处以应用较广、理论基础较为完善的ID3算法的基本原理开始，讨论如何利用局部最优化方法来创建决策模型。

 

1.2.1 ID3算法构建决策树

　　ID3算法原型见于J.R Quinlan的博士论文，是基础理论较为完善，使用较为广泛的决策树模型，在此基础上J.RQuinlan进行优化后，陆续推出了C4.5和C5.0决策树算法，后二者现已称为当前最流行的决策树算法，我们先从ID3开始讲起，再讨论如何从ID3逐渐优化至C4.5。
　　为了要将表格转化为一棵树，决策树需要找出最佳节点和最佳的分枝方法，而衡量这个“最佳”的指标叫做“不纯度”。不纯度基于叶子节点来计算的，所以树中的每个节点都会有一个不纯度，并且子节点的不纯度一定是低于父节点的，也就是说，在同一棵决策树上，叶子节点的不纯度一定是最低的。
 

　　重要概念：不纯度
　　　　决策树的每个叶子节点中都会包含一组数据，在这组数据中，如果有某一类标签占有较大的比例，我们就说叶子节点“纯”，分枝分得好。某一类标签占的比例越大，叶子就越纯，不纯度就越低，分枝就越好。 如果没有哪一类标签的比例很大，各类标签都相对平均，则说叶子节点”不纯“，分枝不好，不纯度高。
 

　　这个其实非常容易理解。分类型决策树在叶子节点上的决策规则是少数服从多数，在一个叶子节点上，如果某一类标签所占的比例较大，那所有进入这个叶子节点的样本都回被认为是这一类别。具体来说，如果90%根据规则进入叶子节点的样本都是类别0（叶子比较纯），那新进入叶子节点的测试样本的类别也很有可能是0。但是，如果51%的样本是0，49%的样本是1（极端情况），叶子节点还是会被认为是0类叶子节点，但此时此刻进入这个叶子的测试样本点几乎有一半的可能性应该是类别1。从数学上来说，类分布为（0,100%）的结点具有零不纯性，而均衡分布（50%,50%）的结点具有最高的不纯性。如果叶子本身不纯，那测试样本就很有可能被判断错误，相对的叶子越纯，那样本被判断错误的可能性就越小。

　　通常来说，不纯度越低，决策树对训练集的拟合越好。现在使用的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。若我们定义 t 代表决策树的某节点， Dt 是 t 节点所对应的数据集，设 p(i|t)  表示给定结点 t 中属于类别 i 的样本所占的比例，这个比例越高，则代表叶子越纯。

【练习】从下面的图来看，哪个不纯度最高？哪个不纯度最低？

怎样计算不纯度？
　　对于节点不纯度的计算和表示方法因决策树模型而异，但不管不纯度的度量方法如何，都是由误差率衍生而来，其计算公式如下：

　　误差率越低，则纯度越高。由此还衍生出了其他两个常用指标，一个是ID3中Information gain（信息增益）的计算方法可用Entropy推导，即最为人熟知的信息熵，又叫做香农熵，其计算公式如下：

　　其中c表示叶子节点上标签类别的个数，c-1表示标签的索引。注意在这里，是从第0类标签开始计算，所以最后的标签类别应该是总共c个标签，c-1为最后一个标签的索引。在计算Entropy时设定log20 = 0。
　　另一个指标则是Gini（基尼）指数，主要用于CART决策树的纯度判定中，其计算公式如下：

　　假设在二分类问题中各节点呈现如下分布，则可进一步计算上述三指数的结果

 　　能够看出，三种方法本质上都相同，在类分布均衡时（即当p=0.5时）达到最大值，而当所有记录都属于同一个类时（p等于1或0）达到最小值。换而言之，在纯度较高时三个指数均较低，而当纯度较低时，三个指数都比较大，且可以计算得出，嫡在0-1区间内分布，而Gini指数和分类误差均在0-0.5区间内分布，三个指数随某变量占比增加而变化的曲线如下所示：

　　决策树最终的优化目标是使得叶节点的总不纯度最低，即对应衡量不纯度的指标最低。
　　ID3采用信息熵来衡量不纯度，此处就先以信息嫡为例进行讨论。ID3最优条件是叶节点的总信息熵最小，因此ID3决策树在决定是否对某节点进行切分的时候，会尽可能选取使得该节点对应的子节点信息熵最小的特征进行切分。换而言之，就是要求父节点信息熵和子节点总信息熵之差要最大。对于ID3而言，二者之差就是信息增益，即Information gain。

 　　但这里需要注意，一个父节点下可能有多个子节点，而每个子节点又有自己的信息熵，所以父节点信息熵和子节点信息熵之差，应该是父节点的信息熵-所有子节点信息熵的加权平均。其中，权重是使用单个叶子节点上所占的样本量比上父节点上的总样本量来确定的一个权重。

　　而父节点和子节点的不纯度下降数可由下述公式进行计算：

　　I（.）是给定结点的不纯性度量（即是基尼系数或者信息上），N是父结点上的样本数，k是这一层上子节点的个数，NVj）是与子结点相关联的样本个数。决策树算法通常选择最大化增益△的测试条件，因为对任何分枝过程来说，
（parent）都是一个不变的值（因为此时父节点已经存在并且不可修改），所以最大化增益等价于最小化子结点的不纯性衡量的加权平均。最后，当选择熵（entropy）作为公式的不纯性度量时，烯的差就是所谓信息增益（Information gain）△info。
　　接下来对此进行举例说明。


1.2.2 简单实例 

　　假设现在有如下数据集，是一个消费者个人属性和信用评分数据，标签是“是否会发生购买电脑行为"，仍然是个而分类问题，在此数据集之上我们使用ID3构建决策树模型，并提取有效的分类规则。

 

 

1.2.3  ID3的局限性 

 

1.3 C4.5算法&CART算法


1.3.1 修改局部最优化条件

1.3.2 连续变量处理手段 

1.4 sklearn中的决策树

  • 模块sklearn.tree

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

　　我们会主要讲解分类树和回归树，并用图像呈现给大家。

 

  • sklearn的基本建模流程

　　在那之前，我们先来了解一下sklearn建模的基本流程。

　　在这个流程下，分类树对应的代码是：

1

2

3

4

from sklearn import tree #导入需要的模块

clf = tree.DecisionTreeClassifier()     #实例化

clf = clf.fit(X_train,y_train) #用训练集数据训练模型

result = clf.score(X_test,y_test) #导入测试集，从接口中调用需要的信息

 

2 DecisionTreeClassifier与红酒数据集

1

2

3

4

5

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)

　

2.1 重要参数

2.1.1 criterion

　　为了要将表格转化为一棵树，决策树需要找出最佳节点和最佳的分枝方法，对分类树来说，衡量这个“最佳”的指标叫做“不纯度”。通常来说，不纯度越低，决策树对训练集的拟合越好。现在使用的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。
　　不纯度基于节点来计算，树中的每个节点都会有一个不纯度，并且子节点的不纯度一定是低于父节点的，也就是说，在同一棵决策树上，叶子节点的不纯度一定是最低的。
　　Criterion这个参数正是用来决定不纯度的计算方法的。sklearn提供了两种选择：

  1. 输入”entropy“，使用信息熵（Entropy）
  2. 输入”gini“，使用基尼系数（Gini Impurity）

　　其中 t 代表给定的节点， i 代表标签的任意分类， p(i|t)  代表标签分类 i 在节点 t 上所占的比例。注意，当使用信息熵时，sklearn实际计算的是基于信息熵的信息增益(Information Gain)，即父节点的信息熵和子节点的信息熵之差。
　　比起基尼系数，信息熵对不纯度更加敏感，对不纯度的惩罚最强。但是在实际使用中，信息熵和基尼系数的效果基本相同。信息熵的计算比基尼系数缓慢一些，因为基尼系数的计算不涉及对数。另外，因为信息熵对不纯度更加敏感，所以信息熵作为指标时，决策树的生长会更加“精细”，因此对于高维数据或者噪音很多的数据，信息熵很容易过拟合，基尼系数在这种情况下效果往往比较好。当模型拟合程度不足的时候，即当模型在训练集和测试集上都表现不太好的时候，使用信息熵（欠拟合情况下使用多）。当然，这些不是绝对的。

　　到这里，决策树的基本流程其实可以简单概括如下：

　　直到没有更多的特征可用，或整体的不纯度指标已经最优，决策树就会停止生长。

 

  • 建立一棵树
  1. 导入需要的算法库和模块

    1

    2

    3

    from sklearn import tree

    from sklearn.datasets import load_wine

    from sklearn.model_selection import train_test_split
  2. 探索数据

    1

    2

    3

    4

    5

    6

    7

    8

    wine = load_wine()

    wine.data.shape#(178,13)

    wine.target

    #如果wine是一张表，应该长这样：

    import pandas as pd

    pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis=1)

    wine.feature_names

    wine.target_names
  3. 分训练集和测试集

    1

    2

    3

    Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data,wine.target,test_size=0.3)

    Xtrain.shape

    Xtest.shape
  4. 建立模型

    1

    2

    3

    4

    clf = tree.DecisionTreeClassifier(criterion="entropy")#实例化，criterion不写的话默认是基尼系数

    clf = clf.fit(Xtrain, Ytrain)

    score = clf.score(Xtest, Ytest) #返回预测的准确度

    score
  5. 画出一棵树吧

    1

    2

    3

    4

    5

    6

    7

    8

    9

    10

    11

    12

    13

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

     

    import graphviz

    dot_data = tree.export_graphviz(clf

                                   # ,out_file = None

                                   ,feature_names= feature_name

                                   ,class_names=["琴酒","雪莉","贝尔摩德"]

                                   ,filled=True#让树的每一块有颜色，颜色越浅，表示不纯度越高

                                   ,rounded=True#树的块的形状

                                   )

    graph = graphviz.Source(dot_data)

    graph.render("Tree")

    graph# graph.view()
  6. 探索决策树

    1

    2

    3

    #特征重要性

    clf.feature_importances_

    [*zip(feature_name,clf.feature_importances_)]

　　我们已经在只了解一个参数的情况下，建立了一棵完整的决策树。但是回到步骤4建立模型，score会在某个值附近波动，引起步骤5中画出来的每一棵树都不一样。它为什么会不稳定呢？如果使用其他数据集，它还会不稳定吗？
　　我们之前提到过，无论决策树模型如何进化，在分枝上的本质都还是追求某个不纯度相关的指标的优化，而正如我们提到的，不纯度是基于节点来计算的，也就是说，决策树在建树时，是靠优化节点来追求一棵优化的树，但最优的节点能够保证最优的树吗？集成算法被用来解决这个问题：sklearn表示，既然一棵树不能保证最优，那就建更多的不同的树，然后从中取最好的。怎样从一组数据集中建不同的树？在每次分枝时，不从使用全部特征，而是随机选取一部分特征，从中选取不纯度相关指标最优的作为分枝用的节点。这样，每次生成的树也就不同了。

1

2

3

4

clf = tree.DecisionTreeClassifier(criterion="entropy",random_state=30)

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest) #返回预测的准确度

score

　　

2.1.2 random_state & splitter

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

 

　　splitter也是用来控制决策树中的随机选项的，有两种输入值，输入”best"，决策树在分枝时虽然随机，但是还是会优先选择更重要的特征进行分枝（重要性可以通过属性feature_importances_查看），输入“random"，决策树在分枝时会更加随机，树会因为含有更多的不必要信息而更深更大，并因这些不必要信息而降低对训练集的拟合。这也是防止过拟合的一种方式。当你预测到你的模型会过拟合，用这两个参数来帮助你降低树建成之后过拟合的可能性。当然，树一旦建成，我们依然是使用剪枝参数来防止过拟合。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

clf = tree.DecisionTreeClassifier(criterion="entropy"

                                    ,random_state=30

                                    ,splitter="random"

                                    )

clf = clf.fit(Xtrain, Ytrain)

score = clf.score(Xtest, Ytest)

 

score#0.9814814814814815

 

import graphviz

dot_data = tree.export_graphviz(clf

                                ,feature_names= feature_name

                                ,class_names=["琴酒","雪莉","贝尔摩德"]

                                ,filled=True

                                ,rounded=True

                                )

graph = graphviz.Source(dot_data)

graph

　　

2.1.3 剪枝参数

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

1

2

3

#我们的树对训练集的拟合程度如何？

score_train = clf.score(Xtrain, Ytrain)

score_train#1.0

　　为了让决策树有更好的泛化性，我们要对决策树进行剪枝。剪枝策略对决策树的影响巨大，正确的剪枝策略是优化决策树算法的核心。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个训练样本，这个节点才允许被分枝，否则分枝就不会发生。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

clf = tree.DecisionTreeClassifier(criterion="entropy"

                                    ,random_state=30

                                    ,splitter="random"

                                    ,max_depth=3

                                #    ,min_samples_leaf=10

                                #    ,min_samples_split=25

                                    )

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

 

score = clf.score(Xtest, Ytest)

score#0.9814814814814815
  • max_features & min_impurity_decrea

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

  • 确认最优的剪枝参数

　　那具体怎么来确定每个参数填写什么值呢？这时候，我们就要使用确定超参数的曲线来进行判断了，继续使用我们已经训练好的决策树模型clf。超参数的学习曲线，是一条以超参数的取值为横坐标，模型的度量指标为纵坐标的曲线，它是用来衡量不同超参数取值下模型的表现的线。在我们建好的决策树里，我们的模型度量指标就是score。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

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

 

　　结果：

 

决策树在sklearn中的实现_第1张图片

思考：

  1. 剪枝参数一定能够提升模型在测试集上的表现吗？-调参没有绝对的答案，一切都是看数据本身。
  2. 这么多参数，一个个画学习曲线？-在泰坦尼克号的案例中，我们会解答这个问题。

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

 

2.1.4 目标权重参数　　

  • class_weight & min_weight_fraction_leaf

　　完成样本标签平衡的参数。样本不平衡是指在一组数据集中，标签的一类天生占有很大的比例。比如说，在银行要判断“一个办了信用卡的人是否会违约"，就是是vs否（1%：99%）的比例。这种分类状况下，即便模型什么也不做，全把结果预测成“否”，正确率也能有99%。因此我们要使用class_weight参数对样本标签进行一定的均衡，给少量的标签更多的权重，让模型更偏向少数类，向捕获少数类的方向建模。该参数默认None，此模式表示自动给与数据集中的所有标签相同的权重。
　　有了权重之后，样本量就不再是单纯地记录数目，而是受输入的权重影响了，因此这时候剪枝，就需要搭配min_weight_fraction_leaf这个基于权重的剪枝参数来使用。另请注意，基于权重的剪枝参数（例如min_weight_fraction_leaf）将比不知道样本权重的标准（比如min_samples_leaf）更少偏向主导类。如果样本是加权的，则使用基于权重的预修剪标准来更容易优化树结构，这确保叶节点至少包含样本权重的总和的一小部分。

 

2.2 重要属性和接口　　

　　属性是在模型训练之后，能够调用查看的模型的各种性质。对决策树来说，最重要的是feature_importances_，能够查看各个特征对模型的重要性。sklearn中许多算法的接口都是相似的，比如说我们之前已经用到的fit和score，几乎对每个算法都可以使用。除了这两个接口之外，决策树最常用的接口还有apply和predict。apply中输入测试集返回每个测试样本所在的叶子节点的索引，predict输入测试集返回每个测试样本的标签。返回的内容一目了然并且非常容易，大家感兴趣可以自己下去试试看。

　　在这里不得不提的是，所有接口中要求输入X_train和X_test的部分，输入的特征矩阵必须至少是一个二维矩阵。sklearn不接受任何一维矩阵作为特征矩阵被输入。如果你的数据的确只有一个特征，那必须用reshape(-1,1)来给矩阵增维；如果你的数据只有一个特征和一个样本，使用reshape(1,-1)来给你的数据增维。

1

2

#apply返回每个测试样本所在的叶子节点的索引

clf.apply(Xtest)

　　结果：

1

2

3

4

array([19, 27, 19, 27,  7,  7,  7, 27, 19, 27, 21, 21,  7, 18,  7, 21,  7,

       10,  7, 19,  7, 27, 19, 19, 27, 21,  7, 21, 27,  7, 19,  7,  7, 27,

       21, 27, 27,  7, 27,  7, 19, 27,  7, 27, 27, 19, 19, 10, 27, 27, 27,

       10,  7, 21], dtype=int64)

 

1

2

#predict返回每个测试样本的分类/回归结果

clf.predict(Xtest)

　　结果：

1

2

3

array([1, 0, 1, 0, 2, 2, 2, 0, 1, 0, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0,

       1, 1, 0, 1, 2, 1, 0, 2, 1, 2, 2, 0, 1, 0, 0, 2, 0, 2, 1, 0, 2, 0,

       0, 1, 1, 1, 0, 0, 0, 1, 2, 1])

 

　　至此，我们已经学完了分类树DecisionTreeClassifier和用决策树绘图（export_graphviz）的所有基础。我们讲解了决策树的基本流程，分类树的八个参数，一个属性，四个接口，以及绘图所用的代码。
　　八个参数：Criterion，两个随机性相关的参数（random_state，splitter），五个剪枝参数（max_depth, min_samples_split，min_samples_leaf，max_feature，min_impurity_decrease）
　　一个属性：feature_importances_
　　四个接口：fit，score，apply，predict

　　有了这些知识，基本上分类树的使用大家都能够掌握了，接下来再到实例中去磨练就好。

 

3 DecisionTreeRegressor

1

2

3

class sklearn.tree.DecisionTreeRegressor (criterion=’mse’, 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, presort=False)

　　几乎所有参数，属性及接口都和分类树一模一样。需要注意的是，在回归树种，没有标签分布是否均衡的问题，因此没有class_weight这样的参数。

 

3.1 重要参数，属性及接口

criterion

　回归树衡量分枝质量的指标，支持的标准有三种：

  1. 输入"mse"使用均方误差mean squared error(MSE)，父节点和叶子节点之间的均方误差的差额将被用来作为特征选择的标准，这种方法通过使用叶子节点的均值来最小化L2损失
  2. 输入“friedman_mse”使用费尔德曼均方误差，这种指标使用弗里德曼针对潜在分枝中的问题改进后的均方误差
  3. 输入"mae"使用绝对平均误差MAE（mean absolute error），这种指标使用叶节点的中值来最小化L1损失

　　属性中最重要的依然是feature_importances_，接口依然是apply, fit, predict, score最核心。

　　其中N是样本数量，i是每一个数据样本，fi是模型回归出的数值，yi是样本点i实际的数值标签。所以MSE的本质，其实是样本真实数据与回归结果的差异。在回归树中，MSE不只是我们的分枝质量衡量指标，也是我们最常用的衡量回归树回归质量的指标，当我们在使用交叉验证，或者其他方式获取回归树的结果时，我们往往选择均方误差作为我们的评估（在分类树中这个指标是score代表的预测准确率）。在回归中，我们追求的是，MSE越小越好。然而，回归树的接口score返回的是R平方，并不是MSE。R平方被定义如下：

　　其中u是残差平方和（MSE * N），v是总平方和，N是样本数量，i是每一个数据样本，fi是模型回归出的数值，yi是样本点i实际的数值标签。y帽是真实数值标签的平均数。R平方可以为正为负（如果模型的残差平方和远远大于模型的总平方和，模型非常糟糕，R平方就会为负），而均方误差永远为正。
　　值得一提的是，虽然均方误差永远为正，但是sklearn当中使用均方误差作为评判标准时，却是计算”负均方误差“（neg_mean_squared_error）。这是因为sklearn在计算模型评估指标的时候，会考虑指标本身的性质，均方误差本身是一种误差，所以被sklearn划分为模型的一种损失(loss)，因此在sklearn当中，都以负数表示。真正的均方误差MSE的数值，其实就是neg_mean_squared_error去掉负号的数字。
 

简单看看回归树是怎样工作的

1

2

3

from sklearn.datasets import load_boston

from sklearn.model_selection import cross_val_score

from sklearn.tree import DecisionTreeRegressor

　　

1

boston = load_boston()

　　

1

boston.data

　　结果：

1

2

3

4

5

6

7

8

9

10

11

12

13

array([[6.3200e-03, 1.8000e+01, 2.3100e+00, ..., 1.5300e+01, 3.9690e+02,

        4.9800e+00],

       [2.7310e-02, 0.0000e+00, 7.0700e+00, ..., 1.7800e+01, 3.9690e+02,

        9.1400e+00],

       [2.7290e-02, 0.0000e+00, 7.0700e+00, ..., 1.7800e+01, 3.9283e+02,

        4.0300e+00],

       ...,

       [6.0760e-02, 0.0000e+00, 1.1930e+01, ..., 2.1000e+01, 3.9690e+02,

        5.6400e+00],

       [1.0959e-01, 0.0000e+00, 1.1930e+01, ..., 2.1000e+01, 3.9345e+02,

        6.4800e+00],

       [4.7410e-02, 0.0000e+00, 1.1930e+01, ..., 2.1000e+01, 3.9690e+02,

        7.8800e+00]])

　　

1

boston.target

　　结果：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

array([24. , 21.6, 34.7, 33.4, 36.2, 28.7, 22.9, 27.1, 16.5, 18.9, 15. ,

       18.9, 21.7, 20.4, 18.2, 19.9, 23.1, 17.5, 20.2, 18.2, 13.6, 19.6,

       15.2, 14.5, 15.6, 13.9, 16.6, 14.8, 18.4, 21. , 12.7, 14.5, 13.2,

       13.1, 13.5, 18.9, 20. , 21. , 24.7, 30.8, 34.9, 26.6, 25.3, 24.7,

       21.2, 19.3, 20. , 16.6, 14.4, 19.4, 19.7, 20.5, 25. , 23.4, 18.9,

       35.4, 24.7, 31.6, 23.3, 19.6, 18.7, 16. , 22.2, 25. , 33. , 23.5,

       19.4, 22. , 17.4, 20.9, 24.2, 21.7, 22.8, 23.4, 24.1, 21.4, 20. ,

       20.8, 21.2, 20.3, 28. , 23.9, 24.8, 22.9, 23.9, 26.6, 22.5, 22.2,

       23.6, 28.7, 22.6, 22. , 22.9, 25. , 20.6, 28.4, 21.4, 38.7, 43.8,

       33.2, 27.5, 26.5, 18.6, 19.3, 20.1, 19.5, 19.5, 20.4, 19.8, 19.4,

       21.7, 22.8, 18.8, 18.7, 18.5, 18.3, 21.2, 19.2, 20.4, 19.3, 22. ,

       20.3, 20.5, 17.3, 18.8, 21.4, 15.7, 16.2, 18. , 14.3, 19.2, 19.6,

       23. , 18.4, 15.6, 18.1, 17.4, 17.1, 13.3, 17.8, 14. , 14.4, 13.4,

       15.6, 11.8, 13.8, 15.6, 14.6, 17.8, 15.4, 21.5, 19.6, 15.3, 19.4,

       17. , 15.6, 13.1, 41.3, 24.3, 23.3, 27. , 50. , 50. , 50. , 22.7,

       25. , 50. , 23.8, 23.8, 22.3, 17.4, 19.1, 23.1, 23.6, 22.6, 29.4,

       23.2, 24.6, 29.9, 37.2, 39.8, 36.2, 37.9, 32.5, 26.4, 29.6, 50. ,

       32. , 29.8, 34.9, 37. , 30.5, 36.4, 31.1, 29.1, 50. , 33.3, 30.3,

       34.6, 34.9, 32.9, 24.1, 42.3, 48.5, 50. , 22.6, 24.4, 22.5, 24.4,

       20. , 21.7, 19.3, 22.4, 28.1, 23.7, 25. , 23.3, 28.7, 21.5, 23. ,

       26.7, 21.7, 27.5, 30.1, 44.8, 50. , 37.6, 31.6, 46.7, 31.5, 24.3,

       31.7, 41.7, 48.3, 29. , 24. , 25.1, 31.5, 23.7, 23.3, 22. , 20.1,

       22.2, 23.7, 17.6, 18.5, 24.3, 20.5, 24.5, 26.2, 24.4, 24.8, 29.6,

       42.8, 21.9, 20.9, 44. , 50. , 36. , 30.1, 33.8, 43.1, 48.8, 31. ,

       36.5, 22.8, 30.7, 50. , 43.5, 20.7, 21.1, 25.2, 24.4, 35.2, 32.4,

       32. , 33.2, 33.1, 29.1, 35.1, 45.4, 35.4, 46. , 50. , 32.2, 22. ,

       20.1, 23.2, 22.3, 24.8, 28.5, 37.3, 27.9, 23.9, 21.7, 28.6, 27.1,

       20.3, 22.5, 29. , 24.8, 22. , 26.4, 33.1, 36.1, 28.4, 33.4, 28.2,

       22.8, 20.3, 16.1, 22.1, 19.4, 21.6, 23.8, 16.2, 17.8, 19.8, 23.1,

       21. , 23.8, 23.1, 20.4, 18.5, 25. , 24.6, 23. , 22.2, 19.3, 22.6,

       19.8, 17.1, 19.4, 22.2, 20.7, 21.1, 19.5, 18.5, 20.6, 19. , 18.7,

       32.7, 16.5, 23.9, 31.2, 17.5, 17.2, 23.1, 24.5, 26.6, 22.9, 24.1,

       18.6, 30.1, 18.2, 20.6, 17.8, 21.7, 22.7, 22.6, 25. , 19.9, 20.8,

       16.8, 21.9, 27.5, 21.9, 23.1, 50. , 50. , 50. , 50. , 50. , 13.8,

       13.8, 15. , 13.9, 13.3, 13.1, 10.2, 10.4, 10.9, 11.3, 12.3,  8.8,

        7.2, 10.5,  7.4, 10.2, 11.5, 15.1, 23.2,  9.7, 13.8, 12.7, 13.1,

       12.5,  8.5,  5. ,  6.3,  5.6,  7.2, 12.1,  8.3,  8.5,  5. , 11.9,

       27.9, 17.2, 27.5, 15. , 17.2, 17.9, 16.3,  7. ,  7.2,  7.5, 10.4,

        8.8,  8.4, 16.7, 14.2, 20.8, 13.4, 11.7,  8.3, 10.2, 10.9, 11. ,

        9.5, 14.5, 14.1, 16.1, 14.3, 11.7, 13.4,  9.6,  8.7,  8.4, 12.8,

       10.5, 17.1, 18.4, 15.4, 10.8, 11.8, 14.9, 12.6, 14.1, 13. , 13.4,

       15.2, 16.1, 17.8, 14.9, 14.1, 12.7, 13.5, 14.9, 20. , 16.4, 17.7,

       19.5, 20.2, 21.4, 19.9, 19. , 19.1, 19.1, 20.1, 19.9, 19.6, 23.2,

       29.8, 13.8, 13.3, 16.7, 12. , 14.6, 21.4, 23. , 23.7, 25. , 21.8,

       20.6, 21.2, 19.1, 20.6, 15.2,  7. ,  8.1, 13.6, 20.1, 21.8, 24.5,

       23.1, 19.7, 18.3, 21.2, 17.5, 16.8, 22.4, 20.6, 23.9, 22. , 11.9])

　　

1

2

3

4

5

regressor = DecisionTreeRegressor(random_state=0)#实例化

 

cross_val_score(regressor, boston.data, boston.target, cv=10,#交叉验证会自动划分数据集为测试集与验证集，不需要自己单独划分，cv为划分的数量，默认是5

                scoring = "neg_mean_squared_error"#scoring指的是返回的是均方误差，如果不写返回的是R的平方

               )

　　结果：

1

2

3

array([-16.41568627, -10.61843137, -18.30176471, -55.36803922,

       -16.01470588, -44.70117647, -12.2148    , -91.3888    ,

       -57.764     , -36.8134    ])

　　

1

cross_val_score(regressor, boston.data, boston.target, cv=10).mean()#返回的是R方的均值：-0.1253505322812249

　　

　　交叉验证是用来观察模型的稳定性的一种方法，我们将数据划分为n份，依次使用其中一份作为测试集，其他n-1份作为训练集，多次计算模型的精确性来评估模型的平均准确程度。训练集和测试集的划分会干扰模型的结果，因此用交叉验证n次的结果求出的平均值，是对模型效果的一个更好的度量。

 

 

3.2 实例：一维回归的图像绘制

　　接下来我们到二维平面上来观察决策树是怎样拟合一条曲线的。我们用回归树来拟合正弦曲线，并添加一些噪声来观察回归树的表现。

1. 导入需要的库

1

2

3

import numpy as np

from sklearn.tree import DecisionTreeRegressor

import matplotlib.pyplot as plt

　

2. 创建一条含有噪声的正弦曲线

　　在这一步，我们的基本思路是，先创建一组随机的，分布在0~5上的横坐标轴的取值(x)，然后将这一组值放到sin函数中去生成纵坐标的值(y)，接着再到y上去添加噪声。全程我们会使用numpy库来为我们生成这个正弦曲线。

1

2

3

4

5

rng = np.random.RandomState(1) #随机数种子

#np.random.rand(数组结构)，生成随机数组的函数

X = np.sort(5 * rng.rand(80,1), axis=0) #生成0~5之间随机的x的取值，80行1列，按照axis = 0(行)进行从小到大排序

y = np.sin(X).ravel() #生成正弦曲线 np.sin(X)生成的是80行1列的数组，通过.ravel()降为1维，.ravel()可以将n维数组降为n-1维，多次允许n-1次可以降为1维

y[::5] += 3 * (0.5 - rng.rand(16)) #在正弦曲线上加噪声， rng.rand(16)指的是生成16个0~1之间的随机数

 

1

2

plt.figure()

plt.scatter(X, y, s=20, edgecolor="black",c="darkorange", label="data")#散点图

　　结果：

决策树在sklearn中的实现_第2张图片

1

2

3

4

#了解降维函数ravel()的用法

np.random.random((2,1))

np.random.random((2,1)).ravel()

np.random.random((2,1)).ravel().shape

　　

3.实例化&训练模型

1

2

3

4

regr_1 = DecisionTreeRegressor(max_depth=2)

regr_2 = DecisionTreeRegressor(max_depth=5)

regr_1.fit(X, y)

regr_2.fit(X, y)

　　结果：

1

2

3

4

5

DecisionTreeRegressor(criterion='mse', max_depth=5, max_features=None,

           max_leaf_nodes=None, min_impurity_decrease=0.0,

           min_impurity_split=None, min_samples_leaf=1,

           min_samples_split=2, min_weight_fraction_leaf=0.0,

           presort=False, random_state=None, splitter='best')

　　

4. 测试集导入模型，预测结果

1

2

3

X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]#np.newaxis作用是增加1个维度

y_1 = regr_1.predict(X_test)

y_2 = regr_2.predict(X_test)

　　

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#了解增维切片np.newaxis的用法

l = np.array([1,2,3,4])

l#array([1, 2, 3, 4])

  

l.shape#(4,)

  

l[:,np.newaxis]

# array([[1],

#        [2],

#        [3],

#        [4]])

  

l[:,np.newaxis].shape#(4, 1)

  

l[np.newaxis,:].shape#(1, 4)

 

l[np.newaxis,:]#array([[1, 2, 3, 4]])

　　

1

2

3

4

5

6

7

8

9

plt.figure()

plt.scatter(X, y, s=20, edgecolor="black",c="darkorange", label="data")#s指的是点的大小

plt.plot(X_test, y_1, color="cornflowerblue",label="max_depth=2", linewidth=2)#折线图

plt.plot(X_test, y_2, color="yellowgreen", label="max_depth=5", linewidth=2)

plt.xlabel("data")

plt.ylabel("target")

plt.title("Decision Tree Regression")

plt.legend()

plt.show()

　　结果：

　　可见，回归树学习了近似正弦曲线的局部线性回归。我们可以看到，如果树的最大深度（由max_depth参数控制）设置得太高，则决策树学习得太精细，它从训练数据中学了很多细节，包括噪声得呈现，从而使模型偏离真实的正弦曲线，形成过拟合。


4 实例：泰坦尼克号幸存者的预测

　　泰坦尼克号的沉没是世界上最严重的海难事故之一，今天我们通过分类树模型来预测一下哪些人可能成为幸存者。数据集来着https://www.kaggle.com/c/titanic，数据集会随着代码一起提供给大家，大家可以在下载页面拿到，或者到群中询问。数据集包含两个csv格式文件，data为我们接下来要使用的数据，test为kaggle提供的测试集。接下来我们就来执行我们的代码。

1. 导入所需要的库

1

2

3

4

5

6

import pandas as pd

from sklearn.tree import DecisionTreeClassifier

from sklearn.model_selection import train_test_split

from sklearn.model_selection import GridSearchCV

from sklearn.model_selection import cross_val_score

import matplotlib.pyplot as plt

2.导入数据集，探索数据

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

data = pd.read_csv(r"C:\work\learnbetter\micro-class\week 1 DT\data\data.csv",index_col = 0)

 

data.head()

 

data.info()

#object属于文本类型，并不属于数值类型！

#查看缺失值，为预处理做准备

'''

Int64Index: 891 entries, 1 to 891

Data columns (total 11 columns):

Survived    891 non-null int64

Pclass      891 non-null int64

Name        891 non-null object

Sex         891 non-null object

Age         714 non-null float64

SibSp       891 non-null int64

Parch       891 non-null int64

Ticket      891 non-null object

Fare        891 non-null float64

Cabin       204 non-null object

Embarked    889 non-null object

dtypes: float64(2), int64(4), object(5)

memory usage: 83.5+ KB

'''

3.对数据集进行预处理

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#筛选特征

 

#删除缺失值过多的列，和观察判断来说和预测的y没有关系的列

data.drop(["Cabin","Name","Ticket"],inplace=True,axis=1)#inplace=True指的是覆盖原表，False则会生成新表

 

#处理缺失值，对缺失值较多的列进行填补，有一些特征只缺失一两个值，可以采取直接删除记录的方法

data["Age"] = data["Age"].fillna(data["Age"].mean())

data = data.dropna()#默认axis = 0

 

#将分类变量（如object类型）转换为数值型变量

 

#将二分类变量转换为数值型变量

#astype能够将一个pandas对象转换为某种类型，和apply(int(x))不同，astype可以将文本类转换为数字，用这个方式可以很便捷地将二分类特征转换为0~1

data["Sex"] = (data["Sex"]== "male").astype("int")#.astype("int")将bool值转换为int类型

 

#将三分类变量转换为数值型变量

labels = data["Embarked"].unique().tolist()#tolist()将数组array变为列表list

data["Embarked"] = data["Embarked"].apply(lambda x: labels.index(x))

 

#查看处理后的数据集

data.head()

4.提取标签和特征矩阵，分测试集和训练集

1

2

3

4

5

6

7

8

9

10

11

12

X = data.iloc[:,data.columns != "Survived"]

y = data.iloc[:,data.columns == "Survived"]

 

from sklearn.model_selection import train_test_split

Xtrain, Xtest, Ytrain, Ytest = train_test_split(X,y,test_size=0.3)

 

#修正测试集和训练集的索引

for i in [Xtrain, Xtest, Ytrain, Ytest]:

    i.index = range(i.shape[0])

     

#查看分好的训练集和测试集

Xtrain.head()

5.导入模型，粗略跑一下查看结果

1

2

3

4

5

6

7

8

9

clf = DecisionTreeClassifier(random_state=25)

clf = clf.fit(Xtrain, Ytrain)

score_ = clf.score(Xtest, Ytest)

 

score_

 

score = cross_val_score(clf,X,y,cv=10).mean()#使用交叉验证

 

score

6.在不同max_depth下观察模型的拟合状况

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

tr = []

te = []

for i in range(10):

    clf = DecisionTreeClassifier(random_state=25

                                 ,max_depth=i+1

                                 ,criterion="entropy"#尝试调参，让结果更好

                                )

    clf = clf.fit(Xtrain, Ytrain)

    score_tr = clf.score(Xtrain,Ytrain)#训练集分数

    score_te = cross_val_score(clf,X,y,cv=10).mean()#测试集分数

    tr.append(score_tr)

    te.append(score_te)

print(max(te))

plt.plot(range(1,11),tr,color="red",label="train")

plt.plot(range(1,11),te,color="blue",label="test")

plt.xticks(range(1,11))#横坐标标尺，只显示1-10。

plt.legend()

plt.show()

　　结果：0.8177860061287026

　　注意：这里为什么使用“entropy”？因为我们注意到，在最大深度=3的时候，模型拟合不足，在训练集和测试集上的表现接近，但却都不是非常理想，只能够达到83%左右，所以我们要使用entropy。

7. 用网格搜索调整参数

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

#网格搜索：能够帮助我们同时调整多个参数的技术，枚举技术

import numpy as np

gini_thresholds = np.linspace(0,0.5,20)#基尼系数的边界

#entropy_thresholds = np.linespace(0, 1, 50)

 

#一串参数和这些参数对应的，我们希望网格搜索来搜索的参数的取值范围

parameters = {'splitter':('best','random')

              ,'criterion':("gini","entropy")

              ,"max_depth":[*range(1,10)]

              ,'min_samples_leaf':[*range(1,50,5)]

              ,'min_impurity_decrease':[*gini_thresholds]

             }

 

clf = DecisionTreeClassifier(random_state=25)#实例化决策树

GS = GridSearchCV(clf, parameters, cv=10)#实例化网格搜索，cv指的是交叉验证

GS.fit(Xtrain,Ytrain)

 

GS.best_params_#从我们输入的参数和参数取值的列表中，返回最佳组合

 

GS.best_score_#网格搜索后的模型的评判标准

　

5 决策树的优缺点

决策树优点

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

决策树的缺点

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

6 附录

6.1 分类树参数列表

 

 6.2分类树属性列表

 

tree_的更多内容可以参考：https://scikit-learn.org/stable/auto_examples/tree/plot_unveil_tree_structure.html#sphx-glr-auto-examples-tree-plot-unveil-tree-structure-py

 

6.3 分类树接口列表

 

 

Bonus Chapter I 实例：分类树在合成数集上的表现

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

1. 导入需要的库

1

2

3

4

5

6

7

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）二分型数据

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

#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. 画出三种数据集和三棵决策树的分类效应图像

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

#创建画布，宽高比为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()

　　结果：

　　从图上来看，每一条线都是决策树在二维平面上画出的一条决策边界，每当决策树分枝一次，就有一条线出现。当数据的维度更高的时候，这条决策边界就会由线变成面，甚至变成我们想象不出的多维图形。
　　同时，很容易看得出，分类树天生不擅长环形数据。每个模型都有自己的决策上限，所以一个怎样调整都无法提升表现的可能性也是有的。当一个模型怎么调整都不行的时候，我们可以选择换其他的模型使用，不要在一棵树上吊死。顺便一说，最擅长月亮型数据的是最近邻算法，RBF支持向量机和高斯过程；最擅长环形数据的是最近邻算法和高斯过程；最擅长对半分的数据的是朴素贝叶斯，神经网络和随机森林。

你可能感兴趣的:(sklearn)

  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • python画出分子化学空间分布（UMAP） Sakaiay python
    利用umap画出分子化学空间分布图安装pipinstallumap-learn下面是用一个数据集举的例子importtorchimportumapimportpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltimportseabornassnsfromsklearn.manifoldimportTSNEfromrdkit.Chemimport
  • 分类算法可视化方法 dundunmm 数据挖掘分类数据挖掘人工智能可视化
    可视化方法可以用于帮助理解分类算法的决策边界、性能和在不同数据集上的行为。下面列举几个常见的可视化方法。1.决策边界可视化这种方法用于可视化不同分类算法在二维特征空间中如何分隔不同类别。对于理解决策树、支持向量机（SVM）、逻辑回归和k近邻（k-NN）等模型的行为非常有用。importnumpyasnpimportmatplotlib.pyplotaspltfromsklearn.datasets
  • conda安装包报PackagesNotFoundError错误 张遥 数据分析pythonanaconda
    先查找包(base)bash-3.2$anacondasearch-tcondasklearn返回包的相关信息根据对应的包的包名使用如下命令(base)bash-3.2$anacondashowcorjos/sklearn-pandas会直接给出安装命令condainstall--channelhttps://conda.anaconda.org/corjossklearn-pandas
  • 【ML】支持向量机SVM及Python实现（详细） 2401_84009698 程序员支持向量机python算法
    fromsklearn.preprocessingimportStandardScalerfrommatplotlib.colorsimportListedColormapfromsklearn.svmimportSVC###2.1加载数据样本加载样本数据及其分类标签iris=datasets.load_iris()X=iris.data[:,[2,3]]#按花瓣划分#X=iris.data[:,
  • python3.7安装keras教程_python 3.7 安装 sklearn keras(tf.keras) weixin_39641103
    #1sklearn一般方法网上有很多教程，不再赘述。注意顺序是numpy+mkl，然后scipy的环境，scipy，然后sklearn#2anocondaanaconda原始的环境已经自带了sklearn，这里说一下新建环境（比如创建了一个tensorflow的环境），activatetensorflow2.0，然后condainstallsklearn即可，会帮你把各种需要的库都安装。#kera
  • # Seaborn热图修改画布大小|Seaborn热图修改横纵坐标大小|Seaborn删除注释|Seaborn删除调色板|Seaborn注释添加标注文字|Seaborn删除刻度线 Red Red 生信小技巧python开发语言ux笔记学习方法
    Seaborn热图修改画布大小|Seaborn热图修改横纵坐标大小|Seaborn删除注释|Seaborn删除调色板|Seaborn注释添加标注文字|Seaborn删除刻度线查看图片importmatplotlibaspltplt.show()修改画布大小#导入需要用到的相关包importseabornassnsimportpandasaspdimportmatplotlibfromsklearn
  • 推荐算法学习记录2.2——kaggle数据集的动漫电影数据集推荐算法实践——基于内容的推荐算法、协同过滤推荐 萱仔学习自我记录 推荐算法学习pythonmatplotlib开发语言
    1、基于内容的推荐：这种方法根据项的相关信息（如描述信息、标签等）和用户对项的操作行为（如评论、收藏、点赞等）来构建推荐算法模型。它可以直接利用物品的内容特征进行推荐，适用于内容较为丰富的场景。‌#1.基于内容的推荐算法fromsklearn.feature_extraction.textimportTfidfVectorizerfromsklearn.metrics.pairwiseimport
  • 30、基于SelectFromModel和LassoCV的特征选择 凌晨思索
    30、基于SelectFromModel和LassoCV的特征选择importmatplotlib.pyplotaspltimportnumpyasnpfromsklearn.datasetsimportload_diabetesfromsklearn.feature_selectionimportSelectFromModelfromsklearn.linear_modelimportLasso
  • 01-30 姬汉斯
    今天看的是关于文档识别和分类的处理案例。利用多项式贝叶斯公式计算TF-IDF值，以此计算出文档中的词频，文档频率等数据属性，TFIDFVectorizer类用于进行整理，NTLK包进行标注处理，计算文档中各个字符的权重，通过分类器进行分类处理。Sklearn在其中依然有巨大作用，还在熟悉其特性
  • Python处理大数据，如何提高处理速度 RS& #pythonpython大数据pandas
    Python处理大数据，如何提高处理速度？一、利用大数据分析工具Dask：https://dask.org/Dask简介：Dask支持Pandas的DataFrame和NumpyArray的数据结构，并且既可在本地计算机上运行，也可以扩展到在集群上运行。Dask可支持pandas、Numpy、Sklearn、XGBoost、XArray、RAPIDS等等。原理及使用方法：https://blog.
  • 自动安装第三方库python,python第三方库自动安装脚本 杏仁菌子 自动安装第三方库python
    #python第三方库自动安装脚本，需要在cmd中运行此脚本#BatchInstall.pyimportoslibs={"numpy","matplotlib","pillow","sklearn","requests",\"jieba","beautifulsoup4","wheel","networkx","sympy",\"pyinstaller","django","flask","wer
  • XGBoost调参demo（Python） 妄念驱动 机器学习算法python机器学习XGBoostpython
    XGBoost我们用的是保险公司的一份数据#各种库importpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltfromsklearn.linear_modelimportLogisticRegressionfromsklearn.ensembleimportRandomForestClassifierfromsklearn.metricsi
  • 机器学习实战----波士顿房价预测模型 永远偷渡不了的非洲人 机器学习机器学习sklearnpython
    波士顿房价模型预测是一个回归问题，可以采用r2_score方法来作为评价指标。importnumpyasnpimportpandasaspdfromsklearn.metricsimportr2_score#从sklearn的数据库中导入波士顿房产数据fromsklearn.datasetsimportload_bostonfromsklearn.model_selectionimporttrai
  • python机器学习算法--贝叶斯算法 在下小天n 机器学习python机器学习算法
    1.贝叶斯定理在20世纪60年代初就引入到文字信息检索中，仍然是文字分类的一种热门（基准）方法。文字分类是以词频为特征判断文件所属类型或其他（如垃圾邮件、合法性、新闻分类等）的问题。原理牵涉到概率论的问题，不在详细说明。sklearn.naive_bayes.GaussianNB(priors=None,var_smoothing=1e-09)#Bayes函数·priors：矩阵，shape=[n
  • Python中sklearn实现随机森林RF回归与变量重要性影响程度排序分析 疯狂学习GIS
      本文详细介绍在Python中，实现随机森林（RandomForest，RF）回归与变量重要性分析、排序的代码编写与分析过程。其中，关于基于MATLAB实现同样过程的代码与实战，大家可以点击查看这篇博客1（https://blog.csdn.net/zhebushibiaoshifu/article/details/114806478）。  本文分为两部分，第一部分为代码的分段讲解，第二部分为完
  • 机器学习小组第三周：简单的数据预处理和特征工程 -Helslie 机器学习机器学习
    学习目标●无量纲化：最值归一化、均值方差归一化及sklearn中的Scaler●缺失值处理●处理分类型特征：编码与哑变量●处理连续型特征：二值化与分段学习资料首先，参考：《机器学习的敲门砖：归一化与KD树》及《特征工程系列：特征预处理（上）》中相关部分。其次，其他知识点可参考推荐博文：sklearn中的数据预处理和特征工程。20200311数据归一化在量纲不同的情况下，对于部分算法不能反映样本中每
  • Python图像纹理分割 2401_84585316 程序员python开发语言
    将下图左右两种不同类型的纹理区域分开，方法输出结果是一幅与该图像等大小的二值图像，左边为0，右边为1，或者相反，灰色边框线在设计的方法中不作考虑，自行去除。2️⃣实现源码importmatplotlib.imageasmpimgimportmatplotlib.pyplotaspltimportnumpyasnpfromcv2importcv2fromsklearn.multiclassimpor
  • 鸢尾花的简单分类器 Oneshot_fea8
    importpandasaspdfromsklearn.model_selectionimporttrain_test_splitfromscipy.spatial.distanceimporteuclideanimportnumpyasnpDATA_FILE='./data_ai/Iris.csv'SPECIES=['Iris-setosa',#山鸢尾'Iris-versicolor',#变色鸢
  • ARIMA-temp-humidity TuringSnowy 笔记
    importpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltfromstatsmodels.tsa.statespace.sarimaximportSARIMAXfromstatsmodels.graphics.tsaplotsimportplot_acf,plot_pacffromsklearn.metricsimportmean_squ
  • 基于Python的机器学习系列（16）：扩展 - AdaBoost 会飞的Anthony 信息系统机器学习人工智能python机器学习开发语言
    简介在本篇中，我们将扩展之前的AdaBoost算法实现，深入探索其细节并进行一些修改。我们将重点修复代码中的潜在问题，并对AdaBoost的实现进行一些调整，以提高其准确性和可用性。1.修复Alpha计算中的问题在AdaBoost中，如果分类器的错误率e为0，则计算出的权重α将是未定义的。为了解决这个问题，我们可以在计算过程中向分母中添加一个非常小的值，以避免除零错误。2.调整学习率sklearn
  • 机器学习基础（四）——决策树与随机森林 Bayesian小孙 机器学习基础决策树机器学习随机森林
    决策树与随机森林文章目录决策树与随机森林一、知识概要（一）二、决策树使用的算法三、sklearn决策树API四、决策树的案例1.数据清洗2.特征工程3.调用决策树API五、集成学习方法-随机森林1.知识概要（二）2.集成学习API3.随机森林的案例importpandasaspdfromsklearn.feature_extractionimportDictVectorizerfromsklear
  • 文本分析之关键词提取（TF-IDF算法） SEVEN-YEARS tf-idf
    键词提取是自然语言处理中的一个重要步骤，可以帮助我们理解文本的主要内容。TF-IDF（TermFrequency-InverseDocumentFrequency）是一种常用的关键词提取方法，它基于词频和逆文档频率的概念来确定词语的重要性。准备工作首先，我们需要准备一些工具和库，包括Pandas、jieba（结巴分词）、sklearn等。Pandas：用于数据处理。jieba：用于中文分词。skl
  • 使用SVM进行评论情感分析 github_czy 支持向量机机器学习人工智能
    importpandasaspdfromsklearn.model_selectionimporttrain_test_splitfromsklearn.feature_extraction.textimportTfidfVectorizerfromsklearn.svmimportSVCfromsklearn.metricsimportaccuracy_score,precision_score
  • sklearn 评估模型 常用函数 小Z资本 sklearn人工智能python
    `sklearn.metrics`是scikit-learn库中的一个模块，它提供了许多用于评估预测模型性能的指标和工具。这些指标和工具可以帮助你了解模型在训练集和测试集上的表现，以及模型是否能够很好地泛化到未见过的数据。以下是一些`sklearn.metrics`中常用的函数和指标：1.**分类指标**：-`accuracy_score`:计算分类准确率。-`classification_rep
  • [sklearn] 分类指标解惑 PigeonGuan sklearn分类人工智能
    首先查看metrics官方文档：https://scikit-learn.org/stable/api/sklearn.metrics.htmlweighted/macro/micro/samples的区别weighted和samplesweighted这个参数在roc_auc_score函数中，其实就是考虑了trueinstance的情况（也就是需要传一个sample_weights的参数？）。
  • 计算机毕业设计Hadoop+Spark知识图谱体育赛事推荐系统 体育赛事热度预测系统 体育赛事数据分析 体育赛事可视化 体育赛事大数据 机器学习 大数据毕业设计 大数据毕设 机器学习 人工智能 计算机毕业设计大全
    开发技术前端：vue.js、element-ui、echarts后端：springboot、mybatis大数据：spark、hadoop数据库：mysql关系型数据库、neo4j图数据库算法：协同过滤推荐算法、MLP深度学习模型、SVD神经网络混合推荐算法、lstm模型、KNN、CNN、Sklearn、K-Means第三方平台：百度AI、阿里云短信、支付宝沙箱支付爬虫：Pythonchrome-
  • PyTorch深度学习模型训练流程的python实现：回归 moyao_miao python人工智能深度学习pytorch回归
    回归的流程与分类基本一致，只需要把评估指标改动一下就行。回归输出的是损失曲线、R^2曲线、训练集预测值与真实值折线图、测试集预测值散点图与真实值折线图。输出效果如下：注意：预测值与真实值图像处理为按真实值排序，图中呈现的升序与数据集趋势无关。代码如下：fromfunctoolsimportpartialimportnumpyasnpimportpandasaspdfromsklearn.prepr
  • 在sklearn中如何实现参数网格搜索（GridSearch）？ 2401_85761762 sklearn人工智能python
    深入理解Scikit-learn中的参数网格搜索（GridSearch）引言在机器学习模型的开发过程中，超参数的调整对于模型性能有着至关重要的影响。Scikit-learn（简称sklearn），作为Python中一个广泛使用的机器学习库，提供了强大的工具来帮助我们进行超参数的优化。其中，GridSearchCV是实现参数网格搜索的利器。本文将详细介绍GridSearchCV的使用方法，并探讨其在
  • sklearn preprocessing perfectmanman 代码
    sklearnpreprocessing代码代码来自Anaconda软件里sklearn模块init.py"""The:mod:`sklearn.preprocessing`moduleincludesscaling,centering,normalization,binarizationandimputationmethods."""from.dataimportBinarizerfrom.da
  • 对股票分析时要注意哪些主要因素？ 会飞的奇葩猪 股票 分析 云掌股吧
    　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。     一、成交量 　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
  • 【Scala十八】视图界定与上下文界定 bit1129 scala
    Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。   隐式参数 首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b }  因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
  • C语言的分支——Object-C程序设计阅读有感 darkblue086 applec框架cocoa
    自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
  • 去除浏览器对表单值的记忆 周凡杨 html记忆autocompleteform浏览
                                       &n
  • java的树形通讯录 g21121 java
    最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
  • Nginx安装部署 510888780 nginxlinux
    Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
  • java servelet异步处理请求 墙头上一根草 ｊａｖａ异步返回ｓｅｒｖｌｅｔ
    servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能，        final AsyncContext ac = request.startAsync(request, response);   ac.s
  • 我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
    在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。 （有构造方法的下个文细说） 2、还
  • 为Mysql创建最优的索引 annan211 mysql索引
    索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。 索引经常会被误解甚至忽略，而且经常被糟糕的设计。 索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比 较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
  • 日期函数 百合不是茶 oraclesql日期函数查询
      ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年 显示值:07 yyy three digits 三位年 显示值:007
  • 线程优先级 bijian1013 javathread多线程java多线程
    多线程运行时需要定义线程运行的先后顺序。 线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。 实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
  • 适配器模式和代理模式的区别 bijian1013 java设计模式
    一.简介        适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。      &nbs
  • 【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
     SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句， 这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
  • oracle大数据表复制备份个人经验 bitcarter oracle大表备份大表数据复制
    前提：    数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。    
  • HTTP加速器varnish安装小记 ronin47 http varnish 加速
    上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！ 苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
  • java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
    public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
  • 学习编程的一点感想 Cb123456 编程感想Gis
           写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目.      本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
  • [能源与安全]美国与中国 comsci 能源
         现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。       在这个大
  • SEMI-JOIN执行计划突然变成HASH JOIN了 的原因分析 cwqcwqmax9 oracle
    甲说： A B两个表总数据量都很大，在百万以上。 idx1  idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn      and exists (select 1 from B where B.idx2 =
  • SpringMVC-ajax返回值乱码解决方案 dashuaifu AjaxspringMVCresponse中文乱码
      SpringMVC-ajax返回值乱码解决方案   一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do")       public @ResponseBody void getPunishReasonB
  • Linux系统中查看日志的常用命令 dcj3sjt126com OS
    因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日 志 文 件 说 明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
  • [应用结构]应用 dcj3sjt126com PHPyii2
    应用主体 应用主体是管理 Yii 应用系统整体结构和生命周期的对象。 每个Yii应用系统只能包含一个应用主体，应用主体在 入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。 补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
  • assertThat用法 eksliang JUnitassertThat
    junit4.0  assertThat用法 一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
  • android点滴2 gundumw100 应用服务器android网络应用OSHTC
    如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
  • 超简洁的CSS下拉菜单 ini htmlWeb工作html5css
    效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
  • kafka consumer防止数据丢失 kane_xie kafkaoffset commit
    kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。   尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。   考虑这样一个case，partiton_num=2
  • @Repository、@Service、@Controller 和 @Component mhtbbx DAOspringbeanprototype
    @Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
  • java 多线程高并发读写控制 误区 qifeifei java thread
    先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
  • mongodb replica set(副本集)设置步骤 tcrct javamongodb
    网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下： 首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
  • rust学习笔记 wudixiaotie 学习笔记
    1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他