Loading [MathJax]/jax/output/CommonHTML/config.js
首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >模型融合与超参数优化

模型融合与超参数优化

作者头像
致Great
发布于 2021-11-24 07:55:07
发布于 2021-11-24 07:55:07
89900
代码可运行
举报
文章被收录于专栏:自然语言处理自然语言处理
运行总次数:0
代码可运行

模型融合

一般来说,通过融合多个不同的模型,可能提升机器学习的性能,这一方法在各种机器学习比赛中广泛应用, 常见的集成学习&模型融合方法包括:简单的Voting/Averaging(分别对于分类和回归问题)、Stacking、Boosting和Bagging。

1 Voting

模型融合其实也没有想象的那么高大上,从最简单的Voting说起,这也可以说是一种模型融合。假设对于一个二分类问题,有3个基础模型,那么就采取投票制的方法,投票多者确定为最终的分类。

2 Averaging

对于回归问题,一个简单直接的思路是取平均。稍稍改进的方法是进行加权平均。 权值可以用排序的方法确定,举个例子,比如A、B、C三种基本模型,模型效果进行排名,假设排名分别是1,2,3,那么给这三个模型赋予的权值分别是3/6、2/6、1/6。

注意两个问题

  • 如果进行投票的模型越多,那么显然其结果将会更好。但是其前提条件是模型之间相互独立,结果之间没有相关性。越相近的模型进行融合,融合效果也会越差。 模型之间差异越大,融合所得的结果将会更好。这种特性不会受融合方式的影响。注意这里所指模型之间的差异,并不是指正确率的差异,而是指模型之间相关性的差异。对于回归问题,对各种模型的预测结果进行平均,所得到的结果通过能够减少过拟合,并使得边界更加平滑,单个模型的边界可能很粗糙。
  • 在上述融合方法的基础上,一个进行改良的方式是对各个投票者/平均者分配不同的权重以改变其对最终结果影响的大小。对于正确率低的模型给予更低的权重,而正确率更高的模型给予更高的权重。

3 Bagging

Bagging就是采用有放回的方式进行抽样,用抽样的样本建立子模型,对子模型进行训练,这个过程重复多次,最后进行融合。大概分为这样两步:

  1. 重复K次 有放回地重复抽样建模 训练子模型
  2. 模型融合 分类问题:voting 回归问题:average

Bagging算法不用我们自己实现,随机森林就是基于Bagging算法的一个典型例子,采用的基分类器是决策树。

4 Boosting

Bagging算法可以并行处理,而Boosting的思想是一种迭代的方法,每一次训练的时候都更加关心分类错误的样例,给这些分类错误的样例增加更大的权重,下一次迭代的目标就是能够更容易辨别出上一轮分类错误的样例。最终将这些弱分类器进行加权相加。

其基本工作机制如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
    1、从初始样本集中训练出一个基学习器;

    2、根据基学习器的表现对样本集分布进行调整,使得做错的样本能在之后的过程中受到更多的关注;

    3、用调整后的样本集训练下一个基学习器;

    4、重复上述步骤,直到满足一定条件。

注意,一般只有弱分类器都是同一种分类器(即同质集成)的时候,才将弱分类器称为基学习器,如果是异质集成,则称之为个体学习器。由于不是本文重点,所以此处不作区分。特此说明。

最终将这些弱分类器进行加权相加。

常见的Boosting方法有Adaboost、GBDT、XGBOOST等

5 Stacking 算法

1、首先我们将训练集分为五份。

2、对于每一个基模型来说,我们用其中的四份来训练,然后对未用来的训练的一份训练集和测试集进行预测。然后改变所选的用来训练的训练集和用来验证的训练集,重复此步骤,直到获得完整的训练集的预测结果。

3、对五个模型,分别进行步骤2,我们将获得5个模型,以及五个模型分别通过交叉验证获得的训练集预测结果。即P1、P2、P3、P4、P5。

4、用五个模型分别对测试集进行预测,得到测试集的预测结果:T1、T2、T3、T4、T5。

5、将P15、T15作为下一层的训练集和测试集。在图中分别作为了模型6的训练集和测试集。

代码实例如下:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
""" 
@author: quincy qiang 
@license: Apache Licence 
@file: 04_stakcing_template.py 
@time: 2019/12/12
@software: PyCharm 
"""

import numpy as np
import pandas as pd
import lightgbm as lgb
import xgboost as xgb
from sklearn.linear_model import BayesianRidge
from sklearn.model_selection import KFold, RepeatedKFold
from sklearn.preprocessing import OneHotEncoder, LabelEncoder
from scipy import sparse
import warnings
import time
import sys
import os
import re
import datetime
import matplotlib.pyplot as plt
import seaborn as sns
import plotly.offline as py

