零基础入门数据挖掘Task05

最新推荐文章于 2022-01-03 14:42:35 发布

编程浪子~

最新推荐文章于 2022-01-03 14:42:35 发布

阅读量116

点赞数

本文链接：https://blog.csdn.net/m0_37744662/article/details/105316198

版权

模型融合

简单加权融合

对于回归任务来说，可以训练出不同的模型，然后在将每个模型预测出来的结果进行加权平均。
根据各个模型的最终预测表现分配不同的权重以改变其对最终结果影响的大小。对于正确率低的模型给予更低的权重，而正确率更高的模型给予更高的权重。

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

这种加权融合是在结果层面进行的，还有一些其他的方式，比如直接取平均。

## 定义结果的加权平均函数
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)
	return Mean_resul

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

在分类任务中，进行模型结果层面的融合可以使用投票机制，即利用少数服从多数的原理，选择最多的那个分类。

'''
硬投票：对多个模型直接进行投票，不区分模型结果的相对重要度，最终投票数最多的类为最终被预测的类。
'''
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, subsampl
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))

'''
软投票：和硬投票原理相同，增加了设置权重的功能，可以为不同模型设置不同权重，进而区别模型不同的重要度
'''
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, subsampl
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', weig
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))

stacking

简单来说stacking 就是当用初始训练数据学习出若干个基学习器后，将这几个学习器的预测结果作为新的训练集，来学习一个新的学习器。
在这里插入图片描述
从上图中可以看出，图中使用相同的数据集训练了几个不同的分类器，然后用不同分类器预测出的结果作为下一个分类器的训练集。
在stacking方法中，我们把个体学习器叫做初级学习器，用于结合的学习器叫做次级学习器或元学习器（metalearner），次级学习器用于训练的数据叫做次级训练集。次级训练集是在训练集上用初级学习器得到的。

Stacking本质上就是这么直接的思路，但是直接这样有时对于如果训练集和测试集分布不那么一致的情况下是有一点问题的，其问题在于用初始模型训练的标签再利用真实标签进行再训练，毫无疑问会导致一定的模型过拟合训练集，这样或许模型在测试集上的泛化能力或者说效果会有一定的下降，因此现在的问题变成了如何降低再训练的过拟合性，这里我们一般有两种方法。

次级模型尽量选择简单的线性模型
利用K折交叉验证

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

bagging

采用的是随机有放回的选择训练数据然后构造分类器，最后进行组合。Bagging方法中基学习器之间不存在强依赖关系，且同时生成并行运行。
首先有放回抽样，抽取K个大小相同的训练数据集然后用K个训练集训练K个模型最后对得到的K个模型预测结果，并将结果进行融合。
由于进行有放回的随机抽样，所以抽取出的训练集不会包含全部的数据。

boosting

Boosting是一种将各种弱分类器串联起来的集成学习方式，每一个分类器的训练都依赖于前一个分类器的结果，顺序运行的方式导致了运行速度慢。
Boosting会根据训练的效果来改变样本的权重，对分错的样本给予较大的权重，对分对的样本给予较小的权重。
Boosting家族里面有代表的像AdaBoost， GBDT， xgboost， lightgbm等，但是这些模型虽然都是串联集成多个弱分类器但是之间还是有区别的，又可以分成AdaBoost流派和GBDT流派，比如AdaBoost，在引入M2的时候，其实它关注的是M1预测不好的那些样本，这些样本如果M2在训练的时候，就会加大权重。后面的模型引入也都是这个道理，即关注前面模型预测不好的那些样本。而GBDT，包括后面的xgboost这些，他们是更加聚焦于残差，即M2引入的时候，它关注的是M1的预测结果与标准结果之间的那个差距，它想减少的是这个差距，后面的模型引入也是这个道理，即关注前面模型预测结果与标准答案之间的差距，然后一步一步的进行缩小。

一些其他方法

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

def Ensemble_add_feature(train,test,target,clfs):
	train_ = np.zeros((train.shape[0],len(clfs*2)))
	test_ = np.zeros((test.shape[0],len(clfs*2)))
	for j,clf in enumerate(clfs):
		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)
	train_ = pd.DataFrame(train_)
    	test_ = pd.DataFrame(test_)
    	return train_,test_

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.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)))

编程浪子~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
零基础入门数据挖掘Task05

模型融合简单加权融合对于回归任务来说，可以训练出不同的模型，然后在将每个模型预测出来的结果进行加权平均。根据各个模型的最终预测表现分配不同的权重以改变其对最终结果影响的大小。对于正确率低的模型给予更低的权重，而正确率更高的模型给予更高的权重。from sklearn import metrics# 各模型的预测结果计算MAEprint('Pred1 MAE:',metrics.mean...
复制链接

扫一扫