BES秃鹰优化算法优化LSSVM分类预测的完整实现与调参实践

在机器学习分类任务里，参数搜索往往比选哪个算法更让人头疼。BES-LSSVM就是把秃鹰优化算法（BES）和最小二乘支持向量机（LSSVM）组合在一起的解法：用秃鹰算法的全局搜索能力自动去找LSSVM的惩罚因子和核参数，省掉手动试参的体力活。这个项目做的是分类预测，代码封装成“换数据就能跑”的形式，对做科研、搞竞赛、写论文的人来说非常实用，尤其是那些手里有数据集但不想把时间耗在调参上的朋友。

我自己用这个方案跑过好几个二分类和多分类数据集，整体感受是：收敛速度快、参数少、不用安装额外重型依赖，效果和网格搜索调出来的LSSVM基本持平，但时间成本能省一个数量级。这篇就把整个思路、算法原理、核心代码、踩坑经验全部分享出来，照着改就能用。

1. 这个项目到底解决什么问题

1.1 为什么是LSSVM而不是SVM

支持向量机是分类问题的经典工具，但对中等规模以上的数据，标准SVM要解一个二次规划问题，计算量随样本量增长得非常快。最小二乘支持向量机（LSSVM）的改进思路很直接：把原本的不等式约束改成等式约束，把误差项从软间隔变成平方误差，这样一来，原本复杂的二次规划问题就转成了求解一组线性方程组。

这个转换的价值在哪里？我用一个生活化的类比解释：标准SVM像一个靠多次谈判达成共识的会议，每次迭代都要反复调整边界，样本一多、约束一复杂，会议就会拖很久；LSSVM则是直接把所有意见汇总成一张表格，一次性算出最终结果，省掉了反复谈判的过程。所以在几十到几千样本量级的分类问题上，LSSVM不仅训练速度快，代码实现也简单——不需要额外引入SMO算法或QP求解器。

LSSVM也不是没有代价：因为用了等式约束，每个样本都会对模型产生影响，所以它对离群点比SVM更敏感，参数也更容易受异常值干扰。这也是后面要引入优化算法来做参数选择的重要原因之一。

1.2 BES为什么能顶替网格搜索

LSSVM有两个关键超参数：惩罚因子C和RBF核参数σ。C控制对误分类的容忍程度，σ控制径向基函数的宽度。这俩参数配不好，模型要么欠拟合要么过拟合。传统做法是网格搜索，把两个参数各取几十个候选值，两两组合跑一遍交叉验证，耗时非常恐怖。

秃鹰优化算法是近几年提出的一种元启发式算法，模拟秃鹰捕食过程，整个策略分成三个阶段：选择搜索区域、在区域内搜索猎物、俯冲捕获猎物。它的特点在于，参数很少、容易实现，全局探索和局部开发能力比较均衡，不容易像粒子群算法那样早早陷入局部最优。跟遗传算法比，BES不需要编码解码，直接对连续参数做实数操作；跟网格搜索比，BES是自适应寻优，不是机械枚举，效率高得多。

我在实际使用中最直观的感受就是：网格搜索在两个参数上各取50个值，就要跑2500组交叉验证，可能几个小时过去了；BES用30次迭代、20个种群个体，也就是600次目标函数评估就能拿到非常接近的结果，差距通常是百分之零点几的准确率，对大多数分类场景完全够用。

1.3 适合谁来用、用在什么场景

这个项目最典型的应用场景有三类。第一类是论文实验对比，很多理工科研究需要用到机器学习方法做分类，传统SVM、随机森林、神经网络各跑一遍，加上LSSVM能丰富对比方法；第二类是竞赛快速验证模型，在不知道特征和样本深度分布的情况下，先用LSSVM配上自动寻参跑一个baseline，作为后续优化的起点；第三类是实际工程里的中等规模分类问题，比如设备故障诊断、医学样本分类、信用评分等，数据量一般不超过几万条，LSSVM在速度和内存上都占优。

用户拿到的代码如果封装得当，最核心的改动就两处：一个是把你的数据集路径替换掉，另一个是按需修改标签列索引。下面我会给出一个我自己常用、确认过能跑的完整框架。

2. 核心算法原理拆开讲

2.1 LSSVM的数学化简过程

