突破最强算法模型，LightGBM ！！!

2024-07-12 13:33:49 浏览数 (1)

天把LightGBM剩余的4个问题和大家分享一下。

先来简单介绍以下LightGBM，给可能不会熟悉的同学一个大概的印象~

LightGBM呢，是微软开发的一个机器学习工具，擅长处理大数据和高维数据。LightGBM是基于决策树的提升方法，通过不断调整和优化预测模型来提高精度。与其他算法相比，LightGBM速度更快、内存占用更少、准确率更高，并且能处理类别特征。

老规矩：大家伙如果觉得近期文章还不错！欢迎大家点个赞、转个发~

咱们今天涉及到的几个问题涉及到：

  • 参数调优
  • 模型训练
  • 模型评估

依旧是大标题分类以及具体的Question，废话不多说，咱们一起来看看~

再有问题，随时私信哈~

参数调优

读者问： 最近刚刚接触LightGBM，有哪些常见的超参数？有些不太理解~

大壮答： 你好！首先，咱们聊一下LightGBM的本质，本质是一种高效的梯度提升框架，用于分类和回归任务。它通过基于决策树的算法进行迭代训练，以提高模型的准确性。为了获得最佳性能，了解并调优超参数是非常重要的。

下面先介绍一些常见的LightGBM超参数：

1. 主要超参数

  • num_leaves：这个参数控制树的复杂度。树的叶子数越多，模型越复杂，越容易过拟合。合理设置这个参数可以在精度和过拟合之间找到平衡。
  • max_depth：这个参数控制树的最大深度。它用于限制树的深度，从而防止过拟合。
  • learning_rate：学习率决定每次迭代更新的幅度。较低的学习率通常需要更多的迭代次数来收敛，但能带来更好的模型性能。
  • n_estimators：这个参数设置提升的树的数量。一般来说，更多的树可以提高模型的性能，但也增加了计算时间。

2. 树的构建参数

  • min_data_in_leaf：一个叶子节点中最少的数据量。这个参数可以用来防止过拟合。
  • min_sum_hessian_in_leaf：一个叶子节点中最小的hessian和（Hessian矩阵是目标函数的二阶导数矩阵）。这个参数同样可以用来防止过拟合。
  • bagging_fraction：每次迭代时用来训练的数据比例。用于Bagging，防止过拟合。
  • feature_fraction：每次迭代时用来训练的特征比例。用于特征采样，防止过拟合。

3. 正则化参数

  • lambda_l1：L1正则化项的权重。可以用来减少模型的复杂度，防止过拟合。
  • lambda_l2：L2正则化项的权重。同样可以用来减少模型的复杂度，防止过拟合。

4. 其他

  • objective：目标函数，决定了任务的类型（如回归、二分类、多分类等）。
  • metric：评估指标，用于评估模型的性能（如rmse、auc等）。

这里，再举一个完整的代码，可以学习理解一下~

代码语言：javascript复制
import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# 示例数据集
X, y = np.random.rand(1000, 10), np.random.rand(100)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建数据集
train_data = lgb.Dataset(X_train, label=y_train)
test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)

# 设置参数
params = {
    'num_leaves': 31,
    'max_depth': -1,
    'learning_rate': 0.1,
    'n_estimators': 100,
    'min_data_in_leaf': 20,
    'min_sum_hessian_in_leaf': 1e-3,
    'bagging_fraction': 0.8,
    'feature_fraction': 0.8,
    'lambda_l1': 0.1,
    'lambda_l2': 0.2,
    'objective': 'regression',
    'metric': 'rmse'
}

# 训练模型
gbm = lgb.train(params, train_data, valid_sets=[test_data], early_stopping_rounds=10)

# 预测
y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration)

# 评估
rmse = mean_squared_error(y_test, y_pred, squared=False)
print(f'Test RMSE: {rmse}')

需要注意的是：

  1. num_leaves和max_depth需要根据数据量和特征数进行调节，以防止过拟合。
  2. learning_rate和n_estimators需要配合使用，较低的学习率需要较多的迭代次数。
  3. bagging_fraction和feature_fraction可以帮助减少过拟合，但也会增加模型训练时间。
  4. 正则化参数（lambda_l1和lambda_l2）需要仔细调试，找到防止过拟合的最佳值。

希望以上内容可以帮助你更好地理解和使用LightGBM的超参数。有问题可以随时私信~

参数调优2

读者问： 在学习LightGBM，其中学习率、最大深度、叶子数等参数，可以帮我简单梳理一下吗？

大壮答： 没问题，在LightGBM实验中，有几个关键参数需要理解和调优，其中包括学习率（learning rate）、最大深度（max_depth）和叶子数（num_leaves）等。

学习率（learning rate）

