数据挖掘竞赛lightgbm通过求最大auc调参

最新推荐文章于 2023-08-14 00:20:58 发布
最新推荐文章于 2023-08-14 00:20:58 发布
阅读量2.1k 收藏 27
点赞数 3
分类专栏： python数据分析 数据挖掘 竞赛 文章标签： 数据挖掘 机器学习 r语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43827767/article/details/120586336
版权

一、使用步骤

0.首先展示最后的结果

# 参数含义
# learning_rate 一般设置在0.05-0.1之间
# n_estimators  100-1000  boosting的迭代次数
# min_split_gain  0  执行节点分裂的最小增益  不建议去调整
# min_child_sample  一个叶子上的最小数据量,默认设置为20。根据数据量来确定，当数据量比较大时，应提升这个数值，
# 让叶子节点的数据分布相对稳定。
# min_child_weight  一个叶子上的最小hessian和。默认设置为0.001，一般设置为1。

# 需要算法调节的参数
# max_depth   树模型的最大深度。防止过拟合的最重要的参数，一般限制为3~5之间
# num_leaves  一棵树上的叶子节点个数。默认设置为31，和max_depth配合来空值树的形状，一般设置为(0, 2^max_depth - 1]的一个数值。
# subsample   默认设置为1，一般设置为0。8~1.0之间，防止过拟合。 
# colsample_bytree  一般设置为0.8~1.0之间，防止过拟合
# reg_alpha   L1正则化参数 
# reg_lambda  L2正则化参数 较大的数值会让各个特征对模型的影响力趋于均匀



def roc_auc_plot(clf,x_train,y_train,x_test, y_test):
    train_auc = roc_auc_score(y_train,clf.predict_proba(x_train)[:,1])
    train_fpr, train_tpr, _ = roc_curve(y_train,clf.predict_proba(x_train)[:,1])
    train_ks = abs(train_fpr-train_tpr).max()
    print('train_ks = ', train_ks)
    print('train_auc = ', train_auc)
    
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
    test_ks = abs(test_fpr-test_tpr).max()
    print('test_ks = ', test_ks)
    print('test_auc = ', test_auc)
    
    from matplotlib import pyplot as plt
    plt.plot(train_fpr,train_tpr,label = 'train_roc')
    plt.plot(test_fpr,test_tpr,label = 'test_roc')
    plt.plot([0,1],[0,1],'k--', c='r')
    plt.xlabel('False positive rate')
    plt.ylabel('True positive rate')
    plt.title('ROC Curve')
    plt.legend(loc = 'best')
    plt.show()

lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=0.01,
                                  max_depth=4,
                              num_leaves=16,
                              colsample_bytree=0.8,
                              subsample=0.8,
                              reg_alpha=0.7777777777777778,
                              reg_lambda=0.3,
                               objective='binary')

clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
roc_auc_plot(clf,x_train,y_train,x_test, y_test)

最终结果

1.读入清洗后的数据集

代码如下：

import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import roc_auc_score,roc_curve,auc
import lightgbm as lgb
from multiprocessing import cpu_count
from sklearn.model_selection import KFold
import time
from sklearn.model_selection import GridSearchCV, StratifiedKFold, cross_val_score
import numpy as np

df_Master_clean = pd.read_csv(r'F:\教师培训\ppd7\df_Master_clean.csv', encoding='gb18030')
c=['Idx','target','ListingInfo','sample_status']
x = df_Master_clean[df_Master_clean['target'].notnull()].drop(columns=c)
y = df_Master_clean[df_Master_clean['target'].notnull()]['target']
x_train,x_test, y_train, y_test = train_test_split(x,y,random_state=2,test_size=0.2)

2.参数调整

代码如下（示例）：

#随机设置一组参数为基础
lgb_model1 = lgb.LGBMClassifier(n_estimators=20,
                                boosting_type='gbdt',
                               learning_rate=0.01,
                               min_child_samples=100,
                               min_child_weight=0.003,
                                  max_depth=4,
                              num_leaves=100,
                              colsample_bytree=0.7,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)

import matplotlib.pyplot as plt

# 通过观察auc大小调参，找到最佳n_estimators
axisx = range(100,1001,10)
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=i,
                                boosting_type='gbdt',
                               learning_rate=0.01,
                               min_child_samples=100,
                               min_child_weight=0.003,
                                  max_depth=4,
                              num_leaves=100,
                              colsample_bytree=0.7,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.xticks(axisx)
plt.legend()
plt.show()

结果图

import matplotlib.pyplot as plt

# 通过观察auc大小调参，找到最佳learning_rate,learning_rate=0.04, max_auc=0.7720493433228038
axisx = np.linspace(0.01,0.05,5)

