快速弄懂机器学习里的集成算法：原理、框架与实战（二）

（3）学习法

上述两种方法都是对弱学习器的结果做平均或者投票，相对比较简单，但是可能学习误差较大，于是就有了学习法这种方法。对于学习法，代表方法是stacking，当使用堆叠stacking的结合策略时， 我们不是对弱学习器的结果做简单的逻辑处理，而是再加上一层学习器，也就是说，我们将训练集弱学习器的学习结果作为输入，将训练集的输出作为输出，重新训练一个学习器来得到最终结果。

如下图，就是一个简单的Stacking算法结构，它是两层的结构，第一层的学习器为初学习器，也称为个体学习器。用于结合的第二层的分类器称为次级学习器或者是元学习器。其基本原理就是在以往算法中大多数是训练集与测试集，用训练集来训练模型，然后根据模型对测试集进行预测；Stacking则是在训练集的训练中加入又一层数据集划分，在训练集的训练与测试后，生成新的训练集，再与原始测试集进行模型训练。

这里仍以以鸢尾花为例，展示Stacking算法。

#导入sklearn及numpy模块
from sklearn.datasets import load_iris
from sklearn import cross_validation
import numpy as np

# 导入鸢尾花数据集
iris = load_iris()
x_train, x_test, y_train, y_test = cross_validation.train_test_split(iris.data, iris.target, test_size=0.4, random_state=1)

from sklearn import tree  #导入决策树库
from sklearn.linear_model import LogisticRegression #导入逻辑回归库

#将数据转换为DataFrame格式
import pandas as pd
x_train = pd.DataFrame(x_train)
y_train = pd.DataFrame(y_train)
x_test = pd.DataFrame(x_test)
y_test = pd.DataFrame(y_test)

接下来构造Stacking算法。

#Stacking techniques
from sklearn.model_selection import StratifiedKFold
def Stacking(model,train,y,test,n_fold):
    folds=StratifiedKFold(n_splits=n_fold,random_state=1)  #分层采样
    test_pred=np.empty((test.shape[0],1),float)  #构建空的测试集
   train_pred=np.empty((0,1),float)   #构建空的训练集
   for train_indices,val_indices in folds.split(train,y):
        x_train,x_val=train.iloc[train_indices],train.iloc[val_indices]
        y_train,y_val=y.iloc[train_indices],y.iloc[val_indices]
        
        model.fit(X=x_train,y=y_train)
        train_pred=np.append(train_pred,model.predict(x_val))
        test_pred=np.column_stack((test_pred,model.predict(test)))
    
    test_pred_a=np.mean(test_pred,axis=1) #按行计算均值
return test_pred_a.reshape(-1,1),train_pred

这里着重说明一下，Stacking的构建过程。如前所述，Stacking主要是在原始训练集（train）中又进行了一次样本划分，比如我们将训练集划分了10份，9份小训练集（x_train、y_train），1份小测试集（x_val、y_val），然后通过for循环，对每一份小训练集（x_train、y_train）进行训练，用训练的模型model.fit(X=x_train,y=y_train)对小测试集（x_val、y_val）进行预测，得到train_pred，同时也用相同的训练模型对原始测试集（test）进行预测，得到test_pred，对于得到的test_pred，按行进行平均得到平均的测试集test_pred_a。

#接下来先用决策树算法进行训练，得到train_pred1，test_pred1：
model1 = tree.DecisionTreeClassifier(random_state=1)

test_pred1 ,train_pred1=Stacking(model=model1,n_fold=10, train=x_train,test=x_test,y=y_train)

train_pred1=pd.DataFrame(train_pred1)
test_pred1=pd.DataFrame(test_pred1)

#再用K近邻算法进行训练，得到train_pred2，test_pred2：
model2 = KNeighborsClassifier()

test_pred2 ,train_pred2=Stacking(model=model2,n_fold=10,train=x_train,test=x_test,y=y_train)

train_pred2=pd.DataFrame(train_pred2)
test_pred2=pd.DataFrame(test_pred2)

#将得到的train_pred1、train_pred12合并成新的训练集df，得到的test_pred1、test _pred12合并成新的训练集df _test，再用逻辑回归算法进行第二层训练
df = pd.concat([train_pred1, train_pred2], axis=1)  #合并数据集
df_test = pd.concat([test_pred1, test_pred2], axis=1)  #合并数据集

model = LogisticRegression(random_state=1)
model.fit(df,y_train)
model.score(df_test, y_test)

以上就是Stacking的原理与算法实现过程。