py.init_notebook_mode(connected=True)
import plotly.graph_objs as go
import plotly.tools as tls
from sklearn.metrics import mean_squared_error
from sklearn.metrics import log_loss
from gen_feas import load_data

train, test, no_features, features = load_data()

X_train = train[features].values
y_train = train['target']
target = y_train
X_test = test[features].values

## lgb
param = {
    'boosting_type': 'gbdt',
    'objective': 'binary',
    'metric': {'auc'},
    'max_depth': 4,
    'min_child_weight': 6,
    'num_leaves': 16,
    'learning_rate': 0.02,  # 0.05
    'feature_fraction': 0.7,
    'bagging_fraction': 0.7,
    'bagging_freq': 5,
    'verbose': -1
}

folds = KFold(n_splits=5, shuffle=True, random_state=2018)
oof_lgb = np.zeros(len(train))
predictions_lgb = np.zeros(len(test))

for fold_, (trn_idx, val_idx) in enumerate(folds.split(X_train, y_train)):
    print("fold n°{}".format(fold_ + 1))
    trn_data = lgb.Dataset(X_train[trn_idx], y_train[trn_idx])
    val_data = lgb.Dataset(X_train[val_idx], y_train[val_idx])

    num_round = 10000
    clf = lgb.train(param, trn_data, num_round, valid_sets=[trn_data, val_data], verbose_eval=200,
                    early_stopping_rounds=100)
    oof_lgb[val_idx] = clf.predict(X_train[val_idx], num_iteration=clf.best_iteration)

    predictions_lgb += clf.predict(X_test, num_iteration=clf.best_iteration) / folds.n_splits

print("CV score: {:<8.8f}".format(mean_squared_error(oof_lgb, target)))

#### xgb
xgb_params = {'booster': 'gbtree', 'objective': 'binary:logistic', 'eta': 0.02, 'max_depth': 4, 'min_child_weight': 6,
              'colsample_bytree': 0.7, 'subsample': 0.7, 'silent': 1, 'eval_metric': ['auc']}

folds = KFold(n_splits=5, shuffle=True, random_state=2018)
oof_xgb = np.zeros(len(train))
predictions_xgb = np.zeros(len(test))

for fold_, (trn_idx, val_idx) in enumerate(folds.split(X_train, y_train)):
    print("fold n°{}".format(fold_ + 1))
    trn_data = xgb.DMatrix(X_train[trn_idx], y_train[trn_idx])
    val_data = xgb.DMatrix(X_train[val_idx], y_train[val_idx])

    watchlist = [(trn_data, 'train'), (val_data, 'valid_data')]
    clf = xgb.train(dtrain=trn_data, num_boost_round=20000, evals=watchlist, early_stopping_rounds=200,
                    verbose_eval=100, params=xgb_params)
    oof_xgb[val_idx] = clf.predict(xgb.DMatrix(X_train[val_idx]), ntree_limit=clf.best_ntree_limit)
    predictions_xgb += clf.predict(xgb.DMatrix(X_test), ntree_limit=clf.best_ntree_limit) / folds.n_splits

print("CV score: {:<8.8f}".format(mean_squared_error(oof_xgb, target)))

# 将lgb和xgb的结果进行stacking
train_stack = np.vstack([oof_lgb, oof_xgb]).transpose()
test_stack = np.vstack([predictions_lgb, predictions_xgb]).transpose()

folds_stack = RepeatedKFold(n_splits=5, n_repeats=2, random_state=4590)
oof_stack = np.zeros(train_stack.shape[0])
predictions = np.zeros(test_stack.shape[0])

for fold_, (trn_idx, val_idx) in enumerate(folds_stack.split(train_stack, target)):
    print("fold {}".format(fold_))
    trn_data, trn_y = train_stack[trn_idx], target.iloc[trn_idx].values
    val_data, val_y = train_stack[val_idx], target.iloc[val_idx].values

    clf_3 = BayesianRidge()
    clf_3.fit(trn_data, trn_y)

    oof_stack[val_idx] = clf_3.predict(val_data)
    predictions += clf_3.predict(test_stack) / 10

mean_squared_error(target.values, oof_stack)

from pandas import DataFrame

result = DataFrame()
result['id'] = test['id']
result['target'] = predictions
result.to_csv('result/stacking.csv', index=False, sep=",", float_format='%.6f')

6 Blending