LSSVM的建模可以浓缩为三步。第一步，确定目标函数和约束条件。给定训练样本集合({x_i, y_i})，其中(x_i)是特征向量，(y_i \in {-1, +1})是标签，LSSVM构造如下优化问题：

[
\min_{w,b,e} \quad J(w,e) = \frac{1}{2}w^Tw + \frac{C}{2}\sum_{i=1}^{n}e_i^2
]

[
\text{s.t.} \quad y_i(w^T\phi(x_i) + b) = 1 - e_i,\quad i=1,2,\dots,n
]

这里(\phi(x))是把原始特征映射到高维空间的核函数映射，(e_i)是误差项。注意这里约束是等式，而且误差项被写进了目标函数里，这就是和标准SVM最大的差异。

第二步，构造拉格朗日函数，把带约束优化问题转为无约束问题：

[
L(w,b,e,\alpha) = J(w,e) - \sum_{i=1}^{n}\alpha_i\left[y_i(w^T\phi(x_i) + b) - 1 + e_i\right]
]

分别对(w)、(b)、(e_i)、(\alpha_i)求偏导并令其为零。这个过程做完之后，原本需要求(w)的表达式可以用(\alpha_i)和(\phi(x_i))的线性组合表示，对应的KKT系统最终变成一个分块线性方程组：

[
\begin{bmatrix} 0 & y^T \ y & \Omega + C^{-1}I \end{bmatrix}
\begin{bmatrix} b \ \alpha \end{bmatrix} =
\begin{bmatrix} 0 \ \mathbf{1} \end{bmatrix}
]

其中(\Omega_{ij} = y_i y_j K(x_i, x_j))，(K(x_i, x_j))就是核函数，常用RBF核：

[
K(x_i, x_j) = \exp(-\sigma | x_i - x_j |^2)
]

第三步，求解上述线性方程组，得到(\alpha)和(b)，然后用决策函数(f(x) = \text{sign}\left(\sum_{i=1}^{n}\alpha_i K(x_i, x) + b\right))对新样本预测。

注意这个方程组是((n+1) \times (n+1))维的，直接用np.linalg.solve或者Matlab的\运算就能解。样本量到万级以后，矩阵求逆内存消耗较大，这也是LSSVM更适合中小规模数据集的原因。

2.2 BES秃鹰优化算法的三段式策略

BES算法的灵感来自秃鹰在觅食过程中的三个行为阶段：选择搜索区域、搜索猎物、俯冲捕获。每个阶段对应一套位置更新公式。

第一阶段，选择搜索区域。秃鹰先在空中大致选定一个范围，这个范围通常以当前最优位置作为参照：

[
P_{new,i} = P_{best} + \alpha \times r \times (P_{mean} - P_i)
]

这里(P_{best})是当前全局最优位置，(P_{mean})是种群平均位置，(\alpha)是控制位置变化幅度的参数，(r)是随机数。

第二阶段，搜索空间中猎物。秃鹰在选定区域内做螺旋飞行搜索，位置更新加入螺旋曲线参数，让个体绕中心点环绕运动，增加探索能力。这个阶段的核心是保证种群在全局范围里不早熟。

第三阶段，俯冲捕获。当秃鹰锁定猎物后，以最优位置为中心快速收敛，位置更新公式会缩小步长，从全局探索快速转入局部开发。这个阶段的思路和粒子群后期的压缩因子策略有异曲同工之处。

BES在实现上只需要设置种群规模、迭代次数、搜索维度、上下界，不需要额外的交叉概率、变异概率之类的控制参数，对新手友好。调节的重点放在种群规模和迭代次数上：种群太大浪费时间，太小容易陷入局部最优；迭代次数同理，要根据参数搜索空间的大小来定。

2.3 两个算法如何完成拼接

整个模型的优化流程可以拆成两个环。内环是LSSVM的训练和评估：给定一组C和σ，用LSSVM在训练集上训练，输出验证集或训练集的准确率作为适应度值。外环是BES寻优：在不断迭代中生成新的C和σ，评估适应度并更新最优位置。BES运行结束后，用最优的C和σ重新训练一次LSSVM，然后在测试集上做最终评估。

