一、决策树的决策边界

In [2]:

import numpy as np
import pandas as pd

In [7]:

#利用sklearn中提供的make_blobs函数生成一个服从高斯分布的二维数组，且将其随机分为四类
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt
X, y =make_blobs(n_samples=300, centers=4, random_state=0)

In [10]:

make_blobs?

In [8]:

plt.scatter(X[:, 0], X[:, 1], c=y)#可视化数据，并生成不同颜色

Out[8]:

<matplotlib.collections.PathCollection at 0x1c64ca3d6a0>

 

随机森林可视化 随机森林可视化sklearn_子节点

In [9]:

#训练模型
from sklearn.tree import DecisionTreeClassifier
tree = DecisionTreeClassifier().fit(X, y)

 

利用辅助函数查看决策树的决策过程，这些辅助函数已被封装在 tree_visualize.py 模块中，直接调用即可

In [128]:

from tree_visualize import visualize_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_blobs
fig, ax = plt.subplots(1, 4, figsize=(16, 3))
fig.subplots_adjust(left=0.02, right=0.98, wspace=0.1)
X, y = make_blobs(n_samples=300, centers=4,
random_state=0, cluster_std=1.0)
for axi, depth in zip(ax, range(1, 5)):
    model = DecisionTreeClassifier(max_depth=depth)
    visualize_tree(model, X, y, ax=axi)
    axi.set_title('depth = {0}'.format(depth))

 

随机森林可视化 随机森林可视化sklearn_决策树_02

由图可知RF无法对局部非线性边界进行捕捉。而集成算法则能很好的弥补这点不足

 

看看集成算法的区别

一般决策树可视化

In [130]:

from tree_visualize import visualize_tree
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_blobs
fig, ax = plt.subplots(1, 4, figsize=(16, 3))
fig.subplots_adjust(left=0.02, right=0.98, wspace=0.1)
X, y = make_blobs(n_samples=300, centers=4,
random_state=0, cluster_std=1.0)
for axi, depth in zip(ax, range(1, 5)):
    model = DecisionTreeClassifier(max_depth=depth)
    visualize_tree(model, X, y, ax=axi)
    axi.set_title('depth = {0}'.format(depth))

 

随机森林可视化 随机森林可视化sklearn_子节点_03

In [131]:

model.feature_importances_

Out[131]:

array([0.32468899, 0.67531101])

In [132]:

model.classes_

Out[132]:

array([0, 1, 2, 3])

 

查看bagging中基分类器为决策树的集成算法决策边界

In [154]:

from tree_visualize import visualize_classifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import BaggingClassifier
tree = DecisionTreeClassifier()
bag = BaggingClassifier(tree, n_estimators=100, max_samples=0.8,
random_state=1)
bag.fit(X, y)
visualize_classifier(bag,X,y)

随机森林可视化 随机森林可视化sklearn_搜索_04

 

查看随机森岭（RF）分决策边界

In [155]:

from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(n_estimators=100, random_state=0)
visualize_classifier(model, X, y)

 

随机森林可视化 随机森林可视化sklearn_决策树_05

 

随机森林中通过引入特征的随机选取，在决策过程随机性更强，决策边界更加不明显，对于没有明显线性边界的数据集分类效果更好。

 

2.随机森林参数解释

 

RF需要调参的参数也包括两部分，第一部分是Bagging框架的参数，第二部分是CART决策树的参数。

 

2.1 Bagging框架参数

 

RF重要的Bagging框架的参数，由于RandomForestClassifier和RandomForestRegressor参数绝大部分相同，这里会将它们⼀起说明，不同点会指出。

 

n_estimators: 也就是弱学习器器的最大迭代次数，或者说最大的弱学习器器的个数。⼀一般来说n_estimators太小，容易欠拟合， n_estimators太大，计算量量会太大，并且n_estimators到一定的数量量后，再增⼤大n_estimators获得的模型提升会很小，所以一般选择一个适中的数值。默认是100。

oob_score :即是否采用袋外样本来评估模型的好坏。默认识False。

criterion: 即CART树做划分时对特征的评价标准。分类模型和回归模型的损失函数是不一样的。分 类RF对应的CART分类树默认是基尼系数gini,另一个可选择的标准是信息增益。回归RF对应的CART回 归树默认是均方差mse，另一个可以选择的标准是绝对值差mae。一般来说选择默认的标准就已经很好的。

从上面可以看出， RF重要的框架参数比较少，主要需要关注的是 n_estimators，即RF最⼤大的决策树个数。

 

2.2 决策树参数

 

RF划分时考虑的最大特征数max_features:

