LightGBM + TA-Lib A股实战进阶：Optuna调优与Plotly可视化详解

LightGBM + TA-Lib A 股实战进阶：Optuna 调优与 Plotly 可视化详解

本文系统讲解了 LightGBM 在 A 股市场的应用，涵盖模型构建、Optuna 参数调优及 Plotly 可视化。通过实战案例，帮助读者全面掌握相关技术，提升在金融数据分析与预测领域的专业能力。
文中内容仅限技术学习与代码实践参考，市场存在不确定性，技术分析需谨慎验证，不构成任何投资建议。适合量化新手建立系统认知，为策略开发打下基础。

第一章 LightGBM 基础与环境搭建

1.1 LightGBM 简介

LightGBM 是一种基于梯度提升框架的高效、快速的决策树算法，由微软开发。其核心优势包括：

梯度助推（Gradient Boosting）：通过迭代地训练决策树来逐步减少模型的残差，提升模型性能。
直方图算法（Histogram Algorithm）：将连续的特征值离散化为直方图，减少搜索最佳分割点的计算量，提升训练速度。
特征并行与数据并行：支持多种并行学习方式，充分利用硬件资源，加速模型训练。

LightGBM 在机器学习中的应用场景广泛，尤其在结构化数据的回归与分类问题中表现出色，如金融领域的风险评估、股市预测等。

1.2 环境搭建

Python 环境准备

推荐使用 Python 3.7 及以上版本。可以通过以下命令安装必要的库：

pip install lightgbm optuna plotly pandas numpy tushare

Tushare 数据接口申请与配置

访问Tushare 官网，注册账号并获取 API 令牌。
在代码中配置 Tushare API：

import tushare as ts
ts.set_token("your_token")  # 替换为你的Tushare令牌
pro = ts.pro_api()

1.3 数据准备与预处理

使用 Tushare 获取 A 股市场数据

以获取某股票的历史日线数据为例：

# 获取股票数据
def get_stock_data(ts_code="000001.SZ", start_date="20200101", end_date="20241231"):
    df = pro.daily(ts_code=ts_code, start_date=start_date, end_date=end_date)
    return df


# 示例：获取贵州茅台（600519.SH）的股票数据
stock_data = get_stock_data(ts_code="600519.SH")
print(stock_data.head())

数据存储为 Parquet 文件格式

Parquet 是一种高效的列式存储格式，适合大数据处理。使用 Pandas 将数据存储为 Parquet 文件：

# 存储为Parquet文件
stock_data.to_parquet("./data/600519.SH.parquet", compression="snappy", index=False)

数据加载与基本探索

import pandas as pd

# 加载Parquet文件
stock_data = pd.read_parquet("./data/600519.SH.parquet")

# 数据基本探索
print("数据描述性统计：")
print(stock_data.describe())
print("\n数据缺失值情况：")
print(stock_data.isnull().sum())

数据预处理

在机器学习项目中，数据预处理是至关重要的一步。对于 A 股市场数据，通常需要进行以下预处理操作：

缺失值处理：根据数据特征选择填充、删除或插值等方法处理缺失值。例如，对于股票价格数据中的少量缺失值，可以采用前向填充（ffill）或后向填充（bfill）的方法进行处理：

# 示例：缺失值填充
stock_data.fillna(method="ffill", inplace=True)
stock_data.fillna(method="bfill", inplace=True)

特征工程：根据业务知识和数据特点，构造有助于模型学习的特征。在 A 股市场预测中，常见的特征包括技术指标（如移动平均线、相对强弱指标等）、量能指标等。例如，计算 5 日和 10 日的收盘价移动平均线作为特征：

import talib as ta

# 计算移动平均线
stock_data["MA5"] = ta.SMA(stock_data["close"], timeperiod=5)
stock_data["MA10"] = ta.SMA(stock_data["close"], timeperiod=10)

数据标准化或归一化：对于某些机器学习算法，尤其是基于距离度量的算法，数据的标准化或归一化可以提升模型性能。可以使用 sklearn 的 StandardScaler 或 MinMaxScaler 进行处理：

from sklearn.preprocessing import StandardScaler

# 选择需要标准化的特征
features = ["open", "high", "low", "close", "MA5", "MA10"]
scaler = StandardScaler()
stock_data[features] = scaler.fit_transform(stock_data[features])

print(stock_data.head())

第二章 LightGBM 模型基础应用

2.1 LightGBM 模型构建流程

数据集划分

在机器学习项目中，合理地划分数据集是确保模型泛化能力的关键步骤。对于 A 股市场数据，通常将数据划分为训练集、验证集和测试集。训练集用于模型的参数学习，验证集用于调整模型的超参数和防止过拟合，测试集用于最终评估模型的性能。划分比例可以根据数据量和具体任务灵活调整，常见的划分比例为 60%训练集、20%验证集和 20%测试集。

from sklearn.model_selection import train_test_split

# 假设 stock_data 是已经预处理好的数据
features = ["open", "high", "low", "MA5", "MA10", "vol"]  # 特征列
target = "close"  # 目标列

X = stock_data[features]
y = stock_data[target]

# 划分训练集、验证集和测试集
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
X_train, X_val, y_train, y_val = train_test_split(
    X_train, y_train, test_size=0.25, random_state=42
)  # 0.25 of 80% is 20% of total data

LightGBM Dataset 对象创建

LightGBM 提供了专门的 Dataset 对象用于数据的高效加载和管理。通过创建 Dataset 对象，可以方便地将数据传递给 LightGBM 模型进行训练，并且支持多种数据格式和预处理操作。

import lightgbm as lgb

# 创建 LightGBM Dataset 对象
train_data = lgb.Dataset(X_train, label=y_train, free_raw_data=False)
val_data = lgb.Dataset(X_val, label=y_val, reference=train_data, free_raw_data=False)

模型参数设置

LightGBM 模型的性能在很大程度上取决于参数的设置。参数设置包括基本参数（如目标函数、评估指标等）、树生长参数（如最大深度、叶子数量等）和学习控制参数（如学习率、迭代次数等）。不同的参数组合会对模型的训练速度、泛化能力和预测性能产生显著影响。

# 设置LightGBM模型参数
params = {
    "objective": "regression",  # 回归任务
    "metric": "mse",  # 评估指标为均方误差
    "boosting_type": "gbdt",  # 梯度提升决策树
    "num_leaves": 31,  # 叶子数量
    "learning_rate": 0.05,  # 学习率
    "feature_fraction": 0.9,  # 特征采样比例
    "verbose": -1,  # 日志输出级别
}

