二手車交易價格預測-Task5 模型融合

五、模型融合

Tip:此部分為零基礎入門數據挖掘的 Task5 模型融合 部分，帶你來了解各種模型結果的融合方式，在比賽的攻堅時刻沖刺Top，歡迎大家后續多多交流。

賽題：零基礎入門數據挖掘 - 二手車交易價格預測

地址：https://tianchi.aliyun.com/competition/entrance/231784/introduction?spm=5176.12281957.1004.1.38b02448ausjSX

5.1 模型融合目標

• 對于多種調參完成的模型進行模型融合。

• 完成對于多種模型的融合，提交融合結果并打卡。

5.2 內容介紹

模型融合是比賽后期一個重要的環節，大體來說有如下的類型方式。

簡單加權融合:

• 回歸（分類概率）：算術平均融合（Arithmetic mean），幾何平均融合（Geometric mean）；
• 分類：投票（Voting)
• 綜合：排序融合(Rank averaging)，log融合

stacking/blending:

• 構建多層模型，并利用預測結果再擬合預測。

boosting/bagging（在xgboost，Adaboost,GBDT中已經用到）:

• 多樹的提升方法

5.3 Stacking相關理論介紹

1) 什么是 stacking

簡單來說 stacking 就是當用初始訓練數據學習出若干個基學習器后，將這幾個學習器的預測結果作為新的訓練集，來學習一個新的學習器。

將個體學習器結合在一起的時候使用的方法叫做結合策略。對于分類問題，我們可以使用投票法來選擇輸出最多的類。對于回歸問題，我們可以將分類器輸出的結果求平均值。

上面說的投票法和平均法都是很有效的結合策略，還有一種結合策略是使用另外一個機器學習算法來將個體機器學習器的結果結合在一起，這個方法就是Stacking。

在stacking方法中，我們把個體學習器叫做初級學習器，用于結合的學習器叫做次級學習器或元學習器（meta-learner），次級學習器用于訓練的數據叫做次級訓練集。次級訓練集是在訓練集上用初級學習器得到的。

2) 如何進行 stacking

算法示意圖如下：

引用自 西瓜書《機器學習》

• 過程1-3 是訓練出來個體學習器，也就是初級學習器。
• 過程5-9是 使用訓練出來的個體學習器來得預測的結果，這個預測的結果當做次級學習器的訓練集。
• 過程11 是用初級學習器預測的結果訓練出次級學習器，得到我們最后訓練的模型。

3）Stacking的方法講解

首先，我們先從一種“不那么正確”但是容易懂的Stacking方法講起。

Stacking模型本質上是一種分層的結構，這里簡單起見，只分析二級Stacking.假設我們有2個基模型 Model1_1、Model1_2 和 一個次級模型Model2

Step 1. 基模型 Model1_1，對訓練集train訓練，然后用于預測 train 和 test 的標簽列，分別是P1，T1

訓練后的模型 Model1_1 分別在 train 和 test 上預測，得到預測標簽分別是P1，T1

Step 2. 基模型 Model1_2 ，對訓練集train訓練，然后用于預測train和test的標簽列，分別是P2，T2

訓練后的模型 Model1_2 分別在 train 和 test 上預測，得到預測標簽分別是P2，T2

Step 3. 分別把P1,P2以及T1,T2合并，得到一個新的訓練集和測試集train2,test2.

再用 次級模型 Model2 以真實訓練集標簽為標簽訓練,以train2為特征進行訓練，預測test2,得到最終的測試集預測的標簽列 $Y_{Pre}$。

這就是我們兩層堆疊的一種基本的原始思路想法。在不同模型預測的結果基礎上再加一層模型，進行再訓練，從而得到模型最終的預測。

