菜菜的sklearn课堂——决策树

scikit-learn的官网:https://scikit-learn.org/stable/index.html
sklearn的基本建模流程：
1.实例化，建立评估模型对象(实例化时需要使用的参数)
2.通过模型接口训练模型(数据模型、数据接口)
3.通过模型接口提取需要的信息(数据模型、数据接口)

1.概述

1.1决策树是如何工作的
计算全部特征的不纯度指标——>选取不纯度指标最优的特征来分枝——>在第一个特征的分枝下，计算全部特征的不纯度指标——>选取不纯度指标最优的特征继续分枝……直到没有更多的特征可用，或整体的不纯度指标已经最优，决策树就会停止生长。
1.2 sklearn中的决策树
(1)模块sklearn.tree
sklearn中决策树的类都在“tree”这个模块之下，这个模块总共包含五个类：

模块	中文名
tree.DecisionTreeClassifier	分类树
tree.DecisionTreeRegressor	回归树
tree.export_graphviz	将生成的决策树导出为DOT格式，画图专用
tree.ExtraTreeClassifier	高随机版本的分类树
tree.ExtraTreeRegressor	高随机版本的回归树

(2)分类树基本代码

from sklearn import tree            #导入需要的模块
clf=tree.DecisionTreeClassifier()   #实例化
clf=clf.fit(x_train,y_train)        #用训练集数据训练模型
result=clf.score(x_test,y_test)     #导入测试集，从接口中调用需要的信息

2.DecisionTreeClassifier与红酒数据集

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:决定不纯度的计算方法，帮忙找出最佳节点和最佳分枝，不纯度越低，决策树的拟合越好。
‘entropy’:信息熵(Entropy)；‘gini’:基尼系数(Gini Impurity)(不填时的默认值)
通常使用基尼系数。数据维度很大，噪声很大时使用基尼系数。
维度低、数据比较清晰的时候，信息熵和基尼系数没区别。
当决策树的拟合程度不够的时候，使用信息熵。
可以两个都试试，一个不好就换另一个。

# 导入需要的模块
from sklearn import tree               # 导入树
from sklearn.datasets import load_wine # 导入红酒数据集
from sklearn.model_selection import train_test_split # 划分训练集和测试集
import pandas as pd
import graphviz

wine = load_wine() # 数据实例化
print(wine) # 是字典
print(wine.data, wine.data.shape) # (178, 13)
print(wine.target)# 三分类的数据集
print(pd.concat([pd.DataFrame(wine.data), pd.DataFrame(wine.target)], axis=1)) # 将wine变成表的形式
print(wine.feature_names) # 特征的名字
print(wine.target_names) # 标签的名字

x_train, x_test, y_train, y_test = train_test_split(wine.data, wine.target, test_size=0.3) # random_state=1,
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)
clf = tree.DecisionTreeClassifier(criterion='entropy') # 实例化
clf.fit(x_train, y_train) # 用训练集数据训练模型
score = clf.score(x_test, y_test) # 返回预测准确度accuracy 从接口中调用需要的信息
print(score)
feature_name = ['酒精', '苹果酸', '灰', '灰的属性', '镁', '总酚', '类黄酮', '非黄烷类酚类', '花青素', '颜色强度', '色调', 'od280/od315稀释葡萄酒', '脯氨酸']
dot_data = tree.export_graphviz(clf
                                , feature_names=feature_name
                                , class_names=['琴酒', '雪莉', '贝尔摩德']
                                , filled=True
                                , rounded=True)# filled=True是否给树填充颜色 rounded=True框的边角是圆角还是方角
graph = graphviz.Source(dot_data)
print(graph)
print(clf.feature_importances_)
print([*zip(feature_name,clf.feature_importances_)])# 决策树用了哪些特征，特征的重要性

