集成算法的目标

集成算法会考虑多个评估器的建模结果，汇总之后得到一个综合的结果，以此来获取比单个模型更好的回归或  分类表现。

#导入我们需要的包

#画图的时候，需要这个环境，将这个jupyter导入到这个环境

%matplotlib inline

from sklearn.tree import DecisionTreeClassifier #分类树

from sklearn.ensemble import RandomForestClassifier

from sklearn.datasets import load_wine #红酒数据集

wine = load_wine()

wine.data

wine.target

#1.实例化

#2.训练集带入实例化后的模型去进行训练，使用的接口是fit

#3.使用其他接口将测试集导入我们训练好的模型去获取我们希望获取的结果（score，Y_test）

#导入划分训练集和测试集的类

from sklearn.model_selection import train_test_split

#test_size=0.3 即70%做训练集，30%测试集(训练集和测试集随机划分导致结果不同)

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

#1.实例化

clf = DecisionTreeClassifier(random_state=0)

#实例化随机森林

rfc = RandomForestClassifier(random_state=0)

#2.训练数据

clf = clf.fit(Xtrain,Ytrain)

rfc = rfc.fit(Xtrain,Ytrain)

#3.测试

score_c = clf.score(Xtest,Ytest)

score_r = rfc.score(Xtest,Ytest)

print("Single Tree:{}".format(score_c),"Random Forest:{}".format(score_r))

-->Single Tree:0.8703703703703703

Random Forest:0.9629629629629629

#交叉验证：cross_val_score

#（分训练集和测试集时，不同的分法会对模型结果产生影响），探讨不同的训练集和测试集中，模型的稳定性

#将数据集划分为n分，依次取每一份做测试集，每n-1份做训练集，多次训练模型以观测模型稳定性的方法

from sklearn.model_selection import cross_val_score

import matplotlib.pyplot as plt

#实例化随机森林(森林中数目的数量=25)

rfc = RandomForestClassifier(n_estimators=25)

#参数（实例化的模型，特征矩阵，标签，循环次数）

rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10)

clf = DecisionTreeClassifier()

clf_s = cross_val_score(clf,wine.data,wine.target,cv=10)

#交叉验证的次数10次

plt.plot(range(1,11),rfc_s,label="RandomForest")

plt.plot(range(1,11),clf_s,label="DecisionTree")

#显示图例

plt.legend()

plt.show()

#====================一种更加有趣也更简单的写法===================# """

label = "RandomForest"

for model in [RandomForestClassifier(n_estimators=25),DecisionTreeClassifier()]: score = cross_val_score(model,wine.data,wine.target,cv=10) print("{}:".format(label)),print(score.mean()) plt.plot(range(1,11),score,label = label)

plt.legend()

label = "DecisionTree"

