博客

菜菜的机器学习sklearn实战—–集成学习—-随机森林

集成学习

集成学习算法概述

集成学习是通过建立很多模型，集成各个模型的结果和参数来提升最终模型的效果

集成算法会考虑多个评估的建模结果，汇总得到最终的评估结果

Bagging和Boosting

sklearn中的集成学习算法

sklearn中的集成算法模块ensemble

随机森林

是一个Bagging算法，每个基评估器都是一个决策树

bagging是对基评估器的预测结果进行平均或者用多数表决原则来决定集成评估器的结果

使用Bagging时，基分类器是相互独立的，是不相同的

RandomForestClassifier

重要参数

控制基评估器的参数

n_estimators

控制基评估器的数量，通常都是越大越好，但是受困于计算量的限制。

默认值为10或者100，一般我们去0到200

来建一片森林吧

%matplotlib inline
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split

wine = load_wine()
wine.data.shape

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

clf = DecisionTreeClassifier(random_state=0)
rfc = RandomForestClassifier(random_state=0)

clf = clf.fit(Xtrain,Ytrain)
rfc = rfc.fit(Xtrain,Ytrain)

score_c = clf.score(Xtest,Ytest)
score_r = rfc.score(Xtest,Ytest)

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

交叉验证 cross_val_score

from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

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)

plt.plot(range(1,11),rfc_s,label="RandomForest")
plt.plot(range(1,11),clf_s,label="DecisionTree")
plt.legend()
plt.show()

n_estimators的学习曲线

200次交叉验证

#n_estimators的学习曲线
superpa = []
for i in range(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)
    
print(max(superpa),superpa.index(max(superpa)))
plt.figure(figsize=[20,5])
plt.plot(range(1,201),superpa)
plt.show()

思路是怎样的呢

从十次交叉验证来看看

#思路是怎样呢
rfc_l = []
clf_l = []
for i in range(10):
    rfc = RandomForestClassifier(n_estimators=25)
    rfc_s = cross_val_score(rfc,wine.data,wine.target,cv=10).mean()
    rfc_l.append(rfc_s)
    
    clf = DecisionTreeClassifier()
    clf_s = cross_val_score(clf,wine.data,wine.target,cv= 10).mean()
    clf_l.append(clf_s)
    
plt.plot(range(1,11),rfc_l,label= "Random Forest")
plt.plot(range(1,11),clf_l,label="Decision Tree")
plt.legend()
plt.show()

random_state

bagging是对基评估器的预测结果进行平均或者用多数表决原则来决定集成评估器的结果

算一个公式：

rfc = RandomForestClassifier(n_estimators=25,random_state=2)
rfc.fit(Xtrain,Ytrain)

随机森林的重要属性之一：estimators_,查看森林中树的状况

#随机森林的重要属性之一：estimators_,查看森林中树的状况
rfc.estimators_

bootstrap & oob_score

为了让基分类器尽量的不一样，一种容易理解的方法就是使用不同的训练集来进行训练，而Bagging是利用随机抽样技术形成不同的训练集数据。

bootstrap就用来控制抽样技术的参数

有放回的抽样




也就是说，在使用随机森林时，我们可以不划分测试集和训练集，只需要用袋外数据来进行测试就可以啦

#无需划分训练集和测试集
rfc = RandomForestClassifier(n_estimators=25,oob_score=True)
rfc = rfc.fit(wine.data,wine.target)

#重要属性oob_score_
rfc.oob_score_

重要属性和接口

rfc = RandomForestClassifier(n_estimators=25)
rfc = rfc.fit(Xtrain,Ytrain)

rfc.score(Xtest,Ytest)

rfc.feature_importances_

rfc.apply(Xtest)

rfc.predict(Xtest)

rfc.predict_proba(Xtest)
#看看更像哪一类

Bonus：Bagging的；另一个必要条件

RandomForestRegressor

重要参数，属性与接口

criterion

回归树衡量分枝质量的指标表，

支持的标准有三种：


1 ）输入“mse”使用均方误差mean squared error(MSE)，父节点与子节点之间的均方误差，这种方法通过使用叶子节点的均值来最小化L2损失









2 ）输入“Friedman_mse”使用费尔德曼均方误差

3 ）输入“mae”使用绝对平均误差（mean absolute error）

随机森林回归的用法

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

#sklearn当中的模型评估指标（打分）列表
import sklearn
sorted(sklearn.metrics.SCORERS.keys())

实例：用随机森林回归填补空缺值

此案例中会使用 均值 ，0，和随机森林来填补缺失值

用来填补缺失值的类

from sklearn.impute import SimpleImputer

实例代码

#导入需要的库
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.data.shape

#无缺失的数据
X_full,y_full = dataset.data,dataset.target
#记录样本数和特征数
n_samples = X_full.shape[0]
n_features = X_full.shape[1]
#放入缺失值
#首先希望确定放入缺失数据的比例，这里假设是50%
rng = np.random.RandomState(0)
missing_rate = 0.5
n_missing_samples = int(np.floor(n_samples*n_features*missing_rate))
#需要用行列索引来确定一个个缺失值的位置
#用两个array来分别存储行索引值和列索引值
#randint(上限，下限，n个)
missing_features = rng.randint(0,n_features,n_missing_samples)

missing_samples = rng.randint(0,n_samples,n_missing_samples)




#创造缺失数据

X_missing = X_full.copy()
Y_missing = y_full.copy()
X_missing[missing_samples,missing_features] = np.nan

#放入pandas的DataFrame中方便处理
X_missing = pd.DataFrame(X_missing)


#使用均值进行填充
from sklearn.impute import SimpleImputer
imp_mean = SimpleImputer(missing_values=np.nan,strategy='mean')#实例化
X_missing_mean = imp_mean.fit_transform(X_missing)#训练fit+导出


#使用0进行填补
imp_0 = SimpleImputer(missing_values=np.nan,strategy="constant",fill_value=0)
X_missing_0 = imp_0.fit_transfrom(X_missing)

使用随机森林填补缺失值

任何回归都是从矩阵中学习，然后求解连续型标签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

接上面

X_missing_reg = X_missing.copy()
#找出数据集中，缺失值从小到大排序的特征们的顺序
#argsort返回从小到大排序所对应的索引
sortindex = np.argsort(X_missing_reg.isnull().sum(axis=0)).values
sortindex

#填补过程
for i in sortindex:
    #构建我们的新特征矩阵（没有被选中去填充的特征+原始的标签）和新标签（被选中去填充的特征）
    df = X_missing_reg
    #新标签（第i列）
    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)
    
    #print(df_0)
    
    #找出训练集和测试集
    #是被选中的填充特征中（现在是我们的标签），存在那些值，非空值
    Ytrain = fillc[fillc.notnull()]
    
    #是选中的要填充的特征中（现在是我们的标签），不存在的那些值，是空值
    #我们需要的不是Ytest的值，需要的是Ytest所带的索引
    Ytest = fillc[fillc.isnull()]
    
    #在新特征矩阵上，被选出来的要填充的特征的非空值所对应的记录
    
    Xtrain = df_0[Ytrain.index,:]
    #新特征矩阵上，被选出的要填充的那个特征的空值所对应的记录
    Xtest = df_0[Ytest.index,:]
    
    #用随机森林来填充缺失值
    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