模型融合（Stacking&Blending）以及相关的知识补充

模型融合之Stacking技术&Blending

• Stacking
  以下是一张经典的stacking过程图
  
  上半部分是用一个基础的模型进行5折交叉验证，如用XGBOOST作为基础模型Model1,5折交叉验证就是先拿出训练集的四折作为training data，另外一折作为testing data。假设我们原本的训练集有10000行数据，测试集有2500行数据，在进行交叉验证时，我们将训练集进行划分，在每一次的交叉验证中，都会将训练集的8000行作为trainning data,将训练集的2000行作为testing data。

每一次的交叉验证包含两个过程，1. 基于training data训练模型；2. 基于training data训练生成的模型对testing data进行预测。在整个第一次的交叉验证完成之后我们将会得到关于当前testing data的预测值，这将会是一个一维2000行的数据，记为a1。注意！在这部分操作完成后，我们还要对数据集原来的整个testing set进行预测，这个过程会生成2500个预测值，这部分预测值将会作为下一层模型testing data的一部分，记为b1。因为我们进行的是5折交叉验证，所以以上提及的过程将会进行五次，最终会生成针对testing data数据预测的5列2000行的数据a1,a2,a3,a4,a5，对testing set的预测会是5列2500行数据b1,b2,b3,b4,b5。

在完成对Model1的整个步骤之后，我们可以发现a1,a2,a3,a4,a5其实就是对原来整个training set的预测值，将他们拼凑起来，会形成一个10000行一列的矩阵，记为A1。而对于b1,b2,b3,b4,b5这部分数据，我们将各部分相加取平均值，得到一个2500行一列的矩阵，记为B1。

以上就是stacking中一个模型的完整流程，stacking中同一层通常包含多个模型，假设还有Model2: LR，Model3：RF，Model4: GBDT，Model5：SVM，对于这四个模型，我们可以重复以上的步骤，在整个流程结束之后，我们可以得到新的A2,A3,A4,A5,B2,B3,B4,B5矩阵。

在此之后，我们把A1,A2,A3,A4,A5并列合并得到一个10000行五列的矩阵作为training data，B1,B2,B3,B4,B5并列合并得到一个2500行五列的矩阵作为testing data。让下一层的模型，基于他们进一步训练。
以上就是stacking的完整步骤！

• Blending
  Blending与Stacking大致相同，只是Blending的主要区别在于训练集不是通过K-Fold的CV策略来获得预测值从而生成第二阶段模型的特征，而是建立一个Holdout集，例如10%的训练数据，第二阶段的stacker模型就基于第一阶段模型对这10%训练数据的预测值进行拟合。说白了，就是把Stacking流程中的K-Fold CV 改成 HoldOut CV。

其主要思路是把原始的训练集先分成两部分，比如70%的数据作为新的训练集，剩下的30%作为测试集，在第一层，我们在这70%的数据上训练多个模型，然后取预测那30%的数据的label以及原始数据测试集test的label,在第二层，我们就直接用这30%的数据在第一层的预测结果作为新特征继续训练模型，然后用test集第一层预测的label做特征，用第二层训练的模型做进一步的预测。

优点在于：

• 比stacking简单（因为不用进行k次的交叉验证来获得stacker feature）
• 避开了一个信息泄露问题：generlizers和stacker使用了不一样的数据集
• 在团队建模过程中，不需要给队友分享自己的随机种子

缺点在于：

• 使用了很少的数据（第二阶段的blender只使用training set10%的量）
• blender可能会过拟合（其实大概率是第一点导致的）
• stacking使用多次的CV会比较稳健

代码示例

回归问题的融合

1）简单加权平均 ，结果直接融合

#生成一些简单的样本数据，test_prei 代表第i个模型的预测值
test_pre1 = [1.2, 3.2, 2.1, 6.2]
test_pre2 = [0.9, 3.1, 2.0, 5.9]
test_pre3 = [1.1, 2.9, 2.2, 6.0]

#y_test_true 代表第模型的真实值
y_test_true = [1, 3, 2, 6] 

import numpy as np
import pandas as pd

#定义结果的加权平均函数
def Weighted_method(test_pre1,test_pre2,test_pre3,w=[1/3,1/3,1/3]):
    Weighted_result = w[0]*pd.Series(test_pre1)+w[1]*pd.Series(test_pre2)+w[2]*pd.Series(test_pre3)
    return Weighted_result