"""

#保存验证结果

rfc_1 = []

clf_1 = []

#进行10次建模,总共100次验证

for i in range(10):

rfc = RandomForestClassifier(n_estimators=25)

#参数（实例化的模型，特征矩阵，标签，循环次数）

rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()

rfc_1.append(rfc_s)

clf = DecisionTreeClassifier()

clf_s = cross_val_score(clf,wine.data,wine.target,cv=10).mean()

clf_1.append(clf_s)

plt.plot(range(1,11),rfc_1,label = "Random Forest")

plt.plot(range(1,11),clf_1,label = "Decision Tree")

plt.legend()

plt.show()

#####【TIME WARNING: 2mins 30 seconds】#####

superpa = []

for i in range(200):

#n_estimators=i+1从建1棵到200棵，跑200次

rfc = RandomForestClassifier(n_estimators=i+1,n_jobs=-1)

rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()

superpa.append(rfc_s)

#找出准确率最高的n_estimators，list.index(object)返回对象object在列表list中的索引

print(max(superpa),superpa.index(max(superpa)))

plt.figure(figsize=[20,5])

plt.plot(range(1,201),superpa)

plt.show()

import numpy as np

from scipy.special import comb

#假设一棵树判断错误的概率0.2

np.array([comb(25,i)*(0.2**i)*((1-0.2)**(25-i)) for i in range(13,26)]).sum()

-->0.00036904803455582827

rfc=RandomForestClassifier(n_estimators=20

,random_state=2)

rfc = rfc.fit(Xtrain, Ytrain)

#随机森林的重要属性之一：estimators，查看森林中树的状况rfc.estimators_[0].random_state

for i in range(len(rfc.estimators_)):

print(rfc.estimators_[i].random_state)

#大家可以分别取尝试一下这些属性和接口

rfc = RandomForestClassifier(n_estimators=25)

rfc = rfc.fit(Xtrain, Ytrain)

rfc.score(Xtest,Ytest）

-->0.9629629629629629

#特征重要性，可以用zip加特征名，显示更直观

rfc.feature_importances_

-->array([0.15289792, 0.05454116, 0.01171529, 0.022256  , 0.02074498,

0.06950304, 0.16920349, 0.01004513, 0.03146696, 0.2042654 ,

0.12648034, 0.04322132, 0.08365897])

#apply输入测试集返回每个测试样本所在的叶子节点的索引（一般需要提取叶子节点使用）

rfc.apply(Xtest)

-->array([[ 8,  4,  1, ...,  4, 13,  3],

[ 6, 19, 11, ..., 16, 12, 12],

...,

[ 3, 19,  1, ...,  9,  8,  5],

[ 3, 10,  3, ...,  9,  8,  5]], dtype=int64)

#predict输入测试集返回每个测试样本的标签（预测结果）

rfc.predict(Xtest)

-->array([2, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 1, 1, 0, 1, 1, 2, 0, 2, 1, 1, 1,

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

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

#返回每个测试样本对应的被分到每一类标签的概率，标签有几个分类就返回几个概率

rfc.predict_proba(Xtest)

-->array([[0.  , 0.  , 1.  ],

[0.96, 0.  , 0.04],

[0.  , 1.  , 0.  ],

...

[0.32, 0.52, 0.16],

[0.28, 0.56, 0.16],

[0.  , 1.  , 0.  ]])

import numpy as np

from scipy.special import comb

import matplotlib.pyplot as plt

#linspace函数，在0,1间返回20个均匀分布的数

x = np.linspace(0,1,20)

y = []

for epsilon in np.linspace(0,1,20):

E = np.array([comb(25,i)*(epsilon**i)*((1-epsilon)**(25-i))

for i in range(13,26)]).sum()

y.append(E)

plt.plot(x,y,"o-",label="when estimators are different")

plt.plot(x,x,"--",color="red",label="if all estimators are same")

plt.xlabel("individual estimator's error")

plt.ylabel("RandomForest's error")

plt.legend() plt.show()

#导库

from sklearn.datasets import load_boston #波士顿房价数据

from sklearn.model_selection import cross_val_score  #交叉验证

from sklearn.ensemble import RandomForestRegressor  #随机森林回归

#加载数据

boston = load_boston()

#实例化

regressor = RandomForestRegressor(n_estimators=100,random_state=0)

#交叉验证（实例化的模型，完整特征矩阵，完整标签，交叉验证次数，交叉验证打分标准）

cross_val_score(regressor, boston.data, boston.target, cv=10

,scoring = "neg_mean_squared_error")

-->array([-10.72900447,  -5.36049859,  -4.74614178, -20.84946337,

-12.23497347, -17.99274635,  -6.8952756 , -93.78884428,

-29.80411702, -15.25776814])

#sklearn当中的模型评估指标（打分）列表

import sklearn

sorted(sklearn.metrics.SCORERS.keys())

-->['accuracy',

'adjusted_mutual_info_score',

'adjusted_rand_score',

...'roc_auc_ovr', 'roc_auc_ovr_weighted','v_measure_score']

#导入需要的库

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.datasets import load_boston #波士顿数据集

from sklearn.impute import SimpleImputer  #填补缺失值的类

from sklearn.ensemble import RandomForestRegressor #随机森林回归器

#以波士顿数据集为例，导入完整的数据集并探索

dataset = load_boston()

dataset.target #标签是连续型变量，用回归

dataset.data.shape #506个样本，13个特征

#总共506*13=6578个数据

X_full,y_full = dataset.data,dataset.target

n_samples = X_full.shape[0]  #样本数量506

n_features = X_full.shape[1]  #标签数量13

#为完整的数据集放入缺失值

#首先确定我们希望放入的缺失数据的比例（即多少数据变成缺失值），在这里我们假设是50%，那总共就要有3289个数据缺失

#确认一种固定的随机模式

rng = np.random.RandomState(0)

missing_rate = 0.5

#总共506*13*0.5=3289个数据缺失，用int与np.floor取整

n_missing_samples = int(np.floor(n_samples * n_features * missing_rate))

#np.floor向下取整，返回.0格式的浮点数

#所有数据要随机遍布在数据集的各行各列当中，而一个缺失的数据会需要一个行索引和一个列索引

#如果能够创造一个数组，包含3289个分布在0~506中间的行索引，和3289个分布在0~13之间的列索引，那我们就可以利用索引来为数据中的任意3289个位置赋空值

#然后我们用0，均值和随机森林来填写这些缺失值，然后查看回归的结果如何

#randint（下限，上限，n）请在下限和上限之间取出n个整数

missing_features = rng.randint(0,n_features,n_missing_samples) #0-13取出3289个随机整数

missing_samples = rng.randint(0,n_samples,n_missing_samples)   #0-506任意取出3289个随机整数

len(missing_features)

-->3289

#missing_samples = rng.choice(n_samples,n_missing_samples,replace=False)

#我们现在采样了3289个数据，远远超过我们的样本量506，所以我们使用随机抽取的函数randint

#但如果我们需要的数据量小于我们的样本量506

#那我们可以采用np.random.choice来抽样，choice会随机抽取不重复的随机数,因此可以帮助我们让数据更加分散，确保数据不会集中在一些行中

#不改变原数据集

X_missing = X_full.copy()

y_missing = y_full.copy()

#填充nan，不用处理y_missing，因为特征可以空，标签不能空

X_missing[missing_samples,missing_features] = np.nan

X_missing = pd.DataFrame(X_missing)

#转换成DataFrame是为了后续方便各种操作，numpy对矩阵的运算速度快到拯救人生，但是在索引等功能上却不如pandas来得好用

X_missing

-->

506 rows × 13 columns

#使用0和均值填补缺失值

from sklearn.impute import SimpleImputer

#使用均值填补

#参数：缺失值(missing_values=np.nan)是什么样子,strategy="",mean代表均值

imp_mean = SimpleImputer(missing_values=np.nan,strategy="mean") #实例化

#训练fit+导出predict >>> 特殊的接口 fit_transform

X_missing_mean = imp_mean.fit_transform(X_missing)

pd.DataFrame(X_missing_mean).isnull().sum()

#布尔值 False = 0，True = 1 ，结果都为0说明缺失值都填补了

-->

0     0

1     0

2     0

3     0

4     0

5     0

6     0

7     0

8     0

9     0

10    0

11    0

12    0

dtype: int64

#使用0进行填补

#constant：常数，fill_value=0即用0

imp_0 = SimpleImputer(missing_values=np.nan, strategy="constant",fill_value=0)

X_missing_0 = imp_0.fit_transform(X_missing)

pd.DataFrame(X_missing_0)

-->之前nan的位置都被0填补了

506 rows × 13 columns

"""（理解很重要）

