心跳信号分类预测Task04建模与调参
心跳信号分类预测Task04建模与调参
- 1. 学习目标
- 2.学习内容
- 3.模型原理
-
- 3.1 逻辑回归模型
- 3.2 决策树模型
- 3.3 GBDT模型
- 3.4 XGBoost模型
- 3.5 LightGBM模型
- 3.6 Catboost模型
- 3.7 时间序列模型
- 4 模型对比与性能评估
-
- 4.1 逻辑回归（核心是sigmoid函数）
- 4.2 决策树模型
- 4.3 集成模型集成方法（ensemble method）
- 4.4 模型评估方法
- 5.代码示例
-
- 5.1 导入包并读取数据
- 5.2 简单建模
- 5.3 模型调参
- 5.3.1 贝叶斯调参
- 5.3.2 贪心调参
- 5.3.3 网格搜索
本次学习利用天池实验室的GPU完成。
1. 学习目标
- 学习机器学习模型的建模过程与调参流程
2.学习内容
- 逻辑回归模型：
理解逻辑回归模型；
逻辑回归模型的应用；
逻辑回归的优缺点； - 树模型：
理解树模型；
树模型的应用；
树模型的优缺点； - 集成模型：
- 基于bagging思想的集成模型
随机森林模型 - 基于boosting思想的集成模型
XGBoost模型
LightGBM模型
CatBoost模型
- 基于bagging思想的集成模型
- 模型对比与性能评估：
回归模型/树模型/集成模型；
模型评估方法；
模型评价结果； - 模型调参：
贪心调参方法；
网格调参方法；
贝叶斯调参方法；
3.模型原理
由于该部分的原理过多，因此只给出了学习链接和自己的一些理解。
3.1 逻辑回归模型
逻辑回归
逻辑回归是对线性回归的一种改进。信号的分类预测问题实际上可以看作是对坐标系空间下的多个点进行划分，如下图中（a）利用线性模型可以对不同颜色的点进行二分类，但是实际经常存在如图（b）中的情况，简单的线性模型无法将实现分类，由此出现了逻辑回归模型。
逻辑回归模型能够将线性回归的结果映射为可以帮助判断和分类的结果，其核心是利用sigmoid函数增加模型的非线性，即预测函数由Y=WTX转换为Y= g(WTX)，其中：
逻辑回归的代价函数如下：
后面模型太多了。。以后再慢慢补充
3.2 决策树模型
决策树1
决策树2
3.3 GBDT模型
梯度提升树GBDT
3.4 XGBoost模型
白话机器学习算法理论+实战番外篇之XGBoost
3.5 LightGBM模型
白话机器学习算法理论+实战番外篇之LightGBM
3.6 Catboost模型
深入理解CatBoost
3.7 时间序列模型
深入理解RNN
长短期记忆网络LSTM
4 模型对比与性能评估
4.1 逻辑回归（核心是sigmoid函数）
- 优点
训练速度较快，分类的时候，计算量仅仅只和特征的数目相关；
简单易理解，模型的可解释性非常好，从特征的权重可以看到不同的特征对最后结果的影响；
适合二分类问题，不需要缩放输入特征；
内存资源占用小，只需要存储各个维度的特征值； - 缺点
逻辑回归需要预先处理缺失值和异常值【参考task3特征工程】；
不能用Logistic回归去解决非线性问题，因为Logistic的决策面是线性的；
对多重共线性数据较为敏感，且很难处理数据不平衡的问题；
准确率并不是很高，因为形式非常简单，很难去拟合数据的真实分布；
4.2 决策树模型
- 优点
简单直观，生成的决策树可以可视化展示
数据不需要预处理，不需要归一化，不需要处理缺失数据
既可以处理离散值，也可以处理连续值 - 缺点
决策树算法非常容易过拟合，导致泛化能力不强（可进行适当的剪枝）
采用的是贪心算法，容易得到局部最优解
4.3 集成模型集成方法（ensemble method）
通过集成方法，可以将多个弱学习器组合成一个强分类器，因此集成学习的泛化能力一般比单一分类器要好。
集成方法主要包括Bagging和Boosting，Bagging和Boosting都是将已有的分类或回归算法通过一定方式组合起来，形成一个更加强大的分类。两种方法都是把若干个分类器整合为一个分类器的方法，只是整合的方式不一样，最终得到不一样的效果。常见的基于Baggin思想的集成模型有：随机森林、基于Boosting思想的集成模型有：Adaboost、GBDT、XgBoost、LightGBM等。
Baggin和Boosting的区别总结如下：
样本选择上： Bagging方法的训练集是从原始集中有放回的选取，所以从原始集中选出的各轮训练集之间是独立的；而Boosting方法需要每一轮的训练集不变，只是训练集中每个样本在分类器中的权重发生变化。而权值是根据上一轮的分类结果进行调整
样例权重上： Bagging方法使用均匀取样，所以每个样本的权重相等；而Boosting方法根据错误率不断调整样本的权值，错误率越大则权重越大
预测函数上： Bagging方法中所有预测函数的权重相等；而Boosting方法中每个弱分类器都有相应的权重，对于分类误差小的分类器会有更大的权重
并行计算上： Bagging方法中各个预测函数可以并行生成；而Boosting方法各个预测函数只能顺序生成，因为后一个模型参数需要前一轮模型的结果。
4.4 模型评估方法
对于模型来说，其在训练集上面的误差被称之为训练误差或者经验误差，而在测试集上的误差称之为测试误差。
学习目标：通过对已有样本的学习，尽可能的学习所有潜在样本的普遍规律，而如果模型对训练样本学的太好，则有可能把训练样本自身所具有的一些特点当做所有潜在样本的普遍特点，这时候我们就会出现过拟合的问题。
因此通常将已有的数据集划分为训练集和测试集两部分，其中训练集用来训练模型，而测试集则是用来评估模型对于新样本的判别能力。
对于数据集的划分，通常要保证满足以下两个条件：
训练集和测试集的分布要与样本真实分布一致，即训练集和测试集都要保证是从样本真实分布中独立同分布采样而得；
训练集和测试集要互斥
对于数据集的划分有三种方法：留出法，交叉验证法和自助法，下面挨个介绍：
①留出法
留出法是直接将数据集D划分为两个互斥的集合，其中一个集合作为训练集S，另一个作为测试集T。需要注意的是在划分的时候要尽可能保证数据分布的一致性，即避免因数据划分过程引入额外的偏差而对最终结果产生影响。为了保证数据分布的一致性，通常我们采用分层采样的方式来对数据进行采样。
Tips： 通常，会将数据集D中大约2/3~4/5的样本作为训练集，其余的作为测试集。
②交叉验证法
k折交叉验证通常将数据集D分为k份，其中k-1份作为训练集，剩余的一份作为测试集，这样就可以获得k组训练/测试集，可以进行k次训练与测试，最终返回的是k个测试结果的均值。交叉验证中数据集的划分依然是依据分层采样的方式来进行。
对于交叉验证法，其k值的选取往往决定了评估结果的稳定性和保真性，通常k值选取10。
当k=1的时候，我们称之为留一法
③自助法
我们每次从数据集D中取一个样本作为训练集中的元素，然后把该样本放回，重复该行为m次，这样我们就可以得到大小为m的训练集，在这里面有的样本重复出现，有的样本则没有出现过，我们把那些没有出现过的样本作为测试集。
进行这样采样的原因是因为在D中约有36.8%的数据没有在训练集中出现过。留出法与交叉验证法都是使用分层采样的方式进行数据采样与划分，而自助法则是使用有放回重复采样的方式进行数据采样
数据集划分总结
- 对于数据量充足的时候，通常采用留出法或者k折交叉验证法来进行训练/测试集的划分；
- 对于数据集小且难以有效划分训练/测试集时使用自助法；
- 对于数据集小且可有效划分的时候最好使用留一法来进行划分，因为这种方法最为准确（留一法、交叉验证法区别）
5.代码示例
5.1 导入包并读取数据
首先导入相关包：
import pandas as pd
import numpy as np
from sklearn.metrics import f1_score
import os
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import KFold
import warnings
warnings.filterwarnings("ignore")
在天池GPU中安装sklearn和seaborn时遇到一些问题，总结在了上一篇博客里：天池实验室安装库时遇到的问题
定义函数reduce_mem_usage，用来调整数据类型，减少数据在内存中占用的空间。
有关代码中fifo的用法：np.fifo()
有关此函数的具体实现并没有细致的分析，但是大致思想是通过转换数据的类型来达到减少内存的目的（例如：如果数据类型是int32，但实际上数据比较小，用int8就可以存储，那么就转换一下数据类型，从而可以减少内存）
def reduce_mem_usage(df):
start_mem = df.memory_usage().sum() / 1024**2
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() / 1024**2
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 = pd.read_csv('train.csv')
对数据进行简单预处理，首先创建一个空的list，然后对于一条心电数据，分别将其id、heartbeat_signals以及label放到list的一行中，这样可以得到长度为10万的list。然后将填充得到的list转换为nparray，再将nparray转换为pandas的数据帧（参考：list、nparray、dataframe的互相转换）
# 简单预处理
data_list = []
for items in data.values:
data_list.append([items[0]] + [float(i) for i in items[1].split(',')] + [items[2]])
data = pd.DataFrame(np.array(data_list))
给组合后的data加上标题，即第一列为id，心电数据从s_0一直到s_204，最后标签列命名为label。然后利用上面构建的函数缩减一下data的尺寸（这一步其实是非必要的，但是如果内存不够的话，还是很有用的）。
data.columns = ['id'] + ['s_'+str(i) for i in range(len(data_list[0])-2)] + ['label']
data = reduce_mem_usage(data)
可以看到data由157.93MB缩减为39.67MB：
5.2 简单建模
该模型使用5折交叉验证来得到模型的测试准确率（KFold实际上是通过在全部数据中选择不同的数据作为验证集，并进行K次验证取平均值，可以达到更加准确的评估模型性能的目的，具体参见：KFold的用法），并且为了方便进行交叉验证，将数据集分离，即将data中的id和label丢掉，只留下有效信号作为训练数据，将label单独存储作为标签数据。
X_train = data.drop(['id','label'], axis=1)
y_train = data['label']
# 5折交叉验证
folds = 5
seed = 2021
kf = KFold(n_splits=folds, shuffle=True, random_state=seed)
自定义评价指标f1-score（机器学习中的f1-score），并在模型迭代中返回验证集f1-score变化情况。
def f1_score_vali(preds, data_vali):
labels = data_vali.get_label()
preds = np.argmax(preds.reshape(4, -1), axis=0)
score_vali = f1_score(y_true=labels, y_pred=preds, average='macro')
return 'f1_score', score_vali, True
使用前文提到的Lightgbm进行建模，并使用上述处理的数据进行模型训练，将X_train中的数据按照4：1的比例划分为训练集和验证集，params（lgb参数官方文档）中如learning_rate代表学习率，boosting为迭代次数，lambdal2的设置是为了改善过拟合，num_leaves为叶子最大数量，max_depth为树的最大深度，然后进行lgb模型训练：
"""对训练集数据进行划分，分成训练集和验证集，并进行相应的操作"""
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 = {
"learning_rate": 0.1,
"boosting": 'gbdt',
"lambda_l2": 0.1,
"max_depth": -1,
"num_leaves": 128,
"bagging_fraction": 0.8,
"feature_fraction": 0.8,
"metric": None,
"objective": "multiclass",
"num_class": 4,
"nthread": 10,
"verbose": -1,
}
"""使用训练集数据进行模型训练"""
model = lgb.train(params,
train_set=train_matrix,
valid_sets=valid_matrix,
num_boost_round=2000,
verbose_eval=50,
early_stopping_rounds=200,
feval=f1_score_vali)
可以看到在200次迭代范围内，效果最好的是第101次，此时验证集的loss为0.0417436，f1-score为0.96615：
使用上述训练的best_iteration对验证集进行预测：
val_pre_lgb = model.predict(X_val, num_iteration=model.best_iteration)
preds = np.argmax(val_pre_lgb, axis=1)
score = f1_score(y_true=y_val, y_pred=preds, average='macro')
print('未调参前lightgbm单模型在验证集上的f1：{}'.format(score))
可以看到，在未调参前验证集的f1为0.9662：
使用5折交叉验证进行模型性能评估：
"""使用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 = {
"learning_rate": 0.1,
"boosting": 'gbdt',
"lambda_l2": 0.1,
"max_depth": -1,
"num_leaves": 128,
"bagging_fraction": 0.8,
"feature_fraction": 0.8,
"metric": None,
"objective": "multiclass",
"num_class": 4,
"nthread": 10,
"verbose": -1,
}
model = lgb.train(params,
train_set=train_matrix,
valid_sets=valid_matrix,
num_boost_round=2000,
verbose_eval=100,
early_stopping_rounds=200,
feval=f1_score_vali)
val_pred = model.predict(X_val, num_iteration=model.best_iteration)
val_pred = np.argmax(val_pred, axis=1)
cv_scores.append(f1_score(y_true=y_val, y_pred=val_pred, average='macro'))
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)))
可以看到五折交叉验证的f1-score结果是0.9664：
5.3 模型调参
这里贪心调参和网格搜索都只是给了程序示例，实际上使用了贝叶斯调参，为了实现程序的连贯性，先介绍了贝叶斯调参。
5.3.1 贝叶斯调参
使用之前先安装包bayesian-optimization，同上述安装步骤一致。
贝叶斯调参的主要思想是：给定优化的目标函数(广义的函数，只需指定输入和输出即可，无需知道内部结构以及数学性质)，通过不断地添加样本点来更新目标函数的后验分布(高斯过程,直到后验分布基本贴合于真实分布）。简单的说，就是考虑了上一次参数的信息，从而更好的调整当前的参数。
贝叶斯调参的步骤如下：
- 定义优化函数(rf_cv）
- 建立模型
- 定义待优化的参数
- 得到优化结果，并返回要优化的分数指标
注意：这里给出的代码没有引用make_scorer和f1_score，如果不加上头文件就会报错。优化迭代15次：
from sklearn.model_selection import cross_val_score
from sklearn.metrics import make_scorer,f1_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', objective='multiclass', num_class=4,
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
)
f1 = make_scorer(f1_score, average='micro')
val = cross_val_score(model_lgb, X_train_split, y_train_split, cv=5, scoring=f1).mean()
return val
输出结果存在一堆Waring（？），这里给出最后一次的调参结果：
显示优化后的结果：
bayes_lgb.max
输出：
参数优化完成后，可以根据优化后的参数建立新的模型，降低学习率并寻找最优模型迭代次数：
"""调整一个较小的学习率，并通过cv函数确定当前最优的迭代次数"""
base_params_lgb = {
'boosting_type': 'gbdt',
'objective': 'multiclass',
'num_class': 4,
'learning_rate': 0.01,
'num_leaves': 138,
'max_depth': 11,
'min_data_in_leaf': 43,
'min_child_weight':6.5,
'bagging_fraction': 0.64,
'feature_fraction': 0.93,
'bagging_freq': 49,
'reg_lambda': 7,
'reg_alpha': 0.21,
'min_split_gain': 0.288,
'nthread': 10,
'verbose': -1,
}
cv_result_lgb = lgb.cv(
train_set=train_matrix,
early_stopping_rounds=1000,
num_boost_round=20000,
nfold=5,
stratified=True,
shuffle=True,
params=base_params_lgb,
feval=f1_score_vali,
seed=0
)
print('迭代次数{}'.format(len(cv_result_lgb['f1_score-mean'])))
print('最终模型的f1为{}'.format(max(cv_result_lgb['f1_score-mean'])))
输出：
即迭代次数4833，最终模型的f1为0.9616414521208757
确定好模型参数后，建立最终模型以对验证集进行验证：
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': 'multiclass',
'num_class': 4,
'learning_rate': 0.01,
'num_leaves': 138,
'max_depth': 11,
'min_data_in_leaf': 43,
'min_child_weight':6.5,
'bagging_fraction': 0.64,
'feature_fraction': 0.93,
'bagging_freq': 49,
'reg_lambda': 7,
'reg_alpha': 0.21,
'min_split_gain': 0.288,
'nthread': 10,
'verbose': -1,
}
model = lgb.train(params, train_set=train_matrix, num_boost_round=4833, valid_sets=valid_matrix,
verbose_eval=1000, early_stopping_rounds=200, feval=f1_score_vali)
val_pred = model.predict(X_val, num_iteration=model.best_iteration)
val_pred = np.argmax(val_pred, axis=1)
cv_scores.append(f1_score(y_true=y_val, y_pred=val_pred, average='macro'))
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)))
输出：
用建立好的模型预测一下测试集：
先读入测试集数据并进行简单的预处理（这部分其实应该在前面读取数据时候一起做）
test=pd.read_csv('testA.csv')
test_list=[]
for items in test.values:
test_list.append([items[0]] + [float(i) for i in items[1].split(',')])
test = pd.DataFrame(np.array(test_list))
test.columns = ['id'] + ['s_'+str(i) for i in range(len(test_list[0])-1)]
test = reduce_mem_usage(test)
x_test=test.drop(['id'], axis=1)
预测：
test_pred = model.predict(x_test, num_iteration=model.best_iteration)
把预测结果转换成pandas的dataframe形式：
temp=pd.DataFrame(test_pred)
temp
把结果存入csv（同baseline）：
result=pd.read_csv('sample_submit.csv')
result['label_0']=temp[0]
result['label_1']=temp[1]
result['label_2']=temp[2]
result['label_3']=temp[3]
result.to_csv('submit.csv',index=False)
最后上传了一下，其实是反向上分了TAT…只是一个模型调参的示例，后续再慢慢调整吧
5.3.2 贪心调参
调整规则：按照对模型的影响程度大小进行调参，先调整对当前模型影响最大的参数，达到当前参数下的模型最优化，再使用对模型影响次之的参数进行调优，如此下去，直到所有的参数调整完毕。
优点：只需要一步一步的进行参数最优化调试即可，容易理解。
缺点：可能会调到局部最优而不是全局最优
日常调参过程中常用的参数和调参顺序：
①：max_depth、num_leaves
②：min_data_in_leaf、min_child_weight
③：bagging_fraction、 feature_fraction、bagging_freq
④：reg_lambda、reg_alpha
⑤：min_split_gain
相关代码：
这里的代码只是给出了lgb调objective、num_leaves以及max_depth的示例程序，和上面的程序并不连续。其中，cross_val_score是sklearn进行交叉验证的函数，调整后的最优参数分别存储在best_obj、best_leaves以及best_depth中。
from sklearn.model_selection import cross_val_score
# 调objective
best_obj = dict()
for obj in objective:
model = LGBMRegressor(objective=obj)
"""预测并计算roc的相关指标"""
score = cross_val_score(model, X_train, y_train, cv=5, scoring='f1').mean()
best_obj[obj] = score
# num_leaves
best_leaves = dict()
for leaves in num_leaves:
model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0], num_leaves=leaves)
"""预测并计算roc的相关指标"""
score = cross_val_score(model, X_train, y_train, cv=5, scoring='f1').mean()
best_leaves[leaves] = score
# max_depth
best_depth = dict()
for depth in max_depth:
model = LGBMRegressor(objective=min(best_obj.items(), key=lambda x:x[1])[0],
num_leaves=min(best_leaves.items(), key=lambda x:x[1])[0],
max_depth=depth)
"""预测并计算roc的相关指标"""
score = cross_val_score(model, X_train, y_train, cv=5, scoring='f1').mean()
best_depth[depth] = score
"""
可依次将模型的参数通过上面的方式进行调整优化，并且通过可视化观察在每一个最优参数下模型的得分情况
"""
可依次将模型的参数通过上面的方式进行调整优化，并且通过可视化观察在每一个最优参数下模型的得分情况。
5.3.3 网格搜索
遍历所以的参数组合,从而选出最优的参数组合，对于数据量较大的模型，网格搜索的速度太慢！
sklearn 提供GridSearchCV用于进行网格搜索，只需要把模型的参数输进去，就能给出最优化的结果和参数。相比起贪心调参，网格搜索的结果会更优，但是网格搜索只适合于小数据集，一旦数据的量级上去了，很难得出结果。
同样以Lightgbm算法为例，进行网格搜索调参：
"""通过网格搜索确定最优参数"""
from sklearn.model_selection import GridSearchCV
def get_best_cv_params(learning_rate=0.1, n_estimators=581, num_leaves=31, max_depth=-1, bagging_fraction=1.0,
feature_fraction=1.0, bagging_freq=0, min_data_in_leaf=20, min_child_weight=0.001,
min_split_gain=0, reg_lambda=0, reg_alpha=0, param_grid=None):
# 设置5折交叉验证
cv_fold = KFold(n_splits=5, shuffle=True, random_state=2021)
model_lgb = lgb.LGBMClassifier(learning_rate=learning_rate,
n_estimators=n_estimators,
num_leaves=num_leaves,
max_depth=max_depth,
bagging_fraction=bagging_fraction,
feature_fraction=feature_fraction,
bagging_freq=bagging_freq,
min_data_in_leaf=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
)
f1 = make_scorer(f1_score, average='micro')
grid_search = GridSearchCV(estimator=model_lgb,
cv=cv_fold,
param_grid=param_grid,
scoring=f1
)
grid_search.fit(X_train, y_train)
print('模型当前最优参数为:{}'.format(grid_search.best_params_))
print('模型当前最优得分为:{}'.format(grid_search.best_score_))
"""
参数确定好了以后，我们设置一个比较小的learning_rate 0.005，来确定最终的num_boost_round
"""
# 设置5折交叉验证
# cv_fold = StratifiedKFold(n_splits=5, random_state=0, shuffle=True, )
final_params = {
'boosting_type': 'gbdt',
'learning_rate': 0.01,
'num_leaves': 29,
'max_depth': 7,
'objective': 'multiclass',
'num_class': 4,
'min_data_in_leaf':45,
'min_child_weight':0.001,
'bagging_fraction': 0.9,
'feature_fraction': 0.9,
'bagging_freq': 40,
'min_split_gain': 0,
'reg_lambda':0,
'reg_alpha':0,
'nthread': 6
}
cv_result = lgb.cv(train_set=lgb_train,
early_stopping_rounds=20,
num_boost_round=5000,
nfold=5,
stratified=True,
shuffle=True,
params=final_params,
feval=f1_score_vali,
seed=0,
)
在实际调整过程中，可先设置一个较大的学习率（上面的例子中0.1），通过Lgb原生的cv函数进行树个数的确定，之后再通过上面的实例代码进行参数的调整优化。
最后针对最优的参数设置一个较小的学习率（例如0.05），同样通过cv函数确定树的个数，确定最终的参数。
需要注意的是，针对大数据集，上面每一层参数的调整都需要耗费较长时间。