from sklearn import metrics
#各模型的预测结果计算MAE
print('Pred1 MAE:',metrics.mean_absolute_error(y_test_true, test_pre1))
print('Pred2 MAE:',metrics.mean_absolute_error(y_test_true, test_pre2))
print('Pred3 MAE:',metrics.mean_absolute_error(y_test_true, test_pre3))

各个模型的预测结果：
Pred1 MAE: 0.175
Pred2 MAE: 0.075
Pred3 MAE: 0.1

#根据加权计算MAE
w = [0.3,0.4,0.3] # 定义比重权值
Weighted_pre = Weighted_method(test_pre1,test_pre2,test_pre3,w)
print('Weighted_pre MAE:',metrics.mean_absolute_error(y_test_true, Weighted_pre))

加权计算结果为：
Weighted_pre MAE: 0.0575

可以发现加权结果相对于之前的结果是有提升的，这种我们称其为简单的加权平均。加权的时候可以根据单个模型的结果适当性的调整权值，比如本例中第二个模型的效果好一些，就可以适当将第二个模型的权重设置大一些，但是每个模型的权重差异不宜过大，比如0.8，0.1，0.1，差异过大一般模型融合效果不会很好。

还有一些特殊的形式，比如mean平均，median平均。

#定义结果的加权平均函数
def Mean_method(test_pre1,test_pre2,test_pre3):
    Mean_result = pd.concat([pd.Series(test_pre1),pd.Series(test_pre2),pd.Series(test_pre3)],axis=1).mean(axis=1)
    return Mean_result

Mean_pre = Mean_method(test_pre1,test_pre2,test_pre3)
print('Mean_pre MAE:',metrics.mean_absolute_error(y_test_true, Mean_pre))

Mean_pre MAE: 0.0666666666667

## 定义结果的加权平均函数
def Median_method(test_pre1,test_pre2,test_pre3):
    Median_result = pd.concat([pd.Series(test_pre1),pd.Series(test_pre2),pd.Series(test_pre3)],axis=1).median(axis=1)
    return Median_result

Median_pre = Median_method(test_pre1,test_pre2,test_pre3)
print('Median_pre MAE:',metrics.mean_absolute_error(y_test_true, Median_pre))

Median_pre MAE: 0.075
2)Stacking融合（回归）：

from sklearn import linear_model

def Stacking_method(train_reg1,train_reg2,train_reg3,y_train_true,test_pre1,test_pre2,test_pre3,model_L2= linear_model.LinearRegression()):
    model_L2.fit(pd.concat([pd.Series(train_reg1),pd.Series(train_reg2),pd.Series(train_reg3)],axis=1).values,y_train_true)
    Stacking_result = model_L2.predict(pd.concat([pd.Series(test_pre1),pd.Series(test_pre2),pd.Series(test_pre3)],axis=1).values)
    return Stacking_result

#生成一些简单的样本数据，test_prei 代表第i个模型的预测值
train_reg1 = [3.2, 8.2, 9.1, 5.2]
train_reg2 = [2.9, 8.1, 9.0, 4.9]
train_reg3 = [3.1, 7.9, 9.2, 5.0]
#y_test_true 代表第模型的真实值
y_train_true = [3, 8, 9, 5] 

test_pre1 = [1.2, 3.2, 2.1, 6.2]
test_pre2 = [0.9, 3.1, 2.0, 5.9]
test_pre3 = [1.1, 2.9, 2.2, 6.0]

#y_test_true 代表第模型的真实值
y_test_true = [1, 3, 2, 6] 

model_L2= linear_model.LinearRegression()
Stacking_pre = Stacking_method(train_reg1,train_reg2,train_reg3,y_train_true,
                               test_pre1,test_pre2,test_pre3,model_L2)
print('Stacking_pre MAE:',metrics.mean_absolute_error(y_test_true, Stacking_pre))

Stacking_pre MAE: 0.0421348314607
可以发现模型结果相对于之前有进一步的提升，这是我们需要注意的一点是，对于第二层Stacking的模型不宜选取的过于复杂，这样会导致模型在训练集上过拟合，从而使得在测试集上并不能达到很好的效果。
以上是最简单的stacking模型融合，没有涉及交叉验证这些。

分类模型融合