学习率是控制模型每次更新步伐的参数。具体来说，它决定了每次迭代调整模型权重的幅度。学习率越小，模型学习得越慢，但可能更精确；学习率越大，模型学习得越快，但可能会跳过最佳解，导致训练不稳定。

公式上可以理解为：模型的权重更新公式为：

其中， 是当前权重， 是梯度。

注意点：

  1. 过大的学习率可能导致模型无法收敛。
  2. 过小的学习率会导致训练时间过长。

最大深度（max_depth）

最大深度是指每棵决策树的最大深度。它限制了树的深度，从而控制模型的复杂度。最大深度越大，模型越复杂，越容易过拟合；最大深度越小，模型越简单，越容易欠拟合。

注意点：

  1. 深度过大，可能会导致模型过拟合训练数据。
  2. 深度过小，可能会导致模型欠拟合。

叶子数（num_leaves）

叶子数是指一棵树中叶子的最大数量。这个参数也直接影响模型的复杂度和拟合能力。理论上，一个树的叶子数越多，模型的表现越强，但同时也增加了过拟合的风险。

公式上可以理解为：树的叶子数和最大深度的关系是非线性的。一个深度为的完全二叉树最多可以有 个叶子节点。

注意点：

  1. 叶子数过多，模型可能会过拟合。
  2. 叶子数过少，模型可能无法捕捉数据的复杂性。

下面，是一个Python代码，涉及到学习率、最大深度、叶子数等等的概念~

代码语言：javascript复制
import lightgbm as lgb
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import numpy as np

# 生成一些示例数据
X, y = np.random.rand(1000, 10), np.random.rand(1000)

# 拆分数据集
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建LightGBM数据集
train_data = lgb.Dataset(X_train, label=y_train)
val_data = lgb.Dataset(X_val, label=y_val, reference=train_data)

# 设置参数
params = {
    'objective': 'regression',
    'metric': 'mse',
    'learning_rate': 0.05,
    'max_depth': 7,
    'num_leaves': 31,
}

# 训练模型
model = lgb.train(params, train_data, valid_sets=[val_data], early_stopping_rounds=10)

# 预测
y_pred = model.predict(X_val, num_iteration=model.best_iteration)

# 评估模型
mse = mean_squared_error(y_val, y_pred)
print(f'Mean Squared Error: {mse}')

以上的解释和代码可以帮助你去更好地理解和使用LightGBM中的学习率、最大深度和叶子数等参数。

如果有进一步的问题，继续聊~

模型评估

读者问： 大壮哥，LightGBM 实验中，怎么样使用交叉验证来评估模型的泛化能力？

大壮答： 是的， 交叉验证是一种常用的方法来评估模型的泛化能力。交叉验证通过将数据集分成多个子集，反复训练和验证模型，从而能够更可靠地评估模型在未见数据上的表现。

下面，咱们从交叉验证是什么？以及LightGBM的交叉验证函数聊聊~

  1. 交叉验证的基本概念：
    • k折交叉验证：将数据集分为k个子集（折），每次用k-1个子集训练模型，剩下的1个子集验证模型。重复k次，每次用不同的子集作为验证集，最后计算k次验证结果的平均值。
    • 评估指标：常用的评估指标包括准确率（Accuracy）、AUC、F1-Score、均方误差（MSE）等，根据具体任务选择合适的评估指标。
  2. LightGBM的交叉验证函数：
    • LightGBM提供了lightgbm.cv函数，用于执行交叉验证。它可以自动处理数据分割、模型训练和评估。
  3. 超参数调优：
    • 通过交叉验证结果，可以调节LightGBM的超参数，以找到最佳参数组合，提高模型的性能。

这里，我会把之前整理好的一些代码进行整合，很完整的和你分享！

首先，准备数据并划分为特征和标签。

代码语言：javascript复制
import lightgbm as lgb
import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split

# 加载加州房价数据集
data = fetch_california_housing()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = pd.Series(data.target)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

创建LightGBM数据集，将数据转换为LightGBM数据格式。

代码语言：javascript复制
# 创建LightGBM数据集
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)

设置参数，设置LightGBM的参数。

代码语言：javascript复制
params = {
    'objective': 'regression',  # 目标函数：回归
    'metric': 'mse',            # 评估指标：均方误差
    'boosting_type': 'gbdt',    # 提升类型：梯度提升决策树
    'learning_rate': 0.1,       # 学习率
    'num_leaves': 31,           # 叶子节点数
    'max_depth': -1,            # 树的最大深度
    'feature_fraction': 0.9,    # 特征选择比例
    'bagging_fraction': 0.8,    # 数据选择比例
    'bagging_freq': 5,          # bagging的频率
    'verbose': -1               # 日志信息
}

交叉验证，使用lightgbm.cv函数执行交叉验证。