模型训练与预测

模型训练是机器学习流程的核心环节，通过训练使模型学习到数据中的模式和规律。在训练过程中，可以设置 early_stopping 参数来提前停止训练，防止过拟合。模型训练完成后，使用测试集进行预测，评估模型的泛化能力。

# 模型训练
model = lgb.train(
    params,
    train_data,  # 训练数据
    valid_sets=[val_data],  # 验证数据
    num_boost_round=1000,  # 最大迭代次数
    callbacks=[lgb.early_stopping(stopping_rounds=10)],  # 早停机制
)

# 模型预测
y_pred = model.predict(X_test, num_iteration=model.best_iteration)

2.2 LightGBM 在 A 股市场的基础应用案例

以某 A 股股票价格预测为例

在 A 股市场中，股票价格预测是一个典型的回归问题，可以通过 LightGBM 模型进行建模和预测。选择具有代表性的股票数据，如某知名蓝筹股的历史交易数据，作为案例进行详细讲解，有助于理解 LightGBM 在实际金融场景中的应用。

# 示例：使用LightGBM预测某股票的收盘价

# 假设已经获取并预处理好了某股票的数据，存储在变量stock_data中

import lightgbm as lgb
import talib as ta
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# 特征工程：计算技术指标等作为特征
stock_data["MA5"] = ta.SMA(stock_data["close"], timeperiod=5)
stock_data["MA10"] = ta.SMA(stock_data["close"], timeperiod=10)
stock_data["MA20"] = ta.SMA(stock_data["close"], timeperiod=20)
stock_data["MA30"] = ta.SMA(stock_data["close"], timeperiod=30)

# 构造目标变量：未来某一天的收盘价
stock_data["target"] = stock_data["close"].shift(-1)

# 删除最后一行，因为最后一行的目标变量是NaN
stock_data = stock_data[:-1]

# 数据集划分
features = ["open", "high", "low", "MA5", "MA10", "MA20", "MA30", "vol"]
target = "target"
scaler = StandardScaler()
stock_data[features] = scaler.fit_transform(stock_data[features])

X = stock_data[features]
y = stock_data[target]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
X_train, X_val, y_train, y_val = train_test_split(
    X_train, y_train, test_size=0.25, random_state=42
)  # 0.25 of 80% is 20% of total data

# 创建LightGBM Dataset对象
train_data = lgb.Dataset(X_train, label=y_train, free_raw_data=False)
val_data = lgb.Dataset(X_val, label=y_val, reference=train_data, free_raw_data=False)

# 设置模型参数
params = {
    "objective": "regression",  # 回归任务
    "metric": "mse",  # 评估指标为均方误差
    "boosting_type": "gbdt",  # 梯度提升决策树
    "num_leaves": 31,  # 叶子数量
    "learning_rate": 0.05,  # 学习率
    "feature_fraction": 0.9,  # 特征采样比例
    "verbose": -1,  # 日志输出级别
}

# 模型训练
model = lgb.train(
    params,
    train_data,  # 训练数据
    valid_sets=[val_data],  # 验证数据
    num_boost_round=1000,  # 最大迭代次数
    callbacks=[lgb.early_stopping(stopping_rounds=10)],  # 早停机制
)

# 模型预测
y_pred = model.predict(X_test, num_iteration=model.best_iteration)

# 模型评估
from sklearn.metrics import mean_squared_error, r2_score

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"均方误差（MSE）：{mse}")
print(f"决定系数（R²）：{r2}")

特征工程

特征工程是机器学习项目中至关重要的一步，尤其在 A 股市场预测中，合理的特征工程可以显著提升模型的性能。除了基本的技术指标外，还可以考虑加入宏观经济指标、行业板块信息、市场情绪指标等多维度特征，以更全面地刻画股票价格的影响因素。

# 示例：加入市场情绪指标作为特征

# 假设已经获取了市场情绪指标数据，存储在变量market_sentiment中

# 合并市场情绪指标到股票数据中
stock_data = pd.merge(stock_data, market_sentiment, on="trade_date", how="left")

# 填充缺失值
stock_data["market_sentiment"].fillna(method="ffill", inplace=True)
stock_data["market_sentiment"].fillna(method="bfill", inplace=True)

# 更新特征列表
features.append("market_sentiment")

模型训练与评估

在模型训练过程中，可以结合交叉验证等方法进一步优化模型的性能，提高模型的泛化能力。同时，除了使用均方误差（MSE）作为评估指标外，还可以考虑使用平均绝对误差（MAE）、决定系数（R²）等多指标综合评估模型的预测性能。

# 执行交叉验证
cv_results = lgb.cv(
    params,
    train_data,
    num_boost_round=100,
    nfold=5,
    stratified=False,
    shuffle=True,
    seed=0,
)

# 输出最佳迭代次数和交叉验证的均方误差
print("最佳迭代次数：", len(cv_results["valid l2-mean"]))
print("交叉验证的均方误差：", cv_results["valid l2-mean"][-1])

2.3 LightGBM 模型评估与解释

性能评估指标

在回归问题中，常用的性能评估指标包括均方误差（MSE）、平均绝对误差（MAE）、决定系数（R²）等。均方误差反映了预测值与真实值之间的平均平方误差，值越小表示模型性能越好；平均绝对误差反映了预测值与真实值之间的平均绝对误差，对异常值不太敏感；决定系数表示模型对数据变异的解释程度，值越接近 1 表示模型性能越好。

# 计算多个评估指标
from sklearn.metrics import mean_absolute_error, r2_score

mse = mean_squared_error(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"均方误差（MSE）：{mse}")
print(f"平均绝对误差（MAE）：{mae}")
print(f"决定系数（R²）：{r2}")

特征重要性分析

通过分析特征的重要性，可以了解哪些特征对模型的预测结果影响最大，有助于特征筛选和模型优化。LightGBM 模型提供了内置的特征重要性计算功能，可以根据特征在树中的分裂次数、分裂增益等指标来衡量特征的重要性。

# 获取特征重要性
feature_importance = model.feature_importance()
feature_names = X_train.columns

# 创建特征重要性DataFrame
importance_df = pd.DataFrame(
    {"feature": feature_names, "importance": feature_importance}
).sort_values(by="importance", ascending=False)

print("特征重要性：")
print(importance_df)

