集成学习之Stacking
Work cited:
<1>.https://cloud.tencent.com/developer/article/1005304
<2>.https://zhuanlan.zhihu.com/p/32896968
Theory part
• 同Blending方法，Stacking方法并不是一种算法，而是一种对模型的集成策略。相对于Blending模型的产生一组训练集和一组验证集的方法，我们可以考虑使用交叉验证的方法，由此引出了Stacking学习方法。
• 在给定数据集的条件下，数据本身的“数据结构”以及数据与数据之间的逻辑关系也是不一样的。不同的模型是从不同的角度观测数据集。比如，决策树专注于分裂节点的变化概率，当满足相应的条件时，就将其划为一类；KNN模型更关注样本点间的距离关系，满足距离远近的点将被归为一类。
Functioning
•请注意，Stacking方法与交叉验证并不等价。
• 选择基础模型：XGBoost、LightGBM、RandomForest、SVM、ANN、KNN等。
• 将训练集分为不交叉的5份，标记为train1，……，train5。
• 将train1作为预测集，用train2到train5建模，用这些模型分别对train1和test进行预测，并保留结果。
• 重复上一步，完成对train2到train5的预测，将所有对train集得到的结果按顺序叠加，得到对train整个数据集在第一个基模型的一个stacking转换；将test集得到的结果取平均，作为第一个基模型对test数据的一个stacking转换。
• 重复上述步骤，完成其他基模型的stacking转换，此时对test会有几项新的特征表达，要注意标签区分。
• 一般会使用LR模型作为第二层的模型进行建模预测
这个图说明的是对五部分的train分别预测之后再组成对train的新的表达，由5个5/N行一列的预测组成一个N行1列预测结果，从而得到对train的新表达；同时，对test的结果也进行处理，由于是5个模型对test的预测，所以要取平均，使得五列平均为一列，从而得到对test的新表达。
Attention
• Stacking框架是集成了不同的算法，充分利用不同算法从不同的数据空间角度和数据结构角度的对数据的不同观测，来取长补短，优化结果。所以我们可以“尽可能”多加一些基模型，包括不同参数的相同模型以及不同种类的基模型，使得集成效果更加稳健，更加精确。
• 如果基模型训练时间过长，可以适当减少折数，将折数改为3折，4折。
Compared with Neural Network
• Stacking通过第一层的特征抽取，来学习有效特征。
• 从逻辑层面上来看，Stacking的第一层等价于神经网络的前n-1层，最终分类层相当于神经网络的最后输出层。
而Stacking集成学习框架的对于基分类器的两个要求是：
·差异化(diversity)要大
·准确性(accuracy)要高
• Stacking的输出层为什么选择LR？
因为第二层的特征来自于对第一层数据的学习，所以第二层的特征不应该再包括原始特征，降低过拟合风险。
特征提取过程，已经使用了复杂的非线性变换，输出层不需要复杂的分类器，类比神经网络的输出层也是很简单的函数。
逻辑回归（LR）的其它优点：
• 可以配合L1正则化进一步防止过拟合。
• 可以选取有效特征，删除第一层中不必要的分类器。
• 输出结果可以被理解为概率，提高可解释性。
• Stacking中第一层分类器的数量问题。
Stacking表征的是不同模型对不同特征的学习能力，而不是像CNN等神经网络的多层堆叠，理论上2层足够，多层的话效果有限。本身Stacking的学习就是将不同角度的数据处理按照一定的权重综合起来而不是简单的累加。
第一层分类器的数量对有效特征的提取起较大作用，考虑Stacking方法对分类器的要求，即便因为分类器所提取特征有所重复，也可以通过降维，特征选取等方法来处理。
• Stacking与深度学习：
Stacking需要宽度，深度学习需要深度。
小样本用Stacking，大样本深度学习较为合适。
Prepared work
• 导入所需的库及数据
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from xgboost.sklearn import XGBClassifier
import lightgbm as lgb
from sklearn.model_selection import cross_val_score
from mlxtend.classifier import StackingCVClassifier
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
from collections import Counter
Start work
RANDOM_SEED = 42
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = GaussianNB()
lr = LogisticRegression()
Starting from v0.16.0, StackingCVRegressor supports
`random_state` to get deterministic result.
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3], # 第一层分类器
meta_classifier=lr, # 第二层分类器
random_state=RANDOM_SEED)
print('3-fold cross validation:\n')
for clf, label in zip([clf1, clf2, clf3, sclf], ['KNN', 'Random Forest', 'Naive Bayes','StackingClassifier']):
scores = cross_val_score(clf, X, y, cv=3, scoring='accuracy')
print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))
1.我们画出决策边界
from mlxtend.plotting import plot_decision_regions
import matplotlib.gridspec as gridspec
import itertools
gs = gridspec.GridSpec(2, 2)
fig = plt.figure(figsize=(10,8))
for clf, lab, grd in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random Forest',
'Naive Bayes',
'StackingCVClassifier'],
itertools.product([0, 1], repeat=2)):
clf.fit(X, y)
ax = plt.subplot(gs[grd[0], grd[1]])
fig = plot_decision_regions(X=X, y=y, clf=clf)
plt.title(lab)
plt.show()
#%% md
使用第一层所有基分类器所产生的类别概率值作为meta-classfier的输入。需要在StackingClassifier 中增加一个参数设置：use_probas = True。
另外，还有一个参数设置average_probas = True,那么这些基分类器所产出的概率值将按照列被平均，否则会拼接。
例如：
基分类器1：predictions=[0.2,0.2,0.7]
基分类器2：predictions=[0.4,0.3,0.8]
基分类器3：predictions=[0.1,0.4,0.6]
1）若use_probas = True，average_probas = True，
则产生的meta-feature 为：[0.233, 0.3, 0.7]
2）若use_probas = True，average_probas = False，
则产生的meta-feature 为：[0.2,0.2,0.7,0.4,0.3,0.8,0.1,0.4,0.6]
2.使用概率作为元特征
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 = GaussianNB()
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3],
use_probas=True, #
meta_classifier=lr,
random_state=42)
print('3-fold cross validation:\n')
for clf, label in zip([clf1, clf2, clf3, sclf],
['KNN',
'Random Forest',
'Naive Bayes',
'StackingClassifier']):
scores = cross_val_score(clf, X, y,
cv=3, scoring='accuracy')
print("Accuracy: %0.2f (+/- %0.2f) [%s]"
% (scores.mean(), scores.std(), label))
3. 堆叠5折CV分类与网格搜索(结合网格搜索调参优化)
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from mlxtend.classifier import StackingCVClassifier
#Initializing models
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = GaussianNB()
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3],
meta_classifier=lr,
random_state=42)
params = {'kneighborsclassifier__n_neighbors': [1, 5],
'randomforestclassifier__n_estimators': [10, 50],
'meta_classifier__C': [0.1, 10.0]}
grid = GridSearchCV(estimator=sclf,
param_grid=params,
cv=5,
refit=True)
grid.fit(X, y)
cv_keys = ('mean_test_score', 'std_test_score', 'params')
for r, _ in enumerate(grid.cv_results_['mean_test_score']):
print("%0.3f +/- %0.2f %r"
% (grid.cv_results_[cv_keys[0]][r],
grid.cv_results_[cv_keys[1]][r] / 2.0,
grid.cv_results_[cv_keys[2]][r]))
print('Best parameters: %s' % grid.best_params_)
print('Accuracy: %.2f' % grid.best_score_)
#如果我们打算多次使用回归算法，我们要做的就是在参数网格中添加一个附加的数字后缀，如下所示：
from sklearn.model_selection import GridSearchCV
#Initializing models
clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = GaussianNB()
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf1, clf2, clf3],
meta_classifier=lr,
random_state=RANDOM_SEED)
params = {'kneighborsclassifier-1__n_neighbors': [1, 5],
'kneighborsclassifier-2__n_neighbors': [1, 5],
'randomforestclassifier__n_estimators': [10, 50],
'meta_classifier__C': [0.1, 10.0]}
grid = GridSearchCV(estimator=sclf,
param_grid=params,
cv=5,
refit=True)
grid.fit(X, y)
cv_keys = ('mean_test_score', 'std_test_score', 'params')
for r, _ in enumerate(grid.cv_results_['mean_test_score']):
print("%0.3f +/- %0.2f %r"
% (grid.cv_results_[cv_keys[0]][r],
grid.cv_results_[cv_keys[1]][r] / 2.0,
grid.cv_results_[cv_keys[2]][r]))
print('Best parameters: %s' % grid.best_params_)
print('Accuracy: %.2f' % grid.best_score_)
4.在不同特征子集上运行的分类器的堆叠
##不同的1级分类器可以适合训练数据集中的不同特征子集。以下示例说明了如何使用scikit-learn管道和ColumnSelector：
from sklearn.datasets import load_iris
from mlxtend.classifier import StackingCVClassifier
from mlxtend.feature_selection import ColumnSelector
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
iris = load_iris()
X = iris.data
y = iris.target
pipe1 = make_pipeline(ColumnSelector(cols=(0, 2)), # 选择第0,2列
LogisticRegression())
pipe2 = make_pipeline(ColumnSelector(cols=(1, 2, 3)), # 选择第1,2,3列
LogisticRegression())
sclf = StackingCVClassifier(classifiers=[pipe1, pipe2],
meta_classifier=LogisticRegression(),
random_state=42)
sclf.fit(X, y)
5.ROC曲线 decision_function
*像其他 scikit-learn 分类器一样，它 StackingCVClassifier 具有decision_function可用于绘制 ROC 曲线的方法。
请注意，decision_function期望并要求元分类器实现decision_function.*
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier
from mlxtend.classifier import StackingCVClassifier
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import train_test_split
from sklearn import datasets
from sklearn.preprocessing import label_binarize
from sklearn.multiclass import OneVsRestClassifier
iris = datasets.load_iris()
X, y = iris.data[:, [0, 1]], iris.target
#Binarize the output
y = label_binarize(y, classes=[0, 1, 2])
n_classes = y.shape[1]
RANDOM_SEED = 42
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.33, random_state=RANDOM_SEED)
clf1 = LogisticRegression()
clf2 = RandomForestClassifier(random_state=RANDOM_SEED)
clf3 = SVC(random_state=RANDOM_SEED)
lr = LogisticRegression()
sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3],
meta_classifier=lr)
#Learn to predict each class against the other
classifier = OneVsRestClassifier(sclf)
y_score = classifier.fit(X_train, y_train).decision_function(X_test)
#Compute ROC curve and ROC area for each class
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
fpr[i], tpr[i], _ = roc_curve(y_test[:, i], y_score[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
#Compute micro-average ROC curve and ROC area
fpr["micro"], tpr["micro"], _ = roc_curve(y_test.ravel(), y_score.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
plt.figure()
lw = 2
plt.plot(fpr[2], tpr[2], color='darkorange',
lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[2])
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
Blending与Stacking对比：
Blending的优点在于：
- 比stacking简单（因为不用进行k次的交叉验证来获得stacker feature）
而缺点在于：
- 使用了很少的数据（是划分hold-out作为测试集，并非cv）
- blender可能会过拟合（其实大概率是第一点导致的）
- stacking使用多次的CV会比较稳健
扫一扫
2117
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