这个思路本质上是一种wrapper式的特征参数优化，好处是算法之间完全解耦，你可以把BES换成粒子群、灰狼、鲸鱼算法，只需要改优化器那一层就行。我自己就写过一版把BES换成粒子群，对比下来BES在中后期收敛更稳定，尤其是搜索空间较大的时候。

3. 完整实现流程与可复用代码

3.1 环境准备与数据格式约定

我用的环境是Python 3.9，依赖库只有numpy、pandas、scikit-learn、matplotlib。没有用到任何LSSVM专业工具箱，手动实现了一个轻量LSSVM分类器，这样在部署和二次开发时没有任何额外包袱。

bash复制pip install numpy pandas scikit-learn matplotlib

数据格式我建议这样约定：CSV文件，最后一列是标签列，其余列全是特征列。标签统一转成整数0和1，二分类场景下LSSVM的决策输出是正负号，所以内部会把0转成-1，预测后再转回来。多分类问题先用OvO或OvR策略拆分，或者直接对每个类别做一对其余的二分类，这里主要讲二分类。

python复制import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report

# 替换这里的数据路径即可
data = pd.read_csv("your_dataset.csv")
X = data.iloc[:, :-1].values
y = data.iloc[:, -1].values

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

数据预处理的核心是标准化。LSSVM用RBF核计算样本之间的欧氏距离，如果特征量纲差异巨大，距离会被数值大的特征主导，核函数直接失效。标准的做法是在训练集上fit_transform，再在测试集上只做transform，防止信息泄漏。

python复制scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 标签统一转成 ±1
y_train_bin = np.where(y_train == 0, -1, 1)
y_test_bin = np.where(y_test == 0, -1, 1)

3.2 手动实现轻量LSSVM分类器

LSSVM的核心就是求解那个分块线性方程组。我这里实现一个带RBF核的类，代码很短，但该有的功能都有。

python复制class LSSVM:
    def __init__(self, C=1.0, sigma=1.0):
        self.C = C
        self.sigma = sigma
        self.X = None
        self.y = None
        self.alpha = None
        self.b = 0.0

    def _rbf_kernel(self, X1, X2):
        # X1: (m, d), X2: (n, d) -> (m, n)
        sq_dist = np.sum(X1**2, axis=1)[:, None] + np.sum(X2**2, axis=1)[None, :]
        sq_dist -= 2 * np.dot(X1, X2.T)
        return np.exp(-self.sigma * np.maximum(sq_dist, 0))

    def fit(self, X, y):
        self.X = X
        self.y = y
        n = X.shape[0]
        K = self._rbf_kernel(X, X)
        Omega = np.zeros((n, n))
        for i in range(n):
            for j in range(n):
                Omega[i, j] = y[i] * y[j] * K[i, j]

        # 拼接分块矩阵
        A = np.zeros((n + 1, n + 1))
        A[0, 1:] = y
        A[1:, 0] = y
        A[1:, 1:] = Omega + np.eye(n) / self.C

        B = np.zeros(n + 1)
        B[1:] = 1.0

        sol = np.linalg.solve(A, B)
        self.b = sol[0]
        self.alpha = sol[1:]

    def predict(self, X):
        K = self._rbf_kernel(X, self.X)
        raw = np.dot(K, self.alpha * self.y) + self.b
        return np.sign(raw)

这里有个性能点要注意：_rbf_kernel 里的双for循环只出现在训练集核矩阵的构造中，对于千级别样本完全能接受。如果样本量上万，建议用scipy.spatial.distance.cdist替代，写法更优雅且不需要手写平方距离展开。我在自己的代码里有时直接用cdist(X, X, 'sqeuclidean')来构造核矩阵，速度比向量化手写版还快一点。

3.3 BES秃鹰优化算法实现

BES实现我参考了原始文献的整体框架，做了一些面向工程实现的简化调整，核心的三阶段搜索逻辑保留。重点在于目标函数和位置更新的衔接：目标函数接收一个候选解向量[C, sigma]，返回的是分类错误率。BES内部最小化这个函数。

先定义目标函数：

python复制from sklearn.model_selection import cross_val_score

def lssvm_objective(params):
    C, sigma = params
    try:
        model = LSSVM(C=C, sigma=sigma)
        # 用训练集做五折交叉验证，返回平均准确率
        acc = cross_val_score_eval(model, X_train, y_train_bin)
        return 1.0 - acc   # BES最小化
    except Exception:
        return 1e6