可以使用很多种类型的值，默认是"auto",意味着划分 时最多考虑 个特征；如果是"log2"意味着划分时最多考虑 个特征；如果是"sqrt"或 者"auto"意味着划分时最多考虑 个特征。如果是整数，代表考虑的特征绝对数。如果是浮点数， 代表考虑特征百分比，即考虑（百分比xN）取整后的特征数。其中N为样本总特征数。⼀一般我们用默 认的"auto"就可以了了，如果特征数非常多，我们可以灵活使用刚才描述的其他取值来控制划分时考虑 的最大特征数，以控制决策树的生成时间。

 

决策树最⼤大深度max_depth:

默认可以不输入，如果不输入的话，决策树在建立子树的时候不会限 制子树的深度。一般来说，数据少或者特征少的时候可以不不管这个值。如果模型样本量量多，特征也多 的情况下，推荐限制这个最大深度，具体的取值取决于数据的分布。常用的可以取值10-100之间

 

内部节点再划分所需最小样本数min_samples_split:

这个值限制了子树继续划分的条件，如果某 节点的样本数少于min_samples_split，则不会继续再尝试选择最优特征来进行划分。 默认是2.如果 样本量不大，不需要管这个值。如果样本量数量级非常大，则推荐增大这个值

 

叶子节点最少样本数min_samples_leaf:

这个值限制了叶⼦节点最少的样本数，如果某叶⼦子节点数 ⽬小于样本数，则会和兄弟节点⼀起被剪枝。 默认是1,可以输入最少的样本数的整数，或者最少样本 数占样本总数的百分比。如果样本量不大，不需要管这个值。如果样本量量数量量级非常大，则推荐增大 这个值。

 

叶子节点最小的样本权重和min_weight_fraction_leaf：

这个值限制了叶子节点所有样本权重和 的最小值，如果小于这个值，则会和兄弟节点一起被剪枝。 默认是0，就是不不考虑权重问题。一般来 说，如果我们有较多样本有缺失值，或者分类树样本的分布类别偏差很大，就会引入样本权重，这时 我们就要注意这个值了。

 

最大叶⼦子节点数max_leaf_nodes:

通过限制最大叶子节点数，可以防止过拟合，默认是"None”， 即不限制最大的叶子节点数。如果加了限制，算法会建立在最大叶子节点数内最优的决策树。如果特 征不多，可以不考虑这个值，但是如果特征分成多的话，可以加以限制，具体的值可以通过交叉验证 得到。

 

节点划分最小不纯度min_impurity_split:

这个值限制了决策树的增长，如果某节点的不纯度(基 于基尼系数，均方差)小于这个阈值，则该节点不再生成子节点。即为叶子节点 。一般不推荐改动默 认值1e-7

 

上面决策树参数中最重要的包括最大特征数max_features， 最大深度max_depth， 内部节点再划分所需最小样本数min_samples_split和叶子节点最少样本数min_samples_leaf

 

3.随机森林调参实例例

In [3]:

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier #随机森林
from sklearn.model_selection import GridSearchCV  #网格搜索
from sklearn import cross_validation, metrics #评估参数
import matplotlib.pyplot as plt

In [4]:

train = pd.read_csv("train_modified.csv")
train.head()

 

 

Out[4]:

 

Disbursed

Existing_EMI

ID

Loan_Amount_Applied

Loan_Tenure_Applied

Monthly_Income

Var4

Var5

Age

EMI_Loan_Submitted_Missing

...

Var2_2

Var2_3

Var2_4

Var2_5

Var2_6

Mobile_Verified_0

Mobile_Verified_1

Source_0

Source_1

Source_2

0

0

0.0

ID000002C20

300000

5

20000

1

0

37

1

...

0

0

0

0

1

1

0

1

0

0

1

0

0.0

ID000004E40

200000

2

35000

3

13

30

0

...

0

0

0

0

1

0

1

1

0

0

2

0

0.0

ID000007H20

600000

4

22500

1

0

34

1

...

0

0

0

0

0

0

1

0

0

1

3

0

0.0

ID000008I30

1000000

5

35000

3

10

28

1

...

0

0

0

0

0

0

1

0

0

1

4

0

25000.0

ID000009J40

500000

2

100000

3

17

31

1

...

0

0

0

0

0

0

1

0

0

1

5 rows × 51 columns

In [5]:

target='Disbursed'
target

Out[5]:

'Disbursed'

In [6]:

IDcol = 'ID'

In [7]:

train['Disbursed'].value_counts()#能够看书样本属于非均衡分布

Out[7]:

