[机器学习] 集成学习 stacking

た入场券 2022-05-12 11:40 284阅读 0赞

首先我们先训练多个不同的模型，然后把之前训练的各个模型的输出作为输入来训练一个新的最终分类器的模型，以得到一个最终的输出。但在实际中，我们通常使用logistic回归作为组合策略。

Stacked Generalization （SG），也叫堆栈泛化的方法，属于异源集成（heterogenous ensembles）的典型代表  
① 将训练集分为3部分，分别用于让3个基分类器（Base-leaner）进行学习和拟合  
② 将3个基分类器预测得到的结果作为下一层分类器（Meta-learner）的输入  
③ 将下一层分类器得到的结果作为最终的预测结果  
这个模型的特点就是通过使用第一阶段（level 0）的预测作为下一层预测的特征，比起相互独立的预测模型能够有更强的非线性表述能力，降低泛化误差。它的目标是同时降低机器学习模型的Bias-Variance。

对于每一轮的 5-fold，Model 1都要做满5次的训练和预测。  
Titanic 栗子：  
Train Data有890行。(请对应图中的上层部分）

每1次的fold，都会生成 713行 小train， 178行 小test。我们用Model 1来训练 713行的小train，然后预测 178行 小test。预测的结果是长度为 178 的预测值。  
这样的动作走5次！ 长度为178 的预测值 X 5 = 890 预测值，刚好和Train data长度吻合。这个890预测值是Model 1产生的，我们先存着，因为，一会让它将是第二层模型的训练来源。

**重点**：这一步产生的预测值我们可以转成 890 X 1 （890 行，1列），记作 P1 (大写P)

接着说 Test Data 有 418 行。(请对应图中的下层部分，对对对，绿绿的那些框框）

每1次的fold，713行 小train训练出来的Model 1要去预测我们全部的Test Data（全部！因为Test Data没有加入5-fold，所以每次都是全部！）。此时，Model 1的预测结果是长度为418的预测值。

这样的动作走5次！我们可以得到一个 5 X 418 的预测值矩阵。然后我们根据行来就平均值，最后得到一个 1 X 418 的平均预测值。

**重点**：这一步产生的预测值我们可以转成 418 X 1 （418行，1列），记作 p1 (小写p)

走到这里，你的第一层的Model 1完成了它的使命。  
第一层还会有其他Model的，比如Model 2，同样的走一遍， 我们有可以得到 890 X 1 (P2) 和 418 X 1 (p2) 列预测值。  
这样吧，假设你第一层有3个模型，这样你就会得到：  
来自5-fold的预测值矩阵 890 X 3，（P1，P2， P3） 和 来自Test Data预测值矩阵 418 X 3， （p1, p2, p3）。

--------------------

到第二层了…

来自5-fold的预测值矩阵 890 X 3 作为你的Train Data，训练第二层的模型  
来自Test Data预测值矩阵 418 X 3 就是你的Test Data，用训练好的模型来预测他们吧。

--------------------

class Ensemble(object):
        def __init__(self, n_folds, stacker, base_models):
            self.n_folds = n_folds
            self.stacker = stacker
            self.base_models = base_models
    
        def fit_predict(self, X, y, T):
            X = np.array(X)
            y = np.array(y)
            T = np.array(T)
    
            folds = list(KFold(len(y), n_folds=self.n_folds, shuffle=True, random_state=2016))
    
            S_train = np.zeros((X.shape[0], len(self.base_models)))
            S_test = np.zeros((T.shape[0], len(self.base_models)))
    
            for i, clf in enumerate(self.base_models):
                S_test_i = np.zeros((T.shape[0], len(folds)))
    
                for j, (train_idx, test_idx) in enumerate(folds):
                    X_train = X[train_idx]
                    y_train = y[train_idx]
                    X_holdout = X[test_idx]
                    # y_holdout = y[test_idx]
                    clf.fit(X_train, y_train)
                    y_pred = clf.predict(X_holdout)[:]
                    S_train[test_idx, i] = y_pred
                    S_test_i[:, j] = clf.predict(T)[:]
    
                S_test[:, i] = S_test_i.mean(1)
    
            self.stacker.fit(S_train, y)
            y_pred = self.stacker.predict(S_test)[:]
            return y_pred

#### 参考 ####

[模型融合方法概述][Link 1]  
[Kaggle机器学习之模型融合（stacking）心得][Kaggle_stacking]  
[今我来思，堆栈泛化][Link 2]  
[如何在 kaggle中首战进入10％][kaggle_10]  
[https://blog.csdn.net/Julialove102123/article/details/78475774][https_blog.csdn.net_Julialove102123_article_details_78475774]  
[https://blog.csdn.net/savinger/article/details/52862004][https_blog.csdn.net_savinger_article_details_52862004]  
[https://blog.csdn.net/g11d111/article/details/80215381][https_blog.csdn.net_g11d111_article_details_80215381]

[Link 1]: https://zhuanlan.zhihu.com/p/25836678
[Kaggle_stacking]: https://zhuanlan.zhihu.com/p/26890738
[Link 2]: https://www.jianshu.com/p/46ccf40222d6
[kaggle_10]: https://dnc1994.com/2016/04/rank-10-percent-in-first-kaggle-competition/
[https_blog.csdn.net_Julialove102123_article_details_78475774]: https://blog.csdn.net/Julialove102123/article/details/78475774
[https_blog.csdn.net_savinger_article_details_52862004]: https://blog.csdn.net/savinger/article/details/52862004
[https_blog.csdn.net_g11d111_article_details_80215381]: https://blog.csdn.net/g11d111/article/details/80215381