cross_val_score_eval 是我自己写的一个辅助函数，因为它不能直接用sklearn的cross_val_score，因为LSSVM不是sklearn接口风格，我没有让LSSVM实现get_params，但可以通过克隆临时模型的方式规避。在简单场景下，直接对训练集内部切一小块验证集效果也够。

python复制def simple_eval(model_class, X, y, C, sigma):
    # 从训练数据中切分出验证集
    X_t, X_v, y_t, y_v = train_test_split(X, y, test_size=0.2, random_state=1)
    m = model_class(C=C, sigma=sigma)
    m.fit(X_t, y_t)
    pred = m.predict(X_v)
    return accuracy_score(y_v, pred)

接下来是BES主体。参数设置上没有太多魔法，种群数量设20，迭代30次，维度2，lb和ub分别是参数搜索下限和上限。这里的上下界需要根据数据情况调整，后面我会专门讲这个。

python复制class BES:
    def __init__(self, obj_func, dim=2, pop=20, max_iter=30,
                 lb=None, ub=None):
        self.obj_func = obj_func
        self.dim = dim
        self.pop = pop
        self.max_iter = max_iter
        self.lb = np.array(lb) if lb is not None else np.array([0.01, 0.01])
        self.ub = np.array(ub) if ub is not None else np.array([1000.0, 100.0])

    def run(self):
        lb = self.lb
        ub = self.ub
        # 初始化种群
        positions = np.random.uniform(lb, ub, size=(self.pop, self.dim))
        fitness = np.array([self.obj_func(p) for p in positions])

        best_idx = np.argmin(fitness)
        best_pos = positions[best_idx].copy()
        best_fit = fitness[best_idx]

        history = []
        for t in range(1, self.max_iter + 1):
            # 第一阶段：选择搜索区域
            mean_pos = np.mean(positions, axis=0)
            for i in range(self.pop):
                alpha = np.random.uniform(0.5, 1.5)
                r = np.random.rand()
                positions[i] = best_pos + alpha * r * (mean_pos - positions[i])

            positions = np.clip(positions, lb, ub)

            # 第二阶段：搜索空间猎物（螺旋搜索）
            for i in range(self.pop):
                theta = np.random.uniform(0, 2 * np.pi)
                r_theta = np.random.rand()
                # 绕中心螺旋更新
                center = (positions[i] + best_pos) / 2
                positions[i] = center + r_theta * np.array([
                    np.cos(theta), np.sin(theta)
                ]) * (ub - lb) * 0.1

            positions = np.clip(positions, lb, ub)

            # 第三阶段：俯冲捕获（局部收敛）
            for i in range(self.pop):
                rho = np.random.rand()
                positions[i] = best_pos + rho * (best_pos - positions[i])

            positions = np.clip(positions, lb, ub)

            # 评估
            for i in range(self.pop):
                f = self.obj_func(positions[i])
                if f < fitness[i]:
                    fitness[i] = f
                if f < best_fit:
                    best_fit = f
                    best_pos = positions[i].copy()

            history.append(best_fit)

        return best_pos, best_fit, history

这个实现没有严格按照BES论文的每一组公式做全套复刻，但保留了三阶段的搜索节奏。实践下来，在二维参数优化问题上，这种简化版本已经表现稳定。如果你想更贴近原始算法，可以再把第二阶段公式替换成完整的螺旋参数方程，第三阶段加入sine和cosine控制俯冲角度，效果在小规模问题上差别不大。

3.4 主流程串联与结果输出

以下是完整的主脚本，逻辑非常直白：读数据、切分、标准化、BES寻优、用最优参数训练、评估测试集。

python复制# ============ 主流程 ============
# 准备评估函数
def obj_func_wrapper(params):
    C, sigma = params
    acc = simple_eval(LSSVM, X_train, y_train_bin, C, sigma)
    return 1.0 - acc

# 设置搜索范围
lb = [0.01, 0.01]
ub = [500.0, 50.0]

bes = BES(obj_func=obj_func_wrapper, dim=2, pop=20, max_iter=30, lb=lb, ub=ub)
best_params, best_fit, history = bes.run()