Stacking本質上就是這么直接的思路，但是直接這樣有時對于如果訓練集和測試集分布不那么一致的情況下是有一點問題的，其問題在于用初始模型訓練的標簽再利用真實標簽進行再訓練，毫無疑問會導致一定的模型過擬合訓練集，這樣或許模型在測試集上的泛化能力或者說效果會有一定的下降，因此現在的問題變成了如何降低再訓練的過擬合性，這里我們一般有兩種方法。

• 次級模型盡量選擇簡單的線性模型
• 利用K折交叉驗證

K-折交叉驗證：
訓練：

預測：

5.4 代碼示例

5.4.1 回歸\分類概率-融合：

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

可以發現加權結果相對于之前的結果是有提升的，這種我們稱其為簡單的加權平均。

還有一些特殊的形式，比如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_modeldef 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的模型不宜選取的過于復雜，這樣會導致模型在訓練集上過擬合，從而使得在測試集上并不能達到很好的效果。

5.4.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即投票機制，分為軟投票和硬投票兩種，其原理采用少數服從多數的思想。

''' 硬投票：對多個模型直接進行投票，不區分模型結果的相對重要度，最終投票數最多的類為最終被預測的類。 ''' 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)) 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兩層模型都使用了全部的訓練數據。

''' 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)))#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_submissiondataset_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%的數據作為新的訓練集，剩下30%的數據作為測試集。

在第一層，我們在這70%的數據上訓練多個模型，然后去預測那30%數據的label，同時也預測test集的label。

在第二層，我們就直接用這30%數據在第一層預測的結果做為新特征繼續訓練，然后用test集第一層預測的label做特征，用第二層訓練的模型做進一步預測

其優點在于：

• 1.比stacking簡單（因為不用進行k次的交叉驗證來獲得stacker feature）
• 2.避開了一個信息泄露問題：generlizers和stacker使用了不一樣的數據集

缺點在于：

• 1.使用了很少的數據（第二階段的blender只使用training set10%的量）
• 2.blender可能會過擬合
• 3.stacking使用多次的交叉驗證會比較穩健
  ‘’’

''' 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

參考博客：https://blog.csdn.net/Noob_daniel/article/details/76087829

3）分類的Stacking融合(利用mlxtend)：

!pip install mlxtendimport warnings warnings.filterwarnings('ignore') import itertools import numpy as np import seaborn as sns import matplotlib.pyplot as plt import matplotlib.gridspec as gridspecfrom 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 StackingClassifierfrom 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.targetclf1 = 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()

可以發現 基模型 用 ‘KNN’, ‘Random Forest’, ‘Naive Bayes’ 然后再這基礎上 次級模型加一個 ‘LogisticRegression’，模型測試效果有著很好的提升。

5.4.3 一些其它方法：

