LightGBM用法速查表

最新推荐文章于 2024-08-22 18:37:12 发布
最新推荐文章于 2024-08-22 18:37:12 发布
阅读量966 收藏 6
点赞数
分类专栏： XGBoost LightGBM CatBoost 文章标签： python 机器学习 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Grateful_Dead424/article/details/123065728
版权
本文介绍了LightGBM库在实际应用中的使用，包括读取数据、训练模型、设置样本权重、模型保存与加载、继续训练及调整参数、自定义损失函数以及与sklearn集成。通过例子展示了模型训练过程中的早停策略、特征重要性评估、超参数调优等关键步骤，并利用sklearn进行模型评估和网格搜索。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

LightGBM用法速查表

1.读取csv数据并指定参数建模
# coding: utf-8
import json
import lightgbm as lgb
import pandas as pd
from sklearn.metrics import mean_squared_error
# 加载数据集合
print('Load data...')
df_train = pd.read_csv('regression.train.txt', header=None, sep='\t')
df_test = pd.read_csv('regression.test.txt', header=None, sep='\t')
# 设定训练集和测试集
y_train = df_train[0].values
y_test = df_test[0].values
X_train = df_train.drop(0, axis=1).values
X_test = df_test.drop(0, axis=1).values

# 构建lgb中的Dataset格式
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)

# 敲定好一组参数
params = {
    'task': 'train',
    'boosting_type': 'gbdt',
    'objective': 'regression',
    'metric': {'l2', 'auc'},
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.9,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'verbose': 0
}

print('开始训练...')
# 训练
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=20,
                valid_sets=lgb_eval,
                early_stopping_rounds=5)

# 保存模型
print('保存模型...')
# 保存模型到文件中
gbm.save_model('model.txt')

print('开始预测...')
# 预测
y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration)
# 评估
print('预估结果的rmse为:')
print(mean_squared_error(y_test, y_pred) ** 0.5)
#Load data...
#开始训练...
#[1]	valid_0's l2: 0.24288	valid_0's auc: 0.764496
#Training until validation scores don't improve for 5 rounds.
#[2]	valid_0's l2: 0.239307	valid_0's auc: 0.766173
#[3]	valid_0's l2: 0.235559	valid_0's auc: 0.785547
#[4]	valid_0's l2: 0.230771	valid_0's auc: 0.797786
#[5]	valid_0's l2: 0.226297	valid_0's auc: 0.805155
#[6]	valid_0's l2: 0.223692	valid_0's auc: 0.800979
#[7]	valid_0's l2: 0.220941	valid_0's auc: 0.806566
#[8]	valid_0's l2: 0.217982	valid_0's auc: 0.808566
#[9]	valid_0's l2: 0.215351	valid_0's auc: 0.809041
#[10]	valid_0's l2: 0.213064	valid_0's auc: 0.805953
#[11]	valid_0's l2: 0.211053	valid_0's auc: 0.804631
#[12]	valid_0's l2: 0.209336	valid_0's auc: 0.802922
#[13]	valid_0's l2: 0.207492	valid_0's auc: 0.802011
#[14]	valid_0's l2: 0.206016	valid_0's auc: 0.80193
#Early stopping, best iteration is:
#[9]	valid_0's l2: 0.215351	valid_0's auc: 0.809041
#保存模型...
#开始预测...
#预估结果的rmse为:
#0.4640593794679212
2.添加样本权重训练
# coding: utf-8
import json
import lightgbm as lgb
import pandas as pd
import numpy as np
from sklearn.metrics import mean_squared_error
import warnings
warnings.filterwarnings("ignore")
# 加载数据集
print('加载数据...')
df_train = pd.read_csv('binary.train', header=None, sep='\t')
df_test = pd.read_csv('./data/binary.test', header=None, sep='\t')
W_train = pd.read_csv('binary.train.weight', header=None)[0]
W_test = pd.read_csv('binary.test.weight', header=None)[0]

y_train = df_train[0].values
y_test = df_test[0].values
X_train = df_train.drop(0, axis=1).values
X_test = df_test.drop(0, axis=1).values
num_train, num_feature = X_train.shape