对于分类，同样的可以使用融合方法，比如简单投票，Stacking…

from sklearn.datasets import make_blobs
from sklearn import datasets
from sklearn.tree import DecisionTreeClassifier
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import VotingClassifier
from xgboost import XGBClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_moons
from sklearn.metrics import accuracy_score,roc_auc_score
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import StratifiedKFold

1)Voting投票机制：
Voting即投票机制，分为软投票和硬投票两种，其原理采用少数服从多数的思想。

• Hard Voting 与 Soft Voting 的对比

1. 使用方式
   • voting = ‘hard’：表示最终决策方式为 Hard Voting Classifier；
   • voting = ‘soft’：表示最终决策方式为 Soft Voting Classifier；
2. 思想
   • Hard Voting Classifier：根据少数服从多数来定最终结果；
   • Soft Voting Classifier：将所有模型预测样本为某一类别的概率的平均值作为标准，概率最高的对应的类型为最终的预测结果；

Hard Voting
模型 1：A - 99%、B - 1%，表示模型 1 认为该样本是 A 类型的概率为 99%，为 B 类型的概率为 1%；

Soft Voting
将所有模型预测样本为某一类别的概率的平均值作为标准；

Hard Voting 投票方式的弊端：
如上图，最终的分类结果不是由概率值更大的模型 1 和模型 4 决定，而是由概率值相对较低的模型 2/3/5 来决定的；
参考博客

'''
硬投票：对多个模型直接进行投票，不区分模型结果的相对重要度，最终投票数最多的类为最终被预测的类。
'''
iris = datasets.load_iris()

x=iris.data
y=iris.target
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3)

clf1 = XGBClassifier(learning_rate=0.1, n_estimators=150, max_depth=3, min_child_weight=2, subsample=0.7,
                     colsample_bytree=0.6, objective='binary:logistic')
clf2 = RandomForestClassifier(n_estimators=50, max_depth=1, min_samples_split=4,
                              min_samples_leaf=63,oob_score=True)
clf3 = SVC(C=0.1)

#硬投票
eclf = VotingClassifier(estimators=[('xgb', clf1), ('rf', clf2), ('svc', clf3)], voting='hard')
for clf, label in zip([clf1, clf2, clf3, eclf], ['XGBBoosting', 'Random Forest', 'SVM', 'Ensemble']):
    scores = cross_val_score(clf, x, y, cv=5, scoring='accuracy')
    print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))

Accuracy: 0.97 (+/- 0.02) [XGBBoosting]
Accuracy: 0.33 (+/- 0.00) [Random Forest]
Accuracy: 0.95 (+/- 0.03) [SVM]
Accuracy: 0.94 (+/- 0.04) [Ensemble]

'''
软投票：和硬投票原理相同，增加了设置权重的功能，可以为不同模型设置不同权重，进而区别模型不同的重要度。
'''
x=iris.data
y=iris.target
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.3)

clf1 = XGBClassifier(learning_rate=0.1, n_estimators=150, max_depth=3, min_child_weight=2, subsample=0.8,
                     colsample_bytree=0.8, objective='binary:logistic')
clf2 = RandomForestClassifier(n_estimators=50, max_depth=1, min_samples_split=4,
                              min_samples_leaf=63,oob_score=True)
clf3 = SVC(C=0.1, probability=True)

#软投票
eclf = VotingClassifier(estimators=[('xgb', clf1), ('rf', clf2), ('svc', clf3)], voting='soft', weights=[2, 1, 1])
clf1.fit(x_train, y_train)

for clf, label in zip([clf1, clf2, clf3, eclf], ['XGBBoosting', 'Random Forest', 'SVM', 'Ensemble']):
    scores = cross_val_score(clf, x, y, cv=5, scoring='accuracy')
    print("Accuracy: %0.2f (+/- %0.2f) [%s]" % (scores.mean(), scores.std(), label))

2)分类的Stacking\Blending融合
stacking是一种分层模型集成框架。
以两层为例，第一层由多个基学习器组成，其输入为原始训练集，第二层的模型则是以第一层基学习器的输出作为训练集进行再训练，从而得到完整的stacking模型, stacking两层模型都使用了全部的训练数据。

'''
5-Fold Stacking
'''
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier,GradientBoostingClassifier
import pandas as pd
#创建训练的数据集
data_0 = iris.data
data = data_0[:100,:]

