一寂拆、模型融合的方式主要是有三種：
1.bagging (隨機森林模型是基于bagging融合的代表)
2.boosting （GBDT和XGboost模型是基于boosting融合的代表）
3.stacking
此三種方法主要是從模型角度講解如何進行集成學習（ensembling learning）惭聂，但是我們參加kaggle炮温、天池類的比賽火脉，常說的模型融合方法不是指這些，主要指的是一些將不同的結(jié)果融合以提高分數(shù)的技巧柒啤。
二倦挂、下面對常用的模型融合技巧進行介紹：
1.回歸（分類概率）
算術(shù)平均融合（Arithmetic mean），幾何平均融合入（Geometric mean）
平均法
此方法顯然是針對回歸問題設計的担巩。就是對多個結(jié)果求平均值方援。
平均法存在問題就是如果不同回歸方法的預測結(jié)果波動幅度相差比較大，那么波動小的回歸結(jié)果在融合時候起的作用就比較小涛癌。因此我們可以進行 Rank Averaging 將回歸的值進行排序犯戏，然后利用均勻分布進行打分。
小例子如下：
Id,Prediction
1,0.35000056
2,0.35000002
3,0.35000098
4,0.35000111
先將結(jié)果排序：
Id,Rank,Prediction
1,1,0.35000056
2,0,0.35000002
3,2,0.35000098
4,3,0.35000111
再進行打分：
Id,Prediction
1,0.33
2,0.0
3,0.66
4,1.0
2.分類
投票（Voting）
此方法比較簡單拳话，就是我們常見的投票機制先匪，少數(shù)服從多數(shù)，針對分類模型使用弃衍。
下面這個例子簡單明了的說明了呀非，為什么不相關(guān)的分類器投票融合效果會增加。假設我們有單個正確率為70%的三個互不相關(guān)的分類器镜盯。然后我們進行投票:
全部正確： 0.7 * 0.7 * 0.7 = 0.3429
兩個正確： 0.7 * 0.7 * 0.3 + 0.7 * 0.3 * 0.7 + 0.3 * 0.7 * 0.7 = 0.4409
一個正確： 0.3 * 0.3 * 0.7 + 0.3 * 0.7 * 0.3 + 0.7 * 0.3 * 0.3 = 0.189
全部爭劝度埂： 0.3 * 0.3 * 0.3 = 0.027
可以發(fā)現(xiàn)我們投票后產(chǎn)生的正確率大約為78%(0.3429 + 0.4409 = 0.7838)
從上面的例子也可以看出用來投票的基分類器基本是越多越好的。
同時基分類器越不相關(guān)融合效果越好速缆，這也是比較容易理解哥桥，大家彼此都一樣了，融合當然不會有效果了激涤。
除了公平的進行投票外拟糕，我們也可以設置投票的權(quán)重，越好的分類器權(quán)重越高倦踢。形象的理解就是說一些相對弱的分類器只有聯(lián)合的足夠多才能夠打敗一個好的分類器從而影響最后結(jié)果送滞。
3.綜合
排序融合（Rank averaging），log融合
三辱挥、代碼示例：
1犁嗅、回歸\分類概率-融合：
1）簡單加權(quán)平均，結(jié)果直接融合
生成一些簡單的樣本數(shù)據(jù)晤碘，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
定義結(jié)果的加權(quán)平均函數(shù)
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
各模型的預測結(jié)果計算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
根據(jù)加權(quán)計算MAE
w = [0.3,0.4,0.3] # 定義比重權(quán)值
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
可以發(fā)現(xiàn)加權(quán)結(jié)果相對于之前的結(jié)果是有提升的褂微，這種我們稱其為簡單的加權(quán)平均功蜓。
還有一些特殊的形式，比如mean平均宠蚂，median平均
定義結(jié)果的加權(quán)平均函數(shù)
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
定義結(jié)果的加權(quán)平均函數(shù)
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
生成一些簡單的樣本數(shù)據(jù)式撼，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
可以發(fā)現(xiàn)模型結(jié)果相對于之前有進一步的提升，這是我們需要注意的一點是求厕，對于第二層Stacking的模型不宜選取的過于復雜著隆，這樣會導致模型在訓練集上過擬合，從而使得在測試集上并不能達到很好的效果呀癣。
2.分類模型融合：
對于分類美浦，同樣的可以使用融合方法，比如簡單投票项栏，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即投票機制浦辨，分為軟投票和硬投票兩種，其原理采用少數(shù)服從多數(shù)的思想沼沈。
'''
硬投票：對多個模型直接進行投票荤牍，不區(qū)分模型結(jié)果的相對重要度，最終投票數(shù)最多的類為最終被預測的類庆冕。
'''
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]
'''
軟投票：和硬投票原理相同，增加了設置權(quán)重的功能劈榨，可以為不同模型設置不同權(quán)重访递，進而區(qū)別模型不同的重要度。
'''
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))
Accuracy: 0.96 (+/- 0.02) [XGBBoosting]
Accuracy: 0.33 (+/- 0.00) [Random Forest]
Accuracy: 0.95 (+/- 0.03) [SVM]
Accuracy: 0.96 (+/- 0.02) [Ensemble]
2）分類的Stacking\Blending融合：
stacking是一種分層模型集成框架同辣。
以兩層為例拷姿，第一層由多個基學習器組成，其輸入為原始訓練集旱函，第二層的模型則是以第一層基學習器的輸出作為訓練集進行再訓練响巢，從而得到完整的stacking模型, stacking兩層模型都使用了全部的訓練數(shù)據(jù)。
'''
5-Fold Stacking
'''
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier,GradientBoostingClassifier
import pandas as pd
創(chuàng)建訓練的數(shù)據(jù)集
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)]
切分一部分數(shù)據(jù)作為測試集
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)))
5折stacking
n_splits = 5
skf = StratifiedKFold(n_splits)
skf = skf.split(X, y)
for j, clf in enumerate(clfs):
#依次訓練各個單模型
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: 0.500000
val auc Score: 0.500000
val auc Score: 0.500000
val auc Score: 0.500000
Val auc Score of Stacking: 1.000000
Blending纷纫，其實和Stacking是一種類似的多層模型融合的形式
其主要思路是把原始的訓練集先分成兩部分枕扫，比如70%的數(shù)據(jù)作為新的訓練集，剩下30%的數(shù)據(jù)作為測試集辱魁。
在第一層烟瞧，我們在這70%的數(shù)據(jù)上訓練多個模型诗鸭，然后去預測那30%數(shù)據(jù)的label，同時也預測test集的label参滴。
在第二層强岸，我們就直接用這30%數(shù)據(jù)在第一層預測的結(jié)果做為新特征繼續(xù)訓練，然后用test集第一層預測的label做特征卵洗，用第二層訓練的模型做進一步預測
其優(yōu)點在于：
1.比stacking簡單（因為不用進行k次的交叉驗證來獲得stacker feature）
2.避開了一個信息泄露問題：generlizers和stacker使用了不一樣的數(shù)據(jù)集
缺點在于：
1.使用了很少的數(shù)據(jù)（第二階段的blender只使用training set10%的量）
2.blender可能會過擬合
3.stacking使用多次的交叉驗證會比較穩(wěn)健 '''
'''
Blending
'''
創(chuàng)建訓練的數(shù)據(jù)集
創(chuàng)建訓練的數(shù)據(jù)集
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)]
切分一部分數(shù)據(jù)作為測試集
X, X_predict, y, y_predict = train_test_split(data, target, test_size=0.3, random_state=2020)
切分訓練數(shù)據(jù)集為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自帶的鳶尾花數(shù)據(jù)集為例
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()
可以發(fā)現(xiàn) 基模型 用 'KNN', 'Random Forest', 'Naive Bayes' 然后再這基礎上 次級模型加一個 'LogisticRegression'，模型測試效果有著很好的提升。
3替久、經(jīng)驗總結(jié)
比賽的融合這個問題诲泌，個人的看法來說其實涉及多個層面，也是提分和提升模型魯棒性的一種重要方法：
1）結(jié)果層面的融合磕谅，這種是最常見的融合方法，其可行的融合方法也有很多，比如根據(jù)結(jié)果的得分進行加權(quán)融合甚亭，還可以做Log，exp處理等击胜。在做結(jié)果融合的時候亏狰，有一個很重要的條件是模型結(jié)果的得分要比較近似，然后結(jié)果的差異要比較大偶摔，這樣的結(jié)果融合往往有比較好的效果提升暇唾。
2）特征層面的融合，這個層面其實感覺不叫融合辰斋，準確說可以叫分割策州，很多時候如果我們用同種模型訓練，可以把特征進行切分給不同的模型宫仗，然后在后面進行模型或者結(jié)果融合有時也能產(chǎn)生比較好的效果够挂。
3）模型層面的融合，模型層面的融合可能就涉及模型的堆疊和設計藕夫，比如加Staking層孽糖，部分模型的結(jié)果作為特征輸入等，這些就需要多實驗和思考了毅贮，基于模型層面的融合最好不同模型類型要有一定的差異梭姓，用同種模型不同的參數(shù)的收益一般是比較小的。
參考鏈接：
https://github.com/datawhalechina/team-learning/blob/master/%E6%95%B0%E6%8D%AE%E6%8C%96%E6%8E%98%E5%AE%9E%E8%B7%B5%EF%BC%88%E4%BA%8C%E6%89%8B%E8%BD%A6%E4%BB%B7%E6%A0%BC%E9%A2%84%E6%B5%8B%EF%BC%89/Task5%20%E6%A8%A1%E5%9E%8B%E8%9E%8D%E5%90%88.md#1voting%E6%8A%95%E7%A5%A8%E6%9C%BA%E5%88%B6
https://blog.csdn.net/Noob_daniel/article/details/76087829