# 加载数据的同时加载权重
lgb_train = lgb.Dataset(X_train, y_train,
                        weight=W_train, free_raw_data=False)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train,
                       weight=W_test, free_raw_data=False)

# 设定参数
params = {
    'boosting_type': 'gbdt',
    'objective': 'binary',
    'metric': 'binary_logloss',
    'num_leaves': 31,
    'learning_rate': 0.05,
    'feature_fraction': 0.9,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'verbose': 0
}

# 产出特征名称
feature_name = ['feature_' + str(col) for col in range(num_feature)]

print('开始训练...')
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=10,
                valid_sets=lgb_train,  # 评估训练集
                feature_name=feature_name,
                categorical_feature=[21])
#加载数据...
#开始训练...
#[1]	valid_0's binary_logloss: 0.681265
#[2]	valid_0's binary_logloss: 0.673318
#[3]	valid_0's binary_logloss: 0.664193
#[4]	valid_0's binary_logloss: 0.655501
#[5]	valid_0's binary_logloss: 0.650956
#[6]	valid_0's binary_logloss: 0.644803
#[7]	valid_0's binary_logloss: 0.637567
#[8]	valid_0's binary_logloss: 0.631224
#[9]	valid_0's binary_logloss: 0.624958
#[10]	valid_0's binary_logloss: 0.619398
3.模型的载入与预测
# 查看特征名称
print('完成10轮训练...')
print('第7个特征为:')
print(repr(lgb_train.feature_name[6]))

# 存储模型
gbm.save_model('./model/lgb_model.txt')

# 特征名称
print('特征名称:')
print(gbm.feature_name())

# 特征重要度
print('特征重要度:')
print(list(gbm.feature_importance()))

# 加载模型
print('加载模型用于预测')
bst = lgb.Booster(model_file='./model/lgb_model.txt')
# 预测
y_pred = bst.predict(X_test)
# 在测试集评估效果
print('在测试集上的rmse为:')
print(mean_squared_error(y_test, y_pred) ** 0.5)
# 查看特征名称
print('完成10轮训练...')
print('第7个特征为:')
print(repr(lgb_train.feature_name[6]))

# 存储模型
gbm.save_model('./model/lgb_model.txt')

# 特征名称
print('特征名称:')
print(gbm.feature_name())

# 特征重要度
print('特征重要度:')
print(list(gbm.feature_importance()))

# 加载模型
print('加载模型用于预测')
bst = lgb.Booster(model_file='./model/lgb_model.txt')
# 预测
y_pred = bst.predict(X_test)
# 在测试集评估效果
print('在测试集上的rmse为:')
print(mean_squared_error(y_test, y_pred) ** 0.5)
# 查看特征名称
print('完成10轮训练...')
print('第7个特征为:')
print(repr(lgb_train.feature_name[6]))
​
# 存储模型
gbm.save_model('./model/lgb_model.txt')
​
# 特征名称
print('特征名称:')
print(gbm.feature_name())
​
# 特征重要度
print('特征重要度:')
print(list(gbm.feature_importance()))
​
# 加载模型
print('加载模型用于预测')
bst = lgb.Booster(model_file='./model/lgb_model.txt')
# 预测
y_pred = bst.predict(X_test)
# 在测试集评估效果
print('在测试集上的rmse为:')
print(mean_squared_error(y_test, y_pred) ** 0.5)
#完成10轮训练...
#第7个特征为:
#'feature_6'
#特征名称:
#[u'feature_0', u'feature_1', u'feature_2', u'feature_3', u'feature_4', u'feature_5', u'feature_6', u'feature_7', u'feature_8', u'feature_9', u'feature_10', u'feature_11', u'feature_12', u'feature_13', u'feature_14', u'feature_15', u'feature_16', u'feature_17', u'feature_18', u'feature_19', u'feature_20', u'feature_21', u'feature_22', u'feature_23', u'feature_24', u'feature_25', u'feature_26', u'feature_27']
#特征重要度:
#[8, 5, 1, 19, 7, 33, 2, 0, 2, 10, 5, 2, 0, 9, 3, 3, 0, 2, 2, 5, 1, 0, 36, 3, 33, 45, 29, 35]
#加载模型用于预测
#在测试集上的rmse为:
#0.4629245607636925
4.接着之前的模型继续训练
# 继续训练
# 从./model/model.txt中加载模型初始化
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=10,
                init_model='./model/lgb_model.txt',
                valid_sets=lgb_eval)