第一步:将原始训练数据划分为训练集和验证集。 第二步:使用训练集对训练T个不同的模型。 第三步:使用T个基模型,对验证集进行预测,结果作为新的训练数据。 第四步:使用新的训练数据,训练一个元模型。 第五步:使用T个基模型,对测试数据进行预测,结果作为新的测试数据。 第六步:使用元模型对新的测试数据进行预测,得到最终结果。

超参数优化

推荐两个工具:Optuna和BayesianOptimization

推荐1:Optuna

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
import numpy as np
import optuna

import lightgbm as lgb
import sklearn.datasets
import sklearn.metrics
from sklearn.model_selection import train_test_split


# FYI: Objective functions can take additional arguments
# (https://optuna.readthedocs.io/en/stable/faq.html#objective-func-additional-args).
def objective(trial):
    data, target = sklearn.datasets.load_breast_cancer(return_X_y=True)
    train_x, valid_x, train_y, valid_y = train_test_split(data, target, test_size=0.25)
    dtrain = lgb.Dataset(train_x, label=train_y)

    param = {
        "objective": "binary",
        "metric": "binary_logloss",
        "verbosity": -1,
        "boosting_type": "gbdt",
        "lambda_l1": trial.suggest_float("lambda_l1", 1e-8, 10.0, log=True),
        "lambda_l2": trial.suggest_float("lambda_l2", 1e-8, 10.0, log=True),
        "num_leaves": trial.suggest_int("num_leaves", 2, 256),
        "feature_fraction": trial.suggest_float("feature_fraction", 0.4, 1.0),
        "bagging_fraction": trial.suggest_float("bagging_fraction", 0.4, 1.0),
        "bagging_freq": trial.suggest_int("bagging_freq", 1, 7),
        "min_child_samples": trial.suggest_int("min_child_samples", 5, 100),
    }

    gbm = lgb.train(param, dtrain)
    preds = gbm.predict(valid_x)
    pred_labels = np.rint(preds)
    accuracy = sklearn.metrics.accuracy_score(valid_y, pred_labels)
    return accuracy


if __name__ == "__main__":
    study = optuna.create_study(direction="maximize")
    study.optimize(objective, n_trials=100)

    print("Number of finished trials: {}".format(len(study.trials)))

    print("Best trial:")
    trial = study.best_trial

    print("  Value: {}".format(trial.value))

    print("  Params: ")
    for key, value in trial.params.items():
        print("    {}: {}".format(key, value))

推荐2 BayesianOptimization

数据来源:https://www.kaggle.com/c/home-credit-default-risk

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
import pandas as pd
import numpy as np
import warnings
import time
warnings.filterwarnings("ignore")
import lightgbm as lgb
from bayes_opt import BayesianOptimization
from sklearn.metrics import roc_auc_score



application_train = pd.read_csv('../input/application_train.csv')
from sklearn.preprocessing import LabelEncoder
def label_encoder(input_df, encoder_dict=None):
    """ Process a dataframe into a form useable by LightGBM """
    # Label encode categoricals
    categorical_feats = input_df.columns[input_df.dtypes == 'object']
    for feat in categorical_feats:
        encoder = LabelEncoder()
        input_df[feat] = encoder.fit_transform(input_df[feat].fillna('NULL'))
    return input_df, categorical_feats.tolist(), encoder_dict
application_train, categorical_feats, encoder_dict = label_encoder(application_train)
X = application_train.drop('TARGET', axis=1)
y = application_train.TARGET

# 第一步:设置需要优化的参数
def lgb_eval(num_leaves, feature_fraction, bagging_fraction, max_depth, lambda_l1, lambda_l2, min_split_gain, min_child_weight):
    params = {'application':'binary','num_iterations':4000, 'learning_rate':0.05, 'early_stopping_round':100, 'metric':'auc'}
    params["num_leaves"] = round(num_leaves)
    params['feature_fraction'] = max(min(feature_fraction, 1), 0)
    params['bagging_fraction'] = max(min(bagging_fraction, 1), 0)
    params['max_depth'] = round(max_depth)
    params['lambda_l1'] = max(lambda_l1, 0)
    params['lambda_l2'] = max(lambda_l2, 0)
    params['min_split_gain'] = min_split_gain
    params['min_child_weight'] = min_child_weight
    cv_result = lgb.cv(params, train_data, nfold=n_folds, seed=random_seed, stratified=True, verbose_eval =200, metrics=['auc'])
    return max(cv_result['auc-mean'])


# 第二步:设置超参数搜索范围