模型解释（SHAP 值）

SHAP（SHapley Additive exPlanations）值是一种基于博弈论的模型解释方法，可以量化每个特征对模型预测结果的贡献。通过计算 SHAP 值，可以更深入地理解模型的决策过程和各特征的影响机制。

# 使用SHAP库计算并可视化SHAP值
import shap

# 创建SHAP解释器
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# 可视化SHAP值
shap.summary_plot(shap_values, X_test, feature_names=features)

第三章 Optuna 参数调优

3.1 Optuna 简介

Optuna 是一个高效的超参数优化框架，能够自动搜索最优的模型参数组合，提升模型性能。其核心功能包括：

参数搜索空间定义：支持多种类型的参数搜索，如整数、浮点数、分类变量等。
优化算法：内置多种优化算法，如随机搜索、TPE（Tree-structured Parzen Estimator）等。
实时监控与可视化：提供 Web 界面监控调优过程，直观展示参数变化与模型性能的关系。

Optuna 的优势在于其简单易用的 API 设计和高效的搜索算法，能够快速集成到现有的机器学习项目中，帮助用户找到更优的模型参数组合。

3.2 Optuna 与 LightGBM 集成进行参数调优

定义 LightGBM 参数搜索空间

在 Optuna 中，通过定义目标函数来指定参数搜索空间。每个参数的类型、范围和取值都可以在目标函数中详细定义。对于 LightGBM 模型，常见的调优参数包括：

num_leaves：树的叶子数量，影响模型的复杂度。
learning_rate：学习率，控制每棵树的贡献程度。
feature_fraction：特征采样比例，用于防止过拟合。
max_depth：树的最大深度，控制模型的拟合能力。
min_child_samples：叶子节点的最小样本数，防止过拟合。

def objective(trial):
    # 定义参数搜索空间
    params = {
        "objective": "regression",
        "metric": "mse",
        "boosting_type": "gbdt",
        "num_leaves": trial.suggest_int("num_leaves", 20, 50),
        "learning_rate": trial.suggest_float("learning_rate", 0.01, 0.1),
        "feature_fraction": trial.suggest_float("feature_fraction", 0.7, 1.0),
        "max_depth": trial.suggest_int("max_depth", 3, 10),
        "min_child_samples": trial.suggest_int("min_child_samples", 5, 30),
        "verbose": -1,
    }

    # 创建LightGBM Dataset对象
    train_data = lgb.Dataset(X_train, label=y_train, free_raw_data=False)
    val_data = lgb.Dataset(
        X_val, label=y_val, reference=train_data, free_raw_data=False
    )

    # 模型训练
    model = lgb.train(
        params,
        train_data,
        valid_sets=[val_data],
        num_boost_round=1000,
        callbacks=[lgb.early_stopping(stopping_rounds=10)],
    )

    # 动态获取验证集名称和MSE值
    mse = model.best_score["valid_0"]["l2"]  # 获取MSE值

    return mse

使用 Optuna 进行参数优化

通过 Optuna 的 study 对象进行参数优化，可以设置优化的试验次数、优化方向等参数。在优化过程中，Optuna 会自动记录每次试验的参数组合和对应的模型性能指标。

import optuna

# 创建Optuna研究对象
study = optuna.create_study(direction="minimize")  # 目标是最小化MSE

# 执行优化
study.optimize(objective, n_trials=100)

# 输出最优参数组合
print("最优参数组合：")
print(study.best_params)
print("最优MSE：")
print(study.best_value)

调优过程监控与结果分析

Optuna 提供了丰富的工具来监控和分析调优过程。通过命令行或 Web 界面，可以实时查看参数变化、模型性能曲线等信息，帮助用户更好地理解调优过程和结果。

# 可视化调优过程
import optuna.visualization as vis

# 绘制优化目标值的变化曲线
fig = vis.plot_optimization_history(study)
fig.show()

# 绘制参数关系图
fig = vis.plot_param_importances(study)
fig.show()

3.3 Optuna 在 A 股市场预测中的应用案例

基于 Optuna 优化 LightGBM 模型参数

在 A 股市场预测项目中，通过 Optuna 优化 LightGBM 模型参数，可以显著提升模型的预测性能。以下是一个完整的应用案例，展示如何在股票价格预测任务中使用 Optuna 进行参数调优。

# 示例：使用Optuna优化LightGBM模型参数进行A股市场预测

# 假设已经获取并预处理好了某股票的数据，存储在变量stock_data中

import lightgbm as lgb
import talib as ta
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# 特征工程：计算技术指标等作为特征
stock_data["MA5"] = ta.SMA(stock_data["close"], timeperiod=5)
stock_data["MA10"] = ta.SMA(stock_data["close"], timeperiod=10)
stock_data["MA20"] = ta.SMA(stock_data["close"], timeperiod=20)
stock_data["MA30"] = ta.SMA(stock_data["close"], timeperiod=30)

# 构造目标变量：未来某一天的收盘价
stock_data["target"] = stock_data["close"].shift(-1)

# 删除最后一行，因为最后一行的目标变量是NaN
stock_data = stock_data[:-1]

# 数据集划分
features = ["open", "high", "low", "MA5", "MA10", "MA20", "MA30", "vol"]
target = "target"
scaler = StandardScaler()
stock_data[features] = scaler.fit_transform(stock_data[features])

X = stock_data[features]
y = stock_data[target]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
X_train, X_val, y_train, y_val = train_test_split(
    X_train, y_train, test_size=0.25, random_state=42
)  # 0.25 of 80% is 20% of total data

# 创建LightGBM Dataset对象
train_data = lgb.Dataset(X_train, label=y_train, free_raw_data=False)
val_data = lgb.Dataset(X_val, label=y_val, reference=train_data, free_raw_data=False)


# 定义Optuna目标函数
def objective(trial):
    # 定义参数搜索空间
    params = {
        "objective": "regression",
        "metric": "mse",
        "boosting_type": "gbdt",
        "num_leaves": trial.suggest_int("num_leaves", 20, 50),
        "learning_rate": trial.suggest_float("learning_rate", 0.01, 0.1),
        "feature_fraction": trial.suggest_float("feature_fraction", 0.7, 1.0),
        "max_depth": trial.suggest_int("max_depth", 3, 10),
        "min_child_samples": trial.suggest_int("min_child_samples", 5, 30),
        "verbose": -1,
    }

    # 模型训练
    model = lgb.train(
        params,
        train_data,
        valid_sets=[val_data],
        num_boost_round=1000,
        callbacks=[lgb.early_stopping(stopping_rounds=10)],
    )

    # 动态获取验证集名称和MSE值
    mse = model.best_score["valid_0"]["l2"]  # 获取MSE值

    return mse