print('以旧模型为初始化，完成第 10-20 轮训练...')

# 在训练的过程中调整超参数
# 比如这里调整的是学习率
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=10,
                init_model=gbm,
                learning_rates=lambda iter: 0.05 * (0.99 ** iter),
                valid_sets=lgb_eval)

print('逐步调整学习率完成第 20-30 轮训练...')

# 调整其他超参数
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=10,
                init_model=gbm,
                valid_sets=lgb_eval,
                callbacks=[lgb.reset_parameter(bagging_fraction=[0.7] * 5 + [0.6] * 5)])
#print('逐步调整bagging比率完成第 30-40 轮训练...')
#[11]	valid_0's binary_logloss: 0.616177
#[12]	valid_0's binary_logloss: 0.611792
#[13]	valid_0's binary_logloss: 0.607043
#[14]	valid_0's binary_logloss: 0.602314
#[15]	valid_0's binary_logloss: 0.598433
#[16]	valid_0's binary_logloss: 0.595238
#[17]	valid_0's binary_logloss: 0.592047
#[18]	valid_0's binary_logloss: 0.588673
#[19]	valid_0's binary_logloss: 0.586084
#[20]	valid_0's binary_logloss: 0.584033
#以旧模型为初始化，完成第 10-20 轮训练...
#[21]	valid_0's binary_logloss: 0.616177
#[22]	valid_0's binary_logloss: 0.611834
#[23]	valid_0's binary_logloss: 0.607177
#[24]	valid_0's binary_logloss: 0.602577
#[25]	valid_0's binary_logloss: 0.59831
#[26]	valid_0's binary_logloss: 0.595259
#[27]	valid_0's binary_logloss: 0.592201
#[28]	valid_0's binary_logloss: 0.589017
#[29]	valid_0's binary_logloss: 0.586597
#[30]	valid_0's binary_logloss: 0.584454
#逐步调整学习率完成第 20-30 轮训练...
#[31]	valid_0's binary_logloss: 0.616053
#[32]	valid_0's binary_logloss: 0.612291
#[33]	valid_0's binary_logloss: 0.60856
#[34]	valid_0's binary_logloss: 0.605387
#[35]	valid_0's binary_logloss: 0.601744
#[36]	valid_0's binary_logloss: 0.598556
#[37]	valid_0's binary_logloss: 0.595585
#[38]	valid_0's binary_logloss: 0.593228
#[39]	valid_0's binary_logloss: 0.59018
#[40]	valid_0's binary_logloss: 0.588391
#逐步调整bagging比率完成第 30-40 轮训练...
5.自定义损失函数
# 类似在xgboost中的形式
# 自定义损失函数需要
def loglikelood(preds, train_data):
    labels = train_data.get_label()
    preds = 1. / (1. + np.exp(-preds))
    grad = preds - labels
    hess = preds * (1. - preds)
    return grad, hess


# 自定义评估函数
def binary_error(preds, train_data):
    labels = train_data.get_label()
    return 'error', np.mean(labels != (preds > 0.5)), False


gbm = lgb.train(params,
                lgb_train,
                num_boost_round=10,
                init_model=gbm,
                fobj=loglikelood,
                feval=binary_error,
                valid_sets=lgb_eval)

print('用自定义的损失函数与评估标准完成第40-50轮...')
#[41]	valid_0's binary_logloss: 0.614429	valid_0's error: 0.268
#[42]	valid_0's binary_logloss: 0.610689	valid_0's error: 0.26
#[43]	valid_0's binary_logloss: 0.606267	valid_0's error: 0.264
#[44]	valid_0's binary_logloss: 0.601949	valid_0's error: 0.258
#[45]	valid_0's binary_logloss: 0.597271	valid_0's error: 0.266
#[46]	valid_0's binary_logloss: 0.593971	valid_0's error: 0.276
#[47]	valid_0's binary_logloss: 0.591427	valid_0's error: 0.278
#[48]	valid_0's binary_logloss: 0.588301	valid_0's error: 0.284
#[49]	valid_0's binary_logloss: 0.586562	valid_0's error: 0.288
#[50]	valid_0's binary_logloss: 0.584056	valid_0's error: 0.288
#用自定义的损失函数与评估标准完成第40-50轮...