target_0 = iris.target
target = target_0[:100]

#模型融合中使用到的各个单模型
clfs = [LogisticRegression(solver='lbfgs'),
       RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),
       ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),
       ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='entropy'),
       GradientBoostingClassifier(learning_rate=0.05, subsample=0.5, max_depth=6, n_estimators=5)]

#切分一部分数据作为测试集
X, X_predict, y, y_predict = train_test_split(data, target, test_size=0.3, random_state=2020)

dataset_blend_train = np.zeros((X.shape[0], len(clfs)))
dataset_blend_test = np.zeros((X_predict.shape[0], len(clfs)))


for j, clf in enumerate(clfs):
   #依次训练各个单模型
   
   #5折stacking
   n_splits = 5
   skf = StratifiedKFold(n_splits)
   skf = skf.split(X, y)
   dataset_blend_test_j = np.zeros((X_predict.shape[0], 5))
   for i, (train, test) in enumerate(skf):
       #5-Fold交叉训练，使用第i个部分作为预测，剩余的部分来训练模型，获得其预测的输出作为第i部分的新特征。
       X_train, y_train, X_test, y_test = X[train], y[train], X[test], y[test]
       clf.fit(X_train, y_train)
       y_submission = clf.predict_proba(X_test)[:, 1]
       dataset_blend_train[test, j] = y_submission
       dataset_blend_test_j[:, i] = clf.predict_proba(X_predict)[:, 1]
   #对于测试集，直接用这k个模型的预测值均值作为新的特征。
   dataset_blend_test[:, j] = dataset_blend_test_j.mean(1)
   print("val auc Score: %f" % roc_auc_score(y_predict, dataset_blend_test[:, j]))

clf = LogisticRegression(solver='lbfgs')
clf.fit(dataset_blend_train, y)
y_submission = clf.predict_proba(dataset_blend_test)[:, 1]

print("Val auc Score of Stacking: %f" % (roc_auc_score(y_predict, y_submission)))

val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
Val auc Score of Blending: 1.000000

'''
Blending
'''
 
#创建训练的数据集
#创建训练的数据集
data_0 = iris.data
data = data_0[:100,:]

target_0 = iris.target
target = target_0[:100]
 
#模型融合中使用到的各个单模型
clfs = [LogisticRegression(solver='lbfgs'),
        RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),
        RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='entropy'),
        ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),
        #ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='entropy'),
        GradientBoostingClassifier(learning_rate=0.05, subsample=0.5, max_depth=6, n_estimators=5)]
 
#切分一部分数据作为测试集
X, X_predict, y, y_predict = train_test_split(data, target, test_size=0.3, random_state=2020)

#切分训练数据集为d1,d2两部分
X_d1, X_d2, y_d1, y_d2 = train_test_split(X, y, test_size=0.5, random_state=2020)
dataset_d1 = np.zeros((X_d2.shape[0], len(clfs)))
dataset_d2 = np.zeros((X_predict.shape[0], len(clfs)))
 
for j, clf in enumerate(clfs):
    #依次训练各个单模型
    clf.fit(X_d1, y_d1)
    y_submission = clf.predict_proba(X_d2)[:, 1]
    dataset_d1[:, j] = y_submission
    #对于测试集，直接用这k个模型的预测值作为新的特征。
    dataset_d2[:, j] = clf.predict_proba(X_predict)[:, 1]
    print("val auc Score: %f" % roc_auc_score(y_predict, dataset_d2[:, j]))

#融合使用的模型
clf = GradientBoostingClassifier(learning_rate=0.02, subsample=0.5, max_depth=6, n_estimators=30)
clf.fit(dataset_d1, y_d2)
y_submission = clf.predict_proba(dataset_d2)[:, 1]
print("Val auc Score of Blending: %f" % (roc_auc_score(y_predict, y_submission)))

val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
val auc Score: 1.000000
Val auc Score of Blending: 1.000000
3)分类的Stacking融合(利用mlxtend)：

!pip install mlxtend

import warnings
warnings.filterwarnings('ignore')
import itertools
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec

from sklearn import datasets
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB 
from sklearn.ensemble import RandomForestClassifier
from mlxtend.classifier import StackingClassifier

from sklearn.model_selection import cross_val_score
from mlxtend.plotting import plot_learning_curves
from mlxtend.plotting import plot_decision_regions