lgbBO = BayesianOptimization(lgb_eval, {'num_leaves': (24, 45),
                                        'feature_fraction': (0.1, 0.9),
                                        'bagging_fraction': (0.8, 1),
                                        'max_depth': (5, 8.99),
                                        'lambda_l1': (0, 5),
                                        'lambda_l2': (0, 3),
                                        'min_split_gain': (0.001, 0.1),
                                        'min_child_weight': (5, 50)}, random_state=0)


# 第三步:设置优化目标

# lgbBO.maximize(init_points=init_round, n_iter=opt_round)


# 第四步:获取最优参数
# lgbBO.res['max']['max_params']

参考资料

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2021/10/18 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
暂无评论
推荐阅读
编辑精选文章
换一批
TIANCHI-津南数字制造算法挑战赛【赛场一】基本分析&Baseline
有趣的是,训练集中缺失值比较多的A23和A21在测试集中并无缺失,同样地,测试集中缺失概率达67%的A25、A27和A20反而在训练集中并无缺失。(此处作者笔误,缺失率只有0.67%)
Coggle数据科学
2019/09/12
6840
TIANCHI-津南数字制造算法挑战赛【赛场一】基本分析&Baseline
LightGBM+Optuna 建模自动调参教程!
在kaggle机器学习竞赛赛中有一个调参神器组合非常热门,在很多个top方案中频频出现LightGBM+Optuna。知道很多小伙伴苦恼于漫长的调参时间里,这次结合一些自己的经验,给大家带来一个LGBM模型+OPTUNA调参的使用教程,这对可谓是非常实用且容易上分的神器组合了,实际工作中也可使用。
Python数据科学
2023/08/29
1.5K0
LightGBM+Optuna 建模自动调参教程!
Optiver波动率预测大赛系列解读二:LightGBM模型及特征工程
量化投资与机器学习微信公众号,是业内垂直于量化投资、对冲基金、Fintech、人工智能、大数据等领域的主流自媒体。公众号拥有来自公募、私募、券商、期货、银行、保险、高校等行业20W+关注者,连续2年被腾讯云+社区评选为“年度最佳作者”。 前言 Optiver波动率预测大赛于上个月27号截止提交,比赛终于告一段落,等待着明年1月份的最终比赛结果。Kaggle上,由财大气粗的对冲基金大佬主办的金融交易类预测大赛,总能吸引大量的人气。在过去3个月的比赛中,也诞生了很多优秀的开源代码,各路神仙应用各种模型算法,在竞争激烈的榜单你追我赶。 关于这个比赛,网络上陆陆续续也有很多参赛经验的分享。但为了充分吸收大神们的精髓,公众号还是决定从0到1解读各种不同类型的开源比赛代码,方便小伙伴们学习归纳,并应用到实际研究中去。本系列大概安排内容如下:
量化投资与机器学习微信公众号
2021/10/22
2.8K0
Optiver波动率预测大赛系列解读二:LightGBM模型及特征工程
NN和树模型通吃的调参神器Optuna!
本文介绍的一种超参寻优策略则同时解决了上面三个问题,与此同时,该方法在目前kaggle的数据竞赛中也都是首选的调参工具包,其优势究竟有多大,我们看一下其与目前最为流行的一些工具包的对比。
炼丹笔记
2021/07/16
1.8K0
NN和树模型通吃的调参神器Optuna!
2019腾讯广告算法大赛方案分享(初赛冠军)
bettenW/Tencent2019_Finals_Rank1st​github.com
Coggle数据科学
2019/09/12
1.8K0
2019腾讯广告算法大赛方案分享(初赛冠军)
python - 机器学习lightgbm相关实践
相关文章: R+python︱XGBoost极端梯度上升以及forecastxgb(预测)+xgboost(回归)双案例解读 python︱sklearn一些小技巧的记录(训练集划分/pipelline/交叉验证等)
悟乙己
2021/12/07
1.2K0
python - 机器学习lightgbm相关实践
数据挖掘实践(金融风控):金融风控之贷款违约预测挑战赛(下篇)xgboots/lightgbm/Catboost等模型--模型融合:stacking、blend
通过组合多个学习器来完成学习任务,通过集成方法,可以将多个弱学习器组合成一个强分类器,因此集成学习的泛化能力一般比单一分类器要好。
汀丶人工智能
2023/05/17
4.2K0
数据挖掘实践(金融风控):金融风控之贷款违约预测挑战赛(下篇)xgboots/lightgbm/Catboost等模型--模型融合:stacking、blend
数据挖掘机器学习[六]---项目实战金融风控之贷款违约预测
因为文档是去年弄的,很多资料都有点找不到了,我尽可能写的详细。后面以2021年研究生数学建模B题为例【空气质量预报二次建模】再进行一个教学。
汀丶人工智能
2022/12/21
1.7K0
数据挖掘机器学习[六]---项目实战金融风控之贷款违约预测
科大讯飞:电信客户流失预测赛方案
2022科大讯飞大赛于6月9日正式开赛了。Datawhale作为大赛生态伙伴,与科大讯飞联合设计了学习型赛事,帮助大家提升数据挖掘、CV、NLP等方向的实践技能。
Coggle数据科学
2022/08/31
1.7K0
​100天搞定机器学习|Day63 彻底掌握 LightGBM
LightGBM 全称为轻量的梯度提升机(Light Gradient Boosting Machine),由微软于2017年开源出来的一款SOTA Boosting算法框架。
Ai学习的老章
2021/11/16
1.5K0
模型融合stacking实战
模型融合stacking的原理具体不再解释,有的博客已经解释很清楚了,还是附一张经典图吧,
全栈程序员站长
2022/07/25
4370
【多层堆叠集成模型(Stacking Ensemble)详解】
 在机器学习中,集成学习(Ensemble Learning)是通过将多个学习器的预测结果结合起来,从而提升模型的性能。集成方法有很多种,其中 堆叠集成(Stacking Ensemble) 是一种非常强大且灵活的集成方法,它通过将多个模型的输出作为特征输入到下一级模型中,从而让最终模型做出更准确的预测。