test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=i,
                               min_child_samples=100,
                               min_child_weight=0.003,
                                  max_depth=4,
                              num_leaves=100,
                              colsample_bytree=0.7,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('learning_rate={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参，找到最佳min_child_samples   min_child_samples=68, max_auc=0.7754420865945606
# axisx = np.linspace(0.01,0.05,5)
axisx = range(65,75,1)
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=i,
                               min_child_weight=0.003,
                                  max_depth=4,
                              num_leaves=100,
                              colsample_bytree=0.7,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('min_child_samples={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参，min_child_weight对auc面积没有影响
axisx = np.linspace(0.001,0.005,10)
# axisx = range(65,75,1)
# axisx = [0.001, 0.005]
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=i,
                                  max_depth=4,
                              num_leaves=100,
                              colsample_bytree=0.7,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('min_child_weight={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参max_depth,  max_depth=4, max_auc=0.7754420865945606
# axisx = np.linspace(0.001,0.005,10)
# axisx = range(65,75,1)
axisx = [3, 4, 5, 6, 7]
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=0.01,
                                  max_depth=i,
                              num_leaves=100,
                              colsample_bytree=0.7,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('max_depth={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参num_leaves,  num_leaves=16, max_auc=0.7754420865945606
# axisx = np.linspace(0.001,0.005,10)
axisx = range(10,20,1)
# axisx = [3, 4, 5, 6, 7]
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=0.01,
                                  max_depth=4,
                              num_leaves=i,
                              colsample_bytree=0.7,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('num_leaves={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参colsample_bytree,  colsample_bytree=0.8, max_auc=0.7770645958950596
axisx = np.linspace(0.8,0.85,5)
# axisx = range(10,101,10)
# axisx = [3, 4, 5, 6, 7]
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=0.01,
                                  max_depth=4,
                              num_leaves=16,
                              colsample_bytree=i,
                              subsample=0.6,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               max_features = 140,)
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('colsample_bytree={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参subsample, 此参数没有对auc产生影响
axisx = np.linspace(0.7,0.8,10)
# axisx = range(10,101,10)
# axisx = [3, 4, 5, 6, 7]
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=0.01,
                                  max_depth=4,
                              num_leaves=16,
                              colsample_bytree=0.8,
                              subsample=i,
                              reg_alpha=0.03,
                              reg_lambda=0.3,
                               objective='binary',
                               )
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('subsample={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参reg_alpha, reg_alpha=0.7777777777777778, max_auc=0.7773465038084242
axisx = np.linspace(0.7,0.8,10)
# axisx = range(0,1,10)
# axisx = [3, 4, 5, 6, 7]
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=0.01,
                                  max_depth=4,
                              num_leaves=16,
                              colsample_bytree=0.8,
                              subsample=0.8,
                              reg_alpha=i,
                              reg_lambda=0.3,
                               objective='binary',
                               )
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('reg_alpha={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

# 通过观察auc大小调参reg_lambda, reg_lambda=0.30000000000000004, max_auc=0.7773465038084242
axisx = np.linspace(0.28,0.32,5)
# axisx = range(0,1,10)
# axisx = [3, 4, 5, 6, 7]
test_aucs = []
for i in axisx:
    lgb_model = lgb.LGBMClassifier(n_estimators=800,
                                boosting_type='gbdt',
                               learning_rate=0.04,
                               min_child_samples=68,
                               min_child_weight=0.01,
                                  max_depth=4,
                              num_leaves=16,
                              colsample_bytree=0.8,
                              subsample=0.8,
                              reg_alpha=0.7777777777777778,
                              reg_lambda=i,
                               objective='binary',
                               )
    clf = lgb_model.fit(x_train, y_train,
              eval_set=[(x_train, y_train),(x_test,y_test)],
              eval_metric='auc',early_stopping_rounds=100)
    test_auc = roc_auc_score(y_test,clf.predict_proba(x_test)[:,1])
    test_aucs.append(test_auc)
print('reg_lambda={}, max_auc={}'.format(axisx[test_aucs.index(max(test_aucs))], max(test_aucs)))
#     test_fpr, test_tpr, _ = roc_curve(y_test,clf.predict_proba(x_test)[:,1])
#     test_ks = abs(test_fpr-test_tpr).max()
#     print('test_ks = ', test_ks)
#     print('test_auc = ', test_auc)
    

plt.figure(figsize=(20,5))
plt.plot(axisx, test_aucs,c="red",label="LGBC")
plt.ylabel('auc')
plt.xticks(axisx)
plt.legend()
plt.show()

在这里插入图片描述

总结

我们观察整个调参过程，有的参数并没有对auc产生影响，有的效果很明显，总的来说调参后的效果要好些。

sunnuan01
关注
  • 3
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LightGBM：基于决策树算法的快速，分布式，高性能梯度提升（GBT，GBDT，GBRT，GBM或MART）框架，用于排名，分类和许多其他机器学习任务
02-03
渐变光机 LightGBM是使用基于树的学习算法的梯度增强框架。 它被设计为分布式且高效的，具有以下优点： 训练速度更快，效率更高。 降低内存使用率。 更好的准确性。 支持并行和GPU学习。 能够处理大规模数据。 有关更多详细信息，请参阅。 受益于这些优势，LightGBM被广泛用于许多机器学习竞赛的中。 在公共数据集上进行的表明，LightGBM可以在效率和准确性上均优于现有的Boosting框架，并且显着降低了内存消耗。 此外， 表明，LightGBM可通过使用多台机器进行特定设置的训练来实现线性加速。 入门和文档 我们的主要文档位于并从该存储库生成。 如果您不熟悉LightGBM，请按照站点上进行。 接下来，您可能需要阅读： 显示常见任务命令行用法的。 LightGBM支持的和算法。 是您可以进行的自定义的详尽列表。 和可以加快计算速度。 是有关超参数的详细指南。 为LightGBM超参数（）提供自动调整。 贡献者文档： 。 查阅《 。 新闻 请参考页面上的变更日志。 一些重要的更新日志可在“页面上找到。 外部（非官方）存储库 Optun
使用LightGBM模型对信贷数据预测，以及AUC、KS、PSI计算
I_am_a_big_tiger的博客
06-14 1629
AUC = 1，是完美分类器，采用这个预测模型时，存在至少一个阈值能得出完美预测。（二）大部分缺失值处理使用中位数进行缺失值填充的方法，对于部分类别型变量先变成浮点型进行中位数填充，再转换成类别型变量，包括Credit_Mix,Payment_Behaviour,Monthly_Balance。超参数调整（或优化）是确定可最大化模型性能的超参数的正确组合的过程，超参数的选择决定了训练的效率。模型PSI指标大于0.25，说明模型不能使用，那就下一篇研究如何调优lightgbm模型psi指标。
机器学习实战 | LightGBM建模应用详解
ShowMeAI研究中心
03-21 2万+
本篇详细讲解LightGBM的工程应用方法。LightGBM是微软开发的boosting集成模型，和XGBoost一样是对GBDT的优化和高效实现，但它很多方面比XGBoost有着更为优秀的表现。
【项目实战】Python实现LightGBM分类模型(LGBMClassifier算法)项目实战
胖哥真不错的博客
11-06 3万+
说明：这是一个机器学习实战项目（附带数据+代码+文档+代码讲解），如需数据+代码+文档+代码讲解可以直接到文章最后获取。 1.项目背景 如今已是大数据时代，具备大数据思想至关重要，人工智能技术在各行各业的应用已是随处可见。GBDT (Gradient Boosting Decision Tree) 是机器学习中一个长盛不衰的模型，其主要思想是利用弱分类器（决策树）迭代训练以得到最优模型，该模型具有训练效果好、不易过拟合等优点。GBDT不仅在工业界应用广泛，通常被用于多分类、点击率预...
LightGBM
银晗的学习博客
04-27 1239
LightGBM是XGBoost的优化。提出算法的原因：GBDT在每一次迭代的时候，都需要遍历整个训练数据多次。如果把整个训练数据装进内存则会限制训练数据的大小；如果不装进内存，反复地读写训练数据又会消耗非常大的时间。尤其面对工业级海量的数据，普通的GBDT算法是不能满足其需求的。
2020第八届泰迪杯数据挖掘挑战赛A题题目及数据
最新发布
02-16
考虑到高送转事件可能与多个因素相关，集成学习方法（如梯度提升机、XGBoost、LightGBM）也可能被用于提高预测性能。 在分析过程中，特征工程是关键。通过对原始数据进行深入理解，提取有意义的特征（如过去一段...
机器学习数据挖掘案例和竞赛代码.zip
10-23
本资源“机器学习数据挖掘案例和竞赛代码.zip”包含了一整个项目或多个项目的源代码，这些项目可能用于教学、研究或者是在数据挖掘竞赛中的实战应用。以下是基于这个压缩包文件可能涵盖的一些关键知识点： 1. 数据...
用户点击广告行为预测竞赛数据.zip
11-10
3. **模型选择**：根据问题的特性和数据规模，可以选择多种分类算法，如逻辑回归、随机森林、梯度提升机（如XGBoost或LightGBM）、支持向量机（SVM）以及神经网络模型（如深度学习的CNN或LSTM）。 4. **模型训练与...
数据挖掘类比赛常用算法模型（含源码及使用案例）
08-09
在数据挖掘领域，模型的选择和应用对于解决实际问题至关重要。本资源包主要涵盖了三种常见的算法模型，它们在各种数据挖掘类比赛中被广泛采用。以下是这些模型的详细介绍： 1. **二分类模型**： - **LightGBM**：...
招商银行的M-Geeker数据竞赛决赛题目与个人解答。.zip
10-23
6. 集成学习：集成学习如bagging（如随机森林）、boosting（如XGBoost、LightGBM）和stacking，可以提高模型的稳定性和准确性，降低过拟合风险。 7. 模型评估：使用准确率、精确率、召回率、F1分数、AUC-ROC曲线等...
lightgbm使用手册——参数篇
zzpl139的博客
03-14 8708
lgbm参数记录
python机器学习案例系列教程——LightGBM算法
热门推荐
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
05-08 5万+
全栈工程师开发手册 （作者：栾鹏） python教程全解 安装pip install lightgbmgitup网址：https://github.com/Microsoft/LightGBM中文教程http://lightgbm.apachecn.org/cn/latest/index.htmllightGBM简介xgboost的出现，让数据民工们告别了传统的机器学习算法们：RF、GBM
【2023天池龙珠计划】机器学习训练营（三）：LightGBM
qq_34107083的博客
08-14 191
天池龙珠计划Task03，LightGBM的学习。
xgb lgb 调参
weixin_30323631的博客
10-16 1601
一、XGBoost参数解释 XGBoost的参数一共分为三类： 通用参数：宏观函数控制。 Booster参数：控制每一步的booster(tree/regression)。booster参数一般可以调控模型的效果和计算代价。我们所说的调参，很这是大程度上都是在调整booster参数。 学习目标参数：控制训练目标的表现。我们对于问题的划分主要体现在学习目标参数上。比如我们要做分类...
数据竞赛达观杯（5）——LightGBM
orient928的博客
04-13 287
文章目录一. LightGBM模型1.GBDT存在的几个问题1.1 如何减少数据量1.2 如何减少特征1.3 关于稀疏的数据2. 引入LightGBM2.1 优点2.2 特点二. lightGBM调参三. lightGBM模型实践 一. LightGBM模型 1.GBDT存在的几个问题 1.1 如何减少数据量 常用的减少训练数据量的方式是down sample。例如权重小于阈值的数据会被过滤掉，...
Kaggle数据科学竞赛使用GBDT、XGBoost、Lightgbm方法预测是否可以成功申请经费
weixin_43217641的博客
10-24 1284
Kaggle数据科学竞赛内容，极度舒适。
Kaggle竞赛首选库！LightGBM详解与实现
jakpopc的博客
03-03 1123
LightGBM(LGBM)是一个开源的梯度提升库，在机器学习开发者中得到了极大的欢迎和喜爱。 目前，它已经成为Kaggle竞赛的首选库之一，正是因为它在训练模型过程中速度和准确度方面具有非常优秀的表现。 LightGBM的性能优势是它对数据进行采样（GOSS —Gradient-based One-Sided Sampling）并减少训练期间稀疏数据集中的特征数量（EFB — Exclusive Feature Bundling）的结果。 在本文中，我将尝试解释LGBM背后的关键概念，并在最后给出一
全国大学生数据统计与分析竞赛2021年【研究生组】-B题：基于 lightGBM 的用户消费行为价值分析（附优秀论文及python代码实现）
getusushu的博客
06-01 608
公司的营销成本，实现小成本促销，达到提高用户转化率的目标。其次，针对数据中的缺失值问题，对存在缺失值的特征列，按。最后，针对用户详情表中的异常数据，采用正态分布检测方法检测各个特征列的异常数。先，绘制用户在各城市分布情况的热力图和玫瑰饼图，直观反映出用户广泛分布在全国。行多种可视化展现，在购买用户和非购买用户中，购买用户比非购买用户的平均登录天。户的下单比例会呈下降的趋势，故企业需尽可能在用户登录时间为早期阶段时，给用户。数更多，登录间隔和登录距离期末天数更短，登录时长更长。一线的用户进行推荐。
利用随机森林、GBDT、xgboost、LightGBM计算准确率和auc
weixin_41710583的博客
12-11 1万+
综合Forest,GBDT,XGBoot,lightgbm几种算法得出的准确率和auc值,GBDT的score:0.8623384430417794,auc：0.7633094425839567的效果最好.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

sunnuan01

一起学习，共同进步

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值