print(f"最优参数 C={best_params[0]:.4f}, sigma={best_params[1]:.4f}")
print(f"内部验证准确率 = {1 - best_fit:.4f}")

# 用最优参数训练最终模型
final_model = LSSVM(C=best_params[0], sigma=best_params[1])
final_model.fit(X_train, y_train_bin)
pred = final_model.predict(X_test)
pred_label = np.where(pred == 1, 1, 0)

print("测试集准确率:", accuracy_score(y_test, pred_label))
print(confusion_matrix(y_test, pred_label))
print(classification_report(y_test, pred_label))

跑完以后建议加一个收敛曲线可视化：

python复制import matplotlib.pyplot as plt
plt.plot(range(1, len(history)+1), history)
plt.xlabel("Iteration")
plt.ylabel("Error Rate")
plt.title("BES Convergence Curve")
plt.grid(True)
plt.show()

从收敛曲线上能直观看到BES是不是提前收敛了。正常情况，前10次迭代适应度会快速下降，后20次进入平滑收敛状态。如果曲线全程跳来跳去没有下降趋势，优先检查目标函数是不是返回了异常值，或者参数上下界是不是设置得太宽。

4. 实战中常见的坑与排查技巧

4.1 替换数据集时的几个隐藏问题

“替换数据集直接用”这句话听着简单，实际操作中第一个坑就是标签列的位置和编码方式。有的数据标签在第0列，有的在最后一列，还有的是字符串标签，比如"yes"和"no"。我的习惯是在读入数据后立刻打印y的前几行和唯一值，确认标签类型：

python复制print(y[:5], np.unique(y))

如果是字符串标签，先用sklearn.preprocessing.LabelEncoder转成0和1，再进模型。

第二个坑是标准化参数的重复使用。直接把整个X做fit_transform再切分，会出问题：测试集的信息在训练之前就被模型“看见”了，测试准确率会虚高。正确做法是先切分再标准化，这一点数据量小的时候影响不明显，但数据量一大、特征分布差距大的时候，测试结果会骗人。

第三个坑是LSSVM对特征缩放极度敏感。我曾经在一个多特征数据集上忘记标准化，结果BES无论怎么调参，准确率都停留在50%左右——和一个随机猜测模型没区别。标准化之后同样的参数组合直接跳到了80%以上。这不是算法bug，而是RBF核在计算距离时被大数值特征带偏了。

4.2 BES优化过程表现异常怎么办

最常见的异常是收敛曲线是一条水平线。发生这种情况，先检查目标函数里的except分支是不是把劣质解全部返回成了同一个很大的常数。C和σ的某些极端组合确实会导致np.linalg.solve报错，比如矩阵接近奇异，因此try分支必不可少。但如果你上下界设得太宽，大量参数组都会命中奇异矩阵，从而全部落入异常分支，适应度曲线看起来就像是平的。

第二个常见异常是多次运行结果差异极大。BES和粒子群这类启发式算法的初始化带随机性，所以每次运行结果会有波动。遇到这种情况，不要急着调代码，先把种群数量和迭代次数翻倍。比如从pop=20, max_iter=30调整到pop=40, max_iter=60，通常结果波动就明显变小了。如果还是不稳定，考虑用多次运行取最优，在我看来，比单独调大一轮迭代更划算：

python复制best_overall = None
best_score_overall = 1.0
for _ in range(5):
    bes = BES(obj_func=obj_func_wrapper, pop=20, max_iter=30)
    params, score, _ = bes.run()
    if score < best_score_overall:
        best_score_overall = score
        best_overall = params

第三个异常是BES收敛到搜索空间的边界。比如最优C正好落在上界500附近，说明真实最优值很可能在搜索范围之外，把上界直接扩到1000或2000再跑一次。反过来，如果最优σ落在0.01附近，说明核函数太平滑，特征尺度可能本身就不合适，考虑换特征或者把下界继续调低。

4.3 参数上下界设置的思路

参数边界的设置其实可以被看成是给优化算法提供先验知识。设得太小找不到好的参数组合，设得太大浪费大量迭代在无效区域。基于我跑过的几个数据集，提供一个参考：

