机器学习-Sklearn-01（决策树）

机器学习-Sklearn-01

学习01

素人的数据分析之路：

什么是sklearn？

sklearn是一个开源的基于python语言的机器学习工具包
它通过Numpy，Scipy和Matplotlib等python数值计算的库实现高效的算法应用，涵盖了几乎所有主流机器学习算法。

为什么是sklearn?

它很友好，却很有深度。
虽然sklearn使用很简单，却缺乏优秀的解读。
它是通往数据挖掘工程师的起点。

学习过程：

基于python3解读10个算法，覆盖从获取数据到模型评估的全流程。

sklearn入门 & 决策树在sklearn中的实现

sklearn入门

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

在工具包中调用算法，调整算法的参数，获取需要的信息，从而实现算法效率和效果之间的平衡。而sklearn，正是这样一个可以帮助我们高效实现算法应用的工具包。

本门学习过程的讲解不会涉及详细的算法原理，只会专注于算法在
sklearn中的实现。

1、概述

1.1、决策树是如何工作的

决策树（Decision Tree）是一种非参数的有监督学习方法，它能够从一系列有特征和标签的数据中总结出决策规则，并用树状图的结构来呈现这些规则，以解决分类和回归问题。决策树算法容易理解，适用各种数据，在解决各种问题时都有良好表现，尤其是以树模型为核心的各种集成算法，在各个行业和领域都有广泛的应用。

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

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

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

决策树算法的核心是要解决两个问题：
1）如何从数据表中找出最佳节点和最佳分枝？
2）如何让决策树停止生长，防止过拟合？

1.2、sklearn中的决策树

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

sklearn的基本建模流程：

在这个流程下，分类树对应的代码是：
from sklearn import tree #导入需要的模块
clf = tree.DecisionTreeClassifier() #实例化
clf = clf.fit(X_train,y_train) #用训练集数据训练模型
result = clf.score(X_test,y_test) #导入测试集，从接口中调用需要的信息

2、DecisionTreeClassifier与红酒数据集

2.1、重要参数

2.1.1、criterion

对分类树来说，衡量这个“最佳”的指标叫做**“不纯度”**。通常来说，不纯度越低，决策树对训练集的拟合越好。现在使用的决策树算法在分枝方法上的核心大多是围绕在对某个不纯度相关指标的最优化上。

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

Criterion这个参数正是用来决定不纯度的计算方法的。sklearn提供了两种选择：
1）输入”entropy“，使用信息熵（Entropy），其实是计算信息的增益。
2）输入”gini“，使用基尼系数（Gini Impurity）

其中t代表给定的节点，i代表标签的任意分类，代表标签分类i在节点t上所占的比例。注意，当使用信息熵时，sklearn实际计算的是基于信息熵的信息增益(Information Gain)，即父节点的信息熵和子节点的信息熵之差。

比起基尼系数，信息熵对不纯度更加敏感，对不纯度的惩罚最强。但是**在实际使用中，信息熵和基尼系数的效果基本相同。**信息熵的计算比基尼系数缓慢一些，因为基尼系数的计算不涉及对数。另外，因为信息熵对不纯度更加敏感，所以信息熵作为指标时，决策树的生长会更加“精细”，因此对于高维数据或者噪音很多的数据，信息熵很容易过拟合，基尼系数在这种情况下效果往往比较好。当模型拟合程度不足的时候，即当模型在训练集和测试集上都表现不太好的时候，使用信息熵。当然，这些不是绝对的。

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

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

建立一棵树(以红酒数据为例)

#导入需要的算法库和模块
from sklearn import tree
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

#**********************************************************************
#探索数据
wine = load_wine()

wine.data.shape
#结果(178, 13)

wine.target
#结果：
‘’’ array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2])‘’’

#如果wine是一张表，应该长这样：
import pandas as pd
pd.concat([pd.DataFrame(wine.data),pd.DataFrame(wine.target)],axis = 1)
#结果
wine.feature_names
#结果：
‘’’ [‘alcohol’,
‘malic_acid’,
‘ash’,
‘alcalinity_of_ash’,
‘magnesium’,
‘total_phenols’,
‘flavanoids’,
‘nonflavanoid_phenols’,
‘proanthocyanins’,
‘color_intensity’,
‘hue’,
‘od280/od315_of_diluted_wines’,
‘proline’] ‘’’

wine.target_names
#结果：
#array([‘class_0’, ‘class_1’, ‘class_2’], dtype=‘<U7’)