建立模型时，score会在某个值附近波动，引起画出来的每一棵树都不一样。它为什么会不稳定呢？如果使用其他数据集，它还会不稳定吗？
因为无论决策树模型如何进化，在分枝上的本质都还是追求某个不纯度相关的指标的优化，而不纯度是基于节点来计算的，也就是说，决策树在建树时，是靠优化节点来追求一棵优化的树，但最优的节点不能够保证最优的树。集成算法被用来解决这个问题：sklearn表示，既然一棵树不能保证最优，那就建更多的不同的树，然后从中取最好的。怎样从一组数据集中建不同的树？在每次分枝时，不从使用全部特征，而是随机选取一部分特征，从中选取不纯度相关指标最优的作为分枝用的节点。这样，每次生成的树也就不同了。
2.1.2 random_state & splitter
random_state用来设置分枝中的随机模式的参数，默认None，在高维度时随机性会表现更明显，低维度的数据(比如鸢尾花数据集)，随机性几乎不会显现。输入任意整数，会一直长出同一棵树，让模型稳定下来。

clf=tree.DecisionTreeClassifier(criterion="entropy",random_state=0)
clf = clf.fit(x_train, y_train)
score = clf.score(x_test, y_test) #返回预测的准确度
score

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

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

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

为了让决策树有更好的泛化性，我们要对决策树进行剪枝。剪枝策略对决策树的影响巨大，正确的剪枝策略是优化决策树算法的核心。sklearn为我们提供了不同的剪枝策略：
(1)max_depth
限制树的最大深度，超过设定深度的树枝全部剪掉。这是用得最广泛的剪枝参数，在高维度低样本量时非常有效。决策树多生长一层，对样本量的需求会增加一倍，所以限制树深度能够有效地限制过拟合。在集成算法中也非常实用。实际使用时，建议从=3开始尝试，看看拟合的效果再决定是否增加设定深度。
(2)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
                                  )

(3)max_features & min_impurity_decrease
一般max_depth使用，用作树的“精修”。max_features限制分枝时考虑的特征个数，超过限制个数的特征都会被舍弃。和max_depth异曲同工，max_features是用来限制高维度数据的过拟合的剪枝参数，但其方法比较暴力，是直接限制可以使用的特征数量而强行使决策树停下的参数，在不知道决策树中的各个特征的重要性的情况下，强行设定这个参数可能会导致模型学习不足。如果希望通过降维的方式防止过拟合，建议使用PCA，ICA或者特征选择模块中的降维算法。
min_impurity_decrease限制信息增益的大小，信息增益(父节点和子结点之间信息熵的差)小于设定数值的分枝不会发生。这是在0.19版本中更新的功能，在0.19版本之前时使用min_impurity_split。
(4)确定最优的剪枝参数
具体怎么来确定每个参数填写什么值呢？这时候，我们就要使用确定超参数的曲线来进行判断了，继续使用我们已经训练好的决策树模型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()

剪枝参数不一定能提升模型在测试集上的表现，一切都是看数据本身。
剪枝参数的默认值会让树无尽地生长，这些树在某些数据集上可能非常巨大，对内存的消耗也非常巨大。所以如果你手中的数据集非常巨大，你已经预测到无论如何你都是要剪枝的，那提前设定这些参数来控制树的复杂性和大小会比较好。
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)来给你的数据增维。

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

以上就是分类树DecisionTreeClassifier和用决策树绘图export_graphviz的所有基础内容。
分类树的八个参数(criterion；两个随机性相关的参数(random_state、splitter)；五个剪枝参数(max_depth、min_samples_leaf、min_samples_split、max_feature、min_impurity_decrease)
一个属性(feature_importances_)
四个接口(fit、score、apply、predict)

总体代码

# 导入需要的模块
from sklearn import tree               # 导入树
from sklearn.datasets import load_wine # 导入红酒数据集
from sklearn.model_selection import train_test_split # 划分训练集和测试集
import pandas as pd
import graphviz
import matplotlib.pyplot as plt

wine = load_wine() # 数据实例化
print(wine) # 是字典
print(wine.data, wine.data.shape) # (178, 13)
print(wine.target)# 三分类的数据集
print(pd.concat([pd.DataFrame(wine.data), pd.DataFrame(wine.target)], axis=1)) # 将wine变成表的形式
print(wine.feature_names) # 特征的名字
print(wine.target_names) # 标签的名字

x_train, x_test, y_train, y_test = train_test_split(wine.data, wine.target, test_size=0.3) # random_state=1,
print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)
'''clf = tree.DecisionTreeClassifier(criterion='entropy'
                                  , random_state=30
                                  , splitter='random'
                                  , max_depth=3
                                  , min_samples_leaf=10
                                  , min_samples_split=10
                                  )
clf.fit(x_train, y_train)
score = clf.score(x_test, y_test) # 返回预测准确度accuracy 结果每次都不一样，是因为
print(score)'''
test = []
for i in range(10):
        clf = tree.DecisionTreeClassifier(max_depth=i+1 # 最大深度为1~10
                                          , criterion="entropy"
                                          , random_state=30
                                          , splitter="random"
                                          )
        clf = clf.fit(x_train, y_train)
        score = clf.score(x_test, y_test)
        test.append(score)