机器学习司猫白
2025/03/12
8260
【多层堆叠集成模型(Stacking Ensemble)详解】
【数据竞赛】Kaggle GM秘技:树模型初始化技巧
作者: 尘沙樱落 树模型初始化技巧 大家都知道神经网络训练的提升分数的技巧之一就是: 依据验证集合的效果,来调整learning rate的大小,从而获得更好的效果; 但我们在训练树模型的时候却往往
黄博的机器学习圈子
2021/02/08
6120
突破最强算法模型,LightGBM !!!
LightGBM呢,是微软开发的一个机器学习工具,擅长处理大数据和高维数据。LightGBM是基于决策树的提升方法,通过不断调整和优化预测模型来提高精度。与其他算法相比,LightGBM速度更快、内存占用更少、准确率更高,并且能处理类别特征。
Python编程爱好者
2024/07/12
4940
突破最强算法模型,LightGBM !!!
LightGBM 如何调参
本文结构: 什么是 LightGBM 怎么调参 和 xgboost 的代码比较 ---- 1. 什么是 LightGBM Light GBM is a gradient boosting framew
杨熹
2018/06/19
3.8K0
【机器学习实战】kaggle背包价格预测(堆叠的实战用法)
该竞赛的数据集是学生背包价格预测数据集中训练的深度学习模型生成的。特征分布与原始分布接近但不完全相同。请随意将原始数据集用作本竞赛的一部分,既要探索差异,又要查看将原始内容纳入训练是否可以改善模型性能。
机器学习司猫白
2025/02/15
1630
在lightgbm中使用交叉验证
防止过拟合的参数: max_depth 树的深度,不要设置的太大; num_leaves 应该小于 2^(max_depth),否则可能会导致过拟合; min_child_samples 较大的值可以避免生成一个过深的树, 避免过拟合,但有可能导致欠拟合; min_sum_hessian_in_leaf 设置较大防止过拟合; feature_fraction 和 bagging_fraction都可以降低过拟合; 正则化参数lambda_l1(reg_alpha), lambda_l2(reg_lambda)。
生信编程日常
2020/09/08
4K0
鱼佬:百行代码入手数据挖掘赛!
本实践以科大讯飞xDatawhale联合举办的数据挖掘赛为例,给出了百行代码Baseline,帮助学习者更好地结合赛事实践。同时,在如何提分上进行了详细解读,以便于大家进阶学习。
Datawhale
2021/07/12
4570
【白话机器学习】算法理论+实战之LightGBM算法
如果想从事数据挖掘或者机器学习的工作,掌握常用的机器学习算法是非常有必要的,在这简单的先捋一捋, 常见的机器学习算法:
石晓文
2020/06/28
7.6K0
Kaggle系列- Russia房产价格预测top1%(22/3270)方案总结
比赛名称:Sberbank Russian Housing Market 比赛链接:https://www.kaggle.com/c/sberbank-russian-housing-market
致Great
2021/01/18
1K0
推荐阅读
相关推荐
TIANCHI-津南数字制造算法挑战赛【赛场一】基本分析&Baseline
更多 >
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档