# 以python自带的鸢尾花数据集为例
iris = datasets.load_iris()
X, y = iris.data[:, 1:3], iris.target

clf1 = KNeighborsClassifier(n_neighbors=1)
clf2 = RandomForestClassifier(random_state=1)
clf3 = GaussianNB()
lr = LogisticRegression()
sclf = StackingClassifier(classifiers=[clf1, clf2, clf3], 
                          meta_classifier=lr)

label = ['KNN', 'Random Forest', 'Naive Bayes', 'Stacking Classifier']
clf_list = [clf1, clf2, clf3, sclf]

fig = plt.figure(figsize=(10,8))
gs = gridspec.GridSpec(2, 2)
grid = itertools.product([0,1],repeat=2)

clf_cv_mean = []
clf_cv_std = []
for clf, label, grd in zip(clf_list, label, grid):
        
    scores = cross_val_score(clf, X, y, cv=3, scoring='accuracy')
    print("Accuracy: %.2f (+/- %.2f) [%s]" %(scores.mean(), scores.std(), label))
    clf_cv_mean.append(scores.mean())
    clf_cv_std.append(scores.std())
        
    clf.fit(X, y)
    ax = plt.subplot(gs[grd[0], grd[1]])
    fig = plot_decision_regions(X=X, y=y, clf=clf)
    plt.title(label)

plt.show()

Accuracy: 0.91 (+/- 0.01) [KNN]
Accuracy: 0.95 (+/- 0.01) [Random Forest]
Accuracy: 0.91 (+/- 0.02) [Naive Bayes]
Accuracy: 0.95 (+/- 0.02) [Stacking Classifier]

其他一些方法:

将特征放进模型中预测，并将预测结果变换并作为新的特征加入原有特征中再经过模型预测结果 （Stacking变化）
（可以反复预测多次将结果加入最后的特征中）

def Ensemble_add_feature(train,test,target,clfs):
    
    # n_flods = 5
    # skf = list(StratifiedKFold(y, n_folds=n_flods))

    train_ = np.zeros((train.shape[0],len(clfs*2)))
    test_ = np.zeros((test.shape[0],len(clfs*2)))

    for j,clf in enumerate(clfs):
        '''依次训练各个单模型'''
        # print(j, clf)
        '''使用第1个部分作为预测，第2部分来训练模型，获得其预测的输出作为第2部分的新特征。'''
        # X_train, y_train, X_test, y_test = X[train], y[train], X[test], y[test]

        clf.fit(train,target)
        y_train = clf.predict(train)
        y_test = clf.predict(test)

        ## 新特征生成
        train_[:,j*2] = y_train**2
        test_[:,j*2] = y_test**2
        train_[:, j+1] = np.exp(y_train)
        test_[:, j+1] = np.exp(y_test)
        # print("val auc Score: %f" % r2_score(y_predict, dataset_d2[:, j]))
        print('Method ',j)
    
    train_ = pd.DataFrame(train_)
    test_ = pd.DataFrame(test_)
    return train_,test_

from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.linear_model import LogisticRegression
clf = LogisticRegression()

data_0 = iris.data
data = data_0[:100,:]

target_0 = iris.target
target = target_0[:100]

x_train,x_test,y_train,y_test=train_test_split(data,target,test_size=0.3)
x_train = pd.DataFrame(x_train) ; x_test = pd.DataFrame(x_test)

#模型融合中使用到的各个单模型
clfs = [LogisticRegression(),
        RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),
        ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='gini'),
        ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='entropy'),
        GradientBoostingClassifier(learning_rate=0.05, subsample=0.5, max_depth=6, n_estimators=5)]

New_train,New_test = Ensemble_add_feature(x_train,x_test,y_train,clfs)

clf = LogisticRegression()
#clf = GradientBoostingClassifier(learning_rate=0.02, subsample=0.5, max_depth=6, n_estimators=30)
clf.fit(New_train, y_train)
y_emb = clf.predict_proba(New_test)[:, 1]

print("Val auc Score of stacking: %f" % (roc_auc_score(y_test, y_emb)))

Method 0
Method 1
Method 2
Method 3
Method 4
Val auc Score of stacking: 1.000000

本示例中的一些知识补充

sklearn中predict()与predict_proba()用法区别