使用随机森林回归填补缺失值(例如用0，均值等填补缺失值都不合适的时候)

任何回归都是从特征矩阵中学习，然后求解连续型标签y的过程，之所以能够实现这个过程，是因为回归算法认为，特征矩阵和标签之前存在着某种联系。实际上，标签和特征是可以相互转换的，比如说，在一个“用地区，环境，附近学校数量”预测“房价”的问题中，我们既可以用“地区”，“环境”，“附近学校数量”的数据来预测“房价”，也可以反过来，用“环境”，“附近学校数量”和“房价”来预测“地区”。而回归填补缺失值，正是利用了这种思想。

对于一个有n个特征的数据来说，其中特征T有缺失值，我们就把特征T当作标签，其他的n-1个特征和原本的标签组成新的特征矩阵。那对于T来说，它没有缺失的部分，就是我们的Y_train，这部分数据既有标签也有特征，而它缺失的部分，只有特征没有标签，就是我们需要预测的部分。

特征T不缺失的值对应的其他n-1个特征 + 本来的标签：X_train（作为特征）

特征T不缺失的值：Y_train（作为标签）

特征T缺失的值对应的其他n-1个特征 + 本来的标签：X_test

特征T缺失的值：未知，我们需要预测的Y_test

这种做法，对于某一个特征大量缺失，其他特征却很完整的情况，非常适用。