代码语言：javascript复制
# 执行交叉验证
cv_results = lgb.cv(
    params,
    lgb_train,
    num_boost_round=1000,          # 最大训练轮数
    nfold=5,                       # 5折交叉验证
    stratified=False,              # 是否进行分层抽样
    shuffle=True,                  # 是否在每次分割时打乱数据
    metrics='mse',                 # 评估指标
    early_stopping_rounds=50,      # 提前停止的轮数
    seed=42                        # 随机种子
)

# 输出交叉验证结果
print(f"最佳迭代次数：{len(cv_results['l2-mean'])}")
print(f"交叉验证的均方误差：{cv_results['l2-mean'][-1]}")

有三点需要注意，大家可以在评论区进行补充~

  1. 数据预处理：在使用交叉验证前，确保数据已经经过适当的预处理，包括缺失值处理、标准化等。
  2. 早停策略：通过设置early_stopping_rounds参数，可以在模型的性能不再提升时提前停止训练，防止过拟合。
  3. 随机种子：设置随机种子seed，确保每次运行得到相同的结果，便于实验的复现性。

使用交叉验证可以有效评估LightGBM模型的泛化能力，通过不断调整参数并验证模型表现，能够找到最佳的模型参数组合，从而提升模型在实际应用中的表现。

模型训练

读者问： 最近刚刚接触LightGBM，LightGBM的训练速度很快，但对于非常大的数据集，有什么具体的办法进一步优化训练速度？

大壮答： 你好。在大数据集上使用 LightGBM 时，即便它已经非常快速，我们仍然可以通过以下几种方法来进一步优化训练速度：

  1. 减少数据量：
    • 采样：对非常大的数据集，可以尝试进行数据采样（比如随机采样），这样可以减少训练数据的量，从而加快训练速度。
    • 特征选择：移除那些对模型贡献不大的特征，减少特征数量也可以显著提高训练速度。
  2. 调节参数：
    • num_leaves：树的叶子节点数量，通常设置为2^(max_depth)。降低num_leaves会减少模型的复杂度，从而加快训练速度。
    • max_depth：树的最大深度。设置一个合适的max_depth可以防止树过深，从而减少训练时间。
    • min_data_in_leaf：每个叶子节点的最小样本数量。增加这个值可以减少树的复杂度，从而加快训练速度。
    • feature_fraction：每次迭代时用来训练的特征比例。减少这个比例可以加快训练速度。
    • bagging_fraction 和 bagging_freq：Bagging的采样比例和频率，增加采样比例和频率可以加快训练速度。
  3. 并行化：
    • 使用多线程或多进程来加速训练。LightGBM本身支持多线程，可以通过设置num_threads参数来控制使用的线程数。
  4. 数据格式优化：
    • 将数据转换成LightGBM专用的二进制格式（.bin），这样可以显著减少数据加载时间。
  5. 硬件优化：
    • 使用更强大的硬件，比如更多的CPU核、更大的内存，以及使用SSD而不是HDD来存储数据。

代码中，我们生成了一百万的数据，结合上面的方式，给大家展示如何通过调整参数和使用多线程来加速LightGBM的训练：

代码语言：javascript复制
import lightgbm as lgb
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import time

# 生成一个大的数据集
X, y = make_classification(n_samples=1000000, n_features=50, n_informative=30, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建数据集格式
train_data = lgb.Dataset(X_train, label=y_train)
test_data = lgb.Dataset(X_test, label=y_test, reference=train_data)

# 设置参数
params = {
    'objective': 'binary',
    'metric': 'binary_logloss',
    'num_leaves': 31,
    'max_depth': -1,
    'min_data_in_leaf': 20,
    'learning_rate': 0.1,
    'feature_fraction': 0.8,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'num_threads': 8  # 使用8个线程
}

# 训练模型并计时
start_time = time.time()
gbm = lgb.train(params,
                train_data,
                num_boost_round=100,
                valid_sets=[train_data, test_data],
                early_stopping_rounds=10)

print(f"Training completed in {time.time() - start_time:.2f} seconds")

# 预测并计算精度
y_pred = gbm.predict(X_test, num_iteration=gbm.best_iteration)
accuracy = sum((y_pred > 0.5) == y_test) / len(y_test)
print(f"Accuracy: {accuracy:.2%}")

还是有三点要注意：

  1. 数据预处理：在使用LightGBM之前，确保数据已经过标准化或归一化处理。
  2. 内存管理：在处理非常大的数据集时，注意内存的使用情况，尽量避免内存溢出。
  3. 参数调优：上述参数只是一个基本的建议，实际使用中可能需要根据具体情况进行调整。

通过这些方法和技巧，你可以在非常大的数据集上进一步优化LightGBM的训练速度。

数据 算法 性能 函数 模型

0 人点赞