predict是训练后返回的预测结果，是标签值。

predict_proba返回的是一个 n 行 k 列的数组， 第 i 行 第 j 列上的数值是模型预测 第 i 个样本为某个标签的概率，并且每一行的概率和为1。

#conding :utf-8  

from sklearn.linear_model import LogisticRegression  
import numpy as np  
x_train = np.array([[1,2,3],  
                    [1,3,4],  
                    [2,1,2],  
                    [4,5,6],  
                    [3,5,3],  
                    [1,7,2]])  
  
y_train = np.array([3, 3, 3, 2, 2, 2])  
  
x_test = np.array([[2,2,2],  
                   [3,2,6],  
                   [1,7,4]])  
  
clf = LogisticRegression()  
clf.fit(x_train, y_train)  
  
#返回预测标签  
print(clf.predict(x_test))  

#返回预测属于某标签的概率  
print(clf.predict_proba(x_test))  

predict的输出结果为[2 3 2]
predict_proba的输出结果为
[[0.56651809 0.43348191]
[0.15598162 0.84401838]
[0.86852502 0.13147498]]

分析结果：
预测[2,2,2]的标签是2的概率为0.56651809，3的概率为0.43348191
预测[3,2,6]的标签是2的概率为0.15598162，3的概率为0.84401838
预测[1,7,4]的标签是2的概率为0.86852502，3的概率为0.13147498

sklearn中的KFold、StratifiedKFold k折交叉切分的区别

sklearn中的Kfold和StratifiedKFold都是k折交叉切分。

但是StratifiedKFold是分层采样，确保训练集，测试集中各类别样本的比例与原始数据集中相同。

import numpy as np 
from sklearn.model_selection import KFold,StratifiedKFold
 
X=np.array([
    [1,2,3,4],
    [11,12,13,14],
    [21,22,23,24],
    [31,32,33,34],
    [41,42,43,44],
    [51,52,53,54],
    [61,62,63,64],
    [71,72,73,74]
])
 
y=np.array([1,1,0,0,1,1,0,0])
#n_folds这个参数没有，引入的包不同，
floder = KFold(n_splits=4,random_state=0,shuffle=False)
sfolder = StratifiedKFold(n_splits=4,random_state=0,shuffle=False)
 
for train, test in sfolder.split(X,y):
    print('Train: %s | test: %s' % (train, test))
    print(" ")
 
for train, test in floder.split(X,y):
    print('Train: %s | test: %s' % (train, test))

结果是：
1.
Train: [1 3 4 5 6 7] | test: [0 2]

Train: [0 2 4 5 6 7] | test: [1 3]

Train: [0 1 2 3 5 7] | test: [4 6]

Train: [0 1 2 3 4 6] | test: [5 7]

Train: [2 3 4 5 6 7] | test: [0 1]

Train: [0 1 4 5 6 7] | test: [2 3]

Train: [0 1 2 3 6 7] | test: [4 5]

Train: [0 1 2 3 4 5] | test: [6 7]
分析：可以看到StratifiedKFold 分层采样交叉切分，确保训练集，测试集中各类别样本的比例与原始数据集中相同。

AUC值的含义与计算方法

roc_auc_score
AUC的全称是Area under the Curve of ROC，也就是ROC曲线下方的面积。这里出现了另一个概念，就是ROC曲线。那么ROC曲线是个什么东西呢？我们参看下维基百科上的定义：在信号检测理论中，接收者操作特征曲线（receiver operating characteristic curve，或者叫ROC曲线）是一种坐标图式的分析工具，用于 (1) 选择最佳的信号侦测模型、舍弃次佳的模型。 (2) 在同一模型中设定最佳阈值。这个概念最早是由二战中的电子工程师和雷达工程师发明的，用来侦测战场上的敌军载具。概括来说，可以把ROC曲线理解为一种用于统计分析的图表工具。
那么具体到机器学习的理论中，ROC曲线该怎么理解呢？首先，需要指出的是，ROC分析的是二元分类模型，也就是输出结果只有两种类别的模型，比如：（阳性/阴性）（有病/没病）（垃圾邮件/非垃圾邮件）。在二分类问题中，数据的标签通常用（0/1）来表示，在模型训练完成后进行测试时，会对测试集的每个样本计算一个介于0~1之间的概率，表征模型认为该样本为阳性的概率，我们可以选定一个阈值，将模型计算出的概率进行二值化，比如选定阈值=0.5，那么当模型输出的值大于等于0.5时，我们就认为模型将该样本预测为阳性，也就是标签为1，反之亦然。选定的阈值不同，模型预测的结果也会相应地改变。二元分类模型的单个样本预测有四种结果：
1.真阳性（TP）：判断为阳性，实际也是阳性。
2.伪阳性（FP）：判断为阳性，实际却是阴性。
3.真阴性（TN）：判断为阴性，实际也是阴性。
4.伪阴性（FN）：判断为阴性，实际却是阳性。