# 创建Optuna研究对象
study = optuna.create_study(direction="minimize")  # 目标是最小化MSE

# 执行优化
study.optimize(objective, n_trials=100)

# 输出最优参数组合
print("最优参数组合：")
print(study.best_params)
print("最优MSE：")
print(study.best_value)

# 使用最优参数重新训练模型并评估
best_params = study.best_params

# 更新参数字典
best_params.update(
    {
        "objective": "regression",
        "metric": "mse",
        "boosting_type": "gbdt",
        "verbose": -1,
    }
)

# 用于存储评估结果
eval_results = {}

# 模型训练
best_model = lgb.train(
    best_params,
    train_data,
    valid_sets=[train_data, val_data],
    num_boost_round=1000,
    callbacks=[
        lgb.early_stopping(stopping_rounds=10),
        lgb.record_evaluation(eval_results),
    ],
)

# 模型预测
y_pred = best_model.predict(X_test, num_iteration=best_model.best_iteration)

# 模型评估
mse = mean_squared_error(y_test, y_pred)
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

print(f"调优后模型评估结果：")
print(f"均方误差（MSE）：{mse}")
print(f"平均绝对误差（MAE）：{mae}")
print(f"决定系数（R²）：{r2}")

调优前后模型性能对比

通过对比调优前后的模型性能指标，可以直观地看到 Optuna 参数调优对模型性能的提升效果。通常，调优后的模型在测试集上的预测误差会减小，决定系数 R² 会提高，表明模型的泛化能力和预测准确性得到了增强。

# 调优前后模型性能对比示例

# 假设调优前的模型评估指标存储在变量before_mse、before_mae、before_r2中
# 调优后的模型评估指标存储在变量after_mse、after_mae、after_r2中

# 此为示例，请自行修改
print("调优前模型性能：")
print(f"MSE: {before_mse}, MAE: {before_mae}, R²: {before_r2}")

print("调优后模型性能：")
print(f"MSE: {after_mse}, MAE: {after_mae}, R²: {after_r2}")

调优结果解读与应用

在完成参数调优后，需要对调优结果进行深入解读，了解各个参数对模型性能的影响，以及如何将调优后的模型应用到实际的 A 股市场预测中。通过分析最优参数组合的特点，可以为进一步的模型优化和特征工程提供指导。

# 分析最优参数组合
print("最优参数组合分析：")
print(f"num_leaves: {best_params['num_leaves']} - 控制树的复杂度，较大的值可能增加模型的拟合能力，但也可能导致过拟合。")
print(f"learning_rate: {best_params['learning_rate']} - 较小的学习率通常需要更多的迭代次数，但可以更精细地学习数据中的模式。")
print(f"feature_fraction: {best_params['feature_fraction']} - 特征采样比例，用于防止过拟合，提高模型的泛化能力。")
print(f"max_depth: {best_params['max_depth']} - 树的最大深度，限制模型的复杂度，防止过深的树导致过拟合。")
print(f"min_child_samples: {best_params['min_child_samples']} - 叶子节点的最小样本数，防止模型对少量样本过度拟合。")

第四章 Plotly 可视化

4.1 Plotly 简介

Plotly 是一个功能强大的 Python 可视化库，支持交互式图表的创建，适用于数据分析和展示。其特点包括：

交互式图表：支持缩放、悬停显示数据等交互操作。
多种图表类型：支持散点图、折线图、柱状图、热力图等多种图表类型。
与 Pandas 等库集成：方便直接从数据框生成图表。

Plotly 在数据可视化中的优势在于其生成的图表既美观又具有高度的交互性，适合用于展示复杂的模型结果和数据分析过程。

4.2 使用 Plotly 绘制 LightGBM 模型结果

模型训练过程可视化

通过 Plotly 可以直观地展示模型训练过程中的损失曲线变化，帮助分析模型的收敛情况和性能表现。

import plotly.graph_objects as go

# 假设model是已经训练好的LightGBM模型
results = model.eval_results

# 提取训练和验证的损失值
train_loss = results['training']['mse']
val_loss = results['valid_1']['mse']

# 创建迭代轮次数组
epochs = list(range(len(train_loss)))

# 绘制训练和验证损失曲线
fig = go.Figure()

fig.add_trace(go.Scatter(x=epochs, y=train_loss, mode='lines+markers', name='训练损失'))
fig.add_trace(go.Scatter(x=epochs, y=val_loss, mode='lines+markers', name='验证损失'))

fig.update_layout(
    title='模型训练过程损失曲线',
    xaxis_title='迭代轮次',
    yaxis_title='均方误差（MSE）',
    template='plotly_white'
)

fig.show()

预测结果与实际值对比图

将模型的预测结果与实际值进行对比，可以直观地评估模型的预测准确性。

import plotly.graph_objects as go

# 假设model是已经训练好的LightGBM模型

# 提取训练和验证的损失值
train_loss = eval_results["training"]["l2"]
val_loss = eval_results["valid_1"]["l2"]

# 创建迭代轮次数组
epochs = list(range(len(train_loss)))

# 绘制训练和验证损失曲线
fig = go.Figure()

fig.add_trace(go.Scatter(x=epochs, y=train_loss, mode="lines+markers", name="训练损失"))
fig.add_trace(go.Scatter(x=epochs, y=val_loss, mode="lines+markers", name="验证损失"))

fig.update_layout(
    title="模型训练过程损失曲线",
    xaxis_title="迭代轮次",
    yaxis_title="均方误差（MSE）",
    template="plotly_white",
)

fig.show()

特征重要性可视化

通过可视化特征重要性，可以了解哪些特征对模型预测结果影响最大，有助于特征筛选和模型优化。

# 获取特征重要性
feature_importance = model.feature_importance()
feature_names = X_train.columns

# 创建特征重要性DataFrame
importance_df = pd.DataFrame(
    {
        "feature": feature_names,
        "importance": feature_importance,
    }
).sort_values(by="importance", ascending=False)

# 绘制特征重要性条形图
fig = go.Figure(
    go.Bar(
        x=importance_df["importance"],
        y=importance_df["feature"],
        orientation="h",
    )
)

