python风控建模项目_风控——建模调参

Bagging与Boosting:

集成方法主要包括bagging与boosting，Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个更加强大的分类。两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果。常见的基于Baggin思想的集成模型有：随机森林、基于Boosting思想的集成模型有：Adaboost、GBDT、XgBoost、LightGBM等。

样本选择上： Bagging方法的训练集是从原始集中有放回的选取，所以从原始集中选出的各轮训练集之间是独立的；而Boosting方法需要每一轮的训练集不变，只是训练集中每个样本在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整

样例权重上： Bagging方法使用均匀取样，所以每个样本的权重相等；而Boosting方法根据错误率不断调整样本的权值，错误率越大则权重越大

预测函数上： Bagging方法中所有预测函数的权重相等；而Boosting方法中每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重

并行计算上： Bagging方法中各个预测函数可以并行生成；而Boosting方法各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。

模型评估方法：

模型评估的总体思想非常简单，就是用一部分样本去训练模型，用另一部分模型去评估。根据不同的做法，有以下三种方法：

1.留出法：

直接将数据集分为两个互斥的集合，其中一个作为训练集，另一个作为测试集，在划分时应该尽可能保持数据的一致性。

2.交叉验证法：

通常将数据集D分为k份，其中k-1份作为训练集，剩余的一份作为测试集，这样就可以获得k组训练/测试集，可以进行k次训练与测试，最终返回的是k个测试结果的均值。

3.自助法：

每次从数据集D中取一个样本作为训练集中的元素，然后把该样本放回，重复该行为m次，这样我们就可以得到大小为m的训练集，在这里面有的样本重复出现，有的样本则没有出现过，我们把那些没有出现过的样本作为测试集。

数据集划分总结

对于数据量充足的时候，通常采用留出法或者k折交叉验证法来进行训练/测试集的划分；

对于数据集小且难以有效划分训练/测试集时使用自助法；

对于数据集小且可有效划分的时候最好使用留一法来进行划分，因为这种方法最为准确

调参：

#读取数据

data = pd.read_csv('dataset/data_for_model.csv')

#减少占用内存

def reduce_mem_usage(df):

start_mem = df.memory_usage().sum()

print('Memory usage of dataframe is {:.2f} MB'.format(start_mem))

for col in df.columns:

col_type = df[col].dtype

if col_type != object:

c_min = df[col].min()

c_max = df[col].max()

if str(col_type)[:3] == 'int':

if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:

df[col] = df[col].astype(np.int8)

elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:

df[col] = df[col].astype(np.int16)

elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:

df[col] = df[col].astype(np.int32)

elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:

df[col] = df[col].astype(np.int64)

else:

if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:

df[col] = df[col].astype(np.float16)

elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:

df[col] = df[col].astype(np.float32)

else:

df[col] = df[col].astype(np.float64)

else:

df[col] = df[col].astype('category')

end_mem = df.memory_usage().sum()

print('Memory usage after optimization is: {:.2f} MB'.format(end_mem))

print('Decreased by {:.1f}%'.format(100 * (start_mem - end_mem) / start_mem))

return df

data = reduce_mem_usage(data)

#分离数据集

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)

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)

#五折交叉验证评估性能

import lightgbm as lgb

"""使用lightgbm 5折交叉验证进行建模预测"""

cv_scores = []

for i, (train_index, valid_index) in enumerate(kf.split(X_train, y_train)):

print('************************************ {} ************************************'.format(str(i+1)))

X_train_split, y_train_split, X_val, y_val = X_train.iloc[train_index], y_train[train_index], X_train.iloc[valid_index], y_train[valid_index]

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, num_boost_round=20000, valid_sets=valid_matrix, verbose_eval=1000, early_stopping_rounds=200)

val_pred = model.predict(X_val, num_iteration=model.best_iteration)

cv_scores.append(roc_auc_score(y_val, val_pred))

print(cv_scores)

print("lgb_scotrainre_list:{}".format(cv_scores))

print("lgb_score_mean:{}".format(np.mean(cv_scores)))

print("lgb_score_std:{}".format(np.std(cv_scores)))

调参方法主要分为贪心调参、网格搜索和贝叶斯调参，不得不说调参是非常耗费时间的一件事情，辣鸡电脑跑了十几个小时。

贪心调参：先使用当前对模型影响最大的参数进行调优，达到当前参数下的模型最优化，再使用对模型影响次之的参数进行调优，如此下去，直到所有的参数调整完毕。这个方法的缺点就是可能会调到局部最优而不是全局最优，但是只需要一步一步的进行参数最优化调试即可，容易理解。

网格搜索：把模型的参数输入后，就可以给出最优化的结果和参数，很费内存！！！！！

贝叶斯调参：给定优化的目标函数(广义的函数，只需指定输入和输出即可，无需知道内部结构以及数学性质)，通过不断地添加样本点来更新目标函数的后验分布(高斯过程,直到后验分布基本贴合于真实分布)。简单的说，就是考虑了上一次参数的信息，从而更好的调整当前的参数。这是我没有理解原理的一个内容。

原文链接:https://blog.csdn.net/m0_46388026/article/details/108781862