plt.plot(range(1, 11), test, color="red", label="max_depth")
plt.legend()
plt.show()
feature_name = ['酒精', '苹果酸', '灰', '灰的属性', '镁', '总酚', '类黄酮', '非黄烷类酚类', '花青素', '颜色强度', '色调', 'od280/od315稀释葡萄酒', '脯氨酸']
dot_data = tree.export_graphviz(clf
                                , feature_names=feature_name
                                , class_names=['琴酒', '雪莉', '贝尔摩德']
                                , filled=True
                                , rounded=True)# filled=True是否给树填充颜色 rounded=True框的边角是圆角还是方角
graph = graphviz.Source(dot_data)
print(graph)
print(clf.feature_importances_)
print([*zip(feature_name, clf.feature_importances_)])# 决策树用了哪些特征，特征的重要性
# 我们的树对训练集的拟合程度如何？
score_train = clf.score(x_train, y_train)
print(score_train)
'''
clf=tree.DecisionTreeClassifier()   #实例化
clf=clf.fit(x_train,y_train)        #用训练集数据训练模型
result=clf.score(x_test,y_test)     #导入测试集，从接口中调用需要的信息
'''

3.DecisionTreeRegressor

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去掉负号的数字。

from sklearn.datasets import load_boston
from sklearn.model_selection import cross_val_score
from sklearn.tree import DecisionTreeRegressor
boston = load_boston()
regressor = DecisionTreeRegressor(random_state=0)
cross_val_score(regressor  # 可以是任何实例化后的算法模型
                , boston.data #完整的，不需要划分训练集和测试集的数据
                , boston.target #完整的，不需要划分训练集和测试集的标签
                , cv=10 # 交叉验证做10次，即测试集为1份，训练集为9次
                , scoring = "neg_mean_squared_error"# 用neg_mean_squared_error来衡量模型，回归默认R方为衡量指标
                )
#交叉验证cross_val_score的用法

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

3.2实例: 一维回归的图像绘制
下面在二维平面上观察决策树怎样拟合一条直线，用回归树来拟合正弦曲线，并添加一些噪声来观察回归树的表现。

# 1.导入需要的库
import numpy as np
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt

# 2.创建一条含有噪声的正弦曲线
# 先创建一组随机的，分布在0~5上的横坐标轴的取值(x)，然后将这一组值放到sin函数中去生成纵坐标的值(y)，接着再到y上去添加噪声。
# 全程使用numpy库来生成这个正弦曲线。
rng = np.random.RandomState(1) # 生成随机数种子，因为后面生成随机数和噪声都要用到随机数种子。1表示随机数种子的随机是固定的随机
# print(rng.rang(10)) # 生成0~1之间的10个随机数
# print(rng.rang(2,3)) # 生成0~1之间的2行3列的随机数数组
# print(rng.rang(80,1)) # 生成0~1之间的80行1列的随机数数组,当想生成80个随机数的时候必须生成数组，因为一些接口(如fit)不允许导入一维特征
# print(5*rng.rang(80,1)) # 生成0~5之间的80行1列的随机数数组
X = np.sort(5 * rng.rand(80, 1), axis=0) # 将生成的随机数从小到大排序作为横坐标的数据
y = np.sin(X).ravel() # 生成对应横坐标的sin值并且降维成一维(python中一维不分行列，就是带了80个对象)
y[::5] += 3 * (0.5 - rng.rand(16)) # 给y的16个数字(每5个数字选1个)通过加上或减去一些数来加上噪声
# 因为y是0~1，0.5-y就变成-0.5~0.5之间的数，太小了再乘3，把效果扩大一点
# np.random.rand(数组结构)，生成随机数组的函数
# 了解降维函数ravel()的用法
# np.random.random((2, 1))
# np.random.random((2, 1)).ravel()
# print(np.random.random((2, 1)).ravel().shape)