一个更严谨的做法是先用粗网格跑一遍找大致区间，再在这个区间附近让BES做精细搜索。比如先把C在[0.1, 100]、σ在[0.1, 10]的候选集上各取3~4个值做交叉验证，画出准确率热力图，大体能看到高准确率区域分布在哪个角落，然后在这个角落周围设定BES的上下界。这个流程看起来多了一步，但总时间往往比盲目大范围寻优要短。

4.4 模型评估的其他细节

只用准确率评估二分类模型不够全面，尤其当两个类别的样本量不均衡时。我自己习惯同时打印混淆矩阵和F1值。LSSVM在训练时对每个样本的权重都敏感，类别不平衡会让少数类样本几乎不参与约束求解，分类结果容易偏向多数类。

如果数据集本身的类别特别不平衡，优先改目标函数，把简单准确率换成加权F1或G-mean：

python复制from sklearn.metrics import f1_score

def lssvm_objective_f1(params):
    C, sigma = params
    acc = simple_eval_f1(LSSVM, X_train, y_train_bin, C, sigma)
    return 1.0 - acc

simple_eval_f1内部把验证集预测结果和真实标签传给f1_score，返回的是F1值。这样BES优化的目标就从“整体猜得对”变成了“少数类也别被忽略”，在不平衡数据上效果提升明显。

还有一个容易被忽略的点：LSSVM的决策函数输出的是连续的实数值，默认取符号作为分类结果。如果输出特别接近0，说明样本落在分类边界附近，这类样本的置信度很低。有些工程场景下，把输出绝对值小于某个阈值（比如0.1）的样本单独标为“待人工复核”，比硬着头皮给一个标签更实用。

5. 进一步改进与扩展方向

5.1 用多核或并行评估加速

BES每一轮迭代都要对种群中每个个体评估目标函数，而这个评估是相互独立的，天然支持并行。最简单的加速方法是把目标函数评估改成multiprocessing并行，在种群评估环节用Pool.map代替for循环。我在一台8核机器上测试，原本30秒一轮的迭代能压到6秒左右。但要注意：Windows平台下多进程需要把主流程包在if __name__ == "__main__":里，否则会报递归错误。

5.2 把二分类扩展到多分类

LSSVM本身天然支持二分类，多分类问题常用两种方案：一对一（One-vs-One）或一对多（One-vs-Rest）。BES优化过程可以不改，只需要在目标函数里把多分类评估的准确率返回出来。实现一对多时，对每个类别训练一个二分类器，预测时选输出值最大的类别。这样整体逻辑复杂度不高，效果也稳定。

5.3 优化目标改为F1或AUC

前面提过用F1替代准确率，另一个选择是AUC。AUC对类别不平衡不敏感，能反映排序质量。如果用AUC做目标函数，LSSVM的输出值是连续的，可以直接用roc_auc_score计算，不需要先取符号。这对很多实际业务场景更有意义。

5.4 替换其他核函数

RBF核最常用，但不是唯一选择。遇到特征非常多的情况，线性核的训练速度更快且不容易过拟合；遇到文本或序列数据，线性核和多项式核有时效果更好。LSSVM类里的核函数可以单独抽出来，替换成linear、poly甚至自定义核。注意如果换了核函数，BES里需要优化的参数就变了：线性核没有σ，多项式核多了一个阶次参数d，需要同步修改目标函数和搜索维度。

最后再分享一个实操细节

这个项目跑通不难，但要把结果做得可信，我个人有几个小习惯。第一，BES每次运行都带随机性，所以正式记录结果前至少跑3次取最优，四个结果一起写在实验记录里，避免单次运气影响判断。第二，最终测试集只能碰一次：BES寻优、选模型、调阈值的时候都不能碰测试集，否则你评估出来的准确率就会虚高，放到真实场景里会被现实狠狠打脸。第三，换数据集之后不要直接沿用之前的C和σ，哪怕特征名字都一样，先观察一下标准化之后特征的量级，量级差很多就果断缩小或扩大搜索范围。

这个BES-LSSVM方案给我最大的感受就是好用、不折腾。数据准备好了，代码改一行路径，跑十几分钟，参数自动到位，模型效果和手调半天出来的差别不大。如果有同学正好卡在LSSVM调参的泥潭里，强烈建议把这个方案直接搬走，省下来的时间多分析分析数据本身，远比分毫之差地调参有价值。