二阶混淆矩阵

有了混淆矩阵，就可以定义ROC曲线了。ROC曲线将假阳性率（FPR）定义为 X 轴，真阳性率（TPR）定义为 Y 轴。其中：

• TPR：在所有实际为阳性的样本中，被正确地判断为阳性的样本比率。
• FPR：在所有实际为阴性的样本中，被错误地判断为阳性的样本比率。
• TPR = TP / (TP + FN)
• FPR = FP / (FP + TN)
  给定一个二分类模型和它的阈值，就可以根据所有测试集样本点的真实值和预测值计算出一个 (X=FPR, Y=TPR) 坐标点，这也就是绘制单个点的方法。那整条ROC曲线又该怎么画呢？具体方法如下：

在我们训练完一个二分类模型后，可以使用该模型对测试集中的全部样本点计算一个对应的概率值，每个值都介于0~1之间。假设测试集有100个样本点，我们可以对这100个样本的预测值从高到低排序，然后依次取每个值作为阈值，一旦阈值确定我们就可以绘制ROC曲线上的一个点，按照这种方法依次将100个点绘制出来，再将各个点依次连接起来，就得到了我们想要的ROC曲线！

然后再回到最初的问题，AUC值其实就是ROC曲线下方所覆盖的面积，当我们绘制出ROC曲线之后，AUC的值自然也就计算好啦。
示例

这里引用上海交大张伟楠老师机器学习课件中的例子来说明：

AUC计算示例

如上图所示，我们有8个测试样本，模型的预测值（按大小排序）和样本的真实标签如右表所示，绘制ROC曲线的整个过程如下所示：

令阈值等于第一个预测值0.91，所有大于等于0.91的预测值都被判定为阳性，此时TPR=1/4，FPR=0/4，所有我们有了第一个点（0.0，0.25）
令阈值等于第二个预测值0.85，所有大于等于0.85的预测值都被判定为阳性，这种情况下第二个样本属于被错误预测为阳性的阴性样本，也就是FP，所以TPR=1/4，FPR=1/4，所以我们有了第二个点（0.25，0.25）
按照这种方法依次取第三、四…个预测值作为阈值，就能依次得到ROC曲线上的坐标点（0.5，0.25）、（0.75，0.25）…（1.0，1.0）
将各个点依次连接起来，就得到了如图所示的ROC曲线
计算ROC曲线下方的面积为0.75，即AUC=0.75

看到这里的小伙伴们是不是对AUC值的概念有了更好的理解呢。总的来说，AUC值就是一个用来评价二分类模型优劣的常用指标，AUC值越高通常表明模型的效果越好，在实际使用中我们可以借助软件包的相应函数进行快速计算。

经验总结

比赛的融合这个问题，个人的看法来说其实涉及多个层面，也是提分和提升模型鲁棒性的一种重要方法：

• 结果层面的融合，这种是最常见的融合方法，其可行的融合方法也有很多，比如根据结果的得分进行加权融合，还可以做Log，exp处理等。在做结果融合的时候，有一个很重要的条件是模型结果的得分要比较近似，然后结果的差异要比较大，这样的结果融合往往有比较好的效果提升。
• 特征层面的融合，这个层面其实感觉不叫融合，准确说可以叫分割，很多时候如果我们用同种模型训练，可以把特征进行切分给不同的模型，然后在后面进行模型或者结果融合有时也能产生比较好的效果。
• 模型层面的融合，模型层面的融合可能就涉及模型的堆叠和设计，比如加Staking层，部分模型的结果作为特征输入等，这些就需要多实验和思考了，基于模型层面的融合最好不同模型类型要有一定的差异，用同种模型不同的参数的收益一般是比较小的。