fig.update_layout(
    title="特征重要性分析",
    xaxis_title="重要性得分",
    yaxis_title="特征",
    template="plotly_white",
    margin=dict(l=150),  # 调整左侧边距以适应特征名称
)

fig.show()

4.3 Plotly 在 A 股市场分析中的应用案例

A 股市场数据可视化

在 A 股市场分析中，使用 Plotly 可以创建交互式的股价走势图、成交量图等，帮助更直观地理解市场动态。

# 示例：绘制某股票的历史股价走势图

# 假设stock_data是已经获取并预处理好的股票数据

# 创建一个包含日期、开盘价、最高价、最低价、收盘价的DataFrame
price_data = stock_data[["trade_date", "open", "high", "low", "close"]]
price_data = price_data.sort_values(by="trade_date")  # 按日期排序

# 绘制股价走势图
fig = go.Figure()

fig.add_trace(
    go.Scatter(
        x=price_data["trade_date"],
        y=price_data["open"],
        mode="lines+markers",
        name="开盘价",
    )
)
fig.add_trace(
    go.Scatter(
        x=price_data["trade_date"],
        y=price_data["high"],
        mode="lines+markers",
        name="最高价",
    )
)
fig.add_trace(
    go.Scatter(
        x=price_data["trade_date"],
        y=price_data["low"],
        mode="lines+markers",
        name="最低价",
    )
)
fig.add_trace(
    go.Scatter(
        x=price_data["trade_date"],
        y=price_data["close"],
        mode="lines+markers",
        name="收盘价",
    )
)

fig.update_layout(
    title="某股票历史股价走势图",
    xaxis_title="日期",
    yaxis_title="价格",
    template="plotly_white",
    hovermode="x",
)

fig.show()

LightGBM 模型在 A 股市场中的结果展示

结合 Plotly 和 LightGBM 模型，可以创建丰富的可视化结果，展示模型在 A 股市场中的预测效果和特征分析。

# 示例：绘制模型预测结果的详细分析图

# 假设已经完成模型训练和预测，y_test是测试集的真实值，y_pred是预测值

# 创建一个DataFrame来存储实际值、预测值和日期
results_df = pd.DataFrame({"日期": X_test.index, "实际值": y_test, "预测值": y_pred})

# 绘制预测结果的详细分析图
fig = go.Figure()

# 添加实际值和预测值的折线图
fig.add_trace(
    go.Scatter(
        x=results_df["日期"],
        y=results_df["实际值"],
        mode="lines+markers",
        name="实际值",
    )
)
fig.add_trace(
    go.Scatter(
        x=results_df["日期"],
        y=results_df["预测值"],
        mode="lines+markers",
        name="预测值",
    )
)

# 添加预测误差的散点图
fig.add_trace(
    go.Scatter(
        x=results_df["日期"],
        y=results_df["实际值"] - results_df["预测值"],
        mode="markers",
        name="预测误差",
    )
)

fig.update_layout(
    title="模型预测结果详细分析",
    xaxis_title="日期",
    yaxis_title="价格",
    template="plotly_white",
    hovermode="x",
    yaxis2=dict(title="误差", overlaying="y", side="right"),
)

fig.show()

可视化结果解读与分析

通过 Plotly 创建的可视化结果，可以更直观地理解模型的性能和市场动态。例如，通过观察预测结果与实际值的对比图，可以发现模型在哪些时间段预测较为准确，哪些时间段存在偏差，从而为进一步的模型优化提供方向。同时，特征重要性分析可以帮助识别对股价波动影响较大的因素，为投资决策提供参考。

# 示例：结合特征重要性和预测结果进行综合分析

# 假设已经完成特征重要性分析，importance_df是特征重要性DataFrame

# 绘制特征重要性与预测结果的关联图
fig = go.Figure()

# 添加特征重要性条形图
fig.add_trace(
    go.Bar(
        x=importance_df["importance"],
        y=importance_df["feature"],
        orientation="h",
        name="特征重要性",
    )
)

# 添加预测误差与特征的散点图
fig.add_trace(
    go.Scatter(
        x=results_df["实际值"] - results_df["预测值"],
        y=results_df["日期"].map(lambda x: "MA5"),  # 假设以MA5为例
        mode="markers",
        name="预测误差与MA5的关系",
    )
)

fig.update_layout(
    title="特征重要性与预测结果关联分析",
    xaxis_title="重要性得分/误差",
    yaxis_title="特征/日期",
    template="plotly_white",
    margin=dict(l=150),
)

fig.show()

附录

LightGBM 核心方法及参数说明

`train` 训练模型

lgb.train(
    params: Dict[str, Any],
    train_set: Dataset,
    num_boost_round: int = 100,
    valid_sets: Optional[List[Dataset]] = None,
    valid_names: Optional[List[str]] = None,
    feval: Optional[Union[_LGBM_CustomMetricFunction, List[_LGBM_CustomMetricFunction]]] = None,
    init_model: Optional[Union[str, Path, Booster]] = None,
    feature_name: _LGBM_FeatureNameConfiguration = 'auto',
    categorical_feature: _LGBM_CategoricalFeatureConfiguration = 'auto',
    keep_training_booster: bool = False,
    callbacks: Optional[List[Callable]] = None
) -> Booster

作用说明：

使用给定的参数和训练数据集来训练一个 LightGBM 模型。

参数说明：

参数名	类型	默认值	说明
params	Dict[str, Any]	-	包含模型训练的参数，如`objective`（目标函数）、`learning_rate`（学习率）、`num_leaves`（叶子数）等
train_set	Dataset	-	训练数据集，需先通过`lgb.Dataset`加载
num_boost_round	int	100	迭代次数，即生成的树的数量
valid_sets	Optional[List[Dataset]]	None	验证数据集列表
valid_names	Optional[List[str]]	None	验证数据集的名称列表
feval	Optional[Union[_LGBM_CustomMetricFunction, List[_LGBM_CustomMetricFunction]]]	None	自定义的评估函数
init_model	Optional[Union[str, Path, Booster]]	None	初始模型，可以是 Booster 对象或模型文件路径
feature_name	_LGBM_FeatureNameConfiguration	‘auto’	特征名称
categorical_feature	_LGBM_CategoricalFeatureConfiguration	‘auto’	离散特征的列名或列索引
keep_training_booster	bool	False	是否保留训练中的 Booster 对象
callbacks	Optional[List[Callable]]	None	回调函数列表，用于在训练过程中执行特定操作

