模型调参

• 本篇博客主要介绍的是模型调参
• 本篇博客内容基于阿里云天池竞赛：心跳信号分类预测写就，着重说明了其模型调参部分
• 学习交流请联系 obito0401@163.com

何为参数

• 参数一般分为超参数和参数
• 在机器学习中，超参数是在学习过程开始之前设置其值的参数。 相反，其他参数的值是通过训练得出的
• 参数和超参数的区别

参数	超参数
定义可使用模型	帮助估计模型参数
从数据估计或获悉	通常由人工指定
不由编程者手动设置	通常可以使用启发式设置
通常被保存为学习模型的一部分	通常被调整为给定的预测建模问题

为何调参

模型的参数直接影响着模型性能，当已确定要使用的模型时，其参数调整就成为了最为重要的部分

调参方法

贪心调参

• 先使用当前对模型影响最大的参数进行调优，达到当前参数下的模型最优化，再使用对模型影响次之的参数进行调优，如此下去，直到所有的参数调整完毕
• 这个方法的缺点就是可能会调到局部最优而不是全局最优，但是只需要一步一步的进行参数最优化调试即可，容易理解
• 需要注意的是在树模型中参数调整的顺序，也就是各个参数对模型的影响程度，这里列举一下日常调参过程中常用的参数和调参顺序：
  • ①：max_depth、num_leaves
  • ②：min_data_in_leaf、min_child_weight
  • ③：bagging_fraction、 feature_fraction、bagging_freq
  • ④：reg_lambda、reg_alpha
  • ⑤：min_split_gain

'''
可依次将模型的参数通过上面的方式进行调整优化，
并且通过可视化观察在每一个最优参数下模型的得分情况
'''
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 

网格搜索

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

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

贝叶斯调参

• 在使用之前需要先安装包pip install bayesian-optimization
• 主要思想：给定优化的目标函数(广义的函数，只需指定输入和输出即可，无需知道内部结构以及数学性质)，通过不断地添加样本点来更新目标函数的后验分布(高斯过程,直到后验分布基本贴合于真实分布）。简单的说，就是考虑了上一次参数的信息，从而更好的调整当前的参数
• 调参步骤：
  • 定义优化函数(rf_cv）
  • 建立模型
  • 定义待优化的参数
  • 得到优化结果，并返回要优化的分数指标

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', 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

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)

# 显示优化结果
bayes_lgb.max