那如果数据中除了特征T之外，其他特征也有缺失值怎么办？

答案是遍历所有的特征，从缺失最少的开始进行填补（因为填补缺失最少的特征所需要的准确信息最少）。

填补一个特征时，先将其他特征的缺失值用0代替，每完成一次回归预测，就将预测值放到原本的特征矩阵中，再继续填补下一个特征。每一次填补完毕，有缺失值的特征会减少一个，所以每次循环后，需要用0来填补的特征就越来越少。当进行到最后一个特征时（这个特征应该是所有特征中缺失值最多的），已经没有任何的其他特征需要用0来进行填补了，而我们已经使用回归为其他特征填补了大量有效信息，可以用来填补缺失最多的特征。

遍历所有的特征后，数据就完整，不再有缺失值了。

"""

#回归填补缺失值的矩阵依然使用copy

X_missing_reg = X_missing.copy()

#找出数据集中缺失值从小到大排列的特征的顺序（本质是找索引）,有了这些特征按缺失值从小到大排序的索引

sortindex = np.argsort(X_missing_reg.isnull().sum(axis=0)).values

#np.argsort会返回从小到大排序的顺序所对应的索引，np.sort排序结果没有索引

（#.values将结果取出

np.argsort(X_missing_reg.isnull().sum(axis=0)).values

-->array([ 6, 12,  8,  7,  9,  0,  2,  1,  5,  4,  3, 10, 11], dtype=int64)

）

for i in sortindex:

#构建我们的新特征矩阵和新标签df = X_missing_reg

df = X_missing_reg

fillc = df.iloc[:,i]

df = pd.concat([df.iloc[:,df.columns != i],pd.DataFrame(y_full)],axis=1)

#在新特征矩阵中，对含有缺失值的列，进行0的填补

df_0=SimpleImputer(missing_values=np.nan,strategy='constant',fill_value=0).fit_transform(df)

#找出我们的训练集和测试集（特征T为有缺失需要填补的特征）

Ytrain = fillc[fillc.notnull()]  #特征T不缺失的值，非空的值

Ytest = fillc[fillc.isnull()]    #特征T缺失的值：未知，我们需要预测

Xtrain = df_0[Ytrain.index,:]    #特征T不缺失的值对应的其他n-1个特征 + 本来的标签

Xtest = df_0[Ytest.index,:]      #特征T缺失的值对应的其他n-1个特征 + 本来的标签

#用随机森林回归来填补缺失值

rfc = RandomForestRegressor(n_estimators=100)

rfc = rfc.fit(Xtrain, Ytrain)

Ypredict = rfc.predict(Xtest)

#将填补好的特征返回到我们的原始的特征矩阵中

X_missing_reg.loc[X_missing_reg.iloc[:,i].isnull(),i] = Ypredict

X_missing_reg.head()

-->nan都填补了

#***********代码讲解*************

#构建我们的新特征矩阵（没有被选中去填充的特征+原始的标签）和新标签（被选中去填充的特征）

#不改变X_missing_reg，所以赋值给df，先在df上操作，避免X_missing_reg被填入0，最后再把结果放回原来的X_missing_reg

df = X_missing_reg

#作为新标签，以索引为6（即第七列nan最少）为例

fillc = df.iloc[:,6]

#新特征矩阵（没有被选中去填充的特征+原始的标签）（可以取索引！= 6 的列）

df = pd.concat([df.iloc[:,df.columns != 6],pd.DataFrame(y_full)],axis=1)

#df.iloc[:,df.colums ! = 6] 取所有的行，索引不为6的列

#y_full为原始的标签，把其变为DataFrame（506行，1列）

#通过pd.concat连接，（axis=1即把y_full作为新的一列，不然会加到下面）

#注意：只能执行一次，不然y_full会一直加进去

#在新特征矩阵中，对含有缺失值的列，进行0的填补，实例化

df_0 =SimpleImputer(missing_values=np.nan,strategy='constant',fill_value=0).fit_transform(df)

#找出我们的训练集和测试集

Ytrain = fillc[fillc.notnull()]  #Ytrain是被选中要填充的特征中（现在是作为标签），存在的那些值，非空值

#Ytest需要我们预测，所以全为nan的Ytest，我们需要的不是Ytest的值，需要的是Ytest的索引

Ytest = fillc[fillc.isnull()]  #Ytest是被选中要填充的特征中（现在使我们的标签），不存在的那些值，是空值

#在新特征矩阵上，被选出来的要填充的特征的非空值所对应的记录

Xtrain = df_0[Ytrain.index,:] #Xtrain是要填充的特征不缺失的值（非空值）对应的其他n-1个特征 + 本来的标签

#在新特征矩阵上，被选出来的要填充的那个特征的空值所对应的记录

Xtest = df_0[Ytest.index,:] #Xtest是要填充的特征缺失的值（空值）对应的其他n-1个特征 + 本来的标签'

#用随机森林回归来填补缺失值

rfc = RandomForestRegressor(n_estimators=100)  #实例化

rfc = rfc.fit(Xtrain, Ytrain)   #导入训练集进行训练

Ypredict = rfc.predict(Xtest) #用predict接口，将Xtest导入得到预测（回归）结果，就是用来填补缺失值的值

#将填补好的特征返回到我们的原始的特征矩阵中

X_missing_reg.loc[X_missing_reg.iloc[:,6].isnull(),6] = Ypredict

#6.对填补好的数据进行建模

#对所有数据进行建模，取得MSE结果

#分别为原本的数据集，用0填补的数据集，用均值填补的数据集，用随机森林回归填补缺失的数据集

X =[X_full,X_missing_mean,X_missing_0,X_missing_reg]

mse = []

for x in X:

estimator = RandomForestRegressor(random_state=0,n_estimators=100)  #实例化

#用负的均方误差打分

scores= cross_val_score(estimator,x,y_full,scoring="neg_mean_squared_error",cv=5).mean()

mse.append(scores * -1)

#元组形式查看结果

[*zip(["X_full","X_missing_mean","X_missing_0","X_missing_reg"],mse)]

-->[('X_full', 21.62860460743544),

('X_missing_mean', 40.84405476955929),

('X_missing_0', 49.50657028893417),

('X_missing_reg', 20.567284947369437)]

#（mse均方误差越小越好，随机森林回归的效果甚至比原数据集更好）

#7.用所得结果画出条形图

x_labels = ["X_full","X_missing_mean","X_missing_0","X_missing_reg"]

colors = ["r","g","b","orange"]

plt.figure(figsize=(12,6),dpi=80)  #画出画布

ax = plt.subplot(111)  #plt.subplot添加子图

for i in np.arange(len(mse)): #np.arange = range(len(mse)) 0-3

#横条形图,alpha是条的粗度，align条形放在中间

ax.barh(i,mse[i],color=colors[i],alpha=0.6,align="center")

ax.set_title('Imputation Techniques with Boston Data')

#使x轴不从0开始

ax.set_xlim(left=np.min(mse) * 0.9,right=np.max(mse) * 1.1)

ax.set_yticks(np.arange(len(mse)))

ax.set_xlabel('MSE')

#用x_labels里面内容作y轴命名

ax.set_yticklabels(x_labels)

plt.show()

#导入库

from sklearn.datasets import load_breast_cancer   #从datasets中导入乳腺癌数据

from sklearn.ensemble import RandomForestClassifier  #导入随机森林分类器

from sklearn.model_selection import GridSearchCV    #导入网格搜索

from sklearn.model_selection import cross_val_score  #导入交叉验证

import matplotlib.pyplot as plt

import pandas as pd

import numpy as np

#导入数据

data = load_breast_cancer()

data

data.data.shape  #569个样本，30个特征，数据少容易过拟合

-->(569, 30)

data.target  #二分类0和1

#可以看到，乳腺癌数据集有569条记录，30个特征，单看维度虽然不算太高，但是样本量非常少。过拟合的情况可能存在。

#进行一次简单的建模，看看模型本身在数据集上的效果

#实例化

rfc = RandomForestClassifier(n_estimators=100,random_state=90)

#交叉验证参数（实例化模型，分训练集测试集前的完整的特征矩阵，特征标签，交叉验证次数，（回归时还有scoring选择以什么回归））

score_pre = cross_val_score(rfc,data.data,data.target,cv=10).mean()

score_pre

-->0.9648809523809524

#这里可以看到，随机森林在乳腺癌数据上的表现本就还不错，在现实数据集上，基本上不可能什么都不调就看到95%以上的准确率

#

在这里我们选择学习曲线，可以使用网格搜索吗？可以，但是只有学习曲线，才能看见趋势

我个人的倾向是，要看见n_estimators在什么取值开始变得平稳，是否一直推动模型整体准确率的上升等信息

第一次的学习曲线，可以先用来帮助我们划定范围，我们取每十个数作为一个阶段，来观察n_estimators的变化如何引起模型整体准确率的变化

"""