params：包含模型训练的所有参数，这些参数控制模型的行为和性能。
- 常用参数：
  - objective：定义学习任务的目标函数类型（如'regression', 'binary', 'multiclass'等）。
  - num_leaves：树的最大叶子节点数。
  - max_depth：限制每棵树的最大深度。
  - learning_rate (或eta)：控制每一步迭代时新树对最终结果的影响程度。
  - n_estimators：构建子模型的数量，即Boosting轮数。
  - min_data_in_leaf：一个叶结点上最小的数据样本数量。
  - feature_fraction：每次迭代时随机选择特征的比例。
  - bagging_fraction：每次迭代时随机选择的数据比例。
  - lambda_l1：L1正则化系数。
  - lambda_l2：L2正则化系数。
  - metric：评估指标（如'auc', 'mse', 'mae'等）。
  - boosting_type：指定使用的增强算法类型（如'gbdt', 'dart', 'goss'等）。
  - num_threads：并行执行线程数。
  - device_type：指定计算设备类型（如'cpu', 'gpu'）。
  - seed：随机种子，用于保证结果的可重复性。
  - verbosity：日志详细级别。
  - early_stopping_rounds：提前停止机制，如果在给定轮次内验证集上的性能没有改善，则停止训练。
  - first_metric_only：仅关注第一个评估指标。
  - eval_train_metric：是否在训练集上计算评估指标。
  - is_unbalance / scale_pos_weight：处理不平衡数据集。
  - categorical_feature：分类特征的索引或名称列表。
  - keep_training_booster：是否保留训练过的booster以继续训练。
- 全部参数：
  - 核心参数
    - objective：定义了学习任务的目标函数类型。
    - num_leaves：树的最大叶子节点数。
    - max_depth：限制每棵树的最大深度。
    - learning_rate (或eta)：控制每一步迭代时新树对最终结果的影响程度。
    - n_estimators：构建子模型的数量，即Boosting轮数。
    - min_data_in_leaf：一个叶结点上最小的数据样本数量。
    - feature_fraction：每次迭代时随机选择特征的比例。
    - bagging_fraction：每次迭代时随机选择的数据比例。
    - lambda_l1, lambda_l2：L1正则化和L2正则化的系数。
    - metric：评估指标。
  - 基本参数
    - boosting_type：指定使用的增强算法类型。
    - num_threads：并行执行线程数。
    - device_type：指定计算设备类型。
    - seed：随机种子，用于保证结果的可重复性。
    - verbosity：日志详细级别。
    - deterministic：是否启用确定性模式。
  - 学习控制参数
    - force_row_wise：强制使用行方向的梯度计算。
    - force_col_wise：强制使用列方向的梯度计算。
    - histogram_pool_size：直方图池的大小。
    - max_bin：特征值离散化后最大的bin数目。
    - min_data_in_bin：每个bin中的最小数据量。
    - bin_construct_sample_cnt：用于构建直方图的样本数量。
    - data_random_seed：数据随机化的种子。
    - feature_pre_filter：是否在训练前过滤掉不重要的特征。
  - IO 参数
    - input_model：从给定路径加载预训练模型继续训练。
    - output_model：保存训练好的模型到指定路径。
    - snapshot_freq：快照频率。
    - output_result：输出预测结果到文件。
    - input_result：从文件读取预测结果。
    - predict_disable_shape_check：禁用形状检查。
  - 目标函数参数
    - is_unbalance / scale_pos_weight：处理不平衡数据集。
    - sigmoid：sigmoid函数的参数。
    - fair_c：Fair损失函数的参数。
    - poisson_max_delta_step：Poisson回归的最大步长。
    - tweedie_variance_power：Tweedie回归的方差幂。
    - alpha：Huber损失函数的参数。
    - quantile_alpha：分位数回归的参数。
    - reg_sqrt：平方根回归的参数。
  - 梯度下降参数
    - neg_bagging_fraction：负样本的采样比例。
    - bagging_freq：执行bagging的频率。
    - bagging_seed：bagging的随机种子。
    - pos_bagging_fraction：正样本的采样比例。
    - drop_rate：DART算法的丢弃率。
    - skip_drop：DART算法的跳过丢弃率。
    - uniform_drop：DART算法的均匀丢弃率。
    - xgboost_dart_mode：是否使用XGBoost的DART模式。
    - max_drop：DART算法的最大丢弃率。
    - top_k：Top-K采样。
    - monotone_constraints：单调约束。
    - monotone_penalty：单调惩罚。
    - feature_contri：特征贡献。
  - 其他参数
    - early_stopping_rounds：提前停止机制。
    - first_metric_only：仅关注第一个评估指标。
    - metric_freq：评估指标的频率。
    - eval_train_metric：是否在训练集上计算评估指标。
    - num_machines：分布式训练中的机器数量。
    - local_listen_port：本地监听端口。
    - machine_list_file：机器列表文件。
    - time_out：超时时间。
    - gpu_platform_id：GPU平台ID。
    - gpu_device_id：GPU设备ID。
    - enable_bundle：是否启用捆绑。
    - use_missing：是否使用缺失值。
    - zero_as_missing：将零值视为缺失值。
    - categorical_feature：分类特征。
    - keep_training_booster：是否保留训练过的booster。

返回值：

返回训练好的 Booster 模型。

`cv` 交叉验证

lgb.cv(
    params: Dict[str, Any],
    train_set: Dataset,
    num_boost_round: int = 100,
    folds: Optional[Union[Iterable[Tuple[np.ndarray, np.ndarray]], _LGBMBaseCrossValidator]] = None,
    nfold: int = 5,
    stratified: bool = True,
    shuffle: bool = True,
    metrics: Optional[Union[str, List[str]]] = None,
    feval: Optional[Union[_LGBM_CustomMetricFunction, List[_LGBM_CustomMetricFunction]]] = None,
    init_model: Optional[Union[str, Path, Booster]] = None,
    feature_name: _LGBM_FeatureNameConfiguration = 'auto',
    categorical_feature: _LGBM_CategoricalFeatureConfiguration = 'auto',
    fpreproc: Optional[_LGBM_PreprocFunction] = None,
    seed: int = 0,
    callbacks: Optional[List[Callable]] = None,
    eval_train_metric: bool = False,
    return_cvbooster: bool = False
) -> Dict[str, Union[List[float], CVBooster]]

作用说明：

