金融风控之贷款违约预测挑战赛 Task5

1、导入数据 略

2、查看数据 略

3、特征工程 略

4、建模与调参 略

5、模型融合

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

#直接平均
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

## 中位数平均
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

5.2 Voting法

原理，每一个算法，计算的方法都不相同，对于同一个问题，就会有不同的结果。假设算法间相互独立，正确率都为70%，那么投票结果的正确率为0.7×0.7×0.7+0.7×0.7×(1-0.7)×3=0.784
sklearn中VotingClassifier可以实现投票法，有hard/soft两种。投票法需要注意选用的模型中如果出现大的偏差，会导致整体出现偏差。

hard voting soft voting

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, probability=True)  # 软投票的时候，probability必须指定且为true

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

5.3 Boosting和Bagging

Boosting家族里面有代表的像AdaBoost， GBDT， xgboost， lightgbm等。又可以分成AdaBoost流派和GBDT流派。
AdaBoost，在引入M2的时候，其实它关注的是M1预测不好的那些样本， 这些样本如果M2在训练的时候，就会加大权重。即关注前面模型预测不好的那些样本。
GBDT，包括后面的xgboost这些，他们是更加聚焦于残差，即M2引入的时候，它关注的是M1的预测结果与标准结果之间的那个差距， 它想减少的是这个差距。关注前面模型预测结果与标准答案之间的差距，然后一步一步的进行缩小。
xgb和lgb：XGBoost是拟合数据残差，并用泰勒展开式（二阶泰勒展开式）对模型损失残差的近似，同时在损失函数上添加了正则化项。 lgb的话和xgboost的原理是一样的，只不过又在模型的训练速度上进行了优化，采用了直方图的决策树算法使得收敛更快。

Bagging是Bootstrap Aggregating的缩写，与Boosting方法中各分类器之间的相互依赖和串行运行不同，基学习器之间不存在强依赖关系，且同时生成并行运行。

5.4 Stacking/Blending构建多层模型

Stacking模型的本质是一种分层的结构，用了大量的基分类器，将其预测的结果作为下一层输入的特征，这样的结构使得它比相互独立训练模型能够获得更多的特征。

stacking
回归中的Stacking

StackingCVRegressor（regressors，meta_regressor，cv = 5，shuffle = True，use_features_in_secondary = False）
regressors: 基回归器，列表的形式，第一层的模型， 比如在这个比赛中，我打算第一层用xgb和lgb，第二层用线性模型， 那我这里就应该这么写[xgb, lgb], 当然这些模型是事先定义好。
meta_regressor: 元回归器， 这个可以理解为第二层的那个模型，即将前面回归器结果合起来的那个回归器，这里我使用lr，因为第二层的模型不要太复杂
cv: 交叉验证策略， 默认是5折交叉验证，不明白的可以看一下上面的原理图
use_features_in_secondary: 默认是false， 意思是第二层的回归器只接收第一层回归器的结果进行训练和预测， 和我们上面介绍的原理样，如果设置为true，意思是第二层的回归器不仅接收第一层回归器的结果，还接收原始的数据集一块进行训练。
shuffle： 如果设置为true， 则在交叉验证之前的训练数据将在拟合阶段打乱顺序。
方法：
依然是.fit(x,y)进行训练， 但这里的x和y要求是数组了， 所以如果是DataFrame， 需要np.array()一下。并且X的shape[n_samples, n_features], y的shape, [n_samples]
预测依然是.redict(x_test), 只不过这里的x_test依然是数组， 形状和上面的一样。

def bulid_modl_xgb(x_train, y_train):
    model = XGBRegressor(n_estimators=400, learning_rate=0.05, gamma=0, subsample=0.8, colsample_bytree=0.9, max_depth=7)
    model.fit(x_train, y_train)
    return model

def bulid_modl_lgb(x_train, y_train):
    model = LGBMRegressor(n_estimators=1100, leaves=200, learning_rate=0.05, objective='regression_l1')
    model.fit(x_train, y_train)
    return model

def build_model_stackReg(x_train, y_train, xgb, lgb, lr):
    model = StackingCVRegressor(regressors=(xgb, lgb), meta_regressor=lr)
    model.fit(np.array(x_train), np.array(y_train))
    return model

xgb = XGBRegressor(n_estimators=4000, learning_rate=0.05, gamma=0, subsample=0.8, colsample_bytree=0.9, max_depth=7)
lgb = LGBMRegressor(n_estimators=11000, leaves=200, learning_rate=0.05, objective='regression_l1')
lr = LinearRegression()
model_stack = build_model_stackReg(X, Y_ln, xgb, lgb, lr)
val_stack = model_stack.predict(np.array(XTest))

分类中的stacking

StackingClassifier(classifiers, meta_classifier, use_probas=False, average_probas=False, verbose=0, use_features_in_secondary=False)， 这里的参数和上面的StackingCVRegressor基本上差不多
classifiers: 基分类器， 数组形式[clf1, clf2, clf3], 每个基分类器的属性被存储在类属性 self.clfs_.
meta_classifier: 目标分类器，即将前面分类器合起来的分类器
use_probas : bool (default: False) ，如果设置为True， 那么目标分类器的输入就是前面分类输出的类别概率值而不是类别标签
average_probas : bool (default: False)，用来设置上一个参数当使用概率值输出的时候是否使用平均值。
verbose : int, optional (default=0)。用来控制使用过程中的日志输出，当 verbose = 0时，什么也不输出， verbose = 1，输出回归器的序号和名字。verbose = 2，输出详细的参数信息。verbose > 2, 自动将verbose设置为小于2的，
use_features_in_secondary : bool (default: False). 如果设置为True，那么最终的目标分类器就被基分类器产生的数据和最初的数据集同时训练。如果设置为False，最终的分类器只会使用基分类器产生的数据训练。
方法： .fit(), .predict()常用

from mlxtend.classifier import StackingCVClassifier
# 上面的这个操作，如果换成StackingClassifier， 是这样的形式：
clf1 = RandomForestClassifier(n_estimators=5, n_jobs=-1, criterion='gini')
clf2 = ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='gini')
clf3 = ExtraTreesClassifier(n_estimators=5, n_jobs=-1, criterion='entropy')
clf4 = GradientBoostingClassifier(learning_rate=0.05, subsample=0.5, max_depth=6, n_estimators=5)
clf5 = LogisticRegression(solver='lbfgs')

sclf = StackingCVClassifier(classifiers=[clf1, clf2, clf3, clf4], meta_classifier=clf, cv=3)
sclf.fit(X, y)
# 5这交叉验证
#scores = cross_val_score(sclf, X, y, cv=3, scoring='accuracy')

y_submission = sclf.predict(X_predict)

Blending将数据分为训练集和Holdout集（留出集）进行训练。没有实现好的工具，得需要自己写。
Blending的优势在于：

• Blending比较简单，而Stacking相对比较复杂；
• 能够防止信息泄露：generalizers和stackers使用不同的数据；
• Stacking实际使用时，需要耗费的时间非常长

而缺点在于：

• 只用了整体数据的一部分；
• 最终模型可能对留出集（holdout set）过拟合；
• Stacking多次交叉验证要更加稳健。

5.5 结果

本次比赛的数据集比较大，无论是voting还是stacking都没有完成，方法已经整理，过后选用小数据集再做尝试。