sklearn与LightGBM配合使用

1.LightGBM建模，sklearn评估
# coding: utf-8
import lightgbm as lgb
import pandas as pd
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import GridSearchCV

# 加载数据
print('加载数据...')
df_train = pd.read_csv('regression.train.txt', header=None, sep='\t')
df_test = pd.read_csv('.regression.test.txt', header=None, sep='\t')

# 取出特征和标签
y_train = df_train[0].values
y_test = df_test[0].values
X_train = df_train.drop(0, axis=1).values
X_test = df_test.drop(0, axis=1).values

print('开始训练...')
# 直接初始化LGBMRegressor
# 这个LightGBM的Regressor和sklearn中其他Regressor基本是一致的
gbm = lgb.LGBMRegressor(objective='regression',
                        num_leaves=31,
                        learning_rate=0.05,
                        n_estimators=20)

# 使用fit函数拟合
gbm.fit(X_train, y_train,
        eval_set=[(X_test, y_test)],
        eval_metric='l1',
        early_stopping_rounds=5)

# 预测
print('开始预测...')
y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration_)
# 评估预测结果
print('预测结果的rmse是:')
print(mean_squared_error(y_test, y_pred) ** 0.5)

#加载数据...
#开始训练...
#[1]	valid_0's l1: 0.491735
#Training until validation scores don't improve for 5 rounds.
#[2]	valid_0's l1: 0.486563
#[3]	valid_0's l1: 0.481489
#[4]	valid_0's l1: 0.476848
#[5]	valid_0's l1: 0.47305
#[6]	valid_0's l1: 0.469049
#[7]	valid_0's l1: 0.465556
#[8]	valid_0's l1: 0.462208
#[9]	valid_0's l1: 0.458676
#[10]	valid_0's l1: 0.454998
#[11]	valid_0's l1: 0.452047
#[12]	valid_0's l1: 0.449158
#[13]	valid_0's l1: 0.44608
#[14]	valid_0's l1: 0.443554
#[15]	valid_0's l1: 0.440643
#[16]	valid_0's l1: 0.437687
#[17]	valid_0's l1: 0.435454
#[18]	valid_0's l1: 0.433288
#[19]	valid_0's l1: 0.431297
#[20]	valid_0's l1: 0.428946
#Did not meet early stopping. Best iteration is:
#[20]	valid_0's l1: 0.428946
#开始预测...
#预测结果的rmse是:
#0.4441153344254208
2.网格搜索查找最优超参数
# 配合scikit-learn的网格搜索交叉验证选择最优超参数
estimator = lgb.LGBMRegressor(num_leaves=31)

param_grid = {
    'learning_rate': [0.01, 0.1, 1],
    'n_estimators': [20, 40]
}

gbm = GridSearchCV(estimator, param_grid)

gbm.fit(X_train, y_train)

print('用网格搜索找到的最优超参数为:')
print(gbm.best_params_)
#用网格搜索找到的最优超参数为:
#{'n_estimators': 40, 'learning_rate': 0.1}
3.绘图解释
# coding: utf-8
import lightgbm as lgb
import pandas as pd

try:
    import matplotlib.pyplot as plt
except ImportError:
    raise ImportError('You need to install matplotlib for plotting.')

# 加载数据集
print('加载数据...')
df_train = pd.read_csv('./data/regression.train.txt', header=None, sep='\t')
df_test = pd.read_csv('./data/regression.test.txt', header=None, sep='\t')

# 取出特征和标签
y_train = df_train[0].values
y_test = df_test[0].values
X_train = df_train.drop(0, axis=1).values
X_test = df_test.drop(0, axis=1).values

# 构建lgb中的Dataset数据格式
lgb_train = lgb.Dataset(X_train, y_train)
lgb_test = lgb.Dataset(X_test, y_test, reference=lgb_train)

# 设定参数
params = {
    'num_leaves': 5,
    'metric': ('l1', 'l2'),
    'verbose': 0
}

evals_result = {}  # to record eval results for plotting