执行交叉验证，用于评估模型在不同数据划分下的性能表现。

参数说明：

参数名	类型	默认值	说明
params	Dict[str, Any]	-	包含模型训练的参数，如`objective`（目标函数）、`learning_rate`（学习率）、`num_leaves`（叶子数）等
train_set	Dataset	-	训练数据集，需先通过`lightgbm.Dataset`加载
num_boost_round	int	100	最大迭代次数，即生成的树的数量
folds	Optional[Union[Iterable[Tuple[np.ndarray, np.ndarray]], _LGBMBaseCrossValidator]]	None	数据分割方式，可以是生成器、迭代器或 scikit-learn 的分割器对象
nfold	int	5	交叉验证的折数
stratified	bool	True	是否进行分层抽样，适用于分类问题
shuffle	bool	True	是否在每次分割时打乱数据
metrics	Optional[Union[str, List[str]]]	None	评估指标，如`'rmse'`、`'mse'`、`'auc'`等
feval	Optional[Union[_LGBM_CustomMetricFunction, List[_LGBM_CustomMetricFunction]]]	None	自定义的评估函数
init_model	Optional[Union[str, Path, Booster]]	None	初始模型，可以是 Booster 对象或模型文件路径
feature_name	_LGBM_FeatureNameConfiguration	‘auto’	特征名称
categorical_feature	_LGBM_CategoricalFeatureConfiguration	‘auto’	离散特征的列名或列索引
fpreproc	Optional[_LGBM_PreprocFunction]	None	数据预处理函数
seed	int	0	随机种子，用于保证结果的可复现性
callbacks	Optional[List[Callable]]	None	回调函数列表，用于在训练过程中执行特定操作
eval_train_metric	bool	False	是否在训练集上评估指标
return_cvbooster	bool	False	是否返回每个折的训练模型

返回值：

返回一个字典，包含每次迭代的训练和验证指标的均值和标准差等信息。例如，cv_results['l2-mean']表示每次迭代的均方误差的均值。如果return_cvbooster为True，还会返回包含每个折的训练模型的CVBooster对象。

`predict` 预测

booster.predict(
    data,
    start_iteration=0,
    num_iteration=None,
    raw_score=False,
    pred_leaf=False,
    pred_contrib=False,
    data_has_header=False,
    validate_features=False,
    **kwargs
)

作用说明：

使用训练好的模型对数据进行预测。

参数说明：

参数名	类型	默认值	说明
data	str, pathlib.Path, numpy array, pandas DataFrame, H2O DataTable’s Frame 或 scipy.sparse	-	预测的数据源。如果是 str 或 pathlib.Path，则表示指向文本文件（CSV、TSV 或 LibSVM）的路径。
start_iteration	int	0	预测开始的迭代索引。如果 <=0，则从第一次迭代开始。
num_iteration	int 或 None	None	预测中使用的总迭代次数。如果为 None，如果存在最佳迭代且 start_iteration <=0，则使用最佳迭代；否则，使用从 start_iteration 开始的所有迭代（无限制）。如果 <=0，则使用从 start_iteration 开始的所有迭代（无限制）。
raw_score	bool	False	是否预测原始分数。
pred_leaf	bool	False	是否预测叶子索引。
pred_contrib	bool	False	是否预测特征贡献。
data_has_header	bool	False	数据是否包含标题。仅在 data 是 str 时使用。
validate_features	bool	False	如果为 True，则确保用于预测的特征与训练时使用的特征匹配。仅在 data 是 pandas DataFrame 时使用。
**kwargs	其他参数	无	预测的其他参数。

返回值：

返回值为 numpy array、scipy.sparse 或 scipy.sparse 列表，表示预测结果。如果是特征贡献（当 pred_contrib=True 时），则可以是稀疏矩阵或稀疏对象列表（每个元素代表一个类别的预测）。

`Dataset` 加载数据

lgb.Dataset(
    data,
    label=None,
    reference=None,
    weight=None,
    group=None,
    init_score=None,
    feature_name="auto",
    categorical_feature="auto",
    params=None,
    free_raw_data=True,
)

类说明：

用于创建数据集对象，作为模型训练的基础数据结构，支持多种数据类型输入，并可配置标签、权重、分组等信息。

参数说明：

参数名	类型	默认值	说明
data	str, pathlib.Path, numpy array, pandas DataFrame, H2O DataTable’s Frame, scipy.sparse, Sequence, list of Sequence 或 list of numpy array	-	数据集的数据源。如果是 str 或 pathlib.Path，则表示指向文本文件（CSV、TSV、LibSVM）或 LightGBM 数据集二进制文件的路径。
label	list, numpy 1-D array, pandas Series / one-column DataFrame 或 None	None	数据的标签。
reference	Dataset 或 None	None	如果此数据集用于验证，训练数据应作为参考。
weight	list, numpy 1-D array, pandas Series 或 None	None	每个实例的权重。权重应为非负值。
group	list, numpy 1-D array, pandas Series 或 None	None	组/查询数据。仅在学习排序任务中使用。sum(group) = n_samples。例如，如果有一个 100 个文档的数据集，group = [10, 20, 40, 10, 10, 10]，这意味着有 6 个组，前 10 条记录在第一组，11-30 条在第二组，31-70 条在第三组等。
init_score	list, list of lists (多分类任务), numpy array, pandas Series, pandas DataFrame (多分类任务) 或 None	None	数据集的初始分数。
feature_name	list of str 或 ‘auto’	‘auto’	特征名称。如果为 ‘auto’ 且数据是 pandas DataFrame，则使用数据列名。
categorical_feature	list of str 或 int, 或 ‘auto’	‘auto’	类别特征。如果为整数列表，解释为索引；如果为字符串列表，解释为特征名称（需要同时指定 feature_name）。如果为 ‘auto’ 且数据是 pandas DataFrame，则使用 pandas 无序类别列。所有类别特征的值将被转换为 int32，因此应小于 int32 最大值（2147483647）。大值可能会消耗更多内存。考虑从零开始使用连续整数。类别特征中的所有负值将被视为缺失值。类别特征中的浮点数将向零取整。
params	dict 或 None	None	数据集的其他参数。
free_raw_data	bool	True	如果为 True，在构建内部数据集后释放原始数据。

返回值

无，此为类的初始化方法，用于创建 Dataset 对象，不直接返回值。

`save_model` 保存模型

booster.save_model(
    filename, num_iteration=None, start_iteration=0, importance_type="split"
)