#**********************************************************************
#随机划分训练集和测试集
Xtrain, Xtest, Ytrain, Ytest = train_test_split(wine.data, wine.target,test_size=0.3)
#其中test_size=0.3表示30%做测试集，剩下做训练集。

Xtrain.shape
#结果：(124, 13)

Xtest.shape
#结果：(54, 13)

Ytrain
#结果：
‘’’ array([1, 1, 1, 1, 0, 1, 1, 1, 2, 1, 2, 2, 0, 2, 1, 2, 0, 1, 1, 0, 2, 0,
0, 1, 2, 2, 0, 1, 0, 0, 1, 0, 1, 0, 2, 1, 2, 1, 0, 1, 1, 1, 0, 1,
0, 2, 1, 0, 0, 2, 0, 1, 0, 0, 0, 1, 0, 1, 0, 2, 1, 2, 0, 1, 2, 1,
0, 0, 0, 2, 0, 2, 1, 2, 0, 0, 0, 1, 2, 2, 2, 0, 0, 0, 2, 0, 2, 1,
1, 0, 1, 1, 2, 0, 0, 2, 2, 1, 1, 2, 2, 1, 0, 0, 1, 1, 2, 1, 1, 2,
0, 0, 1, 1, 0, 0, 1, 2, 1, 1, 0, 0, 1, 1]) ‘’’

#**********************************************************************
#第一步，构建分类器，实例化
#random_state参数，即随机参数种子，让score固定。random_state等于的数字可以自由调试
#参数splitter，默认为"best"
#输入“random"，决策树在分枝时会更加随机，树会因为含有更多的不必要信息而更深更大，并因这些不必要信息而降低对训练集的拟合。
#输入”best"，决策树在分枝时虽然随机，但是还是会优先选择更重要的特征进行分枝（重要性可以通过属性feature_importances_查看）。
clf = tree.DecisionTreeClassifier(criterion = “entropy”
, random_state=30
,splitter=“random” )
#第二步，把数据带进去训练，fit就是用来训练的接口
clf = clf.fit(Xtrain, Ytrain)
#第三步，进行打分，将测试集导入，返回预测的准确度accuracy
score = clf.score(Xtest, Ytest)
score
#结果：0.9074074074074074

#**********************************************************************
#所有用于分类的feature的重要程度
clf.feature_importances_
#结果：
‘’’ array([0. , 0. , 0. , 0. , 0.045538 ,
0. , 0.24835458, 0. , 0.01423504, 0.24627024,
0. , 0. , 0.44560214]) ‘’’
#根节点对决策树的决策影响永远是最高的，通过zip方法将feature_name和重要程度一一对应。
[*zip(feature_name, clf.feature_importances_)]
#结果：
‘’’ [(‘酒精’, 0.0),
(‘苹果酸’, 0.0),
(‘灰’, 0.0),
(‘灰的碱性’, 0.0),
(‘镁’, 0.04553800274817173),
(‘总酚’, 0.0),
(‘类黄酮’, 0.24835457966781713),
(‘非黄烷类酚类’, 0.0),
(‘花青素’, 0.014235035758786927),
(‘颜色强度’, 0.24627023781929838),
(‘色调’, 0.0),
(‘od280/od315稀释葡萄酒’, 0.0),
(‘脯氨酸’, 0.44560214400592596)] ‘’’

#**********************************************************************
#建模已经完成
#下面开始画树
feature_name = [‘酒精’,‘苹果酸’,‘灰’,‘灰的碱性’,‘镁’,‘总酚’,‘类黄酮’,‘非黄烷类酚类’,‘花青素’,‘颜色强度’,‘色调’,‘od280/od315稀释葡萄酒’,‘脯氨酸’]
import graphviz
#参数一，输入已经训练好的模型
#参数二，特征的名字，就是wine.feature_names。
#参数三，标签的名字，就是wine.target_names
#参数四，填充颜色，根据标签名来划分颜色，此外不纯度的大小影响填充颜色的深浅。
#参数五，画图的矩形框为圆角矩形
#这样就设置好了要画的决策树了
dot_data = tree.export_graphviz(clf
,feature_names = feature_name
,class_names=[“琴酒”,“雪梨”,“贝尔摩德”]
,filled = True
,rounded = True
)
#导出要画的树
graph = graphviz.Source(dot_data)
graph
#绘制结果：

2.1.2、random_state & splitter

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

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

2.1.3、剪枝参数

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