# 3.实例化&训练模型
regr_1 = DecisionTreeRegressor(max_depth=2)
regr_2 = DecisionTreeRegressor(max_depth=5)
regr_1.fit(X, y)
regr_2.fit(X, y)

# 4.测试集导入模型，预测结果
X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]# 把一维数据变成二维的
y_1 = regr_1.predict(X_test)
y_2 = regr_2.predict(X_test)
# np.arrange(开始点，结束点，步长) 生成有序数组的函数
# 了解增维切片np.newaxis的用法
# l = np.array([1, 2, 3, 4])
# print(l)
# print(l.shape)
# print(l[:, np.newaxis]) # 把一维变成4行1列的数组
# print(l[:, np.newaxis].shape)
# print(l[np.newaxis, :].shape) # 把一维变成1行4列的数组

# 5.绘制图像
plt.figure() # 生成画布
plt.scatter(X, y, s=20, edgecolor="black", c="darkorange", label="data")
# 绘制散点图 s为点的大小，edgecolor为边框颜色，c为点的颜色，label为纵坐标轴的名字
plt.plot(X_test, y_1, color="cornflowerblue", label="max_depth=2", linewidth=2)
# 绘制折线图，label为这条线的名字，linewidth为线宽
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.导入需要的库
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
import numpy as np

# 2.导入数据集，探索数据
data = pd.read_csv(r"D:\dataprocess\sklearn\DecisionTree\data.csv", index_col=0)#地址中间不能包含中文，要么前面加r，要么把所有斜线换成/
print(data.head())#显示前n行，默认为5，括号里填n
print(data.info())#0   Survived  891 non-null    int64  表示891个非空的整数

# 3.对数据集进行预处理
# 删除缺失值过多的列，和观察判断来说和预测的y没有关系的列，筛选特征
data.drop(["Cabin","Name","Ticket"],inplace=True,axis=1)#axis=1是删除列
#data=data.drop(["Cabin","Name","Ticket"],inplace=True,axis=1)
# 处理缺失值，对缺失值较多的列进行填补，有一些特征只缺失一两个值，可以采取直接删除记录的方法
data["Age"] = data["Age"].fillna(data["Age"].mean())#用均值进行填补
print(data.info())
data = data.dropna()#dropna删除所有有缺失值的行
print(data.info())
# 将分类变量转换为数值型变量，例如性别
# 将二分类变量转换为数值型变量
# astype能够将一个pandas对象转换为某种类型，和apply(int(x))不同，astype可以将文本类转换为数字，用这个方式可以很便捷地将二分类特征转换为0~1
data["Sex"] = (data["Sex"]== "male").astype("int")#先判断每一行数据是不是male，astype将布尔值(True,False)转换为int类型
#data.loc[:,'Sex']#,前面表示所有行，,后面表示Sex这一列，只能用标签名来引用
#data.iloc[:,3]#,前面表示所有行，,后面表示第3列
print(data["Embarked"].unique())#unique表示取出所有的值，但是删掉重复值，只显示所有不同的值
data["Embarked"].unique().tolist()#把数组变成列表
#labels=data["Embarked"].unique().tolist()
#print(labels.index('S'))#0
# 将三分类变量转换为数值型变量
labels = data["Embarked"].unique().tolist()
data["Embarked"] = data["Embarked"].apply(lambda x: labels.index(x))## 将分类变量转换为数值型变量，将每一行数据换成该行数据取到的索引
# 查看处理后的数据集
print(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])
# 查看分好的训练集和测试集
print(Xtrain.head())