作用说明：

用于将模型保存到文件中。可以指定保存的迭代次数范围，并且可以选择保存特征重要性类型。

参数说明：

参数名	类型	默认值	说明
filename	str 或 pathlib.Path	-	保存 Booster 的文件名。
num_iteration	int 或 None	None	需要保存的迭代次数索引。如果为 None，如果存在最佳迭代，则保存最佳迭代；否则，保存所有迭代。如果 <=0，保存所有迭代。
start_iteration	int	0	保存的迭代次数的起始索引。
importance_type	str	‘split’	需要保存的特征重要性类型。如果为 “split”，结果包含特征在模型中被使用的次数。如果为 “gain”，结果包含使用特征的分裂的总增益。

返回值：

返回值为 Booster 对象本身（self），表示该方法是对象的方法，调用后返回对象本身，方便进行链式调用。

`Booster` 加载模型

lgb.Booster(params=None, train_set=None, model_file=None, model_str=None)

作用说明：

用于模型的训练和预测。可以通过参数、训练数据集、模型文件或模型字符串来初始化 Booster。

参数说明：

参数名	类型	默认值	说明
params	dict 或 None	None	Booster 的参数配置。
train_set	Dataset 或 None	None	训练数据集。
model_file	str, pathlib.Path 或 None	None	模型文件的路径。
model_str	str 或 None	None	模型将从这个字符串加载。

返回值：

返回值为 Booster 对象本身（self），表示该方法是对象的初始化方法，用于创建 Booster 实例。

Optuna 核心方法及参数说明

`create_study` 创建一个新的对象

optuna.create_study(
    storage: str | storages.BaseStorage | None = None,
    sampler: "samplers.BaseSampler" | None = None,
    pruner: pruners.BasePruner | None = None,
    study_name: str | None = None,
    direction: str | StudyDirection | None = None,
    load_if_exists: bool = False,
    directions: Sequence[str | StudyDirection] | None = None,
) -> Study

作用说明：
创建一个新的 optuna.study.Study 对象。通过指定不同的参数来定制研究的行为，包括存储方式、采样器、剪枝器等。

参数说明：

参数名	类型	默认值	说明
storage	`str` 或 `storages.BaseStorage` 或 `None`	`None`	数据库URL或存储对象。如果为 `None`，则使用 `InMemoryStorage`，且研究不会持久化。
sampler	`"samplers.BaseSampler"` 或 `None`	`None`	背景算法的采样器对象。如果为 `None`，单目标优化时使用 `TPESampler`，多目标优化时使用 `NSGAIISampler`。
pruner	`pruners.BasePruner` 或 `None`	`None`	决定是否提前停止不理想试验的剪枝器对象。如果为 `None`，默认使用 `MedianPruner`。
study_name	`str` 或 `None`	`None`	研究的名称。如果为 `None`，则自动生成一个唯一名称。
direction	`str` 或 `StudyDirection` 或 `None`	`None`	优化方向。设置为 `minimize` 表示最小化，设置为 `maximize` 表示最大化。也可以传递相应的 `StudyDirection` 对象。`direction` 和 `directions` 不能同时指定。
load_if_exists	`bool`	`False`	控制处理研究名称冲突行为的标志。如果名为 `study_name` 的研究已在 `storage` 中存在，当 `load_if_exists` 为 `False` 时会抛出 `DuplicatedStudyError` 异常；否则，将跳过新研究的创建，并返回已存在的研究。
directions	`Sequence[str]` 或 `Sequence[StudyDirection]` 或 `None`	`None`	多目标优化中的一系列方向。`direction` 和 `directions` 不能同时指定。

返回值：

返回一个 Study 对象，该对象可用于执行优化任务。

`optimize` 优化目标

study.optimize(
    func: ObjectiveFuncType,
    n_trials: int | None = None,
    timeout: float | None = None,
    n_jobs: int = 1,
    catch: Iterable[type[Exception]] | type[Exception] = (),
    callbacks: Iterable[Callable[[Study, FrozenTrial], None]] | None = None,
    gc_after_trial: bool = False,
    show_progress_bar: bool = False,
) -> None

作用说明：

通过从给定范围内选择合适的超参数值来进行优化。使用采样器根据指定的分布建议值。采样器在 create_study 函数中指定，默认选择是 TPE 采样器。优化将在接收到终止信号（如 SIGINT 和 SIGTERM）时停止。

参数说明：

参数名	类型	默认值	说明
func	`ObjectiveFuncType`	-	实现目标函数的可调用对象。
n_trials	`int` 或 `None`	`None`	每个进程的试验次数。`None` 表示没有限制。研究将继续创建试验，直到试验次数达到 `n_trials`、超时时间到达、调用 `Study.stop` 或接收到终止信号（如 SIGTERM 或 Ctrl+C）。
timeout	`float` 或 `None`	`None`	在给定的秒数后停止研究。`None` 表示没有时间限制。研究将继续创建试验，直到试验次数达到 `n_trials`、超时时间到达、调用 `Study.stop` 或接收到终止信号（如 SIGTERM 或 Ctrl+C）。
n_jobs	`int`	`1`	并行作业的数量。如果设置为 `-1`，则数量设置为 CPU 核心数。注意：`n_jobs` 允许使用 `threading` 进行并行化，可能会受到 Python 的 GIL 限制。如果 `func` 是 CPU 密集型任务，建议使用基于进程的并行化。
catch	`Iterable[type[Exception]]` 或 `type[Exception]`	`()`	研究将继续运行，即使试验引发了此参数中指定的异常之一。默认为空元组，即研究将因任何异常而停止（除了 `TrialPruned` 异常）。
callbacks	`Iterable[Callable[[Study, FrozenTrial], None]]` 或 `None`	`None`	在每个试验结束时调用的回调函数列表。每个函数必须接受两个参数，类型分别为 `Study` 和 `FrozenTrial`。
gc_after_trial	`bool`	`False`	标志，确定是否在每次试验后自动运行垃圾回收。设置为 `True` 以运行垃圾回收，否则为 `False`。如果看到内存消耗在几次试验后增加，可以尝试将此标志设置为 `True`。
show_progress_bar	`bool`	`False`	标志，显示进度条或不显示。要显示进度条，设置为 `True`。注意，当 `n_trials` 为 `None`、`timeout` 不为 `None` 且 `n_jobs` 不等于 1 时，进度条将被禁用。