print('开始训练...')
# 训练
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=100,
                valid_sets=[lgb_train, lgb_test],
                feature_name=['f' + str(i + 1) for i in range(28)],
                categorical_feature=[21],
                evals_result=evals_result,
                verbose_eval=10)

print('在训练过程中绘图...')
ax = lgb.plot_metric(evals_result, metric='l1')
plt.show()

print('画出特征重要度...')
ax = lgb.plot_importance(gbm, max_num_features=10)
plt.show()

print('画出第84颗树...')
ax = lgb.plot_tree(gbm, tree_index=83, figsize=(20, 8), show_info=['split_gain'])
plt.show()

#print('用graphviz画出第84颗树...')
#graph = lgb.create_tree_digraph(gbm, tree_index=83, name='Tree84')
#graph.render(view=True)

#加载数据...
#开始训练...
#[10]	training's l2: 0.217995	training's l1: 0.457448	valid_1's l2: 0.21641	valid_1's l1: 0.456464
#[20]	training's l2: 0.205099	training's l1: 0.436869	valid_1's l2: 0.201616	valid_1's l1: 0.434057
#[30]	training's l2: 0.197421	training's l1: 0.421302	valid_1's l2: 0.192514	valid_1's l1: 0.417019
#[40]	training's l2: 0.192856	training's l1: 0.411107	valid_1's l2: 0.187258	valid_1's l1: 0.406303
#[50]	training's l2: 0.189593	training's l1: 0.403695	valid_1's l2: 0.183688	valid_1's l1: 0.398997
#[60]	training's l2: 0.187043	training's l1: 0.398704	valid_1's l2: 0.181009	valid_1's l1: 0.393977
#[70]	training's l2: 0.184982	training's l1: 0.394876	valid_1's l2: 0.178803	valid_1's l1: 0.389805
#[80]	training's l2: 0.1828	training's l1: 0.391147	valid_1's l2: 0.176799	valid_1's l1: 0.386476
#[90]	training's l2: 0.180817	training's l1: 0.388101	valid_1's l2: 0.175775	valid_1's l1: 0.384404
#[100]	training's l2: 0.179171	training's l1: 0.385174	valid_1's l2: 0.175321	valid_1's l1: 0.382929
#在训练过程中绘图...

在这里插入图片描述
画出特征重要度…
在这里插入图片描述
画出第84颗树…
在这里插入图片描述