將特征放進模型中預測，并將預測結果變換并作為新的特征加入原有特征中再經過模型預測結果 （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**2test_[:,j*2] = y_test**2train_[:, 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

5.4.4 本賽題示例

import pandas as pd import numpy as np import warnings import matplotlib import matplotlib.pyplot as plt import seaborn as snswarnings.filterwarnings('ignore') %matplotlib inlineimport itertools 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_regionsfrom sklearn.model_selection import StratifiedKFold from sklearn.model_selection import train_test_splitfrom sklearn import linear_model from sklearn import preprocessing from sklearn.svm import SVR from sklearn.decomposition import PCA,FastICA,FactorAnalysis,SparsePCAimport lightgbm as lgb import xgboost as xgb from sklearn.model_selection import GridSearchCV,cross_val_score from sklearn.ensemble import RandomForestRegressor,GradientBoostingRegressorfrom sklearn.metrics import mean_squared_error, mean_absolute_error ## 數據讀取 Train_data = pd.read_csv('datalab/231784/used_car_train_20200313.csv', sep=' ') TestA_data = pd.read_csv('datalab/231784/used_car_testA_20200313.csv', sep=' ')print(Train_data.shape) print(TestA_data.shape) (150000, 31) (50000, 30) Train_data.head() SaleIDnameregDatemodelbrandbodyTypefuelTypegearboxpowerkilometer...v_5v_6v_7v_8v_9v_10v_11v_12v_13v_1401234

0	736	20040402	30.0	6	1.0	0.0	0.0	60	12.5	...	0.235676	0.101988	0.129549	0.022816	0.097462	-2.881803	2.804097	-2.420821	0.795292	0.914762
1	2262	20030301	40.0	1	2.0	0.0	0.0	0	15.0	...	0.264777	0.121004	0.135731	0.026597	0.020582	-4.900482	2.096338	-1.030483	-1.722674	0.245522
2	14874	20040403	115.0	15	1.0	0.0	0.0	163	12.5	...	0.251410	0.114912	0.165147	0.062173	0.027075	-4.846749	1.803559	1.565330	-0.832687	-0.229963
3	71865	19960908	109.0	10	0.0	0.0	1.0	193	15.0	...	0.274293	0.110300	0.121964	0.033395	0.000000	-4.509599	1.285940	-0.501868	-2.438353	-0.478699
4	111080	20120103	110.0	5	1.0	0.0	0.0	68	5.0	...	0.228036	0.073205	0.091880	0.078819	0.121534	-1.896240	0.910783	0.931110	2.834518	1.923482

5 rows × 31 columns

numerical_cols = Train_data.select_dtypes(exclude = 'object').columns print(numerical_cols) Index(['SaleID', 'name', 'regDate', 'model', 'brand', 'bodyType', 'fuelType','gearbox', 'power', 'kilometer', 'regionCode', 'seller', 'offerType','creatDate', 'price', 'v_0', 'v_1', 'v_2', 'v_3', 'v_4', 'v_5', 'v_6','v_7', 'v_8', 'v_9', 'v_10', 'v_11', 'v_12', 'v_13', 'v_14'],dtype='object') feature_cols = [col for col in numerical_cols if col not in ['SaleID','name','regDate','price']] X_data = Train_data[feature_cols] Y_data = Train_data['price']X_test = TestA_data[feature_cols]print('X train shape:',X_data.shape) print('X test shape:',X_test.shape) X train shape: (150000, 26) X test shape: (50000, 26) def Sta_inf(data):print('_min',np.min(data))print('_max:',np.max(data))print('_mean',np.mean(data))print('_ptp',np.ptp(data))print('_std',np.std(data))print('_var',np.var(data)) print('Sta of label:') Sta_inf(Y_data) Sta of label: _min 11 _max: 99999 _mean 5923.32733333 _ptp 99988 _std 7501.97346988 _var 56279605.9427 X_data = X_data.fillna(-1) X_test = X_test.fillna(-1) def build_model_lr(x_train,y_train):reg_model = linear_model.LinearRegression()reg_model.fit(x_train,y_train)return reg_modeldef build_model_ridge(x_train,y_train):reg_model = linear_model.Ridge(alpha=0.8)#alphas=range(1,100,5)reg_model.fit(x_train,y_train)return reg_modeldef build_model_lasso(x_train,y_train):reg_model = linear_model.LassoCV()reg_model.fit(x_train,y_train)return reg_modeldef build_model_gbdt(x_train,y_train):estimator =GradientBoostingRegressor(loss='ls',subsample= 0.85,max_depth= 5,n_estimators = 100)param_grid = { 'learning_rate': [0.05,0.08,0.1,0.2],}gbdt = GridSearchCV(estimator, param_grid,cv=3)gbdt.fit(x_train,y_train)print(gbdt.best_params_)# print(gbdt.best_estimator_ )return gbdtdef build_model_xgb(x_train,y_train):model = xgb.XGBRegressor(n_estimators=120, learning_rate=0.08, gamma=0, subsample=0.8,\colsample_bytree=0.9, max_depth=5) #, objective ='reg:squarederror'model.fit(x_train, y_train)return modeldef build_model_lgb(x_train,y_train):estimator = lgb.LGBMRegressor(num_leaves=63,n_estimators = 100)param_grid = {'learning_rate': [0.01, 0.05, 0.1],}gbm = GridSearchCV(estimator, param_grid)gbm.fit(x_train, y_train)return gbm

2）XGBoost的五折交叉回歸驗證實現

## xgb xgr = xgb.XGBRegressor(n_estimators=120, learning_rate=0.1, subsample=0.8,\colsample_bytree=0.9, max_depth=7) # ,objective ='reg:squarederror'scores_train = [] scores = []## 5折交叉驗證方式 sk=StratifiedKFold(n_splits=5,shuffle=True,random_state=0) for train_ind,val_ind in sk.split(X_data,Y_data):train_x=X_data.iloc[train_ind].valuestrain_y=Y_data.iloc[train_ind]val_x=X_data.iloc[val_ind].valuesval_y=Y_data.iloc[val_ind]xgr.fit(train_x,train_y)pred_train_xgb=xgr.predict(train_x)pred_xgb=xgr.predict(val_x)score_train = mean_absolute_error(train_y,pred_train_xgb)scores_train.append(score_train)score = mean_absolute_error(val_y,pred_xgb)scores.append(score)print('Train mae:',np.mean(score_train)) print('Val mae',np.mean(scores)) Train mae: 558.212360169 Val mae 693.120168439

3）劃分數據集，并用多種方法訓練和預測

## Split data with val x_train,x_val,y_train,y_val = train_test_split(X_data,Y_data,test_size=0.3)## Train and Predict print('Predict LR...') model_lr = build_model_lr(x_train,y_train) val_lr = model_lr.predict(x_val) subA_lr = model_lr.predict(X_test)print('Predict Ridge...') model_ridge = build_model_ridge(x_train,y_train) val_ridge = model_ridge.predict(x_val) subA_ridge = model_ridge.predict(X_test)print('Predict Lasso...') model_lasso = build_model_lasso(x_train,y_train) val_lasso = model_lasso.predict(x_val) subA_lasso = model_lasso.predict(X_test)print('Predict GBDT...') model_gbdt = build_model_gbdt(x_train,y_train) val_gbdt = model_gbdt.predict(x_val) subA_gbdt = model_gbdt.predict(X_test) Predict LR... Predict Ridge... Predict Lasso... Predict GBDT... {'learning_rate': 0.1, 'n_estimators': 80}

一般比賽中效果最為顯著的兩種方法

print('predict XGB...') model_xgb = build_model_xgb(x_train,y_train) val_xgb = model_xgb.predict(x_val) subA_xgb = model_xgb.predict(X_test)print('predict lgb...') model_lgb = build_model_lgb(x_train,y_train) val_lgb = model_lgb.predict(x_val) subA_lgb = model_lgb.predict(X_test) predict XGB... predict lgb... print('Sta inf of lgb:') Sta_inf(subA_lgb) Sta inf of lgb: _min -126.864734992 _max: 90152.4775557 _mean 5917.96632163 _ptp 90279.3422907 _std 7358.88582391 _var 54153200.5693

1）加權融合

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## Init the Weight w = [0.3,0.4,0.3]## 測試驗證集準確度 val_pre = Weighted_method(val_lgb,val_xgb,val_gbdt,w) MAE_Weighted = mean_absolute_error(y_val,val_pre) print('MAE of Weighted of val:',MAE_Weighted)## 預測數據部分 subA = Weighted_method(subA_lgb,subA_xgb,subA_gbdt,w) print('Sta inf:') Sta_inf(subA) ## 生成提交文件 sub = pd.DataFrame() sub['SaleID'] = X_test.index sub['price'] = subA sub.to_csv('./sub_Weighted.csv',index=False) MAE of Weighted of val: 730.877443666 Sta inf: _min -2816.93914153 _max: 88576.7842223 _mean 5920.38233546 _ptp 91393.7233639 _std 7325.20946801 _var 53658693.7502 ## 與簡單的LR（線性回歸）進行對比 val_lr_pred = model_lr.predict(x_val) MAE_lr = mean_absolute_error(y_val,val_lr_pred) print('MAE of lr:',MAE_lr) MAE of lr: 2597.45638384

2）Starking融合

## Starking## 第一層 train_lgb_pred = model_lgb.predict(x_train) train_xgb_pred = model_xgb.predict(x_train) train_gbdt_pred = model_gbdt.predict(x_train)Strak_X_train = pd.DataFrame() Strak_X_train['Method_1'] = train_lgb_pred Strak_X_train['Method_2'] = train_xgb_pred Strak_X_train['Method_3'] = train_gbdt_predStrak_X_val = pd.DataFrame() Strak_X_val['Method_1'] = val_lgb Strak_X_val['Method_2'] = val_xgb Strak_X_val['Method_3'] = val_gbdtStrak_X_test = pd.DataFrame() Strak_X_test['Method_1'] = subA_lgb Strak_X_test['Method_2'] = subA_xgb Strak_X_test['Method_3'] = subA_gbdt Strak_X_test.head() Method_1Method_2Method_301234

39682.037093	41029.078125	40552.596813
239.498371	266.032654	393.909761
6915.162439	7345.680664	7623.552178
11861.783785	11721.493164	11463.293245
583.773267	513.307983	520.665295

## level2-method model_lr_Stacking = build_model_lr(Strak_X_train,y_train) ## 訓練集 train_pre_Stacking = model_lr_Stacking.predict(Strak_X_train) print('MAE of Stacking-LR:',mean_absolute_error(y_train,train_pre_Stacking))## 驗證集 val_pre_Stacking = model_lr_Stacking.predict(Strak_X_val) print('MAE of Stacking-LR:',mean_absolute_error(y_val,val_pre_Stacking))## 預測集 print('Predict Stacking-LR...') subA_Stacking = model_lr_Stacking.predict(Strak_X_test) MAE of Stacking-LR: 628.399441036 MAE of Stacking-LR: 707.673951794 Predict Stacking-LR... subA_Stacking[subA_Stacking<10]=10 ## 去除過小的預測值sub = pd.DataFrame() sub['SaleID'] = X_test.index sub['price'] = subA_Stacking sub.to_csv('./sub_Stacking.csv',index=False) print('Sta inf:') Sta_inf(subA_Stacking) Sta inf: _min 10.0 _max: 90849.3729816 _mean 5917.39429976 _ptp 90839.3729816 _std 7396.09766172 _var 54702260.6217

3.4 經驗總結

比賽的融合這個問題，個人的看法來說其實涉及多個層面，也是提分和提升模型魯棒性的一種重要方法：

• 1）結果層面的融合，這種是最常見的融合方法，其可行的融合方法也有很多，比如根據結果的得分進行加權融合，還可以做Log，exp處理等。在做結果融合的時候，有一個很重要的條件是模型結果的得分要比較近似，然后結果的差異要比較大，這樣的結果融合往往有比較好的效果提升。

• 2）特征層面的融合，這個層面其實感覺不叫融合，準確說可以叫分割，很多時候如果我們用同種模型訓練，可以把特征進行切分給不同的模型，然后在后面進行模型或者結果融合有時也能產生比較好的效果。

• 3）模型層面的融合，模型層面的融合可能就涉及模型的堆疊和設計，比如加Staking層，部分模型的結果作為特征輸入等，這些就需要多實驗和思考了，基于模型層面的融合最好不同模型類型要有一定的差異，用同種模型不同的參數的收益一般是比較小的。

總結

以上是生活随笔為你收集整理的【算法竞赛学习】二手车交易价格预测-Task5模型融合的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。