#我们的树对训练集的拟合程度如何？
#在不加限制的情况下，一棵决策树会生长到衡量不纯度的指标最优，或者没有更多的特征可用为止。
#这样的决策树往往会过拟合，这就是说，它会在训练集上表现很好，在测试集上却表现糟糕。
score_train = clf.score(Xtrain, Ytrain)
score_train
#结果：1.0
#测试集的score为0.9074074074074074，于1.0差距较大。所以过拟合了。

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

max_depth：

限制树的最大深度，超过设定深度的树枝全部剪掉

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=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.9259259259259259

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

max_features & min_impurity_decrease：

一般max_depth使用，用作树的”精修“。
max_features限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃。和max_depth异曲同工，max_features是用来限制高维度数据的过拟合的剪枝参数，但其方法比较暴力，是直接限制可以使用的特征数量而强行使决策树停下的参数，在不知道决策树中的各个特征的重要性的情况下，强行设定这个参数可能会导致模型学习不足。

min_impurity_decrease限制信息增益的大小，信息增益小于设定数值的分枝不会发生。这是在0.19版本中更新的功能，在0.19版本之前时使用min_impurity_split。

确认最优的剪枝参数

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

这里以绘制max_depth减枝参数学习曲线为例：
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()
#结果：发现max_depth在3-4区间范围内时，测试集打分最高。

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****输入测试集返回每个测试样本的标签。

#apply返回每个测试样本所在的叶子节点的索引
clf.apply(Xtest)
#结果：
‘’’ array([26, 17, 26, 26, 22, 14, 25, 20, 4, 26, 11, 25, 14, 25, 10, 20, 26,
11, 11, 26, 11, 6, 26, 26, 11, 26, 12, 26, 11, 11, 26, 26, 12, 6,
20, 26, 17, 16, 26, 26, 9, 10, 26, 4, 20, 11, 14, 4, 11, 26, 11,
26, 26, 20], dtype=int64) ‘’’

#predict返回每个测试样本的分类/回归结果
clf.predict(Xtest)
#结果：
‘’’ array([0, 2, 0, 0, 1, 1, 1, 1, 2, 0, 2, 1, 1, 1, 2, 1, 0, 2, 2, 0, 2, 1,
0, 0, 2, 0, 1, 0, 2, 2, 0, 0, 1, 1, 1, 0, 2, 1, 0, 0, 1, 2, 0, 2,
1, 2, 1, 2, 2, 0, 2, 0, 0, 1]) ‘’’

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

3、DecisionTreeRegressor回归树

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

3.1、重要参数，属性及接口

criterion

分类树的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平方就会为负），而均方误差永远为正。

在评判回归树的衡量指标通常不选取R平方，虽然默认是R平方。

值得一提的是，**虽然均方误差永远为正，但是sklearn当中使用均方误差作为评判标准时，却是计算”负均方误差“（neg_mean_squared_error）。**这是因为sklearn在计算模型评估指标的时候，会考虑指标本身的性质，均方误差本身是一种误差，所以被sklearn划分为模型的一种损失(loss)，因此在sklearn当中，都以负数表示。真正的均方误差MSE的数值，其实就是neg_mean_squared_error去掉负号的数字。

交叉验证：

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

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

以波士顿房价数据进行回归树实验的数据：
#**********************************************************************
from sklearn.datasets import load_boston
#以波士顿boston房价为实验数据，该数据为连续型变量，用于回归树，而之前的红酒数据为分类型变量。
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeRegressor

#**********************************************************************
#探索数据
boston = load_boston()
boston
#发现标签target不在是classname类名，而是连续型的数字。
#结果：

boston.data
#结果：

boston.target
#结果：

#**********************************************************************
#交叉验证cross_val_score的用法
regressor = DecisionTreeRegressor(random_state=0)

#参数1：实例化后的模型，可以是分类，可以是回归，可以是支持向量机，可以是随机森林等等，可以是任意实例化后的算法模型。
#参数2：完整的，不需要分测试集和训练集的特征矩阵。
#参数3：波士顿数据的标签，完整的标签，不需要划分测试集和训练集的完整的标签。
#参数4：cv=10，即交叉验证做10次。每次提取1份做测试集，剩下的9份做训练集，循环10次。该参数默认为5
#参数5：请用scoring后面的"neg_mean_squared_error"来衡量模型，在做回归树时最常用的是均方误差。
#该参数这样设置就是告诉交叉验证以“负均方根误差”来做衡量指标，来评估这个模型，均方误差越小越好，即负均方误差去掉符号后数值越接近0越好。
#如果第一个参数使用的是分类树，参数5默认不填，则默认返回10个accuracy准确性，即10次不同的训练集和测试集划分下的准确度。
#如果第一个参数使用的是回归树，参数5默认不填，则返回10次小于1的数，这些数为R平方，默认返回R平方，R平方的值越接近1越好。