【2025算法面试通关】【二.机器学习-模型评估与调优】【16. 模型评估与调优面试必知：100 道题吃透准确率、AUC 及交叉验证】
商务合作|问题讨论|交流学习 请联系作者微信，加微信请务必注明来意，博客主页有联系方式
04-09 429
AUC=1表示排序完美（所有正样本得分高于负样本），但可能存在阈值下TPR=1且FPR=0（无FP和FN），或存在阈值下仍有FP/FN（如所有正样本得分等于负样本，但排序无交错）。答：优先选择轻量模型（如LightGBM vs 深度神经网络），简化特征，使用近似算法（如随机森林的子采样），或在超参数中限制模型复杂度（如决策树最大深度）。例如，模型将所有样本预测为正类，AUC=0.5（随机排序），但准确率等于正样本比例（若正样本少，准确率低）。若数据量极大（如n=10万），用k=3或k=5减少训练次数。
Python梯度提升决策树库之lightgbm使用详解
Rocky006的博客
04-29 1138
LightGBM是一个快速、分布式、高性能的梯度提升决策树（Gradient Boosting Decision Tree）库，它在机器学习和数据挖掘领域被广泛应用。本文将介绍LightGBM库的安装方法、主要特性、基本功能、高级功能、以及在实际应用中的场景和总结。
树类算法之---lightGBM使用与调参
Ricky
04-23 9873
1. 说明 官方文献说明，想深入研究的可以戳进去进一步学习 lightGBM是一个基于树模型的分布式Boosting算法，该算法是有微软开源贡献，说到tree-based模型一般都会想到XGBOOST算法，毕竟也是曾经的大杀器，那下面就把这两个算法进行一些对比。 2.Xgboost的优缺点 优点：(不详细说了，默认有树模型基础) 1.Xgboost利用的二阶梯度，相对于lightGBM在进行节点...
Python lightgbm如何使用
youyouxiong的博客
05-01 1580
GiHub地址：LightGBM 是一个高效的梯度提升框架，使用基于树的学习算法。它由微软开发，旨在在提供高效率的同时，也能保持高性能。
LightGBM使用教程
weixin_43217641的博客
09-13 3741
详细的介绍了关于lightgbm的使用教程，展示了lightgbm中的分类与回归问题的可视化。
LightGBM操作指南
qq_42189083的博客
10-20 1524
转自：https://mp.weixin.qq.com/s/9gEfkiZyZkoIgwRCYISQgQ LightGBM是基于XGBoost的一款可以快速并行的树模型框架，内部集成了多种集成学习思路，在代码实现上对XGBoost的节点划分进行了改进，内存占用更低训练速度更快。 LightGBM官网：https://lightgbm.readthedocs.io/en/latest/ 参数介绍：https://lightgbm.readthedocs.io/en/latest/Parameters.h
LightGBM中的一些tips
AiirrrrYee的博客
11-24 1233
改进 直方图算法（Histogram） 根据直方图中的离散值，遍历寻找最优分割点： 把连续的浮点特征离散 -> k个整数 -> 宽为k的直方图 遍历，离散化的值作为索引，在直方图中累积统计量加速 叶子 ＝ 父 － 兄弟 （直方图做差） Leaf-wise带深度限制的叶子生长策略 支持categorical feature 并行 feature parallel：每个worker中有所有fea
NLP核心应用特训特征点提取aXgboost与LightGBM的用法速查表方法 自定义损失函数与评估准则 网格搜索与交叉验证
09-23
特征点提取aXgboost与LightGBM的用法速查表方法 自定义损失函数与评估准则 网格搜索与交叉验证 early- stopping早停及并行训练加速
集成学习-Boosting集成学习算法LightGBM
数据掘金
11-10 1075
在2017年年1月微软在GitHub的上开源了一个新的升压工具LightGBM（Light Gradient Boosting Machine ）。它是一种优秀的机器学习算法框架，与XGBoost算法相比，在不降低准确率的前提下，速度提升了10倍左右，占用内存下降了3倍左右。 下图是LightGBM在GitHub主页上展示的在五个不同数据集上得到的性能实验数据，比起XGBoost算法，LightGBM算法在准确度一样，但在速度和内存的消耗上有更明显的优势。 耗时比较： 准确率比较： 内存消耗
【集成学习系列教程5】LightGBM
qq_42554780的博客
09-30 1822
1.7 LightGBM 1.7.1 概述 前面我们介绍了AdaBoost和GBDT这两种Boosting方法，它们已经在很多问题上发挥了强大的威力，也已经具有较好效率。但是，如今的数据集正在朝着样本数越来越巨大，特征维度也越来越高的方向发展，此时这两种传统的Boosting方法在效率和可扩展性上已经不能满足现在的需求了。主要原因是：传统的Boosting算法中的基学习器需要通过对所有样本点的每一个特征都进行扫描来计算信息增益，进而找到最佳的分割点，这在样本数和特征数巨大的情况下会相当耗时。为了解决传统Bo
机器学习——lightGBM（学习整理）
最新发布
CXDNW的博客
08-22 3753
LightGBM 是 微软的 一个团队 在 Github 上开发的一个 开源项目，高性能 的 LightGBM 算法具有分布式 和 可以 快速处理大量数据的 特点。LightGBM 虽然 基于 决策树和 XGBoost 而生，但它 还遵循 其他不同的 策略。XGBoost 使用决策树 对一个 变量进行 拆分，并在 该变量上 探索不同的 切割点（按级别划分的 树生长策略），而LightGBM 则 专注于 按叶子节点 进行拆分，以便 获得更好的 拟合（按叶划分的树生长策略）。
LightBGM之Dataset
weixin_30556959的博客
09-09 2120
最近使用了LightBGM的Dataset，记录一下： 1.说明：　　classlightgbm.Dataset(data,label=None,reference=None,weight=None,group=None,init_score=None,silent=False,feature_name='auto',categorical_feature='auto',par...
机器学习实战 | LightGBM建模应用详解
热门推荐
ShowMeAI研究中心
03-21 2万+
本篇详细讲解LightGBM的工程应用方法。LightGBM是微软开发的boosting集成模型，和XGBoost一样是对GBDT的优化和高效实现，但它很多方面比XGBoost有着更为优秀的表现。
lightgbm使用-lgb.Dataset()
weixin_44848780的博客
07-11 2483
1.定义数据集和标签，这里定义为二分类问题，注意feature和label的类型，并不要求同类型。虽然feature是array数组，但是也可以指定特征名称。这里指定第五例特征是分类特征。lgb.train的参数明天再补 cout
Digit Recognizer by LightGBM
当回忆不再总是~
04-21 4291
用LightGBM和xgboost分别做了Kaggle的Digit Recognizer，尝试用GridSearchCV调了下参数，主要是对max_depth, learning_rate, n_estimates等参数进行调试，最后在0.969。 能力有限，接下来也不知道该如何进一步调参。 另外xgboost的GridSearchCV还是不会用，如果有大神会的话，烦请告知。 贴下L
lightgbm模型调用
nch970214的博客
07-23 3076
一、原生形式使用lightgbm(import lightgbm as lgb) # 模型训练 gbm = lgb.train(params, lgb_train, num_boost_round=20, valid_sets=lgb_eval, early_stopping_rounds=5) # 模型保存 gbm.save_model('model.txt') # 模型加载 gbm = lgb.Booster(model_file='model.txt') # 模型预测 y_pred = g
LightGBM模型保存save_model后加载
罟霖同学的站点
11-15 1923
LightGBM模型的加载通常会使用外置的joblib接口来实现，但有时候我们也能看到使用其自带接口save_model来实现。但网上对于这一接口下保存的模型该如何读取，并没有相关详尽的介绍。本文将给出保存后后该如何读取。
XGBoost模型及LightGBM模型案例（Python）
qq_42433311的博客
04-29 1万+
XGBoost算法原理参考其他详细博客以及官方文档 LightGBM算法原理参考其他详细博客以及官方文档 这里介绍两个算法的简单案例应用。 1 XGBoosting案例：金融反欺诈模型 信用卡盗刷一般发生在持卡人信息被不法分子窃取后复制卡片进行消费或信用卡被他人冒领后激活并消费等情况下。一旦发生信用卡盗刷，持卡人和银行都会遭受一定的经济损失。因此，通过大数据技术搭建金融反欺诈模型对银行来说尤为重要。 1.1模型搭建 1.1.1读取数据 通过如下代码读取1000条客户信用卡的交易数据。 特..
python的lightgbm使用方法
03-31
LightGBM是一个基于梯度提升决策树（Gradient Boosting Decision Tree）的机器学习框架，它在处理大规模数据集时具有高效性能。下面是Python中使用LightGBM的基本步骤： 1. 安装LightGBM库：使用pip命令安装LightGBM库，例如：`pip install lightgbm` 2. 导入必要的库：在Python脚本中导入LightGBM库和其他需要的库，例如： ```python import lightgbm as lgb from sklearn.model_selection import train_test_split ``` 3. 准备数据集：将数据集划分为训练集和测试集，并将其转换为LightGBM所需的数据格式。通常，LightGBM可以直接处理原始数据，无需进行特征缩放或独热编码。 4. 创建LightGBM数据集：使用`lgb.Dataset()`函数创建LightGBM所需的数据集对象，例如： ```python train_data = lgb.Dataset(X_train, label=y_train) test_data = lgb.Dataset(X_test, label=y_test) ``` 5. 设置模型参数：定义LightGBM模型的参数，例如学习率、树的数量、最大深度等。可以使用`lgb.train()`函数的`params`参数来设置这些参数。 6. 训练模型：使用`lgb.train()`函数训练LightGBM模型，例如： ```python model = lgb.train(params, train_data, num_boost_round=100) ``` 7. 模型预测：使用训练好的模型进行预测，例如： ```python y_pred = model.predict(X_test) ``` 8. 模型评估：根据任务类型选择适当的评估指标，例如分类任务可以使用准确率、召回率等指标进行评估。 9. 调参优化：根据模型表现进行参数调整和优化，以提高模型性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值