0    19680
1      320
Name: Disbursed, dtype: int64

In [8]:

#构建X 和y
x_columns = [x for x in train.columns if x not in [target, IDcol]]
X = train[x_columns]
y = train['Disbursed']

In [9]:

#利用初始默认参数构建模型
rf0 = RandomForestClassifier(oob_score=True, random_state=10)  #默认参数
rf0.fit(X,y) #训练模型

Out[9]:

RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
            max_depth=None, max_features='auto', 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, n_estimators=10, n_jobs=1,
            oob_score=True, random_state=10, verbose=0, warm_start=False)

In [10]:

rf0.oob_score_#模型测试误差

Out[10]:

0.98005

In [12]:

y_predprob = rf0.predict_proba(X)[:,1]#预测分类
y_predprob

Out[12]:

array([0., 0., 0., ..., 0., 0., 0.])

In [13]:

metrics.roc_auc_score(y, y_predprob)#AUC值

Out[13]:

0.9998327140497968

 

然后利用网格搜索对其进行参数调整。首先是对基分类器的最佳数量进行网格搜索

In [17]:

param_test1 = {'n_estimators':list(range(10,100,10))}
gsearch1 = GridSearchCV(estimator =
RandomForestClassifier(min_samples_split=100, #min_samples_split内部节点在划分所需要的最小样本数100，min_samples_leaf叶子节点最小样本数20
                       #max_features最大深度8，max_features最大特特征数8 ，random_state=10 随机数种子
min_samples_leaf=20,max_depth=8,max_features='sqrt' ,random_state=10),
param_grid = param_test1, scoring='roc_auc',cv=5)

然后网格搜索的结果直接可用于建模

In [18]:

gsearch1.fit(X,y)

Out[18]:

GridSearchCV(cv=5, error_score='raise',
       estimator=RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',
            max_depth=8, max_features='sqrt', max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=None,
            min_samples_leaf=20, min_samples_split=100,
            min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1,
            oob_score=False, random_state=10, verbose=0, warm_start=False),
       fit_params={}, iid=True, n_jobs=1,
       param_grid={'n_estimators': [10, 20, 30, 40, 50, 60, 70, 80, 90]},
       pre_dispatch='2*n_jobs', refit=True, scoring='roc_auc', verbose=0)

In [19]:

#查看该网格优化后的模型最佳参数，及每次迭代的输出结果
gsearch1.grid_scores_, gsearch1.best_params_, gsearch1.best_score_

Out[19]:

([mean: 0.80681, std: 0.02236, params: {'n_estimators': 10},
  mean: 0.81600, std: 0.03275, params: {'n_estimators': 20},
  mean: 0.81818, std: 0.03136, params: {'n_estimators': 30},
  mean: 0.81838, std: 0.03118, params: {'n_estimators': 40},
  mean: 0.82034, std: 0.03001, params: {'n_estimators': 50},
  mean: 0.82113, std: 0.02966, params: {'n_estimators': 60},
  mean: 0.81992, std: 0.02836, params: {'n_estimators': 70},
  mean: 0.81955, std: 0.02812, params: {'n_estimators': 80},
  mean: 0.81981, std: 0.02850, params: {'n_estimators': 90}],
 {'n_estimators': 60},
 0.8211334476626017)

 

网格搜索最优基评估器个数为60，且训练集中进行交叉验证的最佳准确率为82.11%。

接着我们对决策树最大深度max_depth和内部节点再划分所需最小样本数min_samples_split进行网 格搜索

In [173]:

param_test2 = {'max_depth':list(range(3,14,2)),'min_samples_split':list(range(50,201,20))}
gsearch2 = GridSearchCV(estimator = RandomForestClassifier(n_estimators=
60, min_samples_leaf=20,max_features='sqrt' ,oob_score=True,
random_state=10),param_grid = param_test2, scoring='roc_auc',iid=False, cv=5)
gsearch2.fit(X,y)

Out[173]:

({'max_depth': 13, 'min_samples_split': 110}, 0.8242016800050813)

In [177]:

gsearch2.best_params_, gsearch2.best_score_

Out[177]:

({'max_depth': 13, 'min_samples_split': 110}, 0.8242016800050813)

In [174]:

#根据网格搜索的结果，我们能设置 基分类器伟 60 个，最大深度13，在划分所需样本数110.
rf1 = RandomForestClassifier(n_estimators= 60, max_depth=13,
min_samples_split=110,
min_samples_leaf=20,max_features='sqrt',oob_score=True, random_state=10)
rf1.fit(X,y)
rf1.oob_score_

Out[174]:

0.984