cross_val_score(regressor, boston.data, boston.target, cv=10,
scoring = “neg_mean_squared_error”)
#结果：

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

接下来我们到二维平面上来观察决策树是怎样拟合一条曲线的。我们用回归树来拟合正弦曲线，并添加一些噪声来观察回归树的表现。
#1、导入需要的库
import numpy as np
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt
#**********************************************************************
#2、创建一条含有噪声的正弦曲线
#numpy生成随机数种子
rng = np.random.RandomState(1)
#np.random.rand(数组结构)，生成随机数组的函数
#生成80行1列的随机数之后乘以5，在进行排序，生成x
X = np.sort(5 * rng.rand(80,1), axis=0)
#np.sin(X)生成的是80行1列的二维数据，需要通过ravel()进行降维，降n-1维。成为1维数组，在python中1维数组不分行列。
y = np.sin(X).ravel()

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

#加噪声(0.5 - rng.rand(16))在-0.5到0.5之间。扩大3被。
y[::5] += 3 * (0.5 - rng.rand(16))
#再画一下
#画图(散点图)
plt.figure()
plt.scatter(X,y,s=20,edgecolor=“black”,c=“darkorange”,label=“data”)

#**********************************************************************
#3、实例化&训练模型
#建立两个回归模型，形成对比，对比不同的拟合效果下，回归树是怎样表现的。
regr_1 = DecisionTreeRegressor(max_depth=2)
regr_2 = DecisionTreeRegressor(max_depth=5)
regr_1.fit(X, y)
regr_2.fit(X, y)
#**********************************************************************
#4、测试集导入模型，预测结果
#np.arrange(开始点，结束点，步长) 生成有序数组的函数
#了解增维切片np.newaxis的用法
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]
#X_test

y_1 = regr_1.predict(X_test)
y_2 = regr_2.predict(X_test)
#**********************************************************************
#5、绘制图像
#观察不同深度的树如何拟合曲线。
#max_depth=5存在过拟合

plt.figure()
plt.scatter(X, y, s=20, edgecolor=“black”,c=“darkorange”, label=“data”)
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()

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

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

#1、导入所需要的库
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、导入数据集，探索数据
data = pd.read_csv(r"D:\whole_development_of_the_stack_study\RS_Algorithm_Course\为其1年的CV课程\04机器学习-Sklearn（第三版）-解锁式学习\24630_机器学习-Sklearn（第三版）\01 决策树课件数据源码\data.csv")

data.info()
#结果

data.head()
#结果：

#**********************************************************************
#3、对数据集进行预处理
#删除缺失值过多的列，和观察判断来说和预测的y没有关系的列
data.drop([“Cabin”,“Name”,“Ticket”],inplace=True,axis=1)

#处理缺失值，对缺失值较多的列进行填补，有一些特征只确实一两个值，可以采取直接删除记录的方法
data[“Age”] = data[“Age”].fillna(data[“Age”].mean())
data = data.dropna()

#将分类变量转换为数值型变量
#将二分类变量转换为数值型变量
#astype能够将一个pandas对象转换为某种类型；
#和apply(int(x))不同，astype可以将文本类转换为数字，用这个方式可以很便捷地将二分类特征转换为0~1
data[“Sex”] = (data[“Sex”]== “male”).astype(“int”)

#将三分类变量转换为数值型变量
labels = data[“Embarked”].unique().tolist()
data[“Embarked”] = data[“Embarked”].apply(lambda x: labels.index(x))

#查看处理后的数据集
data.head()

#**********************************************************************
#4、提取标签和特征矩阵，分测试集和训练集
X = data.iloc[:,data.columns != “Survived”]

y = data.iloc[:,data.columns == “Survived”]

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、导入模型，粗略跑一下查看结果
clf = DecisionTreeClassifier(random_state = 25)
clf = clf.fit(Xtrain,Ytrain)
score = clf.score(Xtest,Ytest)
score

#交叉验证
clf = DecisionTreeClassifier(random_state = 25)
score = cross_val_score(clf,X,y,cv = 10).mean()
score

#**********************************************************************
#6、在不同max_depth下观察模型的拟合状况
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))
plt.legend()
plt.show()

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

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

import numpy as np
#基尼系数的边界,基尼系数取值范围是0到0.5
gini_threholds = np.linspace(0,0.5,20)
#信息熵的取值分为是0到1
#entropy_threholds = np.linspace(0,1,20)

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