#####【TIME WARNING: 30 seconds】#####

scorel = []

for i in range(0,200,10):

rfc = RandomForestClassifier(n_estimators=i+1, #i+1因为n_estimators不能为0

n_jobs=-1,

random_state=90)

score = cross_val_score(rfc,data.data,data.target,cv=10).mean()

scorel.append(score)

#返回score取最大值时的索引，索引*10+1则为最高的score对应的n_estimators

print(max(scorel),(scorel.index(max(scorel))*10)+1)

plt.figure(figsize=[20,5])

plt.plot(range(1,201,10),scorel)

plt.show()

#list.index([object])-->返回这个object在列表list中的索引

#在确定好的范围内，进一步细化学习曲线

scorel = []

for i in range(65,75):

rfc = RandomForestClassifier(n_estimators=i, #i+1因为n_estimators不能为0

n_jobs=-1,

random_state=90)

score = cross_val_score(rfc,data.data,data.target,cv=10).mean()

scorel.append(score)

#返回score取最大值时的索引，*是序列解包，*range(0,6) 等效于0 1 2 3 4 5

print(max(scorel),([*range(65,75)][scorel.index(max(scorel))]))

plt.figure(figsize=[20,5])

plt.plot(range(65,75),scorel)

plt.show()

"""

有一些参数是没有参照的，很难说清一个范围，这种情况下我们使用学习曲线，

看趋势从曲线跑出的结果中选取一个更小的区间，再跑曲线。（参数范围说不清，通过学习曲线缩小区间）

#n_estimators  树最大数量

param_grid = {'n_estimators':np.arange(0, 200, 10)}

#max_depth

param_grid = {'max_depth':np.arange(1, 20, 1)}

#max_leaf_nodes

param_grid = {'max_leaf_nodes':np.arange(25,50,1)}

对于大型数据集，可以尝试从1000来构建，先输入1000，每100个叶子一个区间，再逐渐缩小范围

有一些参数是可以找到一个范围的，或者说我们知道他们的取值和随着他们的取值，模型的整体准确率会如何变化，

这样的参数我们就可以直接跑网格搜索（能通过参数取值知道准确率如何变化用网格搜索）

#criterion

param_grid = {'criterion':['gini', 'entropy']}

#min_samples_split  节点向下分枝所需的最小样本数

param_grid = {'min_samples_split':np.arange(2, 2+20, 1)}

#min_samples_leaf   分枝的叶子节点处所需的最小样本数

param_grid = {'min_samples_leaf':np.arange(1, 1+10, 1)}

#max_features  最大特征数

param_grid = {'max_features':np.arange(5,30,1)}

"""

