數據競賽（五）-模型融合

sklearn 交叉驗證

K折交叉驗證：

sklearn.model_selection.KFold(n_splits=3, shuffle=False, random_state=None)

思路：將訓練/測試數據集劃分n_splits個互斥子集，每次用其中一個子集當作驗證集，剩下的n_splits-1個作爲訓練集，進行n_splits次訓練和測試，得到n_splits個結果

注意點：對於不能均等份的數據集，其前n_samples % n_splits子集擁有n_samples // n_splits + 1個樣本，其餘子集都只有n_samples // n_splits樣本

參數說明：

n_splits：表示劃分幾等份

shuffle：在每次劃分時，是否進行洗牌

①若爲Falses時，其效果等同於random_state等於整數，每次劃分的結果相同

②若爲True時，每次劃分的結果都不一樣，表示經過洗牌，隨機取樣的

random_state：隨機種子數

屬性：

①get_n_splits(X=None, y=None, groups=None)：獲取參數n_splits的值

②split(X, y=None, groups=None)：將數據集劃分成訓練集和測試集，返回索引生成器

通過一個不能均等劃分的栗子，設置不同參數值，觀察其結果

①設置shuffle=False，運行兩次，發現兩次結果相同

from mlxtend.classifier import StackingClassifier
sclf = StackingClassifier(classifiers=[lgb], meta_classifier=xgb_model)
sclf_score=sclf.fit(train,target)
test_predict=sclf.predict(test)

from sklearn.metrics import r2_score
def online_score(pred):
    print("預測結果最大值：{},預測結果最小值：{}".format(pred.max(),pred.min()))
    # a榜測分
    conmbine1 = pd.read_csv(r'C:\Users\lxc\Desktop\featurecup\sub_b_919.csv',engine = "python",header=None)
    score1 = r2_score(pred, conmbine1)
    print("對比919分數:{}".format(score1))
score = online_score(test_predict)



預測結果最大值：19051.067151217972,預測結果最小值：1199.97082591554
對比919分數:0.981891385946527

Stacking

#!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, train_test_split
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()

Blending

Blending方法是區別於bagging和boosting的另一種集成模型的方法。
在已經得到多個弱學習器的狀況下，如何將這些弱學習器的預測值聯合起來，得到更好的預測值，就是Blending做的事情。

def blend(train,test,target):
    '''5折'''
    # n_flods = 5
    # skf = list(StratifiedKFold(y, n_folds=n_flods))
    '''切分訓練數據集爲d1,d2兩部分'''
    X_d1, X_d2, y_d1, y_d2 = train_test_split(train, target, test_size=0.5, random_state=914)

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

    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]
        X_d1fillna=X_d1.fillna(0)
        X_d2fillna = X_d2.fillna(0)

        X_predictfillna= test.fillna(0)

        clf.fit(X_d1fillna,y_d1)
        y_submission = clf.predict(X_d2fillna)
        y_test_submission = clf.predict(X_predictfillna)

        train_[:,j*3] = y_submission*y_submission
        '''對於測試集，直接用這k個模型的預測值作爲新的特徵。'''
        test_[:, j*3] = y_test_submission*y_test_submission

        train_[:, j+1] =(y_submission - y_submission.min()) /(y_submission.max() - y_submission.min())
        '''對於測試集，直接用這k個模型的預測值作爲新的特徵。'''
        y_test_submission = (y_test_submission - y_test_submission.min()) / \
                            (y_test_submission.max() - y_test_submission.min())
        test_[:, j+1] = y_test_submission

        train_[:, j+2] = np.log(y_submission)
        '''對於測試集，直接用這k個模型的預測值作爲新的特徵。'''
        y_test_submission =np.log(y_test_submission)
        test_[:, j+2] = y_test_submission



        # print("val auc Score: %f" % r2_score(y_predict, dataset_d2[:, j]))
        print('已完成第',j)

    train_.to_csv('./input/train_blending.csv', index=False)
    test_.to_csv('./input/test_blending.csv', index=False)