Datawhale第17期组队学习（零基础入门金融风控）Task04：建模与调参

模型的选择多种多样，以下是贴了一些算法原理的网页，可以仔细学习。

1. 逻辑回归模型 https://blog.csdn.net/han_xiaoyang/article/details/49123419
2. 决策树模型 https://blog.csdn.net/c406495762/article/details/76262487
3. GBDT模型 https://zhuanlan.zhihu.com/p/45145899
4. XGBoost模型 https://blog.csdn.net/wuzhongqiang/article/details/104854890
5. LightGBM模型 https://blog.csdn.net/wuzhongqiang/article/details/105350579
6. Catboost模型 https://mp.weixin.qq.com/s/xloTLr5NJBgBspMQtxPoFA

7. 时间序列模型(选学)

   RNN：https://zhuanlan.zhihu.com/p/45289691

   LSTM：https://zhuanlan.zhihu.com/p/83496936

8. 推荐教材： 《机器学习》 https://book.douban.com/subject/26708119/

   《统计学习方法》 https://book.douban.com/subject/10590856/

   《面向机器学习的特征工程》 https://book.douban.com/subject/26826639/

   《信用评分模型技术与应用》https://book.douban.com/subject/1488075/

   《数据化风控》https://book.douban.com/subject/30282558

抛砖引玉用lgb的方法做一次建模的baseline

• 建模前的预处理

from sklearn.model_selection import KFold
# 分离数据集，方便进行交叉验证
X_train = data.loc[data['sample']=='train', :].drop(['id','issueDate','isDefault',
'sample'], axis=1)
X_test = data.loc[data['sample']=='test', :].drop(['id','issueDate','isDefault', 'sample'],
axis=1)
y_train = data.loc[data['sample']=='train', 'isDefault']
# 5折交叉验证
folds = 5
seed = 2020
kf = KFold(n_splits=folds, shuffle=True, random_state=seed)

• 使用lightgbm建模

from sklearn.model_selection import train_test_split
import lightgbm as lgb
# 数据集划分
X_train_split, X_val, y_train_split, y_val = train_test_split(X_train, y_train,
test_size=0.2)
train_matrix = lgb.Dataset(X_train_split, label=y_train_split)
valid_matrix = lgb.Dataset(X_val, label=y_val)

params = {
'boosting_type': 'gbdt',
'objective': 'binary',
'learning_rate': 0.1,
'metric': 'auc',
'min_child_weight': 1e-3,
'num_leaves': 31,
'max_depth': -1,
'reg_lambda': 0,
'reg_alpha': 0,
'feature_fraction': 1,
'bagging_fraction': 1,
'bagging_freq': 0,
'seed': 2020,
'nthread': 8,
'silent': True,
'verbose': -1,
}

"""使用训练集数据进行模型训练"""
model = lgb.train(params, train_set=train_matrix, valid_sets=valid_matrix,
num_boost_round=20000, verbose_eval=1000, early_stopping_rounds=200)

• 对验证集test预测

from sklearn import metrics
from sklearn.metrics import roc_auc_score

"""预测并计算roc的相关指标"""

val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration)
fpr, tpr, threshold = metrics.roc_curve(y_val, val_pre_lgb)
roc_auc = metrics.auc(fpr, tpr)
print('未调参前lightgbm单模型在验证集上的AUC：{}'.format(roc_auc))

• 接下来就是要对模型调参来说明

一般的调参方法有三种：贪心算法、网格搜索、贝叶斯调参。

1. 贪心算法

   贪心算法是先使用当前对模型影响最大的参数进行调优，达到当前参数下的模型最优化，再使用对模型影响次之的参数进行调优，如此下去，直到所有的参数调整完毕。

   这个方法的缺点就是可能会调到局部最优而不是全局最优，但是只需要一步一步的进行参数最优化调试即可，容易理解。 需要注意的是在树模型中参数调整的顺序，也就是各个参数对模型的影响程度，这里列举一下日常调参过程中常用的参数和调参顺序：

   ①：max_depth、num_leaves

   ②：min_data_in_leaf、min_child_weight

   ③：bagging_fraction、 feature_fraction、bagging_freq

   ④：reg_lambda、reg_alpha 

   ⑤：min_split_gain

2. 网格搜索

   sklearn 提供GridSearchCV用于进行网格搜索，只需要把模型的参数输进去，就能给出最优化的结果和参数。相比起贪心调参，网格搜索的结果会更优，但是网格搜索只适合于小数据集，一旦数据的量级上去了，很难得出结果。

3. 贝叶斯调参

   贝叶斯调参的主要思想是：给定优化的目标函数(广义的函数，只需指定输入和输出即可，无需知道内部结构以及数学性质)，通过不断地添加样本点来更新目标函数的后验分布(高斯过程,直到后验分布基本贴合于真实分布）。

   简单的说，就是考虑了上一次参数的信息，从而更好的调整当前的参数。

   贝叶斯调参的步骤如下：

   1. 定义优化函数(rf_cv）

   2. 建立模型

   3. 定义待优化的参数

   4. 得到优化结果，并返回要优化的分数指标

这里主要用了贝叶斯调参来做

首先定义优化函数

from sklearn.model_selection import cross_val_score
"""定义优化函数"""
def rf_cv_lgb(num_leaves, max_depth, bagging_fraction, feature_fraction, bagging_freq,
min_data_in_leaf,
min_child_weight, min_split_gain, reg_lambda, reg_alpha):
# 建立模型
    model_lgb = lgb.LGBMClassifier(boosting_type='gbdt', bjective='binary', metric='auc',
                                    learning_rate=0.1, n_estimators=5000,
                                    num_leaves=int(num_leaves), max_depth=int(max_depth),
                                    bagging_fraction=round(bagging_fraction, 2),
                                    feature_fraction=round(feature_fraction, 2),
                                    bagging_freq=int(bagging_freq),
                                    min_data_in_leaf=int(min_data_in_leaf),
                                    min_child_weight=min_child_weight,
                                    min_split_gain=min_split_gain,
                                    reg_lambda=reg_lambda, reg_alpha=reg_alpha,
                                    n_jobs= 8
                                    )
    val = cross_val_score(model_lgb, X_train_split, y_train_split, cv=5,scoring='roc_auc').mean()

return val

from bayes_opt import BayesianOptimization
"""定义优化参数"""
bayes_lgb = BayesianOptimization(
    rf_cv_lgb,
    {
    'num_leaves':(10, 200),
    'max_depth':(3, 20),
    'bagging_fraction':(0.5, 1.0),
    'feature_fraction':(0.5, 1.0),
    'bagging_freq':(0, 100),
    'min_data_in_leaf':(10,100),
    'min_child_weight':(0, 10),
    'min_split_gain':(0.0, 1.0),
    'reg_alpha':(0.0, 10),
    'reg_lambda':(0.0, 10),
    }
)

"""开始优化"""
bayes_lgb.maximize(n_iter=10)

最后打印出最优结果

print(bayes_lgb.max)

然后就能使用调参后的数据进行学习预测了