#7.开始按照参数对模型整体准确率的影响程度进行调参，首先调整max_depth

#调整max_depth

param_grid = {'max_depth':np.arange(1, 20, 1)}

# 一般根据数据的大小来进行一个试探，乳腺癌数据很小，所以可以采用1~10，或者1~20这样的试探

# 但对于像digit recognition那样的大型数据来说，我们应该尝试30~50层深度（或许还不足够

# 更应该画出学习曲线，来观察深度对模型的影响

#实例化

rfc = RandomForestClassifier(n_estimators=73

,random_state=90

)

#网格搜索GridSearchCV（实例化的模型，搜索的参数，交叉验证的次数）

GS = GridSearchCV(rfc,param_grid,cv=10)

#训练模型

GS.fit(data.data,data.target)

#显示调整出来的最佳参数

GS.best_params_

-->{'max_depth': 8}

#返回调整好的最佳参数对应的准确率

GS.best_score_

-->0.9666353383458647

#调整max_features

#特征从5-30

param_grid = {'max_features':np.arange(5,30,1)}

"""

max_features是唯一一个即能够将模型往左（低方差高偏差）推，也能够将模型往右（高方差低偏差）推的参数。

我们需要根据调参前，模型所在的位置（在泛化误差最低点的左边还是右边）来决定我们要将max_features往哪边调。现在模型位于图像左侧，我们需要的是更高的复杂度，因此我们应该把max_features往更大的方向调整，可用的特征越多，模型才会越复杂。max_features的默认最小值是sqrt(n_features)，因此我们使用这个值作为调参范围的最小值。

"""