# 5.导入模型，粗略跑一下查看结果
clf = DecisionTreeClassifier(random_state=25)
clf = clf.fit(Xtrain, Ytrain)
score_ = clf.score(Xtest, Ytest)
print(score_)
score = cross_val_score(clf, X, y, cv=10).mean()#10次交叉验证来看是否是训练集和测试集的问题
print(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()#测试拟合的分数，10次10折交叉验证的分数
    tr.append(score_tr)#把结果存储进列表
    te.append(score_te)
print(max(te))
plt.plot(range(1,11),tr,color="red",label="train")#x轴为1到10的整数，y轴为训练集的分数
plt.plot(range(1,11),te,color="blue",label="test")
#比较两条线，如果训练集的分数大大高于测试集的分数，模型就是过拟合的；如果测试集的分数大大高于训练集的分数，模型就是欠拟合的
plt.xticks(range(1,11))#x轴显示1到10的整数的标尺
plt.legend()#显示图例
plt.show()#
# 使用“entropy”：因为在最大深度=3的时候，模型拟合不足，在训练集和测试集上的表现接近，但却都不是非常理想，只能够达到83%左右，所以要使用entropy。

# 7.用网格搜索调整参数，能同时调整多个参数的技术，采用枚举的思想，故时间比较长，使用时要缩小参数范围再使用网格搜索
gini_thresholds = np.linspace(0, 0.5, 20)#在0到0.5之间取出20个有序的随机数
parameters = {'splitter': ('best', 'random')
              , 'criterion': ("gini", "entropy")
              , "max_depth": [*range(1, 10)]
              , 'min_samples_leaf': [*range(1, 50, 5)]#1到50间以步长为5来搜索
              , 'min_impurity_decrease': [*np.linspace(0, 0.5, 20)]
              }#parameters是一串参数和这些参数对应的取值范围
clf = DecisionTreeClassifier(random_state=25)
GS = GridSearchCV(clf, parameters, cv=10)
GS.fit(Xtrain, Ytrain)
print(GS.best_params_)#从输入的参数和参数列表中返回最佳组合
print(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_的更多内容可以参考：
http://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.导入需要的模块
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.生成三种数据集 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()

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

Bonus Chapter Ⅱ :配置开发环境&安装sklearn
所用的库和版本有：
Python 3.7.1（你的版本至少要3.4以上
Scikit-learn 0.20.0 （你的版本至少要0.19
Graphviz 0.8.4 (没有画不出决策树哦，安装代码conda install python-graphviz
Numpy 1.15.3, Pandas 0.23.4, Matplotlib 3.0.1, SciPy 1.1.0
以上的库和模块都是必须的，但版本可以不用太过限制，只要python在3.4以上，保证sklearn可以使用就没问题了。接下来，大家可以根据自己计算机的开发环境，选读下面的章节，以完成课程需要的开发环境的配置。

(1)第一次使用python，还没有安装过，一个最简单的方式是直接安装Python针对科学计算而发布的开发环境Anaconda。
https://www.anaconda.com/download/
在这个网站里，根据你所使用的操作系统下载合适的Anaconda版本来安装即可。Anaconda里包含这门课所需要的所有工具包，包括Numpy，Scipy，Pandas和sklearn等等，可以在安装python的时候一并安装完毕，无需任何多余的操作。

(2)已经安装了Python，但没有所需的库，也不想再通过Anaconda进行操作，那可以使用pip逐个安装这些工具包。对于版本在2.7.9以上的python 2，以及3.4以上的python 3而言，pip是自带的，同时，这两个版本也是sklearn库对于python的最低要求。如果发现自己的python中无法运行pip命令，那你的python也将无法运行sklearn，最迅速的方法是直接卸载重装版本更高的python。现在从官网下载，python的版本是带有pip命令的3.7.1。
https://www.python.org/downloads/
能够使用Anaconda，就不推荐使用pip。pip安装一部分库的时候可能会出现异常，原因是pip默认下载的一部分库的版本（如SciPy）可能只适用于linux系统，而Anaconda的安装一般不会有这个问题。对于能够自己排查出现的问题的学员，请随意选择任何安装方式。
注意，Anaconda的安装和pip的安装尽量不要混用，由Anaconda安装的库在使用pip卸载或是更新的时候，可能出现无法卸载干净，无法正常更新，或更新后一部分库变得无法运行的情况。
所有安装命令均在cmd中运行，pip的安装命令如下，这些命令需要每一条分开运行：

pip install numpy
pip install pandas
pip install scipy
pip install matplotlib
pip install –U scikit-learn

Anaconda的安装命令如下：

conda install numpy
conda install pandas
conda install scipy
conda install matplotlib
conda install scikit-learn

安装过程中任何的报错，都可以通过卸载重装来解决问题，这是最有效率的方式。
(3)使用过python，并且对NumPy，Pandas等库比较熟悉，那你可以直接运行pip或conda来安装sklearn，在cmd中运行pip或者conda命令就可安装scikit-learn。命令二选一，不要重复安装。

pip install -U scikit-learn
conda install scikit-learn