rfc = RandomForestClassifier(n_estimators=73

,random_state=90

)

GS = GridSearchCV(rfc,param_grid,cv=10)

GS.fit(data.data,data.target)

#显示调整出来的最佳参数

GS.best_params_

-->{'max_features': 24}

#返回调整好的最佳参数对应的准确率

GS.best_score_

-->0.9666666666666668

#调 整 min_samples_leaf param_grid={'min_samples_leaf':np.arange(1, 1+10, 1)}

#对于min_samples_split和min_samples_leaf,一般是从他们的最小值开始向上增加10或20

#面对高维度高样本量数据，如果不放心，也可以直接+50，对于大型数据，可能需要200~300的范围

#如果调整的时候发现准确率无论如何都上不来，那可以放心大胆调一个很大的数据，大力限制模型的复杂度

rfc = RandomForestClassifier(n_estimators=73

,random_state=90

)

GS = GridSearchCV(rfc,param_grid,cv=10)

GS.fit(data.data,data.target)

#显示调整出来的最佳参数

GS.best_params_

-->{'min_samples_leaf': 1}

#返回调整好的最佳参数对应的准确率

GS.best_score_

-->9666353383458647

# 调 整 min_samples_split

param_grid={'min_samples_split':np.arange(2, 2+20, 1)}

rfc = RandomForestClassifier(n_estimators=73

,random_state=90

)

GS = GridSearchCV(rfc,param_grid,cv=10)

GS.fit(data.data,data.target)

#显示调整出来的最佳参数

GS.best_params_

-->{'min_samples_split':2}

#返回调整好的最佳参数对应的准确率

GS.best_score_

-->0.9666353383458647

param_grid = {'criterion':['gini', 'entropy']}

rfc = RandomForestClassifier(n_estimators=39

,random_state=90

)

GS = GridSearchCV(rfc,param_grid,cv=10)

GS.fit(data.data,data.target)

#显示调整出来的最佳参数

GS.best_params_

-->{'criterion': 'gini'}

#返回调整好的最佳参数对应的准确率

GS.best_score_

-->0.9666353383458647

#最佳参数就是n_estimators,我们在实验中取得最佳的为73

rfc = RandomForestClassifier(n_estimators=73,random_state=90)

score = cross_val_score(rfc,data.data,data.target,cv=10).mean()

#调完后的分数

score

-->0.9666353383458647

#调完-调参前

score-score_pre

-->0.0017543859649122862

rfc = RandomForestClassifier(n_estimators=68

,random_state=90

,criterion="gini"

,min_samples_split=8

,min_samples_leaf=1

,max_depth=12

,max_